_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q274700 | _maybe_class_to_py_ast | test | def _maybe_class_to_py_ast(_: GeneratorContext, node: MaybeClass) -> GeneratedPyAST:
"""Generate a Python AST node for accessing a potential Python module
variable name."""
assert node.op == NodeOp.MAYBE_CLASS
return GeneratedPyAST(
node=ast.Name(
id=Maybe(_MODULE_ALIASES.get(node.class_)).or_else_get(node.class_),
ctx=ast.Load(),
)
) | python | {
"resource": ""
} |
q274701 | _maybe_host_form_to_py_ast | test | def _maybe_host_form_to_py_ast(
_: GeneratorContext, node: MaybeHostForm
) -> GeneratedPyAST:
"""Generate a Python AST node for accessing a potential Python module
variable name with a namespace."""
assert node.op == NodeOp.MAYBE_HOST_FORM
return GeneratedPyAST(
node=_load_attr(
f"{Maybe(_MODULE_ALIASES.get(node.class_)).or_else_get(node.class_)}.{node.field}"
)
) | python | {
"resource": ""
} |
q274702 | _const_val_to_py_ast | test | def _const_val_to_py_ast(ctx: GeneratorContext, form: LispForm) -> GeneratedPyAST:
"""Generate Python AST nodes for constant Lisp forms.
Nested values in collections for :const nodes are not parsed, so recursive
structures need to call into this function to generate Python AST nodes for
nested elements. For top-level :const Lisp AST nodes, see
`_const_node_to_py_ast`."""
handle_value = _CONST_VALUE_HANDLERS.get(type(form))
if handle_value is None and isinstance(form, ISeq):
handle_value = _const_seq_to_py_ast # type: ignore
assert handle_value is not None, "A type handler must be defined for constants"
return handle_value(ctx, form) | python | {
"resource": ""
} |
q274703 | _collection_literal_to_py_ast | test | def _collection_literal_to_py_ast(
ctx: GeneratorContext, form: Iterable[LispForm]
) -> Iterable[GeneratedPyAST]:
"""Turn a quoted collection literal of Lisp forms into Python AST nodes.
This function can only handle constant values. It does not call back into
the generic AST generators, so only constant values will be generated down
this path."""
yield from map(partial(_const_val_to_py_ast, ctx), form) | python | {
"resource": ""
} |
q274704 | gen_py_ast | test | def gen_py_ast(ctx: GeneratorContext, lisp_ast: Node) -> GeneratedPyAST:
"""Take a Lisp AST node as an argument and produce zero or more Python
AST nodes.
This is the primary entrypoint for generating AST nodes from Lisp
syntax. It may be called recursively to compile child forms."""
op: NodeOp = lisp_ast.op
assert op is not None, "Lisp AST nodes must have an :op key"
handle_node = _NODE_HANDLERS.get(op)
assert (
handle_node is not None
), f"Lisp AST nodes :op has no handler defined for op {op}"
return handle_node(ctx, lisp_ast) | python | {
"resource": ""
} |
q274705 | _module_imports | test | def _module_imports(ctx: GeneratorContext) -> Iterable[ast.Import]:
"""Generate the Python Import AST node for importing all required
language support modules."""
# Yield `import basilisp` so code attempting to call fully qualified
# `basilisp.lang...` modules don't result in compiler errors
yield ast.Import(names=[ast.alias(name="basilisp", asname=None)])
for imp in ctx.imports:
name = imp.key.name
alias = _MODULE_ALIASES.get(name, None)
yield ast.Import(names=[ast.alias(name=name, asname=alias)]) | python | {
"resource": ""
} |
q274706 | _from_module_import | test | def _from_module_import() -> ast.ImportFrom:
"""Generate the Python From ... Import AST node for importing
language support modules."""
return ast.ImportFrom(
module="basilisp.lang.runtime",
names=[ast.alias(name="Var", asname=_VAR_ALIAS)],
level=0,
) | python | {
"resource": ""
} |
q274707 | _ns_var | test | def _ns_var(
py_ns_var: str = _NS_VAR, lisp_ns_var: str = LISP_NS_VAR, lisp_ns_ns: str = CORE_NS
) -> ast.Assign:
"""Assign a Python variable named `ns_var` to the value of the current
namespace."""
return ast.Assign(
targets=[ast.Name(id=py_ns_var, ctx=ast.Store())],
value=ast.Call(
func=_FIND_VAR_FN_NAME,
args=[
ast.Call(
func=_NEW_SYM_FN_NAME,
args=[ast.Str(lisp_ns_var)],
keywords=[ast.keyword(arg="ns", value=ast.Str(lisp_ns_ns))],
)
],
keywords=[],
),
) | python | {
"resource": ""
} |
q274708 | set | test | def set(members: Iterable[T], meta=None) -> Set[T]: # pylint:disable=redefined-builtin
"""Creates a new set."""
return Set(pset(members), meta=meta) | python | {
"resource": ""
} |
q274709 | s | test | def s(*members: T, meta=None) -> Set[T]:
"""Creates a new set from members."""
return Set(pset(members), meta=meta) | python | {
"resource": ""
} |
q274710 | PythonASTOptimizer.visit_ExceptHandler | test | def visit_ExceptHandler(self, node: ast.ExceptHandler) -> Optional[ast.AST]:
"""Eliminate dead code from except handler bodies."""
new_node = self.generic_visit(node)
assert isinstance(new_node, ast.ExceptHandler)
return ast.copy_location(
ast.ExceptHandler(
type=new_node.type,
name=new_node.name,
body=_filter_dead_code(new_node.body),
),
new_node,
) | python | {
"resource": ""
} |
q274711 | PythonASTOptimizer.visit_Expr | test | def visit_Expr(self, node: ast.Expr) -> Optional[ast.Expr]:
"""Eliminate no-op constant expressions which are in the tree
as standalone statements."""
if isinstance(
node.value,
(
ast.Constant, # type: ignore
ast.Name,
ast.NameConstant,
ast.Num,
ast.Str,
),
):
return None
return node | python | {
"resource": ""
} |
q274712 | PythonASTOptimizer.visit_FunctionDef | test | def visit_FunctionDef(self, node: ast.FunctionDef) -> Optional[ast.AST]:
"""Eliminate dead code from function bodies."""
new_node = self.generic_visit(node)
assert isinstance(new_node, ast.FunctionDef)
return ast.copy_location(
ast.FunctionDef(
name=new_node.name,
args=new_node.args,
body=_filter_dead_code(new_node.body),
decorator_list=new_node.decorator_list,
returns=new_node.returns,
),
new_node,
) | python | {
"resource": ""
} |
q274713 | PythonASTOptimizer.visit_While | test | def visit_While(self, node: ast.While) -> Optional[ast.AST]:
"""Eliminate dead code from while bodies."""
new_node = self.generic_visit(node)
assert isinstance(new_node, ast.While)
return ast.copy_location(
ast.While(
test=new_node.test,
body=_filter_dead_code(new_node.body),
orelse=_filter_dead_code(new_node.orelse),
),
new_node,
) | python | {
"resource": ""
} |
q274714 | PythonASTOptimizer.visit_Try | test | def visit_Try(self, node: ast.Try) -> Optional[ast.AST]:
"""Eliminate dead code from except try bodies."""
new_node = self.generic_visit(node)
assert isinstance(new_node, ast.Try)
return ast.copy_location(
ast.Try(
body=_filter_dead_code(new_node.body),
handlers=new_node.handlers,
orelse=_filter_dead_code(new_node.orelse),
finalbody=_filter_dead_code(new_node.finalbody),
),
new_node,
) | python | {
"resource": ""
} |
q274715 | _new_module | test | def _new_module(name: str, doc=None) -> types.ModuleType:
"""Create a new empty Basilisp Python module.
Modules are created for each Namespace when it is created."""
mod = types.ModuleType(name, doc=doc)
mod.__loader__ = None
mod.__package__ = None
mod.__spec__ = None
mod.__basilisp_bootstrapped__ = False # type: ignore
return mod | python | {
"resource": ""
} |
q274716 | first | test | def first(o):
"""If o is a ISeq, return the first element from o. If o is None, return
None. Otherwise, coerces o to a Seq and returns the first."""
if o is None:
return None
if isinstance(o, ISeq):
return o.first
s = to_seq(o)
if s is None:
return None
return s.first | python | {
"resource": ""
} |
q274717 | rest | test | def rest(o) -> Optional[ISeq]:
"""If o is a ISeq, return the elements after the first in o. If o is None,
returns an empty seq. Otherwise, coerces o to a seq and returns the rest."""
if o is None:
return None
if isinstance(o, ISeq):
s = o.rest
if s is None:
return lseq.EMPTY
return s
n = to_seq(o)
if n is None:
return lseq.EMPTY
return n.rest | python | {
"resource": ""
} |
q274718 | nthrest | test | def nthrest(coll, i: int):
"""Returns the nth rest sequence of coll, or coll if i is 0."""
while True:
if coll is None:
return None
if i == 0:
return coll
i -= 1
coll = rest(coll) | python | {
"resource": ""
} |
q274719 | nthnext | test | def nthnext(coll, i: int) -> Optional[ISeq]:
"""Returns the nth next sequence of coll."""
while True:
if coll is None:
return None
if i == 0:
return to_seq(coll)
i -= 1
coll = next_(coll) | python | {
"resource": ""
} |
q274720 | cons | test | def cons(o, seq) -> ISeq:
"""Creates a new sequence where o is the first element and seq is the rest.
If seq is None, return a list containing o. If seq is not a ISeq, attempt
to coerce it to a ISeq and then cons o onto the resulting sequence."""
if seq is None:
return llist.l(o)
if isinstance(seq, ISeq):
return seq.cons(o)
return Maybe(to_seq(seq)).map(lambda s: s.cons(o)).or_else(lambda: llist.l(o)) | python | {
"resource": ""
} |
q274721 | to_seq | test | def to_seq(o) -> Optional[ISeq]:
"""Coerce the argument o to a ISeq. If o is None, return None."""
if o is None:
return None
if isinstance(o, ISeq):
return _seq_or_nil(o)
if isinstance(o, ISeqable):
return _seq_or_nil(o.seq())
return _seq_or_nil(lseq.sequence(o)) | python | {
"resource": ""
} |
q274722 | concat | test | def concat(*seqs) -> ISeq:
"""Concatenate the sequences given by seqs into a single ISeq."""
allseqs = lseq.sequence(itertools.chain(*filter(None, map(to_seq, seqs))))
if allseqs is None:
return lseq.EMPTY
return allseqs | python | {
"resource": ""
} |
q274723 | assoc | test | def assoc(m, *kvs):
"""Associate keys to values in associative data structure m. If m is None,
returns a new Map with key-values kvs."""
if m is None:
return lmap.Map.empty().assoc(*kvs)
if isinstance(m, IAssociative):
return m.assoc(*kvs)
raise TypeError(
f"Object of type {type(m)} does not implement Associative interface"
) | python | {
"resource": ""
} |
q274724 | conj | test | def conj(coll, *xs):
"""Conjoin xs to collection. New elements may be added in different positions
depending on the type of coll. conj returns the same type as coll. If coll
is None, return a list with xs conjoined."""
if coll is None:
l = llist.List.empty()
return l.cons(*xs)
if isinstance(coll, IPersistentCollection):
return coll.cons(*xs)
raise TypeError(
f"Object of type {type(coll)} does not implement Collection interface"
) | python | {
"resource": ""
} |
q274725 | partial | test | def partial(f, *args):
"""Return a function which is the partial application of f with args."""
@functools.wraps(f)
def partial_f(*inner_args):
return f(*itertools.chain(args, inner_args))
return partial_f | python | {
"resource": ""
} |
q274726 | deref | test | def deref(o, timeout_s=None, timeout_val=None):
"""Dereference a Deref object and return its contents.
If o is an object implementing IBlockingDeref and timeout_s and
timeout_val are supplied, deref will wait at most timeout_s seconds,
returning timeout_val if timeout_s seconds elapse and o has not
returned."""
if isinstance(o, IDeref):
return o.deref()
elif isinstance(o, IBlockingDeref):
return o.deref(timeout_s, timeout_val)
raise TypeError(f"Object of type {type(o)} cannot be dereferenced") | python | {
"resource": ""
} |
q274727 | equals | test | def equals(v1, v2) -> bool:
"""Compare two objects by value. Unlike the standard Python equality operator,
this function does not consider 1 == True or 0 == False. All other equality
operations are the same and performed using Python's equality operator."""
if isinstance(v1, (bool, type(None))) or isinstance(v2, (bool, type(None))):
return v1 is v2
return v1 == v2 | python | {
"resource": ""
} |
q274728 | divide | test | def divide(x: LispNumber, y: LispNumber) -> LispNumber:
"""Division reducer. If both arguments are integers, return a Fraction.
Otherwise, return the true division of x and y."""
if isinstance(x, int) and isinstance(y, int):
return Fraction(x, y)
return x / y | python | {
"resource": ""
} |
q274729 | sort | test | def sort(coll, f=None) -> Optional[ISeq]:
"""Return a sorted sequence of the elements in coll. If a comparator
function f is provided, compare elements in coll using f."""
return to_seq(sorted(coll, key=Maybe(f).map(functools.cmp_to_key).value)) | python | {
"resource": ""
} |
q274730 | contains | test | def contains(coll, k):
"""Return true if o contains the key k."""
if isinstance(coll, IAssociative):
return coll.contains(k)
return k in coll | python | {
"resource": ""
} |
q274731 | get | test | def get(m, k, default=None):
"""Return the value of k in m. Return default if k not found in m."""
if isinstance(m, IAssociative):
return m.entry(k, default=default)
try:
return m[k]
except (KeyError, IndexError, TypeError) as e:
logger.debug("Ignored %s: %s", type(e).__name__, e)
return default | python | {
"resource": ""
} |
q274732 | to_lisp | test | def to_lisp(o, keywordize_keys: bool = True):
"""Recursively convert Python collections into Lisp collections."""
if not isinstance(o, (dict, frozenset, list, set, tuple)):
return o
else: # pragma: no cover
return _to_lisp_backup(o, keywordize_keys=keywordize_keys) | python | {
"resource": ""
} |
q274733 | to_py | test | def to_py(o, keyword_fn: Callable[[kw.Keyword], Any] = _kw_name):
"""Recursively convert Lisp collections into Python collections."""
if isinstance(o, ISeq):
return _to_py_list(o, keyword_fn=keyword_fn)
elif not isinstance(
o, (IPersistentList, IPersistentMap, IPersistentSet, IPersistentVector)
):
return o
else: # pragma: no cover
return _to_py_backup(o, keyword_fn=keyword_fn) | python | {
"resource": ""
} |
q274734 | lrepr | test | def lrepr(o, human_readable: bool = False) -> str:
"""Produce a string representation of an object. If human_readable is False,
the string representation of Lisp objects is something that can be read back
in by the reader as the same object."""
core_ns = Namespace.get(sym.symbol(CORE_NS))
assert core_ns is not None
return lobj.lrepr(
o,
human_readable=human_readable,
print_dup=core_ns.find(sym.symbol(_PRINT_DUP_VAR_NAME)).value, # type: ignore
print_length=core_ns.find( # type: ignore
sym.symbol(_PRINT_LENGTH_VAR_NAME)
).value,
print_level=core_ns.find( # type: ignore
sym.symbol(_PRINT_LEVEL_VAR_NAME)
).value,
print_meta=core_ns.find(sym.symbol(_PRINT_META_VAR_NAME)).value, # type: ignore
print_readably=core_ns.find( # type: ignore
sym.symbol(_PRINT_READABLY_VAR_NAME)
).value,
) | python | {
"resource": ""
} |
q274735 | _collect_args | test | def _collect_args(args) -> ISeq:
"""Collect Python starred arguments into a Basilisp list."""
if isinstance(args, tuple):
return llist.list(args)
raise TypeError("Python variadic arguments should always be a tuple") | python | {
"resource": ""
} |
q274736 | _trampoline | test | def _trampoline(f):
"""Trampoline a function repeatedly until it is finished recurring to help
avoid stack growth."""
@functools.wraps(f)
def trampoline(*args, **kwargs):
while True:
ret = f(*args, **kwargs)
if isinstance(ret, _TrampolineArgs):
args = ret.args
kwargs = ret.kwargs
continue
return ret
return trampoline | python | {
"resource": ""
} |
q274737 | _with_attrs | test | def _with_attrs(**kwargs):
"""Decorator to set attributes on a function. Returns the original
function after setting the attributes named by the keyword arguments."""
def decorator(f):
for k, v in kwargs.items():
setattr(f, k, v)
return f
return decorator | python | {
"resource": ""
} |
q274738 | _fn_with_meta | test | def _fn_with_meta(f, meta: Optional[lmap.Map]):
"""Return a new function with the given meta. If the function f already
has a meta map, then merge the """
if not isinstance(meta, lmap.Map):
raise TypeError("meta must be a map")
if inspect.iscoroutinefunction(f):
@functools.wraps(f)
async def wrapped_f(*args, **kwargs):
return await f(*args, **kwargs)
else:
@functools.wraps(f) # type: ignore
def wrapped_f(*args, **kwargs):
return f(*args, **kwargs)
wrapped_f.meta = ( # type: ignore
f.meta.update(meta)
if hasattr(f, "meta") and isinstance(f.meta, lmap.Map)
else meta
)
wrapped_f.with_meta = partial(_fn_with_meta, wrapped_f) # type: ignore
return wrapped_f | python | {
"resource": ""
} |
q274739 | _basilisp_fn | test | def _basilisp_fn(f):
"""Create a Basilisp function, setting meta and supplying a with_meta
method implementation."""
assert not hasattr(f, "meta")
f._basilisp_fn = True
f.meta = None
f.with_meta = partial(_fn_with_meta, f)
return f | python | {
"resource": ""
} |
q274740 | resolve_alias | test | def resolve_alias(s: sym.Symbol, ns: Optional[Namespace] = None) -> sym.Symbol:
"""Resolve the aliased symbol in the current namespace."""
if s in _SPECIAL_FORMS:
return s
ns = Maybe(ns).or_else(get_current_ns)
if s.ns is not None:
aliased_ns = ns.get_alias(sym.symbol(s.ns))
if aliased_ns is not None:
return sym.symbol(s.name, aliased_ns.name)
else:
return s
else:
which_var = ns.find(sym.symbol(s.name))
if which_var is not None:
return sym.symbol(which_var.name.name, which_var.ns.name)
else:
return sym.symbol(s.name, ns=ns.name) | python | {
"resource": ""
} |
q274741 | resolve_var | test | def resolve_var(s: sym.Symbol, ns: Optional[Namespace] = None) -> Optional[Var]:
"""Resolve the aliased symbol to a Var from the specified
namespace, or the current namespace if none is specified."""
return Var.find(resolve_alias(s, ns)) | python | {
"resource": ""
} |
q274742 | add_generated_python | test | def add_generated_python(
generated_python: str,
var_name: str = _GENERATED_PYTHON_VAR_NAME,
which_ns: Optional[str] = None,
) -> None:
"""Add generated Python code to a dynamic variable in which_ns."""
if which_ns is None:
which_ns = get_current_ns().name
ns_sym = sym.Symbol(var_name, ns=which_ns)
v = Maybe(Var.find(ns_sym)).or_else(
lambda: Var.intern(
sym.symbol(which_ns), # type: ignore
sym.symbol(var_name),
"",
dynamic=True,
meta=lmap.map({_PRIVATE_META_KEY: True}),
)
)
v.value = v.value + generated_python | python | {
"resource": ""
} |
q274743 | bootstrap | test | def bootstrap(ns_var_name: str = NS_VAR_NAME, core_ns_name: str = CORE_NS) -> None:
"""Bootstrap the environment with functions that are are difficult to
express with the very minimal lisp environment."""
core_ns_sym = sym.symbol(core_ns_name)
ns_var_sym = sym.symbol(ns_var_name, ns=core_ns_name)
__NS = Maybe(Var.find(ns_var_sym)).or_else_raise(
lambda: RuntimeException(f"Dynamic Var {ns_var_sym} not bound!")
)
def in_ns(s: sym.Symbol):
ns = Namespace.get_or_create(s)
__NS.value = ns
return ns
Var.intern_unbound(core_ns_sym, sym.symbol("unquote"))
Var.intern_unbound(core_ns_sym, sym.symbol("unquote-splicing"))
Var.intern(
core_ns_sym, sym.symbol("in-ns"), in_ns, meta=lmap.map({_REDEF_META_KEY: True})
)
Var.intern(
core_ns_sym,
sym.symbol(_PRINT_GENERATED_PY_VAR_NAME),
False,
dynamic=True,
meta=lmap.map({_PRIVATE_META_KEY: True}),
)
Var.intern(
core_ns_sym,
sym.symbol(_GENERATED_PYTHON_VAR_NAME),
"",
dynamic=True,
meta=lmap.map({_PRIVATE_META_KEY: True}),
)
# Dynamic Vars for controlling printing
Var.intern(
core_ns_sym, sym.symbol(_PRINT_DUP_VAR_NAME), lobj.PRINT_DUP, dynamic=True
)
Var.intern(
core_ns_sym, sym.symbol(_PRINT_LENGTH_VAR_NAME), lobj.PRINT_LENGTH, dynamic=True
)
Var.intern(
core_ns_sym, sym.symbol(_PRINT_LEVEL_VAR_NAME), lobj.PRINT_LEVEL, dynamic=True
)
Var.intern(
core_ns_sym, sym.symbol(_PRINT_META_VAR_NAME), lobj.PRINT_META, dynamic=True
)
Var.intern(
core_ns_sym,
sym.symbol(_PRINT_READABLY_VAR_NAME),
lobj.PRINT_READABLY,
dynamic=True,
) | python | {
"resource": ""
} |
q274744 | Var.intern | test | def intern(
ns: sym.Symbol, name: sym.Symbol, val, dynamic: bool = False, meta=None
) -> "Var":
"""Intern the value bound to the symbol `name` in namespace `ns`."""
var_ns = Namespace.get_or_create(ns)
var = var_ns.intern(name, Var(var_ns, name, dynamic=dynamic, meta=meta))
var.root = val
return var | python | {
"resource": ""
} |
q274745 | Var.intern_unbound | test | def intern_unbound(
ns: sym.Symbol, name: sym.Symbol, dynamic: bool = False, meta=None
) -> "Var":
"""Create a new unbound `Var` instance to the symbol `name` in namespace `ns`."""
var_ns = Namespace.get_or_create(ns)
return var_ns.intern(name, Var(var_ns, name, dynamic=dynamic, meta=meta)) | python | {
"resource": ""
} |
q274746 | Var.find_in_ns | test | def find_in_ns(ns_sym: sym.Symbol, name_sym: sym.Symbol) -> "Optional[Var]":
"""Return the value current bound to the name `name_sym` in the namespace
specified by `ns_sym`."""
ns = Namespace.get(ns_sym)
if ns:
return ns.find(name_sym)
return None | python | {
"resource": ""
} |
q274747 | Var.find | test | def find(ns_qualified_sym: sym.Symbol) -> "Optional[Var]":
"""Return the value currently bound to the name in the namespace specified
by `ns_qualified_sym`."""
ns = Maybe(ns_qualified_sym.ns).or_else_raise(
lambda: ValueError(
f"Namespace must be specified in Symbol {ns_qualified_sym}"
)
)
ns_sym = sym.symbol(ns)
name_sym = sym.symbol(ns_qualified_sym.name)
return Var.find_in_ns(ns_sym, name_sym) | python | {
"resource": ""
} |
q274748 | Var.find_safe | test | def find_safe(ns_qualified_sym: sym.Symbol) -> "Var":
"""Return the Var currently bound to the name in the namespace specified
by `ns_qualified_sym`. If no Var is bound to that name, raise an exception.
This is a utility method to return useful debugging information when code
refers to an invalid symbol at runtime."""
v = Var.find(ns_qualified_sym)
if v is None:
raise RuntimeException(
f"Unable to resolve symbol {ns_qualified_sym} in this context"
)
return v | python | {
"resource": ""
} |
q274749 | Namespace.add_default_import | test | def add_default_import(cls, module: str):
"""Add a gated default import to the default imports.
In particular, we need to avoid importing 'basilisp.core' before we have
finished macro-expanding."""
if module in cls.GATED_IMPORTS:
cls.DEFAULT_IMPORTS.swap(lambda s: s.cons(sym.symbol(module))) | python | {
"resource": ""
} |
q274750 | Namespace.add_alias | test | def add_alias(self, alias: sym.Symbol, namespace: "Namespace") -> None:
"""Add a Symbol alias for the given Namespace."""
self._aliases.swap(lambda m: m.assoc(alias, namespace)) | python | {
"resource": ""
} |
q274751 | Namespace.intern | test | def intern(self, sym: sym.Symbol, var: Var, force: bool = False) -> Var:
"""Intern the Var given in this namespace mapped by the given Symbol.
If the Symbol already maps to a Var, this method _will not overwrite_
the existing Var mapping unless the force keyword argument is given
and is True."""
m: lmap.Map = self._interns.swap(Namespace._intern, sym, var, force=force)
return m.entry(sym) | python | {
"resource": ""
} |
q274752 | Namespace._intern | test | def _intern(
m: lmap.Map, sym: sym.Symbol, new_var: Var, force: bool = False
) -> lmap.Map:
"""Swap function used by intern to atomically intern a new variable in
the symbol mapping for this Namespace."""
var = m.entry(sym, None)
if var is None or force:
return m.assoc(sym, new_var)
return m | python | {
"resource": ""
} |
q274753 | Namespace.find | test | def find(self, sym: sym.Symbol) -> Optional[Var]:
"""Find Vars mapped by the given Symbol input or None if no Vars are
mapped by that Symbol."""
v = self.interns.entry(sym, None)
if v is None:
return self.refers.entry(sym, None)
return v | python | {
"resource": ""
} |
q274754 | Namespace.add_import | test | def add_import(
self, sym: sym.Symbol, module: types.ModuleType, *aliases: sym.Symbol
) -> None:
"""Add the Symbol as an imported Symbol in this Namespace. If aliases are given,
the aliases will be applied to the """
self._imports.swap(lambda m: m.assoc(sym, module))
if aliases:
self._import_aliases.swap(
lambda m: m.assoc(
*itertools.chain.from_iterable([(alias, sym) for alias in aliases])
)
) | python | {
"resource": ""
} |
q274755 | Namespace.get_import | test | def get_import(self, sym: sym.Symbol) -> Optional[types.ModuleType]:
"""Return the module if a moduled named by sym has been imported into
this Namespace, None otherwise.
First try to resolve a module directly with the given name. If no module
can be resolved, attempt to resolve the module using import aliases."""
mod = self.imports.entry(sym, None)
if mod is None:
alias = self.import_aliases.get(sym, None)
if alias is None:
return None
return self.imports.entry(alias, None)
return mod | python | {
"resource": ""
} |
q274756 | Namespace.add_refer | test | def add_refer(self, sym: sym.Symbol, var: Var) -> None:
"""Refer var in this namespace under the name sym."""
if not var.is_private:
self._refers.swap(lambda s: s.assoc(sym, var)) | python | {
"resource": ""
} |
q274757 | Namespace.get_refer | test | def get_refer(self, sym: sym.Symbol) -> Optional[Var]:
"""Get the Var referred by Symbol or None if it does not exist."""
return self.refers.entry(sym, None) | python | {
"resource": ""
} |
q274758 | Namespace.__refer_all | test | def __refer_all(cls, refers: lmap.Map, other_ns_interns: lmap.Map) -> lmap.Map:
"""Refer all _public_ interns from another namespace."""
final_refers = refers
for entry in other_ns_interns:
s: sym.Symbol = entry.key
var: Var = entry.value
if not var.is_private:
final_refers = final_refers.assoc(s, var)
return final_refers | python | {
"resource": ""
} |
q274759 | Namespace.refer_all | test | def refer_all(self, other_ns: "Namespace"):
"""Refer all the Vars in the other namespace."""
self._refers.swap(Namespace.__refer_all, other_ns.interns) | python | {
"resource": ""
} |
q274760 | Namespace.__get_or_create | test | def __get_or_create(
ns_cache: NamespaceMap,
name: sym.Symbol,
module: types.ModuleType = None,
core_ns_name=CORE_NS,
) -> lmap.Map:
"""Private swap function used by `get_or_create` to atomically swap
the new namespace map into the global cache."""
ns = ns_cache.entry(name, None)
if ns is not None:
return ns_cache
new_ns = Namespace(name, module=module)
if name.name != core_ns_name:
core_ns = ns_cache.entry(sym.symbol(core_ns_name), None)
assert core_ns is not None, "Core namespace not loaded yet!"
new_ns.refer_all(core_ns)
return ns_cache.assoc(name, new_ns) | python | {
"resource": ""
} |
q274761 | Namespace.get_or_create | test | def get_or_create(
cls, name: sym.Symbol, module: types.ModuleType = None
) -> "Namespace":
"""Get the namespace bound to the symbol `name` in the global namespace
cache, creating it if it does not exist.
Return the namespace."""
return cls._NAMESPACES.swap(Namespace.__get_or_create, name, module=module)[
name
] | python | {
"resource": ""
} |
q274762 | Namespace.get | test | def get(cls, name: sym.Symbol) -> "Optional[Namespace]":
"""Get the namespace bound to the symbol `name` in the global namespace
cache. Return the namespace if it exists or None otherwise.."""
return cls._NAMESPACES.deref().entry(name, None) | python | {
"resource": ""
} |
q274763 | Namespace.remove | test | def remove(cls, name: sym.Symbol) -> Optional["Namespace"]:
"""Remove the namespace bound to the symbol `name` in the global
namespace cache and return that namespace.
Return None if the namespace did not exist in the cache."""
while True:
oldval: lmap.Map = cls._NAMESPACES.deref()
ns: Optional[Namespace] = oldval.entry(name, None)
newval = oldval
if ns is not None:
newval = oldval.dissoc(name)
if cls._NAMESPACES.compare_and_set(oldval, newval):
return ns | python | {
"resource": ""
} |
q274764 | Namespace.__completion_matcher | test | def __completion_matcher(text: str) -> CompletionMatcher:
"""Return a function which matches any symbol keys from map entries
against the given text."""
def is_match(entry: Tuple[sym.Symbol, Any]) -> bool:
return entry[0].name.startswith(text)
return is_match | python | {
"resource": ""
} |
q274765 | Namespace.__complete_alias | test | def __complete_alias(
self, prefix: str, name_in_ns: Optional[str] = None
) -> Iterable[str]:
"""Return an iterable of possible completions matching the given
prefix from the list of aliased namespaces. If name_in_ns is given,
further attempt to refine the list to matching names in that namespace."""
candidates = filter(
Namespace.__completion_matcher(prefix), [(s, n) for s, n in self.aliases]
)
if name_in_ns is not None:
for _, candidate_ns in candidates:
for match in candidate_ns.__complete_interns(
name_in_ns, include_private_vars=False
):
yield f"{prefix}/{match}"
else:
for alias, _ in candidates:
yield f"{alias}/" | python | {
"resource": ""
} |
q274766 | Namespace.__complete_imports_and_aliases | test | def __complete_imports_and_aliases(
self, prefix: str, name_in_module: Optional[str] = None
) -> Iterable[str]:
"""Return an iterable of possible completions matching the given
prefix from the list of imports and aliased imports. If name_in_module
is given, further attempt to refine the list to matching names in that
namespace."""
imports = self.imports
aliases = lmap.map(
{
alias: imports.entry(import_name)
for alias, import_name in self.import_aliases
}
)
candidates = filter(
Namespace.__completion_matcher(prefix), itertools.chain(aliases, imports)
)
if name_in_module is not None:
for _, module in candidates:
for name in module.__dict__:
if name.startswith(name_in_module):
yield f"{prefix}/{name}"
else:
for candidate_name, _ in candidates:
yield f"{candidate_name}/" | python | {
"resource": ""
} |
q274767 | Namespace.__complete_interns | test | def __complete_interns(
self, value: str, include_private_vars: bool = True
) -> Iterable[str]:
"""Return an iterable of possible completions matching the given
prefix from the list of interned Vars."""
if include_private_vars:
is_match = Namespace.__completion_matcher(value)
else:
_is_match = Namespace.__completion_matcher(value)
def is_match(entry: Tuple[sym.Symbol, Var]) -> bool:
return _is_match(entry) and not entry[1].is_private
return map(
lambda entry: f"{entry[0].name}",
filter(is_match, [(s, v) for s, v in self.interns]),
) | python | {
"resource": ""
} |
q274768 | Namespace.__complete_refers | test | def __complete_refers(self, value: str) -> Iterable[str]:
"""Return an iterable of possible completions matching the given
prefix from the list of referred Vars."""
return map(
lambda entry: f"{entry[0].name}",
filter(
Namespace.__completion_matcher(value), [(s, v) for s, v in self.refers]
),
) | python | {
"resource": ""
} |
q274769 | Namespace.complete | test | def complete(self, text: str) -> Iterable[str]:
"""Return an iterable of possible completions for the given text in
this namespace."""
assert not text.startswith(":")
if "/" in text:
prefix, suffix = text.split("/", maxsplit=1)
results = itertools.chain(
self.__complete_alias(prefix, name_in_ns=suffix),
self.__complete_imports_and_aliases(prefix, name_in_module=suffix),
)
else:
results = itertools.chain(
self.__complete_alias(text),
self.__complete_imports_and_aliases(text),
self.__complete_interns(text),
self.__complete_refers(text),
)
return results | python | {
"resource": ""
} |
q274770 | _TrampolineArgs.args | test | def args(self) -> Tuple:
"""Return the arguments for a trampolined function. If the function
that is being trampolined has varargs, unroll the final argument if
it is a sequence."""
if not self._has_varargs:
return self._args
try:
final = self._args[-1]
if isinstance(final, ISeq):
inits = self._args[:-1]
return tuple(itertools.chain(inits, final))
return self._args
except IndexError:
return () | python | {
"resource": ""
} |
q274771 | list | test | def list(members, meta=None) -> List: # pylint:disable=redefined-builtin
"""Creates a new list."""
return List( # pylint: disable=abstract-class-instantiated
plist(iterable=members), meta=meta
) | python | {
"resource": ""
} |
q274772 | l | test | def l(*members, meta=None) -> List:
"""Creates a new list from members."""
return List( # pylint: disable=abstract-class-instantiated
plist(iterable=members), meta=meta
) | python | {
"resource": ""
} |
q274773 | change_style | test | def change_style(style, representer):
"""
This function is used to format the key value as a multi-line string maintaining the line breaks
"""
def new_representer(dumper, data):
scalar = representer(dumper, data)
scalar.style = style
return scalar
return new_representer | python | {
"resource": ""
} |
q274774 | decrypt | test | def decrypt(token, key_store, key_purpose, leeway=120):
"""This decrypts the provided jwe token, then decodes resulting jwt token and returns
the payload.
:param str token: The jwe token.
:param key_store: The key store.
:param str key_purpose: Context for the key.
:param int leeway: Extra allowed time in seconds after expiration to account for clock skew.
:return: The decrypted payload.
"""
tokens = token.split('.')
if len(tokens) != 5:
raise InvalidTokenException("Incorrect number of tokens")
decrypted_token = JWEHelper.decrypt(token, key_store, key_purpose)
payload = JWTHelper.decode(decrypted_token, key_store, key_purpose, leeway)
return payload | python | {
"resource": ""
} |
q274775 | encrypt | test | def encrypt(json, key_store, key_purpose):
"""This encrypts the supplied json and returns a jwe token.
:param str json: The json to be encrypted.
:param key_store: The key store.
:param str key_purpose: Context for the key.
:return: A jwe token.
"""
jwt_key = key_store.get_key_for_purpose_and_type(key_purpose, "private")
payload = JWTHelper.encode(json, jwt_key.kid, key_store, key_purpose)
jwe_key = key_store.get_key_for_purpose_and_type(key_purpose, "public")
return JWEHelper.encrypt(payload, jwe_key.kid, key_store, key_purpose) | python | {
"resource": ""
} |
q274776 | BaseCacheWrapper.delete | test | def delete(self, *args):
"""Remove the key from the request cache and from memcache."""
cache = get_cache()
key = self.get_cache_key(*args)
if key in cache:
del cache[key] | python | {
"resource": ""
} |
q274777 | Constraint.to_python | test | def to_python(self):
"""Deconstruct the ``Constraint`` instance to a tuple.
Returns:
tuple: The deconstructed ``Constraint``.
"""
return (
self.selector,
COMPARISON_MAP.get(self.comparison, self.comparison),
self.argument
) | python | {
"resource": ""
} |
q274778 | AsyncCAM.close | test | def close(self):
"""Close stream."""
if self.writer.can_write_eof():
self.writer.write_eof()
self.writer.close() | python | {
"resource": ""
} |
q274779 | parse_str_to_expression | test | def parse_str_to_expression(fiql_str):
"""Parse a FIQL formatted string into an ``Expression``.
Args:
fiql_str (string): The FIQL formatted string we want to parse.
Returns:
Expression: An ``Expression`` object representing the parsed FIQL
string.
Raises:
FiqlFormatException: Unable to parse string due to incorrect
formatting.
Example:
>>> expression = parse_str_to_expression(
... "name==bar,dob=gt=1990-01-01")
"""
#pylint: disable=too-many-branches
nesting_lvl = 0
last_element = None
expression = Expression()
for (preamble, selector, comparison, argument) in iter_parse(fiql_str):
if preamble:
for char in preamble:
if char == '(':
if isinstance(last_element, BaseExpression):
raise FiqlFormatException(
"%s can not be followed by %s" % (
last_element.__class__, Expression))
expression = expression.create_nested_expression()
nesting_lvl += 1
elif char == ')':
expression = expression.get_parent()
last_element = expression
nesting_lvl -= 1
else:
if not expression.has_constraint():
raise FiqlFormatException(
"%s proceeding initial %s" % (
Operator, Constraint))
if isinstance(last_element, Operator):
raise FiqlFormatException(
"%s can not be followed by %s" % (
Operator, Operator))
last_element = Operator(char)
expression = expression.add_operator(last_element)
if selector:
if isinstance(last_element, BaseExpression):
raise FiqlFormatException("%s can not be followed by %s" % (
last_element.__class__, Constraint))
last_element = Constraint(selector, comparison, argument)
expression.add_element(last_element)
if nesting_lvl != 0:
raise FiqlFormatException(
"At least one nested expression was not correctly closed")
if not expression.has_constraint():
raise FiqlFormatException(
"Parsed string '%s' contained no constraint" % fiql_str)
return expression | python | {
"resource": ""
} |
q274780 | dump | test | def dump(ndb_model, fp, **kwargs):
"""Custom json dump using the custom encoder above."""
for chunk in NdbEncoder(**kwargs).iterencode(ndb_model):
fp.write(chunk) | python | {
"resource": ""
} |
q274781 | NdbDecoder.object_hook_handler | test | def object_hook_handler(self, val):
"""Handles decoding of nested date strings."""
return {k: self.decode_date(v) for k, v in val.iteritems()} | python | {
"resource": ""
} |
q274782 | NdbDecoder.decode_date | test | def decode_date(self, val):
"""Tries to decode strings that look like dates into datetime objects."""
if isinstance(val, basestring) and val.count('-') == 2 and len(val) > 9:
try:
dt = dateutil.parser.parse(val)
# Check for UTC.
if val.endswith(('+00:00', '-00:00', 'Z')):
# Then remove tzinfo for gae, which is offset-naive.
dt = dt.replace(tzinfo=None)
return dt
except (TypeError, ValueError):
pass
return val | python | {
"resource": ""
} |
q274783 | NdbDecoder.decode | test | def decode(self, val):
"""Override of the default decode method that also uses decode_date."""
# First try the date decoder.
new_val = self.decode_date(val)
if val != new_val:
return new_val
# Fall back to the default decoder.
return json.JSONDecoder.decode(self, val) | python | {
"resource": ""
} |
q274784 | NdbEncoder.default | test | def default(self, obj):
"""Overriding the default JSONEncoder.default for NDB support."""
obj_type = type(obj)
# NDB Models return a repr to calls from type().
if obj_type not in self._ndb_type_encoding:
if hasattr(obj, '__metaclass__'):
obj_type = obj.__metaclass__
else:
# Try to encode subclasses of types
for ndb_type in NDB_TYPES:
if isinstance(obj, ndb_type):
obj_type = ndb_type
break
fn = self._ndb_type_encoding.get(obj_type)
if fn:
return fn(obj)
return json.JSONEncoder.default(self, obj) | python | {
"resource": ""
} |
q274785 | validate_version | test | def validate_version():
"""Validate version before release."""
import leicacam
version_string = leicacam.__version__
versions = version_string.split('.', 3)
try:
for ver in versions:
int(ver)
except ValueError:
print(
'Only integers are allowed in release version, '
'please adjust current version {}'.format(version_string))
return None
return version_string | python | {
"resource": ""
} |
q274786 | generate | test | def generate():
"""Generate changelog."""
old_dir = os.getcwd()
proj_dir = os.path.join(os.path.dirname(__file__), os.pardir)
os.chdir(proj_dir)
version = validate_version()
if not version:
os.chdir(old_dir)
return
print('Generating changelog for version {}'.format(version))
options = [
'--user', 'arve0', '--project', 'leicacam', '-v', '--with-unreleased',
'--future-release', version]
generator = ChangelogGenerator(options)
generator.run()
os.chdir(old_dir) | python | {
"resource": ""
} |
q274787 | strongly_connected_components | test | def strongly_connected_components(graph: Graph) -> List:
"""Find the strongly connected components in a graph using Tarjan's algorithm.
The `graph` argument should be a dictionary mapping node names to sequences of successor nodes.
"""
assert check_argument_types()
result = []
stack = []
low = {}
def visit(node: str):
if node in low: return
num = len(low)
low[node] = num
stack_pos = len(stack)
stack.append(node)
for successor in graph[node]:
visit(successor)
low[node] = min(low[node], low[successor])
if num == low[node]:
component = tuple(stack[stack_pos:])
del stack[stack_pos:]
result.append(component)
for item in component:
low[item] = len(graph)
for node in graph:
visit(node)
return result | python | {
"resource": ""
} |
q274788 | robust_topological_sort | test | def robust_topological_sort(graph: Graph) -> list:
"""Identify strongly connected components then perform a topological sort of those components."""
assert check_argument_types()
components = strongly_connected_components(graph)
node_component = {}
for component in components:
for node in component:
node_component[node] = component
component_graph = {}
for component in components:
component_graph[component] = []
for node in graph:
node_c = node_component[node]
for successor in graph[node]:
successor_c = node_component[successor]
if node_c != successor_c:
component_graph[node_c].append(successor_c)
return topological_sort(component_graph) | python | {
"resource": ""
} |
q274789 | BaseExpression.set_parent | test | def set_parent(self, parent):
"""Set parent ``Expression`` for this object.
Args:
parent (Expression): The ``Expression`` which contains this object.
Raises:
FiqlObjectException: Parent must be of type ``Expression``.
"""
if not isinstance(parent, Expression):
raise FiqlObjectException("Parent must be of %s not %s" % (
Expression, type(parent)))
self.parent = parent | python | {
"resource": ""
} |
q274790 | BaseExpression.get_parent | test | def get_parent(self):
"""Get the parent ``Expression`` for this object.
Returns:
Expression: The ``Expression`` which contains this object.
Raises:
FiqlObjectException: Parent is ``None``.
"""
if not isinstance(self.parent, Expression):
raise FiqlObjectException("Parent must be of %s not %s" % (
Expression, type(self.parent)))
return self.parent | python | {
"resource": ""
} |
q274791 | Expression.add_operator | test | def add_operator(self, operator):
"""Add an ``Operator`` to the ``Expression``.
The ``Operator`` may result in a new ``Expression`` if an ``Operator``
already exists and is of a different precedence.
There are three possibilities when adding an ``Operator`` to an
``Expression`` depending on whether or not an ``Operator`` already
exists:
- No ``Operator`` on the working ``Expression``; Simply set the
``Operator`` and return ``self``.
- ``Operator`` already exists and is higher in precedence; The
``Operator`` and last ``Constraint`` belong in a sub-expression of
the working ``Expression``.
- ``Operator`` already exists and is lower in precedence; The
``Operator`` belongs to the parent of the working ``Expression``
whether one currently exists or not. To remain in the context of
the top ``Expression``, this method will return the parent here
rather than ``self``.
Args:
operator (Operator): What we are adding.
Returns:
Expression: ``self`` or related ``Expression``.
Raises:
FiqlObjectExpression: Operator is not a valid ``Operator``.
"""
if not isinstance(operator, Operator):
raise FiqlObjectException("%s is not a valid element type" % (
operator.__class__))
if not self._working_fragment.operator:
self._working_fragment.operator = operator
elif operator > self._working_fragment.operator:
last_constraint = self._working_fragment.elements.pop()
self._working_fragment = self._working_fragment \
.create_nested_expression()
self._working_fragment.add_element(last_constraint)
self._working_fragment.add_operator(operator)
elif operator < self._working_fragment.operator:
if self._working_fragment.parent:
return self._working_fragment.parent.add_operator(operator)
else:
return Expression().add_element(self._working_fragment) \
.add_operator(operator)
return self | python | {
"resource": ""
} |
q274792 | Expression.add_element | test | def add_element(self, element):
"""Add an element of type ``Operator``, ``Constraint``, or
``Expression`` to the ``Expression``.
Args:
element: ``Constraint``, ``Expression``, or ``Operator``.
Returns:
Expression: ``self``
Raises:
FiqlObjectException: Element is not a valid type.
"""
if isinstance(element, BaseExpression):
element.set_parent(self._working_fragment)
self._working_fragment.elements.append(element)
return self
else:
return self.add_operator(element) | python | {
"resource": ""
} |
q274793 | Expression.op_and | test | def op_and(self, *elements):
"""Update the ``Expression`` by joining the specified additional
``elements`` using an "AND" ``Operator``
Args:
*elements (BaseExpression): The ``Expression`` and/or
``Constraint`` elements which the "AND" ``Operator`` applies
to.
Returns:
Expression: ``self`` or related ``Expression``.
"""
expression = self.add_operator(Operator(';'))
for element in elements:
expression.add_element(element)
return expression | python | {
"resource": ""
} |
q274794 | Expression.op_or | test | def op_or(self, *elements):
"""Update the ``Expression`` by joining the specified additional
``elements`` using an "OR" ``Operator``
Args:
*elements (BaseExpression): The ``Expression`` and/or
``Constraint`` elements which the "OR" ``Operator`` applies
to.
Returns:
Expression: ``self`` or related ``Expression``.
"""
expression = self.add_operator(Operator(','))
for element in elements:
expression.add_element(element)
return expression | python | {
"resource": ""
} |
q274795 | logger | test | def logger(function):
"""Decorate passed in function and log message to module logger."""
@functools.wraps(function)
def wrapper(*args, **kwargs):
"""Wrap function."""
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '') # do not add newline by default
out = sep.join([repr(x) for x in args])
out = out + end
_LOGGER.debug(out)
return function(*args, **kwargs)
return wrapper | python | {
"resource": ""
} |
q274796 | _parse_receive | test | def _parse_receive(incomming):
"""Parse received response.
Parameters
----------
incomming : bytes string
Incomming bytes from socket server.
Returns
-------
list of OrderedDict
Received message as a list of OrderedDict.
"""
debug(b'< ' + incomming)
# remove terminating null byte
incomming = incomming.rstrip(b'\x00')
# split received messages
# return as list of several messages received
msgs = incomming.splitlines()
return [bytes_as_dict(msg) for msg in msgs] | python | {
"resource": ""
} |
q274797 | tuples_as_dict | test | def tuples_as_dict(_list):
"""Translate a list of tuples to OrderedDict with key and val as strings.
Parameters
----------
_list : list of tuples
Returns
-------
collections.OrderedDict
Example
-------
::
>>> tuples_as_dict([('cmd', 'val'), ('cmd2', 'val2')])
OrderedDict([('cmd', 'val'), ('cmd2', 'val2')])
"""
_dict = OrderedDict()
for key, val in _list:
key = str(key)
val = str(val)
_dict[key] = val
return _dict | python | {
"resource": ""
} |
q274798 | check_messages | test | def check_messages(msgs, cmd, value=None):
"""Check if specific message is present.
Parameters
----------
cmd : string
Command to check for in bytestring from microscope CAM interface. If
``value`` is falsey, value of received command does not matter.
value : string
Check if ``cmd:value`` is received.
Returns
-------
collections.OrderedDict
Correct messsage or None if no correct message if found.
"""
for msg in msgs:
if value and msg.get(cmd) == value:
return msg
if not value and msg.get(cmd):
return msg
return None | python | {
"resource": ""
} |
q274799 | BaseCAM._prepare_send | test | def _prepare_send(self, commands):
"""Prepare message to be sent.
Parameters
----------
commands : list of tuples or bytes string
Commands as a list of tuples or a bytes string. cam.prefix is
allways prepended before sending.
Returns
-------
string
Message to be sent.
"""
if isinstance(commands, bytes):
msg = self.prefix_bytes + commands
else:
msg = tuples_as_bytes(self.prefix + commands)
debug(b'> ' + msg)
return msg | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.