def stereomers(xgr):
""" all stereomers, ignoring this graph's assignments
"""
bool_vals = (False, True)
def _expand_atom_stereo(sgr):
atm_ste_keys = stereogenic_atom_keys(sgr)
nste_atms = len(atm_ste_keys)
sgrs = [
_set_atom_stereo_parities(
sgr, dict(zip(atm_ste_keys, atm_ste_par_vals)))
for atm_ste_par_vals in _product(bool_vals, repeat=nste_atms)
]
return sgrs
def _expand_bond_stereo(sgr):
bnd_ste_keys = stereogenic_bond_keys(sgr)
nste_bnds = len(bnd_ste_keys)
sgrs = [
_set_bond_stereo_parities(
sgr, dict(zip(bnd_ste_keys, bnd_ste_par_vals)))
for bnd_ste_par_vals in _product(bool_vals, repeat=nste_bnds)
]
return sgrs
last_sgrs = []
sgrs = [_without_stereo_parities(xgr)]
while sgrs != last_sgrs:
last_sgrs = sgrs
sgrs = list(_chain(*map(_expand_atom_stereo, sgrs)))
sgrs = list(_chain(*map(_expand_bond_stereo, sgrs)))
return tuple(sorted(sgrs, key=_frozen))
def __init__(self, x, y, e, *args, line_options=None, error_options=None, texlabel=None, legendentry=None, **kwargs):
super().__init__(*args, **kwargs)
self.line = CPlot(Coordinates(zip(x, y)), texlabel=texlabel, legendentry=legendentry)
self.line.options.add(*args, **kwargs)
if line_options is not None:
self.line.options.add(line_options)
ex = _chain(x, reversed(x))
ey = _chain((yi + ei[0] for yi, ei in zip(y, e)), (yi-ei[1] for yi, ei in reversed(list(zip(y, e)))))
self.error = CPlot(Coordinates(zip(ex, ey)), 'fill', 'forget plot', draw='none', mark='none')
self.error['fill opacity'] = 0.1
self.error.options.add(*args, **kwargs)
self.error.options.add(error_options)
self.children = [self.error, self.line]
def __or__(self, other):
if isinstance(self, group):
if isinstance(other, group):
# group() | group() -> single group
return group(_chain(self.tasks, other.tasks), app=self.app)
# group() | task -> chord
return chord(self, body=other, app=self._app)
elif isinstance(other, group):
# task | group() -> unroll group with one member
other = maybe_unroll_group(other)
return chain(self, other, app=self._app)
if not isinstance(self, chain) and isinstance(other, chain):
# task | chain -> chain
return chain((self, ) + other.tasks, app=self._app)
elif isinstance(other, chain):
# chain | chain -> chain
return chain(*self.tasks + other.tasks, app=self._app)
elif isinstance(self, chord):
sig = self.clone()
sig.body = sig.body | other
return sig
elif isinstance(other, Signature):
if isinstance(self, chain):
# chain | task -> chain
return chain(*self.tasks + (other, ), app=self._app)
# task | task -> chain
return chain(self, other, app=self._app)
return NotImplemented
def _resolved_entry_phase_affordancesets(self, phase, affordances):
upstream_affordancesets = _set()
downstream_affordances = affordances.unfrozen_copy()
downstream_affordances.inputs = '*'
downstream_affordances.outputs = '*'
for resolved_input_affordances \
in self._resolved_phase_input_affordancesets\
(phase, 'upstream',
reverse_affordances=downstream_affordances):
upstream_affordances = resolved_input_affordances.unfrozen()
upstream_affordances.inputs = '*'
upstream_affordances.outputs = affordances.outputs
upstream_affordancesets.add(upstream_affordances.frozen())
self.logger.cond((_logging.DEBUG,
lambda: 'resolved upstream affordance sets {}'
.format(upstream_affordancesets)))
downstream_affordancesets = \
_frozenset(_chain(*[self._resolved_phase_output_affordancesets
(phase, 'downstream',
reverse_affordances=upstream_affordances)
for upstream_affordances
in upstream_affordancesets]))
self.logger.cond((_logging.DEBUG,
lambda: 'resolved downstream affordance sets {}'
.format(downstream_affordancesets)))
return downstream_affordancesets
def flatten_links(self):
return list(
chain_from_iterable(
_chain(
[[self]],
(link.flatten_links()
for link in maybe_list(self.options.get("link")) or []))))
def provisionsets_combinations(provisionsets, choose0=True):
"""
The authentication security provision sets that are yielded by
combinations of given sets.
:param provisionsets:
A set of security provision sets.
:type provisionsets: ~[:class:`ProvisionSetABC`]
:param bool choose0:
Whether to include the empty choice. If true, then the empty set of
security provisions is always included in the result. Otherwise, it
is included only if *provisionsets* contains it.
:rtype: :class:`ProvisionSetABC`
"""
if choose0:
yield iter(provisionsets).next().__class__()
for combination \
in _chain(*(_combinations(provisionsets, nchoices)
for nchoices in range(1, len(provisionsets) + 1))):
yield _reduce(_or, combination)
def min(*iterable, **kwds):
"""
min(iterable, *[, default, key])
min(arg1, arg2, *args, *[, key])
"""
allowed_kwds = ('default', 'key')
for key in kwds:
if key not in allowed_kwds:
msg = "'{0}' is an invalid keyword argument for this function"
raise TypeError(msg.format(key))
if len(iterable) == 1:
iterable = iterable[0]
try:
first_item = next(iter(iterable))
if iter(iterable) is iterable:
iterable = _chain([first_item], iterable)
except StopIteration:
if 'default' not in kwds:
raise ValueError('min() arg is an empty sequence')
return kwds['default']
if 'key' in kwds:
return _min(iterable, key=kwds['key'])
return _min(iterable)
def _atom_stereo_coordinates(anchor_key, atm_key, atm_ngb_keys_dct, xyz_dct,
key_sorter, parity):
""" assign atom-stereo coordinates from a stencil
"""
stencil_xyzs = (
(0, 0, 0), # atm 1
(-1, 0, 0), # atm 1 ngb 0
(0, 1, 0), # atm 1 ngb 1
(0, 0, (-1)**(not parity)), # atm 1 ngb 2
(0, -1, 0)) # atm 1 ngb 3
assert atm_key in atm_ngb_keys_dct
atm_ngb_keys = atm_ngb_keys_dct[atm_key]
stencil_keys = list(_chain([atm_key], key_sorter(atm_ngb_keys)))
assert len(stencil_keys) == len(stencil_xyzs)
xyz_dct = dict.copy(xyz_dct)
xyz_dct.update(
_from_stencil(atm_key, anchor_key, xyz_dct, stencil_keys,
stencil_xyzs))
boundary_edges = tuple((atm_key, ngb_key) for ngb_key in atm_ngb_keys
if ngb_key != anchor_key)
return xyz_dct, boundary_edges
def _make_tables(exprs):
def append_to_all_values(tbl, item):
for L in tbl.itervalues(): L.append(item)
includingUnknownReq = any(e is None for e in exprs)
exprAndReqs = [(expr, expr.getMatchCandidateForLookAhead()) for expr in exprs]
ns, ls = [], []
for r in filter(None, (r for _, r in exprAndReqs)):
if r.nodes is not ANY_ITEM: ns.extend(r.nodes)
if r.literals is not ANY_ITEM: ls.extend(r.literals)
ntbl = dict((lbl, []) for lbl in ns)
unknown_nlst = []
ltbl = dict((s, []) for s in ls)
unknown_llst = []
elst = []
for expr, r in exprAndReqs:
if r is not None:
if r.nodes is not ANY_ITEM:
for lbl in r.nodes: ntbl[lbl].append(expr)
else:
append_to_all_values(ntbl, expr)
unknown_nlst.append(expr)
if r.literals is not ANY_ITEM:
for s in r.literals: ltbl[s].append(expr)
else:
append_to_all_values(ltbl, expr)
unknown_llst.append(expr)
if r.emptyseq: elst.append(expr)
else:
for L in _chain(ntbl.itervalues(), ltbl.itervalues(), [unknown_nlst, unknown_llst, elst]):
L.append(expr)
return ntbl, unknown_nlst, ltbl, unknown_llst, elst, includingUnknownReq
def _devel_searchpaths_iter(names,
srcs,
require=False,
include_deps=False,
distinction='dist',
extras=False,
update_cmd=None,
seen_paths=None,
logger=None,
loglevel=_logging.DEBUG):
if seen_paths is None:
seen_paths = set()
missing_names = []
for name in names:
name = _projects_misc.normalized_project_name(name)
path = None
for path in _chain(*(_devel_project_searchpaths_iter(name, src=src)
for src in srcs)):
if path in seen_paths:
continue
seen_paths.add(path)
if update_cmd:
_misc.update_metadata_at(path, cmd=update_cmd, logger=logger,
loglevel=loglevel)
yield path
if include_deps:
project = _projects.Project.from_path(path)
env = _envs.DistEnv(project.dists)
project_extras = \
_misc.normalized_extras(extras, env=env).get(name, ())
requirements_names = \
(_requirements.normalized_requirement_name(requirement)
for requirement
in project.requirements(extras=project_extras))
for dep_path \
in _devel_searchpaths_iter(requirements_names,
srcs=srcs,
require=False,
include_deps=include_deps,
distinction=distinction,
extras=extras,
update_cmd=update_cmd,
logger=logger,
loglevel=loglevel,
seen_paths=seen_paths):
yield dep_path
if path is None:
missing_names.append(name)
continue
if require and missing_names:
tried_paths = list(_devel_searchpaths_iter(missing_names, srcs=srcs))
raise _exc.ProjectsNotFound(missing_names, tried_paths)
def __init__(self, m, to, sender, subject=None, cc=None, bcc=None):
super().__init__()
self.m = check_m(m)
to = to_list(to)
cc = to_list(cc)
bcc = to_list(bcc)
if not subject:
subject = '%s mailer' % (IDENT)
subject = '%s - %s' % (subject, get_timestamp())
self.__sender = sender
self.__recipients = list(_chain(to, cc, bcc))
_charset.add_charset('utf-8', _charset.QP, _charset.QP, 'UTF-8')
self.__message = _MIMEMultipart()
self.__message.add_header('To', ', '.join(to))
if cc:
self.__message.add_header('CC', ', '.join(cc))
self.__message.add_header('From', sender)
self.__message.add_header('Subject', subject)
self.__message.add_header('Date', _formatdate())
self.__message.add_header('X-Mailer', '%s mailer' % (IDENT))
self.m('mail tool startup done',
more=dict(to=to, cc=cc, bcc=bcc, sender=sender,
subject=subject),
verbose=False)
def __init__(self, m, to, sender, subject=None, cc=None, bcc=None):
super().__init__()
self.m = check_m(m)
to = to_list(to)
cc = to_list(cc)
bcc = to_list(bcc)
if not subject:
subject = '%s mailer' % (IDENT)
subject = '%s - %s' % (subject, get_timestamp())
self.__sender = sender
self.__recipients = list(_chain(to, cc, bcc))
_charset.add_charset('utf-8', _charset.QP, _charset.QP, 'UTF-8')
self.__message = _MIMEMultipart()
self.__message.add_header('To', ', '.join(to))
if cc:
self.__message.add_header('CC', ', '.join(cc))
self.__message.add_header('From', sender)
self.__message.add_header('Subject', subject)
self.__message.add_header('Date', _formatdate())
self.__message.add_header('X-Mailer', '%s mailer' % (IDENT))
self.m(
'mail tool startup done',
more=dict(to=to, cc=cc, bcc=bcc, sender=sender, subject=subject),
verbose=False
)
def inner(*args, **kwargs):
# as zip terminates as soon as one iterator is exausted we dont
# have to worry about the case where some args are specified and
# some use thier default value as the len(args) (ie the specified
# args) will cause automatic termination
args_mapping = zip(argspec.args, args)
cache_keys = []
for key, item in _chain(args_mapping, kwargs.items()):
if key in cacheable_keys:
cache_keys.append((key, item))
# lists are unhashable and cant be used as dict keys
cache_keys.sort()
cache_keys = tuple(val for key, val in cache_keys)
recalculate = False
cached = backend.get(cache_keys)
if cached:
expiry, output = cached
expire = lifetime_func(expiry)
if expire:
recalculate = True
else:
recalculate = True
if recalculate:
output = func(*args, **kwargs)
expiry = lifetime_func()
backend[cache_keys] = expiry, output
return output
def _explicit_stereo(sgr):
""" make the hydrogens at atom and bond stereo sites explicit
"""
atm_ste_keys = atom_stereo_keys(sgr)
bnd_ste_keys = bond_stereo_keys(sgr)
bnd_ste_atm_keys = set(_chain(*bnd_ste_keys))
ste_atm_keys = atm_ste_keys | bnd_ste_atm_keys
return _explicit(sgr, atm_keys=ste_atm_keys)
def ensure_row_length(matrix, ncols, fill=''):
"""Make sure each row in matrix has length ncols.
If a row's length is less than ncols add elements fill
Returns a 2d tuple
"""
tcols = (fill, ) * ncols
return tuple(tuple(_islice(_chain(x, tcols), ncols)) for x in matrix)
def flatten_links(self):
"""Return a recursive list of dependencies (unchain if you will,
but with links intact)."""
return list(_chain.from_iterable(_chain(
[[self]],
(link.flatten_links()
for link in maybe_list(self.options.get('link')) or [])
)))
def make_legacy_params_dict(req):
"""convert new-style params to old style athana params dict"""
req.params = params = {}
for key, values in _chain(req.form.iterlists(), req.args.iterlists()):
value = ";".join(values)
params[key] = value
# params[key.encode("utf8")] = value.encode("utf8")
params.update(req.files.iteritems())
def flatten_links(self):
"""Return a recursive list of dependencies (unchain if you will,
but with links intact)."""
return list(_chain.from_iterable(_chain(
[[self]],
(link.flatten_links()
for link in maybe_list(self.options.get('link')) or [])
)))
def _bond_stereo_coordinates(anchor_key, bnd_key, atm_ngb_keys_dct, xyz_dct,
key_sorter, parity):
""" assign bond-stereo coordinates from a stencil
"""
stencil1_xyzs = (
(0, 0, 0), # atm 1
(-1, 0, 0), # atm 1 ngb 0 (anchor?)
(1, 0, 0)) # atm 1 ngb 1 (anchor?)
stencil2_xyzs = (
(0, 1, 0), # atm 2
((-1)**(not parity), 1, 0), # atm 2 ngb 0
((-1)**parity, 1, 0)) # atm 2 ngb 1
atm1_key, atm2_key = bnd_key
assert atm1_key in atm_ngb_keys_dct
assert atm2_key in atm_ngb_keys_dct
atm1_ngb_keys = atm_ngb_keys_dct[atm1_key]
atm2_ngb_keys = atm_ngb_keys_dct[atm2_key]
if anchor_key in atm2_ngb_keys:
atm1_key, atm2_key = atm2_key, atm1_key
atm1_ngb_keys, atm2_ngb_keys = atm2_ngb_keys, atm1_ngb_keys
atm1_ngb_keys -= {atm2_key}
atm2_ngb_keys -= {atm1_key}
stencil_xyz_dct = {}
stencil_xyz_dct.update(
zip(_chain([atm1_key], key_sorter(atm1_ngb_keys)), stencil1_xyzs))
stencil_xyz_dct.update(
zip(_chain([atm2_key], key_sorter(atm2_ngb_keys)), stencil2_xyzs))
xyz_dct = dict.copy(xyz_dct)
xyz_dct.update(
_from_stencil(atm1_key, anchor_key, xyz_dct, stencil_xyz_dct.keys(),
stencil_xyz_dct.values()))
boundary_edges = tuple(
_chain(
((atm1_key, ngb_key) for ngb_key in atm1_ngb_keys - {anchor_key}),
((atm2_key, ngb_key) for ngb_key in atm2_ngb_keys)))
return xyz_dct, boundary_edges
def bond_induced_subgraph(xgr, bnd_keys):
""" the subgraph induced by a subset of the bonds
"""
atm_keys = set(_chain(*bnd_keys))
bnd_keys = set(bnd_keys)
assert atm_keys <= _atom_keys(xgr)
assert bnd_keys <= _bond_keys(xgr)
atm_dct = _by_key(_atoms(xgr), atm_keys)
bnd_dct = _by_key(_bonds(xgr), bnd_keys)
return _from_atoms_and_bonds(atm_dct, bnd_dct)
def _zip_longest(*args, **kwds):
# izip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-
fillvalue = kwds.get('fillvalue')
def sentinel(counter = ([fillvalue]*(len(args)-1)).pop):
yield counter() # yields the fillvalue, or raises IndexError
fillers = _repeat(fillvalue)
iters = [_chain(it, sentinel(), fillers) for it in args]
try:
for tup in izip(*iters):
yield tup
except IndexError:
pass
def _zip_longest(*args, **kwds):
# izip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-
fillvalue = kwds.get('fillvalue')
def sentinel(counter = ([fillvalue]*(len(args)-1)).pop):
yield counter() # yields the fillvalue, or raises IndexError
fillers = _repeat(fillvalue)
iters = [_chain(it, sentinel(), fillers) for it in args]
try:
for tup in izip(*iters):
yield tup
except IndexError:
pass
def make_sig(*fields):
Parameter, Signature = _inspect.Parameter, _inspect.Signature
pos_parms = []
kw_parms = []
for field in fields:
if isinstance(field, str):
pos_parms.append(
Parameter(field, Parameter.POSITIONAL_OR_KEYWORD))
else:
name, default = field
kw_parms.append(
Parameter(name, Parameter.KEYWORD_ONLY, default=default))
return Signature(_chain(pos_parms, kw_parms))
def __new__(cls, clsname, bases, clsdict):
# print(clsname, '->', bases)
# print(clsdict)
fields = clsdict.get('_fields', [])
kwfields = clsdict.get('_kwfields', {})
parameters = _chain(
fields,
kwfields.items(),
*StructureMeta._get_fields(*bases),
)
sig = StructureMeta.make_sig(*parameters)
clsdict['__signature__'] = sig
clsdict['__slots__'] = tuple(sig.parameters)
return super().__new__(cls, clsname, bases, clsdict)
def _interpret_range_strings(rng_strs):
def _interpret_range_string(rng_str):
split_rng = str(rng_str).split('-')
if len(split_rng) == 1:
rng = [int(split_rng[-1])]
elif len(split_rng) == 2:
start, stop = map(int, split_rng)
rng = list(range(start, stop+1))
else:
raise ValueError("Failed to interet index ranges")
return rng
return tuple(_chain(*map(_interpret_range_string, rng_strs)))
def from_path(cls, path, name=None, dists_relpaths=('.',)):
dists_paths = [_os.path.join(path, dists_relpath)
for dists_relpath in dists_relpaths]
dists = list(_chain(*(_pkgr.find_distributions(dists_path, only=True)
for dists_path in dists_paths)))
if not dists:
raise _exc.DistNotFound(location=dists_paths)
if name is None:
name = dists[0].project_name
return cls(name, dists, location=path)
def _call(self, *, ws, pos):
assert isinstance(ws, _SegParagraph)
assert isinstance(pos, _SegParagraph)
conparse_text = []
for ws_sent, pos_sent in zip(ws, pos):
conparse_sent_text = []
ws_clause = []
pos_clause = []
for ws_token, pos_token in _chain(zip(ws_sent, pos_sent), [
(None, None),
]):
# Skip WHITESPACE
if pos_token == 'WHITESPACE':
continue
# Segment clauses by punctuations
if pos_token is None or (pos_token.endswith('CATEGORY')
and pos_token != 'PAUSECATEGORY'):
if ws_clause:
wspos_clause_text = _WsPosSentence.to_text(
ws_clause, pos_clause)
for conparse_clause_text in self._core.apply_list(
[wspos_clause_text]):
conparse_sent_text.append([
self._normalize(conparse_clause_text),
'',
])
if ws_token:
if not conparse_sent_text:
conparse_sent_text.append([
None,
'',
])
conparse_sent_text[-1][1] += ws_token
ws_clause = []
pos_clause = []
else:
ws_clause.append(self._half2full(ws_token))
pos_clause.append(pos_token)
conparse_text.append(conparse_sent_text)
conparse = _ParseParagraph.from_list(conparse_text)
return conparse
def load_recursive(path,
encoding="cp932",
node_type=_OtoNode,
greedy_recursion=True):
if greedy_recursion:
inis = _glob(_path.join(path, "**/oto.ini"), recursive=True)
else:
inis = _chain(_glob(_path.join(path, "oto.ini")),
_glob(_path.join(path, "*/oto.ini")))
oto_dict = {}
for oto_ini in inis:
oto_dict.update(
load(oto_ini, root=path, encoding=encoding, node_type=node_type))
return oto_dict
def __or__(self, other):
if isinstance(self, group):
if isinstance(other, group):
return group(_chain(self.tasks, other.tasks), app=self.app)
return chord(self, body=other, app=self._app)
elif isinstance(other, group):
other = maybe_unroll_group(other)
if not isinstance(self, chain) and isinstance(other, chain):
return chain((self, ) + other.tasks, app=self._app)
elif isinstance(other, chain):
return chain(*self.tasks + other.tasks, app=self._app)
elif isinstance(other, Signature):
if isinstance(self, chain):
return chain(*self.tasks + (other, ), app=self._app)
return chain(self, other, app=self._app)
return NotImplemented
def _fill_atom_inchi_numbers(xgr, bbn_ich_num_dct):
""" atom inchi number dictionary from inchi-sorted backbone keys
"""
atm_ich_num_dct = bbn_ich_num_dct.copy()
ich_srt_bbn_keys = _keys_sorted_by_value(bbn_ich_num_dct)
atm_exp_hyd_keys_dct = atom_explicit_hydrogen_keys(xgr)
ich_srt_bbn_exp_hyd_keys = _values_by_key(atm_exp_hyd_keys_dct,
ich_srt_bbn_keys)
ich_srt_exp_hyd_keys = tuple(_chain(*ich_srt_bbn_exp_hyd_keys))
first_exp_hyd_ich_num = min(bbn_ich_num_dct.values()) - 1
atm_ich_num_dct.update({
exp_hyd_key: first_exp_hyd_ich_num - exp_hyd_srt_idx
for exp_hyd_srt_idx, exp_hyd_key in enumerate(ich_srt_exp_hyd_keys)
})
assert set(atm_ich_num_dct.keys()) == atom_keys(xgr)
return atm_ich_num_dct
def __or__(self, other):
if isinstance(self, group):
if isinstance(other, group):
return group(_chain(self.tasks, other.tasks), app=self.app)
return chord(self, body=other, app=self._app)
elif isinstance(other, group):
other = maybe_unroll_group(other)
if not isinstance(self, chain) and isinstance(other, chain):
return chain((self,) + other.tasks, app=self._app)
elif isinstance(other, chain):
return chain(*self.tasks + other.tasks, app=self._app)
elif isinstance(other, Signature):
if isinstance(self, chain):
return chain(*self.tasks + (other,), app=self._app)
return chain(self, other, app=self._app)
return NotImplemented
def retrying(*args, **kwargs):
problems = []
for delay in _chain(DataFeed.retryDelays, [None]):
try:
# attempt call
return func(*args, **kwargs)
# we need to try again
except DataFeedException as problem:
problems.append(problem)
if delay is None:
Logger.debug(DataFeed, problems)
raise MaxRetriesException('retryDelays exhausted ' + str(problem))
else:
# log exception and wait
Logger.debug(DataFeed, problem)
Logger.error(DataFeed, "No reply... -- delaying for %ds" % delay)
sleep(delay)
def retrying(*args, **kwargs):
problems = []
for delay in _chain(retryDelays, [None]):
try:
# attempt call
return func(*args, **kwargs)
# we need to try again
except RequestException as problem:
problems.append(problem)
if delay is None:
logger.error(problems)
raise
else:
# log exception and wait
logger.exception(problem)
logger.info("-- delaying for %ds", delay)
sleep(delay)
def __init__(self):
self.relation_count = 1
if os.path.exists("wn_hierarchy_data.npy"):
self.data = numpy.load("wn_hierarchy_data.npy")
self.train_data = numpy.load("wn_hierarchy_train_data.npy")
self.valid_data = numpy.load("wn_hierarchy_valid_data.npy")
self.test_data = numpy.load("wn_hierarchy_test_data.npy")
self.entity_count, self.id2entity, self.entity2id = pickle.load(open("wn_hierarchy_metadata.pickle", "rb"))
else:
self.data = list(map(lambda x: list(map(str, x.strip().split('\t'))), open("WN_HIERARCHY/noun_closure.tsv").readlines()))
self.id2entity = dict(enumerate(sorted(list(set(list(_chain(*self.data)))))))
self.entity2id = {v: k for k, v in self.id2entity.items()}
self.entity_count = len(self.id2entity)
self.data = numpy.array(list(map(lambda x: [self.entity2id[x[0]], self.entity2id[x[1]], 0], self.data)))
numpy.random.shuffle(self.data)
self.train_data = self.data[:-50000]
self.valid_data = self.data[-50000:-25000]
self.test_data = self.data[-25000:]
numpy.save("wn_hierarchy_data", self.data)
numpy.save("wn_hierarchy_train_data", self.train_data)
numpy.save("wn_hierarchy_valid_data", self.valid_data)
numpy.save("wn_hierarchy_test_data", self.test_data)
pickle.dump((self.entity_count, self.id2entity, self.entity2id), open("wn_hierarchy_metadata.pickle", "wb"))
if os.path.exists("wn_hierarchy_all_data.pickle"):
self.all_data = pickle.load(open("wn_hierarchy_all_data.pickle", "rb"))
else:
self.all_data = set(map(tuple, self.data.tolist()))
pickle.dump(self.all_data, open("wn_hierarchy_all_data.pickle", "wb"))
if os.path.exists("wn_hierarchy_hierarchy.pickle"):
self.hierarchy = pickle.load(open("wn_hierarchy_hierarchy.pickle", "rb"))
else:
self.hierarchy = self.create_hierarchy()
pickle.dump(self.hierarchy, open("wn_hierarchy_hierarchy.pickle", "wb"))
del self._children_of_all_entities
if os.path.exists("wn_hierarchy_entity_distances.npy"):
self.entity_distances = numpy.load("wn_hierarchy_entity_distances.npy")
else:
self.entity_distances = self.get_entity_distances()
numpy.save("wn_hierarchy_entity_distances", self.entity_distances)
def implicit(xgr, atm_keys=None):
""" make the hydrogens at these atoms implicit
"""
atm_keys = backbone_keys(xgr) if atm_keys is None else atm_keys
atm_keys = list(atm_keys)
atm_imp_hyd_vlcs = _values_by_key(_atom_implicit_hydrogen_valences(xgr),
atm_keys)
atm_exp_hyd_keys = _values_by_key(atom_explicit_hydrogen_keys(xgr),
atm_keys)
atm_exp_hyd_vlcs = tuple(map(len, atm_exp_hyd_keys))
atm_tot_hyd_vlcs = numpy.add(atm_imp_hyd_vlcs, atm_exp_hyd_vlcs)
exp_hyd_keys = tuple(_chain(*atm_exp_hyd_keys))
xgr = _set_atom_implicit_hydrogen_valences(
xgr, dict(zip(atm_keys, atm_tot_hyd_vlcs)))
xgr = _delete_atoms(xgr, exp_hyd_keys)
return xgr
def retrying(*args, **kwargs):
problems = []
for delay in _chain(DataFeed.retryDelays, [None]):
try:
# attempt call
return func(*args, **kwargs)
# we need to try again
except PoloniexError as problem:
problems.append(problem)
if delay is None:
DataFeed.logger.debug(DataFeed, problems)
raise RetryException(
'retryDelays exhausted ' + str(problem))
else:
# log exception and wait
DataFeed.logger.debug(DataFeed, problem)
DataFeed.logger.info(DataFeed, "-- delaying for %ds" % delay)
sleep(delay)
def python_entrypoint_reference(value: str) -> bool:
module, _, rest = value.partition(":")
if "[" in rest:
obj, _, extras_ = rest.partition("[")
if extras_.strip()[-1] != "]":
return False
extras = (x.strip()
for x in extras_.strip(string.whitespace + "[]").split(","))
if not all(pep508_identifier(e) for e in extras):
return False
_logger.warning(
f"`{value}` - using extras for entry points is not recommended")
else:
obj = rest
module_parts = module.split(".")
identifiers = _chain(module_parts,
obj.split(".")) if rest else module_parts
return all(python_identifier(i.strip()) for i in identifiers)
def retrying(*args, **kwargs):
problems = []
for delay in _chain(retryDelays, [None]):
try:
# attempt call
return func(*args, **kwargs)
# we need to try again
except RequestException as problem:
problems.append(problem)
if delay is None:
Logger.debug(func, problems)
raise MaxRetriesException(
'retryDelays exhausted ' + str(problem))
else:
# log exception and wait
Logger.debug(func, problem)
Logger.info(func, "-- delaying for %ds" % delay)
sleep(delay)
def retrying(*args, **kwargs):
problems = []
for delay in _chain(retryDelays, [None]):
try:
# attempt call
return func(*args, **kwargs)
# we need to try again
except RequestException as problem:
problems.append(problem)
if delay is None:
logger.debug(problems)
raise RetryException('retryDelays exhausted ' +
str(problem))
else:
# log exception and wait
logger.debug(problem)
logger.info("-- retrying in %ds", delay)
sleep(delay)
def join(components, *arg):
"""
Joins path components to form a normalized key.
>>> join("foo", "bar", "baz")
"/foo/bar/baz"
>>> join(["foo", "bar"], "baz")
"/foo/bar/baz"
:param components:
An iterable value of path components, or a string (which will be
passed to :func:`split()` to turn it into an iterable value).
:param arg:
Additional path components to be appended to the generated key.
:return:
Normalized key, as a string.
"""
if not (isinstance(components, (list, tuple))
or _isgenerator(components)):
components = (c for c in components.split("/") if c)
return "/" + "/".join(_chain(components, arg))
def elements(self):
'''Iterator over elements repeating each as many times as its count.
>>> c = Counter('ABCABC')
>>> sorted(c.elements())
['A', 'A', 'B', 'B', 'C', 'C']
# Knuth's example for prime factors of 1836: 2**2 * 3**3 * 17**1
>>> prime_factors = Counter({2: 2, 3: 3, 17: 1})
>>> product = 1
>>> for factor in prime_factors.elements(): # loop over factors
... product *= factor # and multiply them
>>> product
1836
Note, if an element's count has been set to zero or is a negative
number, elements() will ignore it.
'''
# Emulate Bag.do from Smalltalk and Multiset.begin from C++.
return _chain(*_starmap(_repeat, self.iteritems()))
def devel_searchpaths_iter(names=True,
src=None,
ext_dir=DEVEL_SRC_EXT_DIR,
require=False,
include_deps=False,
distinction='dist',
extras=False,
update_cmd=None,
logger=None,
loglevel=_logging.DEBUG):
if src is None:
src = devel_src()
srcs = [src]
if ext_dir is not None:
srcs.append(_os.path.join(src, ext_dir))
if names is True:
for path in _chain(*([_os.path.join(src_, dirname)
for dirname
in devel_projects_dirnames_iter(src=src_)]
for src_ in srcs)):
if update_cmd:
_misc.update_metadata_at(path, cmd=update_cmd, logger=logger,
loglevel=loglevel)
yield path
return
for path in _devel_searchpaths_iter(names,
srcs=srcs,
require=require,
include_deps=include_deps,
distinction=distinction,
extras=extras,
update_cmd=update_cmd,
logger=logger,
loglevel=loglevel):
yield path
def flatten_links(self):
return list(chain_from_iterable(_chain([[self]],
(link.flatten_links()
for link in maybe_list(self.options.get('link')) or []))))
def __hash__(self):
return hash("MatchCandiateForLookAhead") + sum(map(hash, _chain(self.__nodes, self.__literals, self.__emptyseq)))
from functools import partial as _partial
from itertools import chain as _chain
from .termformatconstants import FG_COLORS, BG_COLORS, STYLES
from .fmtstr import fmtstr
for att in _chain(FG_COLORS, ("on_" + x for x in BG_COLORS), STYLES):
locals()[att] = _partial(fmtstr, style=att)
plain = _partial(fmtstr)
if __name__ == "__main__":
import doctest
doctest.testmod()
print((blue("adf")))
print((blue(on_red("ad"))))
print((blue("asdf") + on_red("adsf")))
print(((blue("asdf") + on_red("adsf"))[3:7]))
f = blue("hey there") + on_red(" Tom!")
print(f)
f[1:3] = "ot"
print((repr(f)))
print(f)
f = on_blue(red("stuff"))
print((repr(f)))
print((repr(str(f))))
print(f)
print(((f + "!")[0:6] + "?"))
from functools import partial as _partial
from itertools import chain as _chain
from .termformatconstants import FG_COLORS, BG_COLORS, STYLES
from .formatstring import fmtstr
for att in _chain(FG_COLORS, ('on_'+x for x in BG_COLORS), STYLES):
locals()[att] = _partial(fmtstr, style=att)
plain = _partial(fmtstr)
if __name__ == '__main__':
import doctest
doctest.testmod()
print((blue('adf')))
print((blue(on_red('ad'))))
print((blue('asdf') + on_red('adsf')))
print(((blue('asdf') + on_red('adsf'))[3:7]))
f = blue('hey there') + on_red(' Tom!')
print(f)
f[1:3] = 'ot'
print((repr(f)))
print(f)
f = on_blue(red('stuff'))
print((repr(f)))
print((repr(str(f))))
print(f)
print(((f + '!')[0:6] + '?'))
import re as _re
from spruce.collections import frozenusetset as _frozenusetset
from ... import digest as _digest
from .. import _std as _std_http
_DIGEST_USER_OPTIONAL_TOKENS = ('qop', 'digest_algorithm', 'client_nonce',
'opaque', 'server_nonce_use_count')
_DIGEST_USER_REQUIRED_TOKENS = ('user', 'realm', 'server_nonce', 'digest_uri',
'digest')
_DIGEST_USER_TOKENSETS = \
_frozenusetset(_chain(_DIGEST_USER_REQUIRED_TOKENS, optional_tokens)
for optional_tokens
in _chain((),
*(_combinations(_DIGEST_USER_OPTIONAL_TOKENS,
n + 1)
for n
in range(len(_DIGEST_USER_OPTIONAL_TOKENS)))))
class HttpDigestClerk(_std_http.HttpStandardClerk):
"""An authentication clerk for HTTP Digest authentication"""
__metaclass__ = _abc.ABCMeta
_DIGEST_USER_OPTIONAL_TOKENS = _DIGEST_USER_OPTIONAL_TOKENS
'CST': -6,
'MDT': -6,
'MST': -7,
'PDT': -7,
'PST': -8,
}
"""
A mapping of names to offset hours for the obsolete time zone names
specified by :rfc:`Internet Message Format Obsolete Date and Time \
<5322#section-4.3>`
:type: {:obj:`str`: :obj:`int`}
"""
for military_tz_name in (chr(ord_) for ord_ in _chain(range(65, 74),
range(75, 91),
range(97, 106),
range(107, 122))):
RFC5322_OBSOLETE_TZ_HOURS_BY_NAME[military_tz_name] = 0
del military_tz_name
RFC5322_OBSOLETE_TZ_NAMES_RE = \
_re.compile('|'.join(RFC5322_OBSOLETE_TZ_HOURS_BY_NAME.keys()) + '$')
"""
A regular expression that matches any of the obsolete time zone names
specified by :rfc:`Internet Message Format Obsolete Date and Time \
<5322#section-4.3>`
:type: :class:`re.RegexObject`
"""
def tokens_combinations(tokens_or_names):
names = tokens_names(tokens_or_names)
return _chain(*(_combinations(names, ntokens)
for ntokens in range(len(names) + 1)))
def extras(self):
return set(_chain(*(dist.extras for dist in self.dists)))
def requirements(self, extras=()):
return set(_chain(*(dist.requires(extras=extras)
for dist in self.dists)))
def projects_dists_iter(projects):
return _chain(*(project.dists for project in projects))
def tdfilesiterschain(filenames, default=_stdin):
"""return chained iterator for the sequence of files, or the default"""
return _chain(*tdfilesiters(filenames, default))
def __iter__(self):
return _chain(*self._items_by_name.values())
