\
    Returns a set of cable identifiers of cables published by Aftenposten.
    See: <http://aebr.home.xs4all.nl/wl/aftenposten/>
777839
def _aftenposten_cable_ids():
    
    s = urllib2.urlopen(_AP_IRI).read()
    return set(_WL_CABLE_ID_PATTERN.findall(s))
801812
def adj_names(self):
        
        return list(self.pst.parameter_data.parnme.loc[~self.fixed_indexer])
554173
def IdentifiersIndexer(instance):
    
    identifiers = instance.Schema()['Identifiers'].get(instance)
    return [safe_unicode(i['Identifier']) for i in identifiers]
849274
public Collection<String> getIdentifiers() {
    List<String> keys = new LinkedList<String>();
    keys.addAll(this.stateMap.keySet());
    return keys;
  }
1187301
def clean_cable_content(content):
    
    for pattern, subst in _CLEAN_PATTERNS:
        content = pattern.sub(subst, content)
    return content
372808
def GetFormatStringAttributeNames(self):
    
    if self._format_string_attribute_names is None:
      self._format_string_attribute_names = []
      for format_string_piece in self.FORMAT_STRING_PIECES:
        attribute_names = self._FORMAT_STRING_ATTRIBUTE_NAME_RE.findall(
            format_string_piece)

        if attribute_names:
          self._format_string_attribute_names.extend(attribute_names)

    return set(self._format_string_attribute_names)
1039981
private final String[] getValidPortPrefixes(String CandidatePortPrefixes[]) {
        /*
         256 is the number of prefixes ( COM, cua, ttyS, ...) not
         the number of devices (ttyS0, ttyS1, ttyS2, ...)

         On a Linux system there are about 400 prefixes in
         deviceDirectory.
         registerScannedPorts() assigns CandidatePortPrefixes to
         something less than 50 prefixes.

         Trent
         */

        String ValidPortPrefixes[] = new String[256];
        logger.fine("\nRXTXCommDriver:getValidPortPrefixes()");
        if (CandidatePortPrefixes == null) {
            logger.fine("\nRXTXCommDriver:getValidPortPrefixes() No ports prefixes known for this System.\nPlease check the port prefixes listed for " + RXTXVersion.getOsName() + " in RXTXCommDriver:registerScannedPorts()\n");
        }
        int i = 0;
        for (int j = 0; j < CandidatePortPrefixes.length; j++) {
            if (isPortPrefixValid(CandidatePortPrefixes[j])) {
                ValidPortPrefixes[i++]
                        = CandidatePortPrefixes[j];
            }
        }
        String[] returnArray = new String[i];
        System.arraycopy(ValidPortPrefixes, 0, returnArray, 0, i);
        if (ValidPortPrefixes[0] == null) {

            logger.fine("\nRXTXCommDriver:getValidPortPrefixes() No ports matched the list assumed for this\nSystem in the directory " + deviceDirectory + ".  Please check the ports listed for \"" + RXTXVersion.getOsName() + "\" in\nRXTXCommDriver:registerScannedPorts()\nTried:");
            for (int j = 0; j < CandidatePortPrefixes.length; j++) {
                logger.fine("\t"
                        + CandidatePortPrefixes[i]);
            }

        } else {
            logger.fine("\nRXTXCommDriver:getValidPortPrefixes()\nThe following port prefixes have been identified as valid on " + RXTXVersion.getOsName() + ":\n");
            /*
             for(int j=0;j<returnArray.length;j++)
             {
             if (debug)
             System.out.println("\t" + j + " " +
             returnArray[j]);
             }
             */
        }
        return returnArray;
    }
314328
private static Set<String> collectIntersectionPrefixes(FieldInfo fi)
      throws IOException {
    if (fi != null) {
      Set<String> result = new HashSet<>();
      String intersectingPrefixes = fi.getAttribute(
          MtasCodecPostingsFormat.MTAS_FIELDINFO_ATTRIBUTE_PREFIX_INTERSECTION);
      if (intersectingPrefixes != null) {
        String[] prefixes = intersectingPrefixes
            .split(Pattern.quote(MtasToken.DELIMITER));
        for (int i = 0; i < prefixes.length; i++) {
          String item = prefixes[i].trim();
          if (!item.equals("")) {
            result.add(item);
          }
        }
      }
      return result;
    } else {
      return Collections.emptySet();
    }
  }
