def _lower_neighbors(
dist_mat: array_like_2d, max_scale: tc.any(int, float)
) -> tc.list_of(tc.list_of(np.int32)):
"""
Converts a distance matrix to neighbor information.
Takes a square, possibly lower triangular, and returns a list of lists of neighbor indices,
for neighbors up to the specified scale.
Parameters
----------
dist_mat: 2D array
the distance matrix, which may be lower triangular
max_scale: float
the highest scale (distance) to consider
Returns
-------
neighbors: list of lists of int
"""
d = sp.lil_matrix(dist_mat)
d[d == 0] = sys.float_info.epsilon
d[np.diag_indices(d.shape[0])] = 0
d[d > max_scale] = 0
d = sp.tril(d)
result = [[] for i in range(d.shape[0])]
for k, v in np.transpose(d.nonzero()):
result[k].append(v)
return result
def __init__(self,
*,
timeout: optional(float) = None,
interface: optional(str) = None,
protocol: optional(str) = None,
parameters: optional(dict) = None,
description: optional(str) = None,
log_levels: optional(list_of(int)) = None):
# infinite "requests" can only be anonymous, "normal" requests
# having a deadline must be assigned an interface and protocol
self._start = time()
if timeout is not None:
self._deadline = self._start + timeout
assert interface is not None and protocol is not None, \
"request with deadline from unspecified interface/protocol"
else:
self._deadline = None
assert interface is None and protocol is None, \
"infinite request from specific interface/protocol"
self._interface, self._protocol = interface, protocol
self._parameters = parameters or {}
request_time = strftime("%Y%m%d%H%M%S")
random_id = b2a_hex(urandom(6)).decode("ascii").upper()
self._unique_id = "RQ-{0:s}-{1:s}".format(request_time, random_id)
self._description = description
self._log_levels = (log_levels or [])[:]
def _add_cofaces(lower_neighbors: tc.list_of(tc.list_of(np.int32)),
max_dim: int, dist_mat: array_like_2d, start: int):
"""
Returns all cofaces for the given start node.
Cofaces are represented by lists of indices, paired with their stepwise distance from the start node.
Parameters
----------
lower_neighbors: list of lists of int
neighbors for each index, as returned by the `_lower_neighbors` function
max_dim: int
the largest simplex dimension to consider
dist_mat: 2D array
the distance matrix, which may be lower triangular
Returns
-------
simplices: list of (coface, distance) pairs
"""
# TODO: iterative implementation (maybe), since Python doesn't have tailcall elimination
simplices = []
def coface(tau, tau_dist, N):
simplices.append((tau, tau_dist))
if len(tau) >= max_dim + 1 or len(N) == 0:
return
else:
for v in N:
sigma = tau + [v]
M = [val for val in N if val in lower_neighbors[v]]
# get the distance at which sigma appears
sigma_dist = max(tau_dist, *[dist_mat[u][v] for u in tau])
coface(sigma, sigma_dist, M)
coface([start], 0, lower_neighbors[start])
return simplices
def foo_l(x: tc.list_of(int)) -> tc.list_of(float):
return list(map(float, x))
def _reload(self, filename, request):
re = self._module is not None and "re" or ""
self._loader.log.message("{0:s}loading module {1:s} from {2:s}".\
format(re, self._name, filename))
try:
# managing imports requires holding a global lock
acquire_imp_lock()
try:
if self._name in sys_modules:
raise ModuleAlreadyImportedError("module {0:s} has already been "
"imported".format(self._name))
with open(filename, "rb") as module:
ext = os_path.splitext(filename)[1]
assert valid_module_ext(ext)
if ext == ".py":
# as a simple guard against picking up incomplete files,
# being simultaneously written to, we require the modules
# to end with # EOF
try:
next(filter(lambda s: s.rstrip() == b"# EOF", module))
except StopIteration:
raise ModuleFileIncompleteError("file {0:s} is incomplete, does not "
"end with # EOF".format(filename))
else:
module.seek(0) # rewind the file
# actually import the module, it can already be broken
# again at this point, but we don't care
try:
load_module(self._name, module, filename, ("", "rb", ext == ".py" and PY_SOURCE or PY_COMPILED))
except Exception as e:
raise ModuleFileBrokenError("file {0:s} is broken: {1:s}".format(filename, e))
# the pmnc-accessible modules are invisible in sys.modules
module = sys_modules.pop(self._name)
# see if the loaded module has __all__ attribute,
# and if not provide a default empty list
all = getattr(module, "__all__", None)
if all is None:
setattr(module, "__all__", [])
self._loader.log.warning("module {0:s} has no __all__ attribute and will "
"export no methods or classes".format(self._name))
else:
assert list_of(str)(all), "__all__ attribute must be a list of strings"
# append self_test method to a list of accessible
# methods for the module being tested
if request.self_test == self._name:
all.append("self_test")
finally:
release_imp_lock()
# the module has been successfully loaded from the file
try:
# the newly imported module should have just one reference to it
if getrefcount(module) != 2:
raise ModuleWithDependenciesError("the newly loaded module {0:s} has "
"unexpected dependencies".format(self._name))
# a module containing __reloadable__ = False is assumed
# to have state and hence be not reloadable
reloadable = bool(getattr(module, "__reloadable__", True))
# the imported module is instrumented with pmnc and others
setattr(module, "pmnc", ModuleLoaderProxy(self._loader, self._name))
setattr(module, "__node__", self._loader._node_name)
setattr(module, "__cage__", self._loader._cage_name)
setattr(module, "__module__", self._name)
setattr(module, "__cage_dir__", self._loader._cage_directory)
# success, the methods cache is cleared and the previous version is discarded
with self._lock:
self._attrs.clear()
self._module, module, self._reloadable = module, self._module, reloadable
finally:
del module
except ModuleLoaderError as e:
if self._module is not None:
self._loader.log.message("reloading of module {0:s} failed: {1:s} (the error "
"is ignored)".format(self._name, str(e)))
else:
raise
else:
self._loader.log.message("module {0:s} has been {1:s}loaded{2:s}".format(self._name, re,
not reloadable and " (not reloadable)" or ""))
def __init__(self, cursor_ids: list_of(int)):
MongoDB_Request.__init__(self)
self._cursor_ids = cursor_ids
def __init__(self, collection: str, documents: list_of(dict)):
MongoDB_Request.__init__(self)
self._collection = collection
self._documents = documents
def foo(x: tc.list_of((tc.has("^[01]+$"), int))) -> bool:
return functools.reduce(lambda r, e: r and int(e[0], 2) == e[1],
x, True)
with expected(InputParameterError("foo() has got an incompatible value for x: ()")):
foo(())
###################
@typecheck
def foo(x: tc.list_of((tc.has("^[01]+$"), int))) -> bool:
return functools.reduce(lambda r, e: r and int(e[0], 2) == e[1],
x, True)
assert foo([("1010", 10), ("0101", 5)])
assert not foo([("1010", 10), ("0111", 77)])
###################
assert tc.list_of(tc.optional(tc.has("^foo$")))(["foo", None, "foo"]) and \
tc.list_of(tc.optional(tc.has("^foo$"))).check(["foo", None, "foo"])
assert not tc.list_of(tc.optional(tc.has("^foo$")))(["123", None, "foo"]) and \
not tc.list_of(tc.optional(tc.has("^foo$"))).check(["123", None, "foo"])
print("ok")
############################################################################
print("sequence_of: ", end="")
@typecheck
def foo(x: tc.sequence_of(int)) -> tc.sequence_of(float):
return list(map(float, x))
# noinspection PyPackageRequirements
import typecheck as tc
import sys
import scipy.sparse as sp
import types
import collections
def numpy_2d_float(x):
"""Type predicate: a numpy array containing floating point values"""
return isinstance(x, (np.ndarray, np.generic)) and len(
x.shape) == 2 and x.dtype in (np.float32, np.float64)
"""Type predicate: something like a 2D array"""
array_like_2d = tc.any(tc.list_of(tc.list_of(tc.any(int,
float))), numpy_2d_float,
sp.lil_matrix, sp.csc_matrix, sp.csr_matrix)
@tc.typecheck
def _lower_neighbors(
dist_mat: array_like_2d, max_scale: tc.any(int, float)
) -> tc.list_of(tc.list_of(np.int32)):
"""
Converts a distance matrix to neighbor information.
Takes a square, possibly lower triangular, and returns a list of lists of neighbor indices,
for neighbors up to the specified scale.
Parameters
----------
def _kill_cursors(self, collection: empty_string, cursor_ids: list_of(int),
**kwargs):
self._async_request(OP_KILL_CURSORS(cursor_ids, **kwargs))
def _insert(self, collection: valid_collection, documents: list_of(dict)):
collection = "{0:s}.{1:s}".format(self._database, collection)
self._async_request(OP_INSERT(collection, documents))
def foo_l(x: tc.list_of(int)) -> tc.list_of(float):
return list(map(float, x))
def _frag_message(message: bytes, bits_per_char: optional(int) = 8,
frag_bytes: optional(int) = 140, prefix_bytes: optional(int) = 0) -> list_of(bytes):
if not message:
return [ message ]
bpc = bits_per_char
pad_bits = (bpc - prefix_bytes * 8 % bpc) % bpc if (bpc < 8 and prefix_bytes > 0) else 0 # 7 bit left padding to septet
mbpf = frag_bytes - prefix_bytes - (1 if pad_bits > 0 else 0) # maximum bytes per fragment we could squeeze
# each fragment should contain full characters, with 7 bit encoding
# we round each fragment up to 7 bytes to guarantee that
bpp = bpc if bpc % 8 != 0 else bpc // 8
if mbpf < bpp:
raise Exception("fragment size {0:d} is too small".format(frag_bytes))
bpf = mbpf // bpp * bpp
# note that escape sequences are not honored and could be split
frags, frag, message = [], message[:bpf], message[bpf:]
while frag:
# each fragment is padded independently
if pad_bits > 0:
pbb, pbm, nbb = pad_bits, (1 << pad_bits) - 1, 8 - pad_bits
pb, fb = 0, []
for b in frag:
fb.append(pb << nbb | b >> pbb)
pb = b & pbm
fb.append(pb << nbb)
frag = bytes(fb)
frags.append(frag)
frag, message = message[:bpf], message[bpf:]
return frags
