Returns a list of NODC sea names

    source of list: http://www.nodc.noaa.gov/General/NODC-Archive/seanames.xml
170949
def get_sea_names():
    '''
    
    '''
    global _SEA_NAMES
    if _SEA_NAMES is None:
        resource_text = get_data("cc_plugin_ncei", "data/seanames.xml")
        parser = etree.XMLParser(remove_blank_text=True)
        root = etree.fromstring(resource_text, parser)
        buf = {}
        for seaname in root.findall('seaname'):
            name = seaname.find('seaname').text
            buf[name] = seaname.find('seacode').text if seaname.find('seacode') is not None else 'N/A'

        _SEA_NAMES = buf
    return _SEA_NAMES
1012938
def symlink_list(self, load):
        '''
        
        '''
        if 'env' in load:
            # "env" is not supported; Use "saltenv".
            load.pop('env')

        ret = {}
        if 'saltenv' not in load:
            return {}
        if not isinstance(load['saltenv'], six.string_types):
            load['saltenv'] = six.text_type(load['saltenv'])

        for fsb in self.backends(load.pop('fsbackend', None)):
            symlstr = '{0}.symlink_list'.format(fsb)
            if symlstr in self.servers:
                ret = self.servers[symlstr](load)
        # some *fs do not handle prefix. Ensure it is filtered
        prefix = load.get('prefix', '').strip('/')
        if prefix != '':
            ret = dict([
                (x, y) for x, y in six.iteritems(ret) if x.startswith(prefix)
            ])
        return ret
601416
def get_domain_list(list_name):
    '''
    

    '''
    payload = {"jsonrpc": "2.0",
               "id": "ID0",
               "method": "get_policy_domain_names",
               "params": [list_name, 0, 256]}

    response = __proxy__['bluecoat_sslv.call'](payload, False)

    return _convert_to_list(response, 'item_name')
535342
function getNames(names) {
    var result = [];

    ['copyright', 'fontFamily', 'uniqueID', 'fontSubfamily', 'licence'].forEach(function(n) {
        if(names[n]) {
            result.push.apply(result, getStrings(names[n], TTF_NAMES[n]));
        }
    });

    result.push.apply(result, getStrings('Generated by node-freetype.', TTF_NAMES.description));
    result.push.apply(result, getStrings('https://github.com/YuhangGe/node-freetype', TTF_NAMES.url));

    result.sort(function (a, b) {
        var orderFields = ['platformID', 'encodingID', 'languageID', 'id'];
        var i;
        for (i = 0; i < orderFields.length; i++) {
            if (a[orderFields[i]] !== b[orderFields[i]]) {
                return a[orderFields[i]] < b[orderFields[i]] ? -1 : 1;
            }
        }
        return 0;
    });

    return result;
}
742520
def _get_name_map(saltenv='base'):
    '''
    
    '''
    u_name_map = {}
    name_map = get_repo_data(saltenv).get('name_map', {})

    if not six.PY2:
        return name_map

    for k in name_map:
        u_name_map[k] = name_map[k]
    return u_name_map
443626
def names(self, with_namespace=False):
        '''
        '''
        N = self.count()
        names = self.name.split(settings.splittingnames)[:N]
        n = 0
        while len(names) < N:
            n += 1
            names.append('unnamed%s' % n)
        if with_namespace and self.namespace:
            n = self.namespace
            s = settings.field_separator
            return [n + s + f for f in names]
        else:
            return names
