def test_representation(self, plot, lattice_axes, grid_representation): kwargs = {"isos": [], "reduce_method": "average"} ndim = len(lattice_axes) if ndim == 3: kwargs["isos"] = [{"frac": 0.5}] new_grid, representation = grid_representation if new_grid.grid.min() == new_grid.grid.max() and ndim == 3: return plot.update_settings(axes=lattice_axes, represent=representation, nsc=[1, 1, 1], **kwargs) new_plot = new_grid.plot(**ChainMap( plot.settings, dict(axes=lattice_axes, represent="real", grid_file=None))) assert np.allclose( self._get_plotted_values(plot), self._get_plotted_values(plot=new_plot) ), f"'{representation}' representation of the {ndim}D plot is not correct"
def __init__( self, constructor_dict: ConstructorDict = DEFAULT_CLASS_MAP, default_encoding: Optional[str] = None, force_default_encoding: bool = False, global_environment: Optional[StrMap] = None, ) -> None: self.constructor_dict = constructor_dict self.default_encoding = default_encoding self.force_default_encoding = force_default_encoding self.global_environment = ChainMap( {} if global_environment is None else global_environment, ) self.empty_environment: StrMap = ChainMap({}) self._reset()
def scan_profile(args: ArgsType) -> None: """ Report working connection parameters """ if args["dryrun"]: raise SyntaxError("Can't reasonably show a dry run for a profile scan") url = args["url"] org = args["org"] fid = args["fid"] useragent = args["useragent"] gen_newfileuid = not args["nonewfileuid"] timeout = 2.0 scan_results = _scan_profile( url=url, org=org, fid=fid, useragent=useragent, gen_newfileuid=gen_newfileuid, timeout=timeout, ) v1, v2, signoninfo = scan_results if (not v2["versions"]) and (not v1["versions"]): msg = f"Scan found no working formats for {url}" print(msg) else: print(json.dumps(scan_results)) if args["write"]: extra_args = _best_scan_format(scan_results) write_config(ChainMap(extra_args, dict(args)))
def merge_config( args: argparse.Namespace, config: configparser.ConfigParser ) -> ArgsType: """ Merge CLI args > user config > OFX Home > defaults """ logger.info("Merging args") # All ArgumentParser args that have a value set _args = extractns(args) logger.debug(f"CLI args: {_args}") if "server" in _args: user_cfg = read_config(config, _args["server"]) else: user_cfg = {} logger.debug(f"Configs: {user_cfg}") merged: ArgsType = ChainMap(_args, user_cfg, DEFAULTS) # logger.debug(f"CLI args merged with user configs and defaults: {extrargs(merged)}") # Try to perform an OFX Home lookup if: # - it's configured from the CLI # - it's configured in ofxget.cfg # - we don't have a URL if "ofxhome" in _args or "ofxhome" in user_cfg or (not merged["url"]): merge_from_ofxhome(merged) if not ( merged.get("url", None) or merged.get("dryrun", False) or merged.get("request", None) == "list" ): err = "Missing URL" if "server" not in _args: logger.error(err) msg = ( f"{err} - please provide a server nickname, " "or configure 'url' / 'ofxhome'\n" ) print(msg) command = merged["request"] make_argparser().subparsers[command].print_help() # type: ignore sys.exit() server = _args["server"] # Allow sloppy CLI args - passing URL as "server" positional arg if urllib_parse.urlparse(server).scheme: merged["url"] = server merged["server"] = None else: logger.error(err) msg = f"{err} - please configure 'url' or 'ofxhome' for server '{server}'" raise ValueError(msg) logger.info(f"Merged args: {extrargs(merged)}") return merged
async def _update_backend_configs(self, backend_configs): added, removed, updated = compute_dict_delta(self.backend_replicas, backend_configs) for backend_tag, config in ChainMap(added, updated).items(): self.backend_replicas[backend_tag].set_max_concurrent_queries( config.max_concurrent_queries) for backend_tag in removed.keys(): if backend_tag in self.backend_replicas: del self.backend_replicas[backend_tag]
def test_symtable_ctx(self): node = _NodeWithSymbolTable(symbols=[_NodeWithSymbolName()]) kwargs = dict(symtable=ChainMap({"a": True})) with eve.SymbolTableTrait.symtable_merger(None, node, kwargs): assert "symtable" in kwargs assert "symbol_name" in kwargs["symtable"] assert "symtable" in kwargs assert "symbol_name" not in kwargs["symtable"]
def load_local(self, source: Union[str, Path, TextIO] = None): """Load schemas from a local file These files will be treated as local schemas, and will not be sent to the bus. This can be useful for validation during development and testing. """ if isinstance(source, str): source = Path(source) def _load_schema(path, file_data): try: return json.loads(file_data) except JSONDecodeError as e: raise InvalidSchema( "Could not parse schema file {}: {}".format(path, e.msg)) if source is None: # No source, read from stdin schema = _load_schema("[stdin]", sys.stdin.read()) elif hasattr(source, "is_dir") and source.is_dir(): # Read each json file in directory schemas = [] for file_path in source.glob("*.json"): schemas.append( _load_schema(file_path, file_path.read_text(encoding="utf8"))) schema = ChainMap(*schemas) elif hasattr(source, "read"): # Read file handle schema = _load_schema(source.name, source.read()) elif hasattr(source, "read_text"): # Read pathlib Path schema = _load_schema(source.name, source.read_text()) else: raise InvalidSchema( "Did not recognise provided source as either a " "directory path, file path, or file handle: {}".format(source)) for api_name, api_schema in schema.items(): self.local_schemas[api_name] = api_schema return schema
def run(exps: Iterable[Value], ctx: Context = None, show: bool = False) -> Value: res = VList([]) if ctx is None: ctx = ChainMap({}, stdlib) for e in exps: res = e.run(ctx) if show: print(res) return res
async def _update_replica_handles(self, replica_handles): added, removed, updated = compute_dict_delta(self.backend_replicas, replica_handles) for backend_tag, replica_handles in ChainMap(added, updated).items(): self._get_or_create_replica_set( backend_tag).update_worker_replicas(replica_handles) for backend_tag in removed.keys(): if backend_tag in self.backend_replicas: del self.backend_replicas[backend_tag]
def build_request( body: MutableMapping[str, Any], parser: Parser, settings_class: Union[Type[HTTPRequestSettings], Type[SubscriptionRequestSettings]], schema: RequestSchema, dataset: Dataset, timer: Timer, referrer: str, ) -> Request: with sentry_sdk.start_span(description="build_request", op="validate") as span: try: request_parts = schema.validate(body) if settings_class == HTTPRequestSettings: settings = { **request_parts.settings, "consistent": _consistent_override( request_parts.settings.get("consistent", False), referrer ), } settings_obj: Union[ HTTPRequestSettings, SubscriptionRequestSettings ] = settings_class(**settings) elif settings_class == SubscriptionRequestSettings: settings_obj = settings_class( consistent=_consistent_override(True, referrer) ) query = parser(request_parts, settings_obj, dataset) request_id = uuid.uuid4().hex request = Request( request_id, # TODO: Replace this with the actual query raw body. # this can have an impact on subscriptions so we need # to be careful with the change. ChainMap(request_parts.query, *request_parts.extensions.values()), query, settings_obj, referrer, ) except (InvalidJsonRequestException, InvalidQueryException) as exception: record_invalid_request(timer, referrer) raise exception except Exception as exception: record_error_building_request(timer, referrer) raise exception span.set_data("snuba_query", request.body) timer.mark("validate_schema") return request
def main(): fis: Mapping[str, str] = ofxhome.list_institutions() for ofxhome_id in fis.keys(): print("Scanning {}".format(ofxhome_id)) lookup: Optional[ofxhome.OFXServer] = ofxhome.lookup(ofxhome_id) if lookup is None or lookup.url is None: continue url = lookup.url org = lookup.org fid = lookup.fid lookup_name = saxutils.unescape(lookup.name) srvr_nick = known_servers.get(ofxhome_id, lookup_name) ofxhome_id = lookup.id assert ofxhome_id names = LibraryConfig["NAMES"] if ofxhome_id not in names: names[ofxhome_id] = lookup_name if ofxhome.ofx_invalid(lookup) or ofxhome.ssl_invalid(lookup): blank_fmt = {"versions": [], "formats": {}} scan_results = (blank_fmt, blank_fmt, {}) else: scan_results: ofxget.ScanResults = ofxget._scan_profile( url=url, org=org, fid=fid, timeout=10.0 ) v1, v2, _ = scan_results if (not v2["versions"]) and (not v1["versions"]): # If no OFX response, blank the server config LibraryConfig[srvr_nick] = {"ofxhome": ofxhome_id} continue format = ofxget._best_scan_format(scan_results) looked_up_data = { "ofxhome": ofxhome_id, "url": url, "org": org, "fid": fid, "brokerid": lookup.brokerid, } args = ChainMap({"server": srvr_nick}, looked_up_data, format) write_config(args)
async def _update_traffic_policies(self, traffic_policies): added, removed, updated = compute_dict_delta(self.endpoint_policies, traffic_policies) for endpoint, traffic_policy in ChainMap(added, updated).items(): self.endpoint_policies[endpoint] = RandomEndpointPolicy( traffic_policy) if endpoint in self._pending_endpoints: future = self._pending_endpoints.pop(endpoint) future.set_result(_PendingEndpointFound.ADDED) for endpoint, traffic_policy in removed.items(): del self.endpoint_policies[endpoint] if endpoint in self._pending_endpoints: future = self._pending_endpoints.pop(endpoint) future.set_result(_PendingEndpointFound.REMOVED)
def get_arguments(): parser = argparse.ArgumentParser() parser.add_argument( '-k', '--token', required=False, help="Ceye.io API token, geting on Ceye.io user's profile") parser.add_argument('-t', '--type', help='Ceye log type, dns or http, default http') parser.add_argument('-f', '--filter', type=str, help='filter args') args = parser.parse_args() cmd_args = {k: v for k, v in vars(args).items() if v} default = {'token': 'your token', 'type': 'http', 'filter': ''} return ChainMap(cmd_args, default)
def convert_env( r_env: parser.RObject, conversion_function: ConversionFunction, ) -> ChainMap[Union[str, bytes], Any]: """Convert environment objects.""" if r_env.info.type is not parser.RObjectType.ENV: raise TypeError("Must receive a ENV object") frame = conversion_function(r_env.value.frame) enclosure = conversion_function(r_env.value.enclosure) hash_table = conversion_function(r_env.value.hash_table) dictionary = {} for d in hash_table: if d is not None: dictionary.update(d) return ChainMap(dictionary, enclosure)
def gen_clinit(self, var_decls: Iterable[VarDecl], symtab: MutableMapping[str, Symbol]) -> Iterator[str]: methodname = '<clinit>' methodtype = MType([], VOID_TYPE) frame = Frame(methodname, methodtype.rettype) frame.func_type = methodtype frame.enterScope(True) method_env = MethodEnv(frame, ChainMap(symtab)) var_gens = [ self.visitVarDecl(var_decl, method_env) for var_decl in var_decls ] # Generate static field definitions for global variables yield from map(next, var_gens) # type: ignore yield from emitter.emit_method(methodname, methodtype) # Generate variable initialization code yield from chain.from_iterable(var_gens) yield from emitter.emit_return(frame) yield from emitter.emit_end_method(frame)
def _merge_acctinfo(args: ArgsType, markup: BytesIO) -> None: # *ACCTINFO classes don't have rich comparison methods; # can't sort by class sortKey = attrgetter("__class__.__name__") acctinfos: List[AcctInfo] = sorted(extract_acctinfos(markup), key=sortKey) def parse_acctinfos(clsName, acctinfos): dispatcher = { "BANKACCTINFO": parse_bankacctinfos, "CCACCTINFO": parse_ccacctinfos, "INVACCTINFO": parse_invacctinfos, } parser = dispatcher.get(clsName, lambda x: {}) return parser(acctinfos) parsed_args: List[ParsedAcctinfo] = [ parse_acctinfos(clsnm, infos) for clsnm, infos in itertools.groupby(acctinfos, key=sortKey) ] # Insert extracted ACCTINFO after CLI commands, but before config files args.maps.insert(1, ChainMap(*parsed_args))
def _superdict(cls) -> Mapping[str, Any]: """ Consolidate ``cls.__dict__`` with that of all superclasses. Ordering is significant for OFX messages, which maps to significant ordering of class attributes of ``ofxtools.models.base.Aggregate`` subclasses. That ordering is implemented by combining `PEP 520`_ (which was implemented as of Python 3.6), `collections.ChainMap`_, and Python's `inheritance chain`_ (i.e. the MRO). PEP 520 guarantees that each class's ``__dict__`` preserves the order in which its attributes and methods were defined. ``ChainMap`` searches its list of mappings from left to right. By feeding a class's MRO into ``ChainMap``, we get an ordering where attributes defined on subclasses override those defined on the parent, preserving the order of the class definition in each case. .. _PEP 520: https://www.python.org/dev/peps/pep-0520/ .. _collections.ChainMap: https://docs.python.org/3/library/collections.html#collections.ChainMap .. _inheritance order: https://www.python.org/download/releases/2.3/mro/ """ return ChainMap(*[base.__dict__ for base in cls.mro()])
def visitFuncDecl(self, ast: FuncDecl, global_symtab: MutableMapping[str, Symbol]) -> BodyGen: name = ast.name.name func_sym = global_symtab[name] func_type = cast(MType, func_sym.type) frame = Frame(name, func_type.rettype) frame.func_type = func_type frame.enterScope(True) param_syms = { param.variable.name: Symbol(param_type, frame.getNewIndex()) for param, param_type in zip(ast.param, func_type.partype) } symtab = ChainMap(param_syms, global_symtab) if name == 'main' and not ast.param: # Method `main` always has a parameter frame.getNewIndex() method_env = MethodEnv(frame, symtab) body_code = [] body_gen = self.visit_stmt_list(*ast.body, method_env, new_scope=False) for ret in body_gen: if isinstance(ret, SkipToFunc): yield ret else: body_code.append(ret) yield from emitter.emit_method(name, func_type) # Generate .var directives for parameters for param in ast.param: name = param.variable.name param_sym = symtab[name] yield from emitter.emit_var(name, param_sym, frame) yield from iter(body_code) yield from emitter.emit_return(frame) yield from emitter.emit_end_method(frame)
def merge_msdf( *msdfs: MappingSetDataFrame, reconcile: bool = True, ) -> MappingSetDataFrame: """Merge multiple MappingSetDataFrames into one. :param msdfs: A Tuple of MappingSetDataFrames to be merged :param reconcile: If reconcile=True, then dedupe(remove redundant lower confidence mappings) and reconcile (if msdf contains a higher confidence _negative_ mapping, then remove lower confidence positive one. If confidence is the same, prefer HumanCurated. If both HumanCurated, prefer negative mapping). Defaults to True. :returns: Merged MappingSetDataFrame. """ merged_msdf = MappingSetDataFrame() # Inject metadata of msdf into df msdf_with_meta = [inject_metadata_into_df(msdf) for msdf in msdfs] # merge df [# 'outer' join in pandas == FULL JOIN in SQL] df_merged = reduce( lambda left, right: left.merge(right, how="outer", on=list(left.columns)), [msdf.df for msdf in msdf_with_meta if msdf.df is not None], ) # merge the non DataFrame elements prefix_map_list = [msdf.prefix_map for msdf in msdf_with_meta] # prefix_map_merged = {k: v for d in prefix_map_list for k, v in d.items()} merged_msdf.prefix_map = dict(ChainMap(*prefix_map_list)) merged_msdf.df = df_merged if reconcile: merged_msdf.df = filter_redundant_rows(merged_msdf.df) if PREDICATE_MODIFIER in merged_msdf.df.columns: merged_msdf.df = deal_with_negation(merged_msdf.df) # deals with negation # TODO: Add default values for license and mapping_set_id. return merged_msdf
# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED # OF THE POSSIBILITY OF SUCH DAMAGE. from typing import Union, ChainMap, Optional from fhirtordf.rdfsupport.namespaces import AnonNS, namespaces as fhirtordf_namespaces, FHIR, SCT from fhirtordf.rdfsupport.numericnamespace import NumericNamespace from rdflib import Namespace, URIRef HGNC = Namespace("http://www.genenames.org/") RXNORM = NumericNamespace("http://www.nlm.nih.gov/research/umls/rxnorm/") # Note that this is a different namespace than the one that is included in the type arc SNOMED = Namespace("http://snomed.info/sct/") namespaces = ChainMap(fhirtordf_namespaces, { "hgnc": str(HGNC), "rxnorm": str(RXNORM) }) def fhir_namespace_for(uri: Union[URIRef, Namespace, str]) -> Optional[str]: """ Reverse namespace lookup. Note that returned namespace may not be unique :param uri: namespace URI :return: namespace (lower case form) """ uri = str(uri) if not uri.endswith(('#', '/')): uri += '/' if uri not in namespaces.values(): if uri.startswith(str(FHIR)):
Counter, DefaultDict, Deque, Dict, FrozenSet, List, Optional, OrderedDict, Set, Tuple, Type, Union, ) # These should be marked deprecated for Python >= 3.9 v1: List[int] = [1, 2, 3] v2: Dict[int, str] = {} v3: Set[int] = set() v4: Tuple[int] = (3, ) v5: FrozenSet[int] = frozenset() v6: Type[int] = int v7 = Deque() v8 = DefaultDict() v9 = OrderedDict() v10 = Counter() v11 = ChainMap() # These should be marked deprecated for Python >= 3.10 v20: Union[int, str] v21: Optional[int]
"country": "US" } print("Default command line args :") print(defaults) parser = argparse.ArgumentParser( description="Test reading command line arguments.") parser.add_argument("-c", "--color", help="Specifies the preferred color.") parser.add_argument("-u", "--user", help="Specifies the current user.") parser.add_argument("-o", "--os", help="Specifies the preferred Operating System.") parser.add_argument("-l", "--language", help="Specifies the user language.") parser.add_argument("-n", "--country", help="Specifies the current country.") namespace = parser.parse_args() actual_command_line_args = {k: v for k, v in vars(namespace).items() if v} # vars(obj) : returns the __dict__ attribute for an object (if present). print("actual_command_line_args:", actual_command_line_args) # Dont't link them together like this, it will copy all the data: # result = defaults.copy() # result.update(os.environ) # result.update(actual_command_line_args) # use this instead, doesn't copy but itterates : result = ChainMap(actual_command_line_args, defaults) print("Resulting command line args :") for k, v in result.items(): print(k, "-->", v)
try: import readline except ImportError: pass from typing import cast, ChainMap, List, Sequence import malcore as core import maltypes as t from malerrors import MalError, MalNoInputError from reader import read_str from printer import pr_str Env = ChainMap[str, t.MalType] repl_env: Env = ChainMap(core.ns) def READ(in_: str) -> t.MalType: return read_str(in_) def eval_ast(ast: t.MalType, env: Env) -> t.MalType: if isinstance(ast, t.MalSymbol): try: return env[ast.name] except KeyError: raise MalError(f'{ast.name} not found') if isinstance(ast, (t.MalList, t.MalVector)): return type(ast)([EVAL(i, env) for i in ast.items]) if isinstance(ast, t.MalHashMap):
@functools.wraps(op) def wrapper(*args: t.MalType) -> t.MalType: if not all(isinstance(i, t.MalInt) for i in args): raise MalError('Only ints are supported as arguments') acc, *rest = map(o.attrgetter('value'), args) # type: Tuple[int, List[int]] for i in rest: acc = op(acc, i) return t.MalInt(acc) return t.MalFunction(cast(t.MalNativeFunction, wrapper)) repl_env: Env = ChainMap({ '+': _int_op(o.add), '-': _int_op(o.sub), '*': _int_op(o.mul), '/': _int_op(o.floordiv), }) def READ(in_: str) -> t.MalType: return read_str(in_) def eval_ast(ast: t.MalType, env: Env) -> t.MalType: if isinstance(ast, t.MalSymbol): try: return env[ast.name] except KeyError: raise MalError(f'{ast.name} not found') if isinstance(ast, (t.MalList, t.MalVector)):
def data(self) -> ChainMap[Any, Any]: # type: ignore return ChainMap(self._context_data, self._parent_context or {})
def _superdict(cls) -> Mapping[str, Any]: """ Consolidate cls.__dict__ with that of all superclasses. """ return ChainMap(*[base.__dict__ for base in cls.mro()])
def __post_init__(self) -> None: from simplegist import Simplegist gh_gist = Simplegist(username='******', api_token='API_TOKEN') self._gist = gh_gist[self.gist_id] def _getitem(self, key: str) -> str: return self._gist[key] _base_config = { 'handlers': ['console'], 'level': logging.ERROR, 'propagate': False } _info_config = ChainMap({'level': logging.INFO}, _base_config) _debug_config = ChainMap({'level': logging.DEBUG}, _base_config) def configure_logging(): logging_config = { 'version': 1, 'formatters': { 'f': { 'format': '%(asctime)s %(levelname)-8s %(name)-20s -- %(message)s' } }, 'handlers': { 'console': { 'class': 'logging.StreamHandler',