962762
def get_identifiers_from_input_file(input_file_name):
    
    valid_identifiers = ['address', 'zipcode', 'unit', 'city', 'state', 'slug', 'block_id', 'msa',
                         'num_bins', 'property_type', 'client_value', 'client_value_sqft', 'meta']
    mode = 'r'
    if sys.version_info[0] < 3:
        mode = 'rb'
    with io.open(input_file_name, mode) as input_file:
        result = [{identifier: val for identifier, val in list(row.items())
                   if identifier in valid_identifiers}
                  for row in csv.DictReader(input_file, skipinitialspace=True)]
        return result
128695
def _ident(*elements):
        
        try:
            # for hashable elements
            return len(set(elements)) == 1
        except TypeError:
            # for unhashable elements
            for e1, e2 in zip(elements, elements[1:]):
                if e1 != e2:
                    return False
            return True
747696
def getAttachmentUIDs(self):
        
        attachments = self.getAttachment()
        uids = [att.UID() for att in attachments]
        return uids
125206
def extract_table_identifiers(token_stream):
    """"""

    for item in token_stream:
        if isinstance(item, IdentifierList):
            for identifier in item.get_identifiers():
                # Sometimes Keywords (such as FROM ) are classified as
                # identifiers which don't have the get_real_name() method.
                try:
                    schema_name = identifier.get_parent_name()
                    real_name = identifier.get_real_name()
                except AttributeError:
                    continue
                if real_name:
                    yield (schema_name, real_name, identifier.get_alias())
        elif isinstance(item, Identifier):
            real_name = item.get_real_name()
            schema_name = item.get_parent_name()

            if real_name:
                yield (schema_name, real_name, item.get_alias())
            else:
                name = item.get_name()
                yield (None, name, item.get_alias() or name)
        elif isinstance(item, Function):
            yield (None, item.get_name(), item.get_name())
635513
def _get_repr_list(self):
        
        spacing = ' '*2
        text = ['']
        text.append("%sfile: %s" % (spacing, self._filename))
        text.append("%sextension: %d" % (spacing, self._info['hdunum']-1))
        text.append(
            "%stype: %s" % (spacing, _hdu_type_map[self._info['hdutype']]))

        extname = self.get_extname()
        if extname != "":
            text.append("%sextname: %s" % (spacing, extname))
        extver = self.get_extver()
        if extver != 0:
            text.append("%sextver: %s" % (spacing, extver))

        return text, spacing
1177209
public StringIdentifierGenerator[] getIdentifierGenerators() {
        int len = identifierGenerators.length;
        StringIdentifierGenerator[] out = 
            new StringIdentifierGenerator[len];
        System.arraycopy(identifierGenerators, 0, out, 0, len);
        return out;
    }
146136
def identify_with_list(identifier):
    
    @wraps(identifier)
    def decorated_func(origin, filepath, fileobj, *args, **kwargs):
        # pylint: disable=missing-docstring
        try:
            filepath = file_list(filepath)[0]
        except ValueError:
            if filepath is None:
                try:
                    files = file_list(args[0])
                except (IndexError, ValueError):
                    pass
                else:
                    if files:
                        filepath = files[0]
        except IndexError:
            pass
        return identifier(origin, filepath, fileobj, *args, **kwargs)
    return decorated_func
651865
def get_names(self):
        
        names = [id for id in self.ecrm_P1_is_identified_by if id.uri == surf.ns.EFRBROO['F12_Name']]
        self.names = []
        for name in names:
            for variant in name.rdfs_label:
                self.names.append((variant.language,variant.title()))
        return self.names
767208
public function getList()
    {
        $identifiers = array();

        $fileList = $this->filesystem->listFiles($this->getPath());
        foreach ($fileList as $file) {
            $identifiers[] = $file['filename'];
        }
        return $identifiers;

    }