102287
def collection_names
      namespaces = self["system.namespaces"].find(name: { "$not" => /#{name}\.system\.|\$/ })
      namespaces.map do |doc|
        _name = doc["name"]
        _name[name.length + 1, _name.length]
      end
    end
585176
def _load_names(self) -> List[str]:
        
        names = []
        for path in self._get_files():
            for name in self._get_names(path):
                names.append(self._normalize_name(name))
        return names
163165
def _rec_get_names(args, names=None):
    """"""
    if names is None:
        names = []
    for arg in args:
        if isinstance(arg, node_classes.Tuple):
            _rec_get_names(arg.elts, names)
        else:
            names.append(arg.name)
    return names
311966
def _do_names(names, fun, path=None):
    '''
    
    '''
    ret = {}
    hosts = find_guests(names, path=path)
    if not hosts:
        return False

    client = salt.client.get_local_client(__opts__['conf_file'])
    for host, sub_names in six.iteritems(hosts):
        cmds = []
        for name in sub_names:
            cmds.append(client.cmd_iter(
                    host,
                    'lxc.{0}'.format(fun),
                    [name],
                    kwarg={'path': path},
                    timeout=60))
        for cmd in cmds:
            data = next(cmd)
            data = data.get(host, {}).get('ret', None)
            if data:
                ret.update({host: data})
    return ret
156135
def symlink_list(self, load):
        '''
        
        '''
        if 'env' in load:
            # "env" is not supported; Use "saltenv".
            load.pop('env')

        if not salt.utils.stringutils.is_hex(load['saltenv']) \
                and load['saltenv'] not in self.envs():
            return {}
        if 'prefix' in load:
            prefix = load['prefix'].strip('/')
        else:
            prefix = ''
        symlinks = self._file_lists(load, 'symlinks')
        return dict([(key, val)
                     for key, val in six.iteritems(symlinks)
                     if key.startswith(prefix)])
77057
def get_instance_route53_names(self, instance):
        '''  '''

        instance_attributes = [ 'public_dns_name', 'private_dns_name',
                                'ip_address', 'private_ip_address' ]

        name_list = set()

        for attrib in instance_attributes:
            try:
                value = getattr(instance, attrib)
            except AttributeError:
                continue

            if value in self.route53_records:
                name_list.update(self.route53_records[value])

        return list(name_list)
1344075
def dir_names(self, connId='default'):
        
        files_list = []
        thisConn = self.__getConnection(connId)
        try:
            files_list = thisConn.nlst()
        except:
            files_list = []
        return files_list
370057
def list_nodes(search="unsigned"):
    
    nodes = nago.core.get_nodes()
    if search == "all":
        return map(lambda x: {x[0]: x[1].data}, nodes.items())
    elif search == 'unsigned':
        result = {}
        for token, node in nodes.items():
            if node.get('access') is None:
                result[token] = node.data
        return result
    else:
        result = {}
        for token, node in nodes.items():
            host_name = node.get('host_name')
            if search in (token, host_name):
                result[token] = node.data
        return result
57696
def get_d1nts(self):
        """"""
        data = []
        ntdata = cx.namedtuple("NtPrt", "D1 NS dcnt depth GO name")
        namespace = None
        for ntlet in sorted(self.goone2ntletter.values(),
                            key=lambda nt: [nt.goobj.namespace, -1 * nt.dcnt, nt.D1]):
            goobj = ntlet.goobj
            goid = goobj.id
            assert len(goobj.parents) == 1
            if namespace != goobj.namespace:
                namespace = goobj.namespace
                ntns = self.ns2nt[namespace]
                pobj = ntns.goobj
                ns2 = self.str2ns[goobj.namespace]
                data.append(ntdata._make([" ", ns2, ntns.dcnt, pobj.depth, pobj.id, pobj.name]))
            data.append(ntdata._make(
                [ntlet.D1, self.str2ns[namespace], ntlet.dcnt, goobj.depth, goid, goobj.name]))
        return data
989592
def buoy_data_types(cls, buoy):
        
        endpoint = cls()
        file_types = {'txt': 'standard meteorological data',
                      'drift': 'meteorological data from drifting buoys and limited moored'
                               'buoy data mainly from international partners',
                      'cwind': 'continuous wind data (10 minute average)',
                      'spec': 'spectral wave summaries',
                      'data_spec': 'raw spectral wave data',
                      'swdir': 'spectral wave data (alpha1)',
                      'swdir2': 'spectral wave data (alpha2)',
                      'swr1': 'spectral wave data (r1)',
                      'swr2': 'spectral wave data (r2)',
                      'adcp': 'acoustic doppler current profiler',
                      'ocean': 'oceanographic data',
                      'tide': 'tide data',
                      'srad': 'solar radiation data',
                      'dart': 'water column height',
                      'supl': 'supplemental measurements data',
                      'rain': 'hourly rain data'}
        available_data = {}
        buoy_url = 'https://www.ndbc.noaa.gov/data/realtime2/' + buoy + '.'
        for key in file_types:
            if endpoint._check_if_url_valid(buoy_url + key):
                available_data[key] = file_types[key]
        return available_data
1139085
def list_public_containers(self):
        
        resp, resp_body = self.api.cdn_request("", "GET")
        return [cont["name"] for cont in resp_body]