Python six.moves.map() Examples
The following are 30
code examples of six.moves.map().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
six.moves
, or try the search function
.
Example #1
Source File: misc.py From mmdetection with Apache License 2.0 | 8 votes |
def multi_apply(func, *args, **kwargs): """Apply function to a list of arguments. Note: This function applies the ``func`` to multiple inputs and map the multiple outputs of the ``func`` into different list. Each list contains the same type of outputs corresponding to different inputs. Args: func (Function): A function that will be applied to a list of arguments Returns: tuple(list): A tuple containing multiple list, each list contains a kind of returned results by the function """ pfunc = partial(func, **kwargs) if kwargs else func map_results = map(pfunc, *args) return tuple(map(list, zip(*map_results)))
Example #2
Source File: __init__.py From pkg_resources with MIT License | 6 votes |
def __init__( self, search_path=None, platform=get_supported_platform(), python=PY_MAJOR): """Snapshot distributions available on a search path Any distributions found on `search_path` are added to the environment. `search_path` should be a sequence of ``sys.path`` items. If not supplied, ``sys.path`` is used. `platform` is an optional string specifying the name of the platform that platform-specific distributions must be compatible with. If unspecified, it defaults to the current platform. `python` is an optional string naming the desired version of Python (e.g. ``'3.3'``); it defaults to the current version. You may explicitly set `platform` (and/or `python`) to ``None`` if you wish to map *all* distributions, not just those compatible with the running platform or Python version. """ self._distmap = {} self.platform = platform self.python = python self.scan(search_path)
Example #3
Source File: __init__.py From lambda-packs with MIT License | 6 votes |
def parse_map(cls, data, dist=None): """Parse a map of entry point groups""" if isinstance(data, dict): data = data.items() else: data = split_sections(data) maps = {} for group, lines in data: if group is None: if not lines: continue raise ValueError("Entry points must be listed in groups") group = group.strip() if group in maps: raise ValueError("Duplicate group name", group) maps[group] = cls.parse_group(group, lines, dist) return maps
Example #4
Source File: __init__.py From lambda-packs with MIT License | 6 votes |
def __init__(self, search_path=None, platform=get_supported_platform(), python=PY_MAJOR): """Snapshot distributions available on a search path Any distributions found on `search_path` are added to the environment. `search_path` should be a sequence of ``sys.path`` items. If not supplied, ``sys.path`` is used. `platform` is an optional string specifying the name of the platform that platform-specific distributions must be compatible with. If unspecified, it defaults to the current platform. `python` is an optional string naming the desired version of Python (e.g. ``'3.3'``); it defaults to the current version. You may explicitly set `platform` (and/or `python`) to ``None`` if you wish to map *all* distributions, not just those compatible with the running platform or Python version. """ self._distmap = {} self.platform = platform self.python = python self.scan(search_path)
Example #5
Source File: namespaces.py From Safejumper-for-Desktop with GNU General Public License v2.0 | 6 votes |
def install_namespaces(self): nsp = self._get_all_ns_packages() if not nsp: return filename, ext = os.path.splitext(self._get_target()) filename += self.nspkg_ext self.outputs.append(filename) log.info("Installing %s", filename) lines = map(self._gen_nspkg_line, nsp) if self.dry_run: # always generate the lines, even in dry run list(lines) return with open(filename, 'wt') as f: f.writelines(lines)
Example #6
Source File: utils.py From elasticsearch_parse with MIT License | 6 votes |
def _setattr(self, name, value): # if this attribute has special type assigned to it... if name in self._param_defs: pinfo = self._param_defs[name] if 'type' in pinfo: # get the shortcut used to construct this type (query.Q, aggs.A, etc) shortcut = self.__class__.get_dsl_type(pinfo['type']) if pinfo.get('multi'): value = list(map(shortcut, value)) # dict(name -> DslBase), make sure we pickup all the objs elif pinfo.get('hash'): value = dict((k, shortcut(v)) for (k, v) in iteritems(value)) # single value object, just convert else: value = shortcut(value) self._params[name] = value
Example #7
Source File: package_index.py From Safejumper-for-Desktop with GNU General Public License v2.0 | 6 votes |
def __init__( self, index_url="https://pypi.python.org/simple", hosts=('*',), ca_bundle=None, verify_ssl=True, *args, **kw ): Environment.__init__(self, *args, **kw) self.index_url = index_url + "/" [:not index_url.endswith('/')] self.scanned_urls = {} self.fetched_urls = {} self.package_pages = {} self.allows = re.compile('|'.join(map(translate, hosts))).match self.to_scan = [] use_ssl = ( verify_ssl and ssl_support.is_available and (ca_bundle or ssl_support.find_ca_bundle()) ) if use_ssl: self.opener = ssl_support.opener_for(ca_bundle) else: self.opener = urllib.request.urlopen
Example #8
Source File: package_index.py From Safejumper-for-Desktop with GNU General Public License v2.0 | 6 votes |
def find_external_links(url, page): """Find rel="homepage" and rel="download" links in `page`, yielding URLs""" for match in REL.finditer(page): tag, rel = match.groups() rels = set(map(str.strip, rel.lower().split(','))) if 'homepage' in rels or 'download' in rels: for match in HREF.finditer(tag): yield urllib.parse.urljoin(url, htmldecode(match.group(1))) for tag in ("<th>Home Page", "<th>Download URL"): pos = page.find(tag) if pos != -1: match = HREF.search(page, pos) if match: yield urllib.parse.urljoin(url, htmldecode(match.group(1)))
Example #9
Source File: __init__.py From Safejumper-for-Desktop with GNU General Public License v2.0 | 6 votes |
def parse_map(cls, data, dist=None): """Parse a map of entry point groups""" if isinstance(data, dict): data = data.items() else: data = split_sections(data) maps = {} for group, lines in data: if group is None: if not lines: continue raise ValueError("Entry points must be listed in groups") group = group.strip() if group in maps: raise ValueError("Duplicate group name", group) maps[group] = cls.parse_group(group, lines, dist) return maps
Example #10
Source File: __init__.py From pkg_resources with MIT License | 6 votes |
def __init__(self, requirement_string): """DO NOT CALL THIS UNDOCUMENTED METHOD; use Requirement.parse()!""" try: super(Requirement, self).__init__(requirement_string) except packaging.requirements.InvalidRequirement as e: raise RequirementParseError(str(e)) self.unsafe_name = self.name project_name = safe_name(self.name) self.project_name, self.key = project_name, project_name.lower() self.specs = [ (spec.operator, spec.version) for spec in self.specifier] self.extras = tuple(map(safe_extra, self.extras)) self.hashCmp = ( self.key, self.specifier, frozenset(self.extras), str(self.marker) if self.marker else None, ) self.__hash = hash(self.hashCmp)
Example #11
Source File: __init__.py From Safejumper-for-Desktop with GNU General Public License v2.0 | 6 votes |
def __init__(self, search_path=None, platform=get_supported_platform(), python=PY_MAJOR): """Snapshot distributions available on a search path Any distributions found on `search_path` are added to the environment. `search_path` should be a sequence of ``sys.path`` items. If not supplied, ``sys.path`` is used. `platform` is an optional string specifying the name of the platform that platform-specific distributions must be compatible with. If unspecified, it defaults to the current platform. `python` is an optional string naming the desired version of Python (e.g. ``'3.3'``); it defaults to the current version. You may explicitly set `platform` (and/or `python`) to ``None`` if you wish to map *all* distributions, not just those compatible with the running platform or Python version. """ self._distmap = {} self.platform = platform self.python = python self.scan(search_path)
Example #12
Source File: docsim.py From topical_word_embeddings with MIT License | 6 votes |
def query_shards(self, query): """ Return the result of applying shard[query] for each shard in self.shards, as a sequence. If PARALLEL_SHARDS is set, the shards are queried in parallel, using the multiprocessing module. """ args = zip([query] * len(self.shards), self.shards) if PARALLEL_SHARDS and PARALLEL_SHARDS > 1: logger.debug("spawning %i query processes" % PARALLEL_SHARDS) pool = multiprocessing.Pool(PARALLEL_SHARDS) result = pool.imap(query_shard, args, chunksize=1 + len(args) / PARALLEL_SHARDS) else: # serial processing, one shard after another pool = None result = imap(query_shard, args) return pool, result
Example #13
Source File: docsim.py From topical_word_embeddings with MIT License | 6 votes |
def query_shards(self, query): """ Return the result of applying shard[query] for each shard in self.shards, as a sequence. If PARALLEL_SHARDS is set, the shards are queried in parallel, using the multiprocessing module. """ args = zip([query] * len(self.shards), self.shards) if PARALLEL_SHARDS and PARALLEL_SHARDS > 1: logger.debug("spawning %i query processes" % PARALLEL_SHARDS) pool = multiprocessing.Pool(PARALLEL_SHARDS) result = pool.imap(query_shard, args, chunksize=1 + len(args) / PARALLEL_SHARDS) else: # serial processing, one shard after another pool = None result = imap(query_shard, args) return pool, result
Example #14
Source File: docsim.py From topical_word_embeddings with MIT License | 6 votes |
def query_shards(self, query): """ Return the result of applying shard[query] for each shard in self.shards, as a sequence. If PARALLEL_SHARDS is set, the shards are queried in parallel, using the multiprocessing module. """ args = zip([query] * len(self.shards), self.shards) if PARALLEL_SHARDS and PARALLEL_SHARDS > 1: logger.debug("spawning %i query processes" % PARALLEL_SHARDS) pool = multiprocessing.Pool(PARALLEL_SHARDS) result = pool.imap(query_shard, args, chunksize=1 + len(args) / PARALLEL_SHARDS) else: # serial processing, one shard after another pool = None result = imap(query_shard, args) return pool, result
Example #15
Source File: embeddings.py From polyglot with GNU General Public License v3.0 | 6 votes |
def _from_word2vec_binary(fname): with _open(fname, 'rb') as fin: words = [] header = _decode(fin.readline()) vocab_size, layer1_size = list(map(int, header.split())) # throws for invalid file format vectors = np.zeros((vocab_size, layer1_size), dtype=float32) binary_len = np.dtype(float32).itemsize * layer1_size for line_no in xrange(vocab_size): # mixed text and binary: read text first, then binary word = [] while True: ch = fin.read(1) if ch == b' ': break if ch != b'\n': # ignore newlines in front of words (some binary files have newline, some don't) word.append(ch) word = _decode(b''.join(word)) index = line_no words.append(word) vectors[index, :] = np.fromstring(fin.read(binary_len), dtype=float32) return words, vectors
Example #16
Source File: functional.py From pylivetrader with Apache License 2.0 | 6 votes |
def mapall(funcs, seq): """ Parameters ---------- funcs : iterable[function] Sequence of functions to map over `seq`. seq : iterable Sequence over which to map funcs. Yields ------ elem : object Concatenated result of mapping each ``func`` over ``seq``. Example ------- >>> list(mapall([lambda x: x + 1, lambda x: x - 1], [1, 2, 3])) [2, 3, 4, 0, 1, 2] """ for func in funcs: for elem in seq: yield func(elem)
Example #17
Source File: compiler.py From dragonfly with GNU Lesser General Public License v3.0 | 6 votes |
def _compile_literal(self, element, src_state, dst_state, grammar, kaldi_rule, fst): weight = self.get_weight(element) # Handle weight internally below, without adding a state words = element.words words = list(map(text_type, words)) # words = self.translate_words(words) # Special case optimize single-word literal if len(words) == 1: word = words[0].lower() if word not in self.lexicon_words: word = self.handle_oov_word(word) fst.add_arc(src_state, dst_state, word, weight=weight) else: words = [word.lower() for word in words] for i in range(len(words)): if words[i] not in self.lexicon_words: words[i] = self.handle_oov_word(words[i]) # "Insert" new states for individual words states = [src_state] + [fst.add_state() for i in range(len(words)-1)] + [dst_state] for i, word in enumerate(words): fst.add_arc(states[i], states[i + 1], word, weight=weight) weight = None # Only need to set weight on first arc # @trace_compile
Example #18
Source File: misc.py From AerialDetection with Apache License 2.0 | 5 votes |
def multi_apply(func, *args, **kwargs): pfunc = partial(func, **kwargs) if kwargs else func map_results = map(pfunc, *args) return tuple(map(list, zip(*map_results)))
Example #19
Source File: field.py From Mastering-Elasticsearch-7.0 with MIT License | 5 votes |
def serialize(self, data): if isinstance(data, (list, AttrList, tuple)): return list(map(self._serialize, data)) return self._serialize(data)
Example #20
Source File: utils.py From Mastering-Elasticsearch-7.0 with MIT License | 5 votes |
def to_dict(self): """ Serialize the DSL object to plain dict """ d = {} for pname, value in iteritems(self._params): pinfo = self._param_defs.get(pname) # typed param if pinfo and 'type' in pinfo: # don't serialize empty lists and dicts for typed fields if value in ({}, []): continue # list of dict(name -> DslBase) if pinfo.get('multi') and pinfo.get('hash'): value = list( {k: v.to_dict() for k, v in iteritems(obj)} for obj in value ) # multi-values are serialized as list of dicts elif pinfo.get('multi'): value = list(map(lambda x: x.to_dict(), value)) # squash all the hash values into one dict elif pinfo.get('hash'): value = {k: v.to_dict() for k, v in iteritems(value)} # serialize single values else: value = value.to_dict() # serialize anything with to_dict method elif hasattr(value, 'to_dict'): value = value.to_dict() d[pname] = value return {self.name: d}
Example #21
Source File: hubstorage.py From spidermon with BSD 3-Clause "New" or "Revised" License | 5 votes |
def __init__(self): self.available = "SHUB_JOBKEY" in os.environ and HubstorageClient is not None self._client = None self._project = None self._job = None if self.available: self.job_key = os.environ["SHUB_JOBKEY"] self._project_id, self._spider_id, self._job_id = map( int, self.job_key.split("/") ) else: self._project_id = None self._spider_id = None self._job_id = None
Example #22
Source File: easy_install.py From Safejumper-for-Desktop with GNU General Public License v2.0 | 5 votes |
def delete_blockers(self, blockers): extant_blockers = ( filename for filename in blockers if os.path.exists(filename) or os.path.islink(filename) ) list(map(self._delete_path, extant_blockers))
Example #23
Source File: package_index.py From Safejumper-for-Desktop with GNU General Public License v2.0 | 5 votes |
def prescan(self): """Scan urls scheduled for prescanning (e.g. --find-links)""" if self.to_scan: list(map(self.scan_url, self.to_scan)) self.to_scan = None # from now on, go ahead and process immediately
Example #24
Source File: utils.py From Mastering-Elasticsearch-7.0 with MIT License | 5 votes |
def __iter__(self): return map(lambda i: _wrap(i, self._obj_wrapper), self._l_)
Example #25
Source File: utils.py From Mastering-Elasticsearch-7.0 with MIT License | 5 votes |
def __iter__(self): return map(lambda i: _wrap(i, self._obj_wrapper), self._l_)
Example #26
Source File: utils.py From Mastering-Elasticsearch-7.0 with MIT License | 5 votes |
def to_dict(self): """ Serialize the DSL object to plain dict """ d = {} for pname, value in iteritems(self._params): pinfo = self._param_defs.get(pname) # typed param if pinfo and 'type' in pinfo: # don't serialize empty lists and dicts for typed fields if value in ({}, []): continue # list of dict(name -> DslBase) if pinfo.get('multi') and pinfo.get('hash'): value = list( {k: v.to_dict() for k, v in iteritems(obj)} for obj in value ) # multi-values are serialized as list of dicts elif pinfo.get('multi'): value = list(map(lambda x: x.to_dict(), value)) # squash all the hash values into one dict elif pinfo.get('hash'): value = {k: v.to_dict() for k, v in iteritems(value)} # serialize single values else: value = value.to_dict() # serialize anything with to_dict method elif hasattr(value, 'to_dict'): value = value.to_dict() d[pname] = value return {self.name: d}
Example #27
Source File: field.py From Mastering-Elasticsearch-7.0 with MIT License | 5 votes |
def serialize(self, data): if isinstance(data, (list, AttrList, tuple)): return list(map(self._serialize, data)) return self._serialize(data)
Example #28
Source File: test.py From Safejumper-for-Desktop with GNU General Public License v2.0 | 5 votes |
def run(self): installed_dists = self.install_dists(self.distribution) cmd = ' '.join(self._argv) if self.dry_run: self.announce('skipping "%s" (dry run)' % cmd) return self.announce('running "%s"' % cmd) paths = map(operator.attrgetter('location'), installed_dists) with self.paths_on_pythonpath(paths): with self.project_on_sys_path(): self.run_tests()
Example #29
Source File: __init__.py From Safejumper-for-Desktop with GNU General Public License v2.0 | 5 votes |
def get_entry_map(dist, group=None): """Return the entry point map for `group`, or the full entry map""" return get_distribution(dist).get_entry_map(group)
Example #30
Source File: test.py From Safejumper-for-Desktop with GNU General Public License v2.0 | 5 votes |
def run_tests(self): # Purge modules under test from sys.modules. The test loader will # re-import them from the build location. Required when 2to3 is used # with namespace packages. if six.PY3 and getattr(self.distribution, 'use_2to3', False): module = self.test_suite.split('.')[0] if module in _namespace_packages: del_modules = [] if module in sys.modules: del_modules.append(module) module += '.' for name in sys.modules: if name.startswith(module): del_modules.append(name) list(map(sys.modules.__delitem__, del_modules)) exit_kwarg = {} if sys.version_info < (2, 7) else {"exit": False} test = unittest_main( None, None, self._argv, testLoader=self._resolve_as_ep(self.test_loader), testRunner=self._resolve_as_ep(self.test_runner), **exit_kwarg ) if not test.result.wasSuccessful(): msg = 'Test failed: %s' % test.result self.announce(msg, log.ERROR) raise DistutilsError(msg)