INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Return the value current bound to the name name_sym in the namespace specified by ns_sym. | 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 |
Return the value currently bound to the name in the namespace specified by ns_qualified_sym. | 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) |
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. | 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 |
Add a gated default import to the default imports. | 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))) |
Add a Symbol alias for the given Namespace. | 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)) |
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. | 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) |
Swap function used by intern to atomically intern a new variable in the symbol mapping for this Namespace. | 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 |
Find Vars mapped by the given Symbol input or None if no Vars are mapped by that Symbol. | 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 |
Add the Symbol as an imported Symbol in this Namespace. If aliases are given the aliases will be applied to the | 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])
)
) |
Return the module if a moduled named by sym has been imported into this Namespace None otherwise. | 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 |
Refer var in this namespace under the name sym. | 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)) |
Get the Var referred by Symbol or None if it does not exist. | 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) |
Refer all _public_ interns from another namespace. | 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 |
Refer all the Vars in the other namespace. | def refer_all(self, other_ns: "Namespace"):
"""Refer all the Vars in the other namespace."""
self._refers.swap(Namespace.__refer_all, other_ns.interns) |
Private swap function used by get_or_create to atomically swap the new namespace map into the global cache. | 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) |
Get the namespace bound to the symbol name in the global namespace cache creating it if it does not exist. Return the namespace. | 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
] |
Get the namespace bound to the symbol name in the global namespace cache. Return the namespace if it exists or None otherwise.. | 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) |
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. | 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 |
Return a function which matches any symbol keys from map entries against the given text. | 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 |
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. | 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}/" |
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. | 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}/" |
Return an iterable of possible completions matching the given prefix from the list of interned Vars. | 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]),
) |
Return an iterable of possible completions matching the given prefix from the list of referred Vars. | 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]
),
) |
Return an iterable of possible completions for the given text in this namespace. | 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 |
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. | 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 () |
Creates a new list. | 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
) |
Creates a new list from members. | def l(*members, meta=None) -> List:
"""Creates a new list from members."""
return List( # pylint: disable=abstract-class-instantiated
plist(iterable=members), meta=meta
) |
This function is used to format the key value as a multi - line string maintaining the line breaks | 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 |
Loads a public key from the file system and adds it to a dict of keys: param keys: A dict of keys: param platform the platform the key is for: param service the service the key is for: param key_use what the key is used for: param version the version of the key: param purpose: The purpose of the public key: param public_key: The name of the public key to add: param keys_folder: The location on disk where the key exists: param kid_override: This allows the caller to override the generated KID value: return: None | def get_public_key(platform, service, purpose, key_use, version, public_key, keys_folder):
'''
Loads a public key from the file system and adds it to a dict of keys
:param keys: A dict of keys
:param platform the platform the key is for
:param service the service the key is for
:param key_use what the key is used for
:param version the version of the key
:param purpose: The purpose of the public key
:param public_key: The name of the public key to add
:param keys_folder: The location on disk where the key exists
:param kid_override: This allows the caller to override the generated KID value
:return: None
'''
public_key_data = get_file_contents(keys_folder, public_key)
pub_key = load_pem_public_key(public_key_data.encode(), backend=backend)
pub_bytes = pub_key.public_bytes(Encoding.PEM, PublicFormat.SubjectPublicKeyInfo)
kid = _generate_kid_from_key(pub_bytes.decode())
key = _create_key(platform=platform, service=service, key_use=key_use,
key_type="public", purpose=purpose, version=version,
public_key=public_key_data)
return kid, key |
Loads a private key from the file system and adds it to a dict of keys: param keys: A dict of keys: param platform the platform the key is for: param service the service the key is for: param key_use what the key is used for: param version the version of the key: param purpose: The purpose of the private key: param private_key: The name of the private key to add: param keys_folder: The location on disk where the key exists: param kid_override: This allows the caller to override the generated KID value: return: None | def get_private_key(platform, service, purpose, key_use, version, private_key, keys_folder):
'''
Loads a private key from the file system and adds it to a dict of keys
:param keys: A dict of keys
:param platform the platform the key is for
:param service the service the key is for
:param key_use what the key is used for
:param version the version of the key
:param purpose: The purpose of the private key
:param private_key: The name of the private key to add
:param keys_folder: The location on disk where the key exists
:param kid_override: This allows the caller to override the generated KID value
:return: None
'''
private_key_data = get_file_contents(keys_folder, private_key)
private_key = load_pem_private_key(private_key_data.encode(), None, backend=backend)
pub_key = private_key.public_key()
pub_bytes = pub_key.public_bytes(Encoding.PEM, PublicFormat.SubjectPublicKeyInfo)
kid = _generate_kid_from_key(pub_bytes.decode())
key = _create_key(platform=platform, service=service, key_use=key_use,
key_type="private", purpose=purpose, version=version,
public_key=pub_bytes.decode(), private_key=private_key_data)
return kid, key |
Decrypts JWE token with supplied key: param encrypted_token:: param key: A (: class: jwcrypto. jwk. JWK ) decryption key or a password: returns: The payload of the decrypted token | def decrypt_with_key(encrypted_token, key):
"""
Decrypts JWE token with supplied key
:param encrypted_token:
:param key: A (:class:`jwcrypto.jwk.JWK`) decryption key or a password
:returns: The payload of the decrypted token
"""
try:
jwe_token = jwe.JWE(algs=['RSA-OAEP', 'A256GCM'])
jwe_token.deserialize(encrypted_token)
jwe_token.decrypt(key)
return jwe_token.payload.decode()
except (ValueError, InvalidJWEData) as e:
raise InvalidTokenException(str(e)) from e |
This decrypts the provided jwe token then decodes resulting jwt token and returns the payload. | 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 |
This encrypts the supplied json and returns a jwe token. | 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) |
Gets a list of keys that match the purpose and key_type and returns the first key in that list Note if there are many keys that match the criteria the one you get back will be random from that list: returns: A key object that matches the criteria | def get_key_for_purpose_and_type(self, purpose, key_type):
"""
Gets a list of keys that match the purpose and key_type, and returns the first key in that list
Note, if there are many keys that match the criteria, the one you get back will be random from that list
:returns: A key object that matches the criteria
"""
key = [key for key in self.keys.values() if key.purpose == purpose and key.key_type == key_type]
try:
return key[0]
except IndexError:
return None |
returns a dictionary of arg_name: default_values for the input function | def get_default_args(func):
"""
returns a dictionary of arg_name:default_values for the input function
"""
args, _, _, defaults, *rest = inspect.getfullargspec(func)
return dict(zip(reversed(args), reversed(defaults))) |
: param kwargs: kwargs used to call the multiget function: param objects: objects returned from the inner function: param object_key: field or set of fields that map to the kwargs provided: param object_tuple_key: A temporary shortcut until we allow dot. path traversal for object_key. Will call getattr ( getattr ( result join_table_name ) object_key ): param argument_key: field or set of fields that map to the objects provided: param result_value: Limit the fields returned to this field or set of fields ( none = whole object ): param default_result: If the inner function returned none for a set of parameters default to this: return: | def map_arguments_to_objects(kwargs, objects, object_key, object_tuple_key, argument_key, result_value, default_result):
"""
:param kwargs: kwargs used to call the multiget function
:param objects: objects returned from the inner function
:param object_key: field or set of fields that map to the kwargs provided
:param object_tuple_key: A temporary shortcut until we allow dot.path traversal for object_key.
Will call getattr(getattr(result, join_table_name), object_key)
:param argument_key: field or set of fields that map to the objects provided
:param result_value: Limit the fields returned to this field or set of fields (none = whole object)
:param default_result: If the inner function returned none for a set of parameters, default to this
:return:
"""
# Map each object to the set of desired result data using a key
# that corresponds to the parameters for ordering purposes
map_ = map_objects_to_result(objects, object_key, object_tuple_key, result_value, default_result)
element_count = get_request_count(kwargs)
# Using the map we just made, return the objects in the same order
# they were primed using the object and argument keys to match against
return [map_[get_argument_key(kwargs, argument_key, index)] for index in range(0, element_count)] |
Remove the key from the request cache and from memcache. | 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] |
: param object_key: the names of the attributes on the result object that are meant to match the function parameters: param argument_key: the function parameter names you wish to match with the object_key s. By default this will be all of your wrapped function s arguments in order. So you d really only use this when you want to ignore a given function argument.: param default_result: The result to put into the cache if nothing is matched.: param result_fields: The attribute on your result object you wish to return the value of. By default the whole object is returned.: param join_table_name: A temporary shortcut until we allow dot. path traversal for object_key. Will call getattr ( getattr ( result join_table_name ) object_key ): param coerce_args_to_strings: force coerce all arguments to the inner function to strings. Useful for SQL where mixes of ints and strings in WHERE x IN ( list ) clauses causes poor performance.: return: A wrapper that allows you to queue many O ( 1 ) calls and flush the queue all at once rather than executing the inner function body N times. | def multiget_cached(object_key, argument_key=None, default_result=None,
result_fields=None, join_table_name=None, coerce_args_to_strings=False):
"""
:param object_key: the names of the attributes on the result object that are meant to match the function parameters
:param argument_key: the function parameter names you wish to match with the `object_key`s.
By default, this will be all of your wrapped function's arguments, in order.
So, you'd really only use this when you want to ignore a given function argument.
:param default_result: The result to put into the cache if nothing is matched.
:param result_fields: The attribute on your result object you wish to return the value of.
By default, the whole object is returned.
:param join_table_name: A temporary shortcut until we allow dot.path traversal for object_key.
Will call getattr(getattr(result, join_table_name), object_key)
:param coerce_args_to_strings: force coerce all arguments to the inner function to strings.
Useful for SQL where mixes of ints and strings in `WHERE x IN (list)` clauses causes poor performance.
:return: A wrapper that allows you to queue many O(1) calls and flush the queue all at once,
rather than executing the inner function body N times.
"""
def create_wrapper(inner_f):
return MultigetCacheWrapper(
inner_f, object_key, argument_key, default_result, result_fields,
join_table_name, coerce_args_to_strings=coerce_args_to_strings
)
return create_wrapper |
Returns the current version/ module in - dot - notation which is used by target: parameters. | def get_dot_target_name(version=None, module=None):
"""Returns the current version/module in -dot- notation which is used by `target:` parameters."""
version = version or get_current_version_name()
module = module or get_current_module_name()
return '-dot-'.join((version, module)) |
Returns the current version/ module in - dot - notation which is used by target: parameters. If there is no current version or module then None is returned. | def get_dot_target_name_safe(version=None, module=None):
"""
Returns the current version/module in -dot- notation which is used by `target:` parameters.
If there is no current version or module then None is returned.
"""
version = version or get_current_version_name_safe()
module = module or get_current_module_name_safe()
if version and module:
return '-dot-'.join((version, module))
return None |
Return a dictionary of key/ values from os. environ. | def _get_os_environ_dict(keys):
"""Return a dictionary of key/values from os.environ."""
return {k: os.environ.get(k, _UNDEFINED) for k in keys} |
This helper function attempts to resolve the dot - colon import path for a given object. Specifically searches for classes and methods it should be able to find nearly anything at either the module level or nested one level deep. Uses __qualname__ if available. | def name(obj) -> str:
"""This helper function attempts to resolve the dot-colon import path for a given object.
Specifically searches for classes and methods, it should be able to find nearly anything at either the module
level or nested one level deep. Uses ``__qualname__`` if available.
"""
if not isroutine(obj) and not hasattr(obj, '__name__') and hasattr(obj, '__class__'):
obj = obj.__class__
module = getmodule(obj)
return module.__name__ + ':' + obj.__qualname__ |
Deconstruct the Constraint instance to a tuple. | 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
) |
Connect to LASAF through a CAM - socket. | async def connect(self):
"""Connect to LASAF through a CAM-socket."""
self.reader, self.writer = await asyncio.open_connection(
self.host, self.port, loop=self.loop)
self.welcome_msg = await self.reader.read(self.buffer_size) |
Send commands to LASAF through CAM - socket. | async def send(self, commands):
"""Send commands to LASAF through CAM-socket.
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
-------
int
Bytes sent.
Example
-------
::
>>> # send list of tuples
>>> await cam.send([('cmd', 'enableall'), ('value', 'true')])
>>> # send bytes string
>>> await cam.send(b'/cmd:enableall /value:true')
"""
msg = self._prepare_send(commands)
self.writer.write(msg)
await self.writer.drain() |
Receive message from socket interface as list of OrderedDict. | async def receive(self):
"""Receive message from socket interface as list of OrderedDict."""
try:
incomming = await self.reader.read(self.buffer_size)
except OSError:
return []
return _parse_receive(incomming) |
Hang until command is received. | async def wait_for(self, cmd, value=None, timeout=60):
"""Hang until command is received.
If value is supplied, it will hang until ``cmd:value`` is received.
Parameters
----------
cmd : string
Command to wait for in bytestring from microscope CAM interface. If
``value`` is falsey, value of received command does not matter.
value : string
Wait until ``cmd:value`` is received.
timeout : int
Minutes to wait for command. If timeout is reached, an empty
OrderedDict will be returned.
Returns
-------
collections.OrderedDict
Last received messsage or empty message if timeout is reached.
"""
try:
async with async_timeout(timeout * 60):
while True:
msgs = await self.receive()
msg = check_messages(msgs, cmd, value=value)
if msg:
return msg
except asyncio.TimeoutError:
return OrderedDict() |
Close stream. | def close(self):
"""Close stream."""
if self.writer.can_write_eof():
self.writer.write_eof()
self.writer.close() |
Lazily load and cache an object reference upon dereferencing. Assign the result of calling this function with either an object reference passed in positionally: class MyClass: debug = lazyload ( logging: debug ) Or the attribute path to traverse ( using marrow. package. loader: traverse ) prefixed by a period. class AnotherClass: target = logging: info log = lazyload (. target ) Additional arguments are passed to the eventual call to load (). | def lazyload(reference: str, *args, **kw):
"""Lazily load and cache an object reference upon dereferencing.
Assign the result of calling this function with either an object reference passed in positionally:
class MyClass:
debug = lazyload('logging:debug')
Or the attribute path to traverse (using `marrow.package.loader:traverse`) prefixed by a period.
class AnotherClass:
target = 'logging:info'
log = lazyload('.target')
Additional arguments are passed to the eventual call to `load()`.
"""
assert check_argument_types()
def lazily_load_reference(self):
ref = reference
if ref.startswith('.'):
ref = traverse(self, ref[1:])
return load(ref, *args, **kw)
return lazy(lazily_load_reference) |
Iterate through the FIQL string. Yield a tuple containing the following FIQL components for each iteration: | def iter_parse(fiql_str):
"""Iterate through the FIQL string. Yield a tuple containing the
following FIQL components for each iteration:
- preamble: Any operator or opening/closing paranthesis preceding a
constraint or at the very end of the FIQL string.
- selector: The selector portion of a FIQL constraint or ``None`` if
yielding the last portion of the string.
- comparison: The comparison portion of a FIQL constraint or ``None``
if yielding the last portion of the string.
- argument: The argument portion of a FIQL constraint or ``None`` if
yielding the last portion of the string.
For usage see :func:`parse_str_to_expression`.
Args:
fiql_str (string): The FIQL formatted string we want to parse.
Yields:
tuple: Preamble, selector, comparison, argument.
"""
while len(fiql_str):
constraint_match = CONSTRAINT_COMP.split(fiql_str, 1)
if len(constraint_match) < 2:
yield (constraint_match[0], None, None, None)
break
yield (
constraint_match[0],
unquote_plus(constraint_match[1]),
constraint_match[4],
unquote_plus(constraint_match[6]) \
if constraint_match[6] else None
)
fiql_str = constraint_match[8] |
Parse a FIQL formatted string into an Expression. | 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 |
Encode objects like ndb. Model which have a. to_dict () method. | def encode_model(obj):
"""Encode objects like ndb.Model which have a `.to_dict()` method."""
obj_dict = obj.to_dict()
for key, val in obj_dict.iteritems():
if isinstance(val, types.StringType):
try:
unicode(val)
except UnicodeDecodeError:
# Encode binary strings (blobs) to base64.
obj_dict[key] = base64.b64encode(val)
return obj_dict |
Custom json dump using the custom encoder above. | 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) |
Handles decoding of nested date strings. | def object_hook_handler(self, val):
"""Handles decoding of nested date strings."""
return {k: self.decode_date(v) for k, v in val.iteritems()} |
Tries to decode strings that look like dates into datetime objects. | 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 |
Override of the default decode method that also uses decode_date. | 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) |
Overriding the default JSONEncoder. default for NDB support. | 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) |
Traverse down an object using getattr or getitem. If executable is True any executable function encountered will be with no arguments. Traversal will continue on the result of that call. You can change the separator as desired i. e. to a/. By default attributes ( but not array elements ) prefixed with an underscore are taboo. They will not resolve raising a LookupError. Certain allowances are made: if a path segment is numerical it s treated as an array index. If attribute lookup fails it will re - try on that object using array notation and continue from there. This makes lookup very flexible. | def traverse(obj, target:str, default=nodefault, executable:bool=False, separator:str='.', protect:bool=True):
"""Traverse down an object, using getattr or getitem.
If ``executable`` is ``True`` any executable function encountered will be, with no arguments. Traversal will
continue on the result of that call. You can change the separator as desired, i.e. to a '/'.
By default attributes (but not array elements) prefixed with an underscore are taboo. They will not resolve,
raising a LookupError.
Certain allowances are made: if a 'path segment' is numerical, it's treated as an array index. If attribute
lookup fails, it will re-try on that object using array notation and continue from there. This makes lookup
very flexible.
"""
# TODO: Support numerical slicing, i.e. ``1:4``, or even just ``:-1`` and things.
assert check_argument_types()
value = obj
remainder = target
if not target:
return obj
while separator:
name, separator, remainder = remainder.partition(separator)
numeric = name.lstrip('-').isdigit()
try:
if numeric or (protect and name.startswith('_')):
raise AttributeError()
value = getattr(value, name)
if executable and callable(value):
value = value()
except AttributeError:
try:
value = value[int(name) if numeric else name]
except (KeyError, TypeError):
if default is nodefault:
raise LookupError("Could not resolve '" + target + "' on: " + repr(obj))
return default
return value |
This helper function loads an object identified by a dotted - notation string. For example:: # Load class Foo from example. objects load ( example. objects: Foo ) # Load the result of the class method new of the Foo object load ( example. objects: Foo. new executable = True ) If a plugin namespace is provided simple name references are allowed. For example:: # Load the plugin named routing from the web. dispatch namespace load ( routing web. dispatch ) The executable protect and first tuple element of separators are passed to the traverse function. Providing a namespace does not prevent full object lookup ( dot - colon notation ) from working. | def load(target:str, namespace:str=None, default=nodefault, executable:bool=False, separators:Sequence[str]=('.', ':'),
protect:bool=True):
"""This helper function loads an object identified by a dotted-notation string.
For example::
# Load class Foo from example.objects
load('example.objects:Foo')
# Load the result of the class method ``new`` of the Foo object
load('example.objects:Foo.new', executable=True)
If a plugin namespace is provided simple name references are allowed. For example::
# Load the plugin named 'routing' from the 'web.dispatch' namespace
load('routing', 'web.dispatch')
The ``executable``, ``protect``, and first tuple element of ``separators`` are passed to the traverse function.
Providing a namespace does not prevent full object lookup (dot-colon notation) from working.
"""
assert check_argument_types()
if namespace and ':' not in target:
allowable = dict((i.name, i) for i in iter_entry_points(namespace))
if target not in allowable:
raise LookupError('Unknown plugin "' + target + '"; found: ' + ', '.join(allowable))
return allowable[target].load()
parts, _, target = target.partition(separators[1])
try:
obj = __import__(parts)
except ImportError:
if default is not nodefault:
return default
raise
return traverse(
obj,
separators[0].join(parts.split(separators[0])[1:] + target.split(separators[0])),
default = default,
executable = executable,
protect = protect
) if target else obj |
Run client. | def run():
"""Run client."""
cam = CAM()
print(cam.welcome_msg)
print(cam.send(b'/cmd:deletelist'))
sleep(0.1)
print(cam.receive())
print(cam.send(b'/cmd:deletelist'))
sleep(0.1)
print(cam.wait_for(cmd='cmd', timeout=0.1))
cam.close() |
Validate version before release. | 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 |
Generate changelog. | 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) |
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. | 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 |
Identify strongly connected components then perform a topological sort of those components. | 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) |
Set parent Expression for this object. | 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 |
Get the parent Expression for this object. | 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 |
Add an Operator to the Expression. | 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 |
Add an element of type Operator Constraint or Expression to the Expression. | 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) |
Update the Expression by joining the specified additional elements using an AND Operator | 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 |
Update the Expression by joining the specified additional elements using an OR Operator | 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 |
Deconstruct the Expression instance to a list or tuple ( If Expression contains only one Constraint ). | def to_python(self):
"""Deconstruct the ``Expression`` instance to a list or tuple
(If ``Expression`` contains only one ``Constraint``).
Returns:
list or tuple: The deconstructed ``Expression``.
"""
if len(self.elements) == 0:
return None
if len(self.elements) == 1:
return self.elements[0].to_python()
operator = self.operator or Operator(';')
return [operator.to_python()] + \
[elem.to_python() for elem in self.elements] |
Run client. | async def run(loop):
"""Run client."""
cam = AsyncCAM(loop=loop)
await cam.connect()
print(cam.welcome_msg)
await cam.send(b'/cmd:deletelist')
print(await cam.receive())
await cam.send(b'/cmd:deletelist')
print(await cam.wait_for(cmd='cmd', timeout=0.1))
await cam.send(b'/cmd:deletelist')
print(await cam.wait_for(cmd='cmd', timeout=0))
print(await cam.wait_for(cmd='cmd', timeout=0.1))
print(await cam.wait_for(cmd='test', timeout=0.1))
cam.close() |
Decorate passed in function and log message to module logger. | 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 |
Parse received response. | 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] |
Format list of tuples to CAM message with format/ key: val. | def tuples_as_bytes(cmds):
"""Format list of tuples to CAM message with format /key:val.
Parameters
----------
cmds : list of tuples
List of commands as tuples.
Returns
-------
bytes
Sequence of /key:val.
Example
-------
::
>>> tuples_as_bytes([('cmd', 'val'), ('cmd2', 'val2')])
b'/cmd:val /cmd2:val2'
"""
cmds = OrderedDict(cmds) # override equal keys
tmp = []
for key, val in cmds.items():
key = str(key)
val = str(val)
tmp.append('/' + key + ':' + val)
return ' '.join(tmp).encode() |
Translate a list of tuples to OrderedDict with key and val as strings. | 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 |
Parse CAM message to OrderedDict based on format/ key: val. | def bytes_as_dict(msg):
"""Parse CAM message to OrderedDict based on format /key:val.
Parameters
----------
msg : bytes
Sequence of /key:val.
Returns
-------
collections.OrderedDict
With /key:val => dict[key] = val.
"""
# decode bytes, assume '/' in start
cmd_strings = msg.decode()[1:].split(r' /')
cmds = OrderedDict()
for cmd in cmd_strings:
unpacked = cmd.split(':')
# handle string not well formated (ex filenames with c:\)
if len(unpacked) > 2:
key = unpacked[0]
val = ':'.join(unpacked[1:])
elif len(unpacked) < 2:
continue
else:
key, val = unpacked
cmds[key] = val
return cmds |
Check if specific message is present. | 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 |
Prepare message to be sent. | 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 |
Connect to LASAF through a CAM - socket. | def connect(self):
"""Connect to LASAF through a CAM-socket."""
self.socket = socket.socket()
self.socket.connect((self.host, self.port))
self.socket.settimeout(False) # non-blocking
sleep(self.delay) # wait for response
self.welcome_msg = self.socket.recv(
self.buffer_size) |
Flush incomming socket messages. | def flush(self):
"""Flush incomming socket messages."""
debug('flushing incomming socket messages')
try:
while True:
msg = self.socket.recv(self.buffer_size)
debug(b'< ' + msg)
except socket.error:
pass |
Send commands to LASAF through CAM - socket. | def send(self, commands):
"""Send commands to LASAF through CAM-socket.
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
-------
int
Bytes sent.
Example
-------
::
>>> # send list of tuples
>>> cam.send([('cmd', 'enableall'), ('value', 'true')])
>>> # send bytes string
>>> cam.send(b'/cmd:enableall /value:true')
"""
self.flush() # discard any waiting messages
msg = self._prepare_send(commands)
return self.socket.send(msg) |
Receive message from socket interface as list of OrderedDict. | def receive(self):
"""Receive message from socket interface as list of OrderedDict."""
try:
incomming = self.socket.recv(self.buffer_size)
except socket.error:
return []
return _parse_receive(incomming) |
Hang until command is received. | def wait_for(self, cmd, value=None, timeout=60):
"""Hang until command is received.
If value is supplied, it will hang until ``cmd:value`` is received.
Parameters
----------
cmd : string
Command to wait for in bytestring from microscope CAM interface. If
``value`` is falsey, value of received command does not matter.
value : string
Wait until ``cmd:value`` is received.
timeout : int
Minutes to wait for command. If timeout is reached, an empty
OrderedDict will be returned.
Returns
-------
collections.OrderedDict
Last received messsage or empty message if timeout is reached.
"""
wait = time() + timeout * 60
while True:
if time() > wait:
return OrderedDict()
msgs = self.receive()
msg = check_messages(msgs, cmd, value=value)
if msg:
return msg
sleep(self.delay) |
Enable a given scan field. | def enable(self, slide=0, wellx=1, welly=1, fieldx=1, fieldy=1):
"""Enable a given scan field."""
# pylint: disable=too-many-arguments
cmd = [
('cmd', 'enable'),
('slide', str(slide)),
('wellx', str(wellx)),
('welly', str(welly)),
('fieldx', str(fieldx)),
('fieldy', str(fieldy)),
('value', 'true')
]
self.send(cmd)
return self.wait_for(*cmd[0]) |
Save scanning template to filename. | def save_template(self, filename="{ScanningTemplate}leicacam.xml"):
"""Save scanning template to filename."""
cmd = [
('sys', '0'),
('cmd', 'save'),
('fil', str(filename))
]
self.send(cmd)
return self.wait_for(*cmd[0]) |
Load scanning template from filename. | def load_template(self, filename="{ScanningTemplate}leicacam.xml"):
"""Load scanning template from filename.
Template needs to exist in database, otherwise it will not load.
Parameters
----------
filename : str
Filename to template to load. Filename may contain path also, in
such case, the basename will be used. '.xml' will be stripped
from the filename if it exists because of a bug; LASAF implicit
add '.xml'. If '{ScanningTemplate}' is omitted, it will be added.
Returns
-------
collections.OrderedDict
Response from LASAF in an ordered dict.
Example
-------
::
>>> # load {ScanningTemplate}leicacam.xml
>>> cam.load_template('leicacam')
>>> # load {ScanningTemplate}leicacam.xml
>>> cam.load_template('{ScanningTemplate}leicacam')
>>> # load {ScanningTemplate}leicacam.xml
>>> cam.load_template('/path/to/{ScanningTemplate}leicacam.xml')
"""
basename = os.path.basename(filename)
if basename[-4:] == '.xml':
basename = basename[:-4]
if basename[:18] != '{ScanningTemplate}':
basename = '{ScanningTemplate}' + basename
cmd = [
('sys', '0'),
('cmd', 'load'),
('fil', str(basename))
]
self.send(cmd)
return self.wait_for(*cmd[1]) |
Get information about given keyword. Defaults to stage. | def get_information(self, about='stage'):
"""Get information about given keyword. Defaults to stage."""
cmd = [
('cmd', 'getinfo'),
('dev', str(about))
]
self.send(cmd)
return self.wait_for(*cmd[1]) |
r Include a Python source file in a docstring formatted in reStructuredText. | def incfile(fname, fpointer, lrange="1,6-", sdir=None):
r"""
Include a Python source file in a docstring formatted in reStructuredText.
:param fname: File name, relative to environment variable
:bash:`${TRACER_DIR}`
:type fname: string
:param fpointer: Output function pointer. Normally is :code:`cog.out` but
:code:`print` or other functions can be used for
debugging
:type fpointer: function object
:param lrange: Line range to include, similar to Sphinx
`literalinclude <http://sphinx-doc.org/markup/code.html
#directive-literalinclude>`_ directive
:type lrange: string
:param sdir: Source file directory. If None the :bash:`${TRACER_DIR}`
environment variable is used if it is defined, otherwise
the directory where the :code:`docs.support.incfile` module
is located is used
:type sdir: string
For example:
.. code-block:: python
def func():
\"\"\"
This is a docstring. This file shows how to use it:
.. =[=cog
.. import docs.support.incfile
.. docs.support.incfile.incfile('func_example.py', cog.out)
.. =]=
.. code-block:: python
# func_example.py
if __name__ == '__main__':
func()
.. =[=end=]=
\"\"\"
return 'This is func output'
"""
# Read file
file_dir = (
sdir
if sdir
else os.environ.get("TRACER_DIR", os.path.abspath(os.path.dirname(__file__)))
)
fname = os.path.join(file_dir, fname)
with open(fname) as fobj:
lines = fobj.readlines()
# Parse line specification
tokens = [item.strip() for item in lrange.split(",")]
inc_lines = []
for token in tokens:
if "-" in token:
subtokens = token.split("-")
lmin, lmax = (
int(subtokens[0]),
int(subtokens[1]) if subtokens[1] else len(lines),
)
for num in range(lmin, lmax + 1):
inc_lines.append(num)
else:
inc_lines.append(int(token))
# Produce output
fpointer(".. code-block:: python\n")
fpointer("\n")
for num, line in enumerate(lines):
if num + 1 in inc_lines:
fpointer(" " + line.replace("\t", " ") if line.strip() else "\n")
fpointer("\n") |
Find and return the location of package. json. | def locate_package_json():
"""
Find and return the location of package.json.
"""
directory = settings.SYSTEMJS_PACKAGE_JSON_DIR
if not directory:
raise ImproperlyConfigured(
"Could not locate 'package.json'. Set SYSTEMJS_PACKAGE_JSON_DIR "
"to the directory that holds 'package.json'."
)
path = os.path.join(directory, 'package.json')
if not os.path.isfile(path):
raise ImproperlyConfigured("'package.json' does not exist, tried looking in %s" % path)
return path |
Extract the JSPM configuration from package. json. | def parse_package_json():
"""
Extract the JSPM configuration from package.json.
"""
with open(locate_package_json()) as pjson:
data = json.loads(pjson.read())
return data |
Figure out where jspm_packages/ system. js will be put by JSPM. | def find_systemjs_location():
"""
Figure out where `jspm_packages/system.js` will be put by JSPM.
"""
location = os.path.abspath(os.path.dirname(locate_package_json()))
conf = parse_package_json()
if 'jspm' in conf:
conf = conf['jspm']
try:
conf = conf['directories']
except TypeError:
raise ImproperlyConfigured("`package.json` doesn't appear to be a valid json object. "
"Location: %s" % location)
except KeyError:
raise ImproperlyConfigured("The `directories` configuarion was not found in package.json. "
"Please check your jspm install and/or configuarion. `package.json` "
"location: %s" % location)
# check for explicit location, else fall back to the default as jspm does
jspm_packages = conf['packages'] if 'packages' in conf else 'jspm_packages'
base = conf['baseURL'] if 'baseURL' in conf else '.'
return os.path.join(location, base, jspm_packages, 'system.js') |
Handle YOURLS API errors. | def _handle_api_error_with_json(http_exc, jsondata, response):
"""Handle YOURLS API errors.
requests' raise_for_status doesn't show the user the YOURLS json response,
so we parse that here and raise nicer exceptions.
"""
if 'code' in jsondata and 'message' in jsondata:
code = jsondata['code']
message = jsondata['message']
if code == 'error:noloop':
raise YOURLSNoLoopError(message, response=response)
elif code == 'error:nourl':
raise YOURLSNoURLError(message, response=response)
elif 'message' in jsondata:
message = jsondata['message']
raise YOURLSHTTPError(message, response=response)
http_error_message = http_exc.args[0]
raise YOURLSHTTPError(http_error_message, response=response) |
Validate response from YOURLS server. | def _validate_yourls_response(response, data):
"""Validate response from YOURLS server."""
try:
response.raise_for_status()
except HTTPError as http_exc:
# Collect full HTTPError information so we can reraise later if required.
http_error_info = sys.exc_info()
# We will reraise outside of try..except block to prevent exception
# chaining showing wrong traceback when we try and parse JSON response.
reraise = False
try:
jsondata = response.json()
except ValueError:
reraise = True
else:
logger.debug('Received error {response} with JSON {json}',
response=response, json=jsondata)
_handle_api_error_with_json(http_exc, jsondata, response)
if reraise:
six.reraise(*http_error_info)
else:
# We have a valid HTTP response, but we need to check what the API says
# about the request.
jsondata = response.json()
logger.debug('Received {response} with JSON {json}', response=response,
json=jsondata)
if {'status', 'code', 'message'} <= set(jsondata.keys()):
status = jsondata['status']
code = jsondata['code']
message = jsondata['message']
if status == 'fail':
if code == 'error:keyword':
raise YOURLSKeywordExistsError(message, keyword=data['keyword'])
elif code == 'error:url':
url = _json_to_shortened_url(jsondata['url'], jsondata['shorturl'])
raise YOURLSURLExistsError(message, url=url)
else:
raise YOURLSAPIError(message)
else:
return jsondata
else:
# Without status, nothing special needs to be handled.
return jsondata |
Generate combined independent variable vector. | def _homogenize_waves(wave_a, wave_b):
"""
Generate combined independent variable vector.
The combination is from two waveforms and the (possibly interpolated)
dependent variable vectors of these two waveforms
"""
indep_vector = _get_indep_vector(wave_a, wave_b)
dep_vector_a = _interp_dep_vector(wave_a, indep_vector)
dep_vector_b = _interp_dep_vector(wave_b, indep_vector)
return (indep_vector, dep_vector_a, dep_vector_b) |
Create new dependent variable vector. | def _interp_dep_vector(wave, indep_vector):
"""Create new dependent variable vector."""
dep_vector_is_int = wave.dep_vector.dtype.name.startswith("int")
dep_vector_is_complex = wave.dep_vector.dtype.name.startswith("complex")
if (wave.interp, wave.indep_scale) == ("CONTINUOUS", "LOG"):
wave_interp_func = scipy.interpolate.interp1d(
np.log10(wave.indep_vector), wave.dep_vector
)
ret = wave_interp_func(np.log10(indep_vector))
elif (wave.interp, wave.indep_scale) == ("CONTINUOUS", "LINEAR"):
dep_vector = (
wave.dep_vector.astype(np.float64)
if not dep_vector_is_complex
else wave.dep_vector
)
wave_interp_func = scipy.interpolate.interp1d(wave.indep_vector, dep_vector)
ret = wave_interp_func(indep_vector)
else: # wave.interp == 'STAIRCASE'
wave_interp_func = scipy.interpolate.interp1d(
wave.indep_vector, wave.dep_vector, kind="zero"
)
# Interpolator does not return the right value for the last
# data point, it gives the previous "stair" value
ret = wave_interp_func(indep_vector)
eq_comp = np.all(
np.isclose(wave.indep_vector[-1], indep_vector[-1], FP_RTOL, FP_ATOL)
)
if eq_comp:
ret[-1] = wave.dep_vector[-1]
round_ret = np.round(ret, 0)
return (
round_ret.astype("int")
if (dep_vector_is_int and np.all(np.isclose(round_ret, ret, FP_RTOL, FP_ATOL)))
else ret
) |
Create new independent variable vector. | def _get_indep_vector(wave_a, wave_b):
"""Create new independent variable vector."""
exobj = pexdoc.exh.addex(RuntimeError, "Independent variable ranges do not overlap")
min_bound = max(np.min(wave_a.indep_vector), np.min(wave_b.indep_vector))
max_bound = min(np.max(wave_a.indep_vector), np.max(wave_b.indep_vector))
exobj(bool(min_bound > max_bound))
raw_range = np.unique(np.concatenate((wave_a.indep_vector, wave_b.indep_vector)))
return raw_range[np.logical_and(min_bound <= raw_range, raw_range <= max_bound)] |
Verify that two waveforms can be combined with various mathematical functions. | def _verify_compatibility(wave_a, wave_b, check_dep_units=True):
"""Verify that two waveforms can be combined with various mathematical functions."""
exobj = pexdoc.exh.addex(RuntimeError, "Waveforms are not compatible")
ctuple = (
bool(wave_a.indep_scale != wave_b.indep_scale),
bool(wave_a.dep_scale != wave_b.dep_scale),
bool(wave_a.indep_units != wave_b.indep_units),
(bool(wave_a.dep_units != wave_b.dep_units) if check_dep_units else False),
bool(wave_a.interp != wave_b.interp),
)
exobj(any(ctuple)) |
Load the existing systemjs manifest and remove any entries that no longer exist on the storage. | def load_systemjs_manifest(self):
"""
Load the existing systemjs manifest and remove any entries that no longer
exist on the storage.
"""
# backup the original name
_manifest_name = self.manifest_name
# load the custom bundle manifest
self.manifest_name = self.systemjs_manifest_name
bundle_files = self.load_manifest()
# reset the manifest name
self.manifest_name = _manifest_name
# check that the files actually exist, if not, remove them from the manifest
for file, hashed_file in bundle_files.copy().items():
if not self.exists(file) or not self.exists(hashed_file):
del bundle_files[file]
return bundle_files |
Define trace parameters. | def trace_pars(mname):
"""Define trace parameters."""
pickle_fname = os.path.join(os.path.dirname(__file__), "{0}.pkl".format(mname))
ddir = os.path.dirname(os.path.dirname(__file__))
moddb_fname = os.path.join(ddir, "moddb.json")
in_callables_fname = moddb_fname if os.path.exists(moddb_fname) else None
out_callables_fname = os.path.join(ddir, "{0}.json".format(mname))
noption = os.environ.get("NOPTION", None)
exclude = ["_pytest", "execnet"]
partuple = collections.namedtuple(
"ParTuple",
[
"pickle_fname",
"in_callables_fname",
"out_callables_fname",
"noption",
"exclude",
],
)
return partuple(
pickle_fname, in_callables_fname, out_callables_fname, noption, exclude
) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.