Transforms the interfaces names into URI strings, with the interface
    implementation language as a scheme.

    :param specifications: Specifications to transform
    :return: The transformed names
336279
def format_specifications(specifications):
    # type: (Iterable[str]) -> List[str]
    
    transformed = set()
    for original in specifications:
        try:
            lang, spec = _extract_specification_parts(original)
            transformed.add(_format_specification(lang, spec))
        except ValueError:
            # Ignore invalid specifications
            pass

    return list(transformed)
227884
def _to_spec(project, name, template_spec_name, destination_dir)
      project.from_directory do
        spec_name = "#{name}.spec"
        spec_dir = File.join(destination_dir, name)
        FileUtils.mkdir_p(spec_dir)

        spec_path = File.join(spec_dir, spec_name)

        new_content = generate(template_spec_name, binding)
        label = "Spec for #{name} generated"
        conflict_count = project.merge_new_content(new_content, spec_path,
                                                   label, "#{name}-spec")
        [spec_path, conflict_count]
      end
    end
910776
def interfaces(self, addresses=False):
        
        schema = InterfaceSchema()
        resp = self.service.get(self.base+'interfaces/', params={'addresses': addresses})
        return self.service.decode(schema, resp, many=True)
1048635
def GetFormatSpecification(cls):
    
    format_specification = specification.FormatSpecification(cls.NAME)
    format_specification.AddNewSignature(b'ElfFile\x00', offset=0)
    return format_specification
518058
def translate(self):
        
        expressions = []
        varnames = set()
        funcnames = set()
        for part in self.parts:
            if isinstance(part, str):
                expressions.append(ex_literal(part))
            else:
                e, v, f = part.translate()
                expressions.extend(e)
                varnames.update(v)
                funcnames.update(f)
        return expressions, varnames, funcnames
900339
def build_definitions_example(self):
        """"""
        for def_name, def_spec in self.specification.get('definitions', {}).items():
            self.build_one_definition_example(def_name)
904728
def add_implemented_interfaces(cls, interfaces):
    
    implemented = set(
        six.moves.reduce(
            lambda x, y: x.union(y),
            map(operator.attrgetter('implied'), interfaces),
            set()
        )
    )
    implemented.update(*map(
        get_implemented_interfaces,
        inspect.getmro(cls)
    ))
    setattr(cls, '__interfaces__', frozenset(implemented))
396708
def rename(old, new)
      parameters = Specification.new(
        old: Types::Tags,
        new: Types::Tags
      ).parameters(old: old, new: new)
      @client.action('/tags/rename', parameters)
      self
    end
254883
def scheme_specification(cls):
		
		return WSchemeSpecification(
			cls.scheme_name(),

			WURIComponentVerifier(WURI.Component.username, WURIComponentVerifier.Requirement.optional),
			WURIComponentVerifier(WURI.Component.password, WURIComponentVerifier.Requirement.optional),
			WURIComponentVerifier(WURI.Component.hostname, WURIComponentVerifier.Requirement.required),
			WURIComponentVerifier(WURI.Component.port, WURIComponentVerifier.Requirement.optional),
			WURIComponentVerifier(WURI.Component.path, WURIComponentVerifier.Requirement.optional),
			WURIQueryVerifier(
				WURIComponentVerifier.Requirement.optional,
				WStrictURIQuery.ParameterSpecification(
					'remote_path', nullable=False, multiple=False, optional=False
				),
				extra_parameters=False
			)
		)
1261363
static String getInterfaceSignature(String[] interfaces, String apiName) {
        StringBuilder signature = new StringBuilder("<T::L" + XsdSupportingStructure.elementType + "<TT;TZ;>;Z::" + XsdSupportingStructure.elementTypeDesc + ">" + JAVA_OBJECT_DESC);

        if (interfaces != null){
            for (String anInterface : interfaces) {
                signature.append("L")
                        .append(getFullClassTypeName(anInterface, apiName))
                        .append("<TT;TZ;>;");
            }
        }

        return signature.toString();
    }
1098225
def geturi(self):
        
        scheme, authority, path, query, fragment = self

        # RFC 3986 5.3. Component Recomposition
        result = []
        if scheme is not None:
            result.extend([scheme, self.COLON])
        if authority is not None:
            result.extend([self.SLASH, self.SLASH, authority])
        result.append(path)
        if query is not None:
            result.extend([self.QUEST, query])
        if fragment is not None:
            result.extend([self.HASH, fragment])
        return self.EMPTY.join(result)
399889
public static Vector<Object> toXmlRpcSpecificationsParameters(Collection<Specification> specifications)
    { 
        Vector<Object> specificationsParams = new Vector<Object>();        
        for(Specification specification : specifications)
        {
            specificationsParams.add(specification.marshallize());
        }
        
        return specificationsParams;
    }
902734
def _create_interface_specification(schema_graph, graphql_types, hidden_classes, cls_name):
    """"""
    def interface_spec():
        """Return a list of GraphQL interface types implemented by the type named 'cls_name'."""
        abstract_inheritance_set = (
            superclass_name
            for superclass_name in sorted(list(schema_graph.get_inheritance_set(cls_name)))
            if (superclass_name not in hidden_classes and
                schema_graph.get_element_by_class_name(superclass_name).abstract)
        )

        return [
            graphql_types[x]
            for x in abstract_inheritance_set
            if x not in hidden_classes
        ]

    return interface_spec
83980
def _implementations(cls):
        
        if cls.__implementations:
            return cls.__implementations

        cls.__implementations = {}
        for implementation in all_subclasses(MetadataExtractor):
            try:
                feature_name = implementation.feature_name()
                cls.__implementations[feature_name] = implementation
            except NotImplementedError:
                pass
        return cls.__implementations
346456
def to_s
      string =  "Workflow:    #{@name}\n"
      string << "ID:          #{@id}\n"
      string << "Description: #{@description}\n"
      string << "Version:     #{@version}\n"

      string << "\nInput Parameters:\n"
      if @input_parameters.size > 0
        @input_parameters.each_value { |wf_param| string << " #{wf_param}" }
      end

      string << "\nOutput Parameters:" << "\n"
      if @output_parameters.size > 0
        @output_parameters.each_value { |wf_param| string << " #{wf_param}" }
      end

      # Assert
      string
    end
368890
def _build_qname(self, uri=None, namespaces=None):
        
        if not uri:
            uri = self.uri
        if not namespaces:
            namespaces = self.namespaces
        return uri2niceString(uri, namespaces)
360712
def interfaces_names():
    '''
    
    '''

    ret = []
    with salt.utils.winapi.Com():
        c = wmi.WMI()
        for iface in c.Win32_NetworkAdapter(NetEnabled=True):
            ret.append(iface.NetConnectionID)
    return ret