from typing import NamedTuple, Tuple, Dict, Union, List import logging import sys import numpy as np log = logging.getLogger('sampleOutput') epsilon = sys.float_info.epsilon ComparisonResult = NamedTuple('ComparisonResult', [('tp', int), ('fp', int), ('tn', int), ('fn', int)]) ValidationResult = NamedTuple('ValidationResult', [('precision', float), ('recall', float), ('f_measure', float)]) def precision(tp: int, fp: int) -> float: if (tp + fp) == 0: return 0 else: return tp / (tp + fp) def recall(tp: int, fn: int) -> float: if (tp + fn) == 0: return 0 else: return tp / (tp + fn) def f_measure(p: float, r: float) -> float:
from fractions import Fraction from typing import NamedTuple ProbabilisticInterval = NamedTuple("ProbabilisticInterval", [ ("lower_bound", int), ("upper_bound", int), ("confidence", Fraction), ])
@dataclass(frozen=True) class Let: """ Here: Let is more a syntactic sugar for `Ap (Lam ref body) expr` """ ref: Ref expr: Expr body: Expr @dataclass(frozen=True) class Lam: name: str # Pattern body: Expr # May refer to `Ref(name)` MethodName = NamedTuple('MethodName', [('val', str)]) @dataclass(frozen=True) class Intrin: name: MethodName args: TMap[str, Expr] Mem = TMap[Ref, Expr] # ___ _____ # |_ _| ____|_ ___ __ _ __ # | || _| \ \/ / '_ \| '__| # | || |___ > <| |_) | | # |___|_____/_/\_\ .__/|_|
from typing import (Any, Dict, Iterable, List, Mapping, NamedTuple, Optional, Sequence, Set, Tuple, Union) import numpy from numpy import count_nonzero from scipy.stats import fisher_exact from sklearn.base import BaseEstimator, ClassifierMixin from sklearn.ensemble import RandomForestClassifier from sklearn.exceptions import NotFittedError from sklearn.metrics import accuracy_score from sklearn.model_selection import train_test_split from sklearn.tree import _tree as Tree, DecisionTreeClassifier from lookout.core.ports import Type RuleAttribute = NamedTuple("RuleAttribute", (("feature", int), ("cmp", bool), ("threshold", float))) """ `feature` is the feature taken for comparison `cmp` is the comparison type: True is "x > v", False is "x <= v" `threshold` is "v", the threshold value """ RuleStats = NamedTuple("RuleStats", (("cls", int), ("conf", float))) """ `cls` is the predicted class `conf` is the rule confidence \\in [0, 1], "1" means super confident """ Rule = NamedTuple("RuleType", (("attrs", Tuple[RuleAttribute, ...]), ("stats", RuleStats)))
from selenium.webdriver.common.by import By from selenium.webdriver.support import expected_conditions as EC from selenium.webdriver.support.select import Select OMEGAUP_ROOT = os.path.normpath(os.path.join(__file__, '../../../..')) PATH_WHITELIST = ('/api/grader/status/', '/js/error_handler.js') MESSAGE_WHITELIST = ('http://staticxx.facebook.com/', '/api/grader/status/') # This contains all the Python path-hacking to a single file instead of # spreading it throughout all the files. sys.path.append(os.path.join(OMEGAUP_ROOT, 'stuff')) # pylint: disable=wrong-import-position,unused-import import database_utils # NOQA Identity = NamedTuple('Identity', [('username', Text), ('password', Text)]) class StatusBarIsDismissed: """A class that can wait for the status bar to be dismissed.""" def __init__(self, status_element, message_class, already_opened=False): self.status_element = status_element self.counter = int( self.status_element.get_attribute('data-counter') or '0') self.clicked = False self.message_class = message_class self.already_opened = already_opened def _click_button(self): if self.clicked: return
from neuralmonkey.decorators import tensor from neuralmonkey.model.sequence import (EmbeddedSequence, EmbeddedFactorSequence) RNN_CELL_TYPES = { "NematusGRU": NematusGRUCell, "GRU": OrthoGRUCell, "LSTM": tf.nn.rnn_cell.LSTMCell } RNN_DIRECTIONS = ["forward", "backward", "bidirectional"] # pylint: disable=invalid-name RNNCellTuple = Tuple[tf.nn.rnn_cell.RNNCell, tf.nn.rnn_cell.RNNCell] RNNSpec = NamedTuple("RNNSpec", [("size", int), ("direction", str), ("cell_type", str)]) RNNSpecTuple = Union[Tuple[int], Tuple[int, str], Tuple[int, str, str]] # pylint: enable=invalid-name def _make_rnn_spec(size: int, direction: str = "bidirectional", cell_type: str = "GRU") -> RNNSpec: if size <= 0: raise ValueError( "RNN size must be a positive integer. {} given.".format(size)) if direction not in RNN_DIRECTIONS: raise ValueError("RNN direction must be one of {}. {} given.".format( str(RNN_DIRECTIONS), direction))
int_neg_op = int_unary_op('-', 'CPyTagged_Negate') int_invert_op = int_unary_op('~', 'CPyTagged_Invert') # integer comparsion operation implementation related: # Description for building int logical ops # For each field: # binary_op_variant: identify which BinaryIntOp to use when operands are short integers # c_func_description: the C function to call when operands are tagged integers # c_func_negated: whether to negate the C function call's result # c_func_swap_operands: whether to swap lhs and rhs when call the function IntLogicalOpDescrption = NamedTuple( 'IntLogicalOpDescrption', [('binary_op_variant', int), ('c_func_description', CFunctionDescription), ('c_func_negated', bool), ('c_func_swap_operands', bool)]) # description for equal operation on two boxed tagged integers int_equal_ = c_custom_op(arg_types=[int_rprimitive, int_rprimitive], return_type=bit_rprimitive, c_function_name='CPyTagged_IsEq_', error_kind=ERR_NEVER) int_less_than_ = c_custom_op(arg_types=[int_rprimitive, int_rprimitive], return_type=bit_rprimitive, c_function_name='CPyTagged_IsLt_', error_kind=ERR_NEVER) # provide mapping from textual op to short int's op variant and boxed int's description
stage_name='EvaluateMetricsAndPlots', run_after=run_after, ptransform=_EvaluateMetricsPlotsAndValidations( eval_config=eval_config, eval_shared_models=eval_shared_models, metrics_key=metrics_key, plots_key=plots_key, attributions_key=attributions_key, schema=schema, random_seed_for_testing=random_seed_for_testing)) MetricComputations = NamedTuple('MetricComputations', [ ('non_derived_computations', List[metric_types.MetricComputation]), ('derived_computations', List[metric_types.DerivedMetricComputation]), ('cross_slice_computations', List[metric_types.CrossSliceMetricComputation]), ('ci_derived_computations', List[metric_types.CIDerivedMetricComputation]) ]) def _filter_and_separate_computations( computations: metric_types.MetricComputations) -> MetricComputations: """Filters duplicate computations and separates non-derived and derived. All metrics are based on either direct computations using combiners or are based on the results of one or more other computations. This code separates the three types of computations so that only the combiner based computations are passed to the main combiner call and the remainder are processed after those combiners have run. Filtering is required because DerivedMetricComputations and CrossSliceMetricComputations typically include
if PY3: CONFIG_SYNTAX_ERROR += "\nDid you change the syntax from 2.x to 3.x?" CONFIG_ERROR = "There is a programable error in your configuration file:\n\n%s" CONFIG_EXIT_ERROR = "The configuration file (or one of the modules it imports) " \ "called sys.exit()" CONFIG_ENUM_WARNING = "The config value `{name}` has to be a one of {candidates}, " \ "but `{current}` is given." CONFIG_PERMITTED_TYPE_WARNING = "The config value `{name}' has type `{current.__name__}', " \ "expected to {permitted}." CONFIG_TYPE_WARNING = "The config value `{name}' has type `{current.__name__}', " \ "defaults to `{default.__name__}'." if PY3: unicode = str # special alias for static typing... ConfigValue = NamedTuple('ConfigValue', [('name', str), ('value', Any), ('rebuild', Union[bool, unicode])]) class ENUM(object): """represents the config value should be a one of candidates. Example: app.add_config_value('latex_show_urls', 'no', None, ENUM('no', 'footnote', 'inline')) """ def __init__(self, *candidates): # type: (unicode) -> None self.candidates = candidates def match(self, value): # type: (Union[unicode,List,Tuple]) -> bool if isinstance(value, (list, tuple)):
_SETUP_PY_TEMPLATE = """# -*- coding: utf-8 -*- from setuptools import setup, find_packages setup( name="{name}", version="{version}", description="Modular pipeline `{name}`", packages=find_packages(), include_package_data=True, package_data={package_data}, ) """ PipelineArtifacts = NamedTuple( "PipelineArtifacts", [("pipeline_dir", Path), ("pipeline_tests", Path), ("pipeline_conf", Path)], ) def _check_pipeline_name(ctx, param, value): # pylint: disable=unused-argument if value: _assert_pkg_name_ok(value) return value @click.group() def pipeline(): """Commands for working with pipelines.""" @command_with_verbosity(pipeline, "create")
from keras.initializers import * from keras.activations import * from keras.layers import Dense from keras.models import Sequential import itertools from data import Data EPOCHS: int = 10 BATCH_SIZE: int = 512 denseLayerConfig = { 'activation': ('relu', 'selu', 'tanh'), 'kernel_initializer': ('he_normal', 'RandomNormal', 'RandomUniform') } LayerConfig = NamedTuple('LayerConfig', [(field_name, str) for field_name in denseLayerConfig.keys()]) def all_combos(in_dict: Dict[object, Iterable]): ''' returns all dicts in which for each key, the key remains the same but the value is an element chosen from the original value which is an iterable :param in_dict: :return: ''' for tuple in itertools.product(*in_dict.values()): yield dict(zip(denseLayerConfig.keys(), tuple)) def exhaustive_interpolate_vectors(a: float, b: float,
""" We'll feed inputs into out network in batches. So here are some tools for iterating over data in batches. """ from typing import Iterator, NamedTuple import numpy as np from joelnet.tensor import Tensor Batch = NamedTuple("Batch", [("inputs", Tensor), ("targets", Tensor)]) class DataIterator: def __call__(self, inputs: Tensor, targets: Tensor) -> Iterator: raise NotImplementedError class BatchIterator(DataIterator): def __init__(self, batch_size: int = 32, shuffle: bool = True) -> None: self.batch_size = batch_size self.shuffle = shuffle def __call__(self, inputs: Tensor, targets: Tensor) -> Iterator: starts = np.arange(0, len(inputs), self.batch_size) if self.shuffle: np.random.shuffle(starts) for start in starts: end = start + self.batch_size
from recidiviz.common.constants.state.state_supervision_violation import ( StateSupervisionViolationType, ) from recidiviz.common.constants.state.state_supervision_violation_response import ( StateSupervisionViolationResponseRevocationType, ) from recidiviz.persistence.entity.state.entities import ( StateIncarcerationPeriod, StateSupervisionPeriod, StateSupervisionViolationResponse, ) RevocationDetails = NamedTuple( "RevocationDetails", [ ("revocation_type", Optional[StateSupervisionViolationResponseRevocationType]), ("revocation_type_subtype", Optional[str]), ("source_violation_type", Optional[StateSupervisionViolationType]), ("supervising_officer_external_id", Optional[str]), ("level_1_supervision_location_external_id", Optional[str]), ("level_2_supervision_location_external_id", Optional[str]), ], ) def get_revocation_details( incarceration_period: StateIncarcerationPeriod, supervision_period: Optional[StateSupervisionPeriod], violation_responses: List[StateSupervisionViolationResponse], supervision_period_to_agent_associations: Optional[Dict[int, Dict[Any, Any]]], ) -> RevocationDetails: """Identifies the attributes of the revocation return from the supervision period that was revoked, if available,
>>> curl 'localhost:8000/atom?f=https%3A%2F%2Famericancynic.net%2Fshaarli%2F%3Fdo%3Datom&f=https%3A%2F%2Fhnrss.org%2Fnewest&n=1' Interface --------- """ from feedmixer import FeedMixer from shelfcache import ShelfCache import falcon from typing import NamedTuple, List import json import urllib import urllib.parse ParsedQS = NamedTuple('ParsedQS', [('f', List[str]), ('n', int), ('full', bool)]) def parse_qs(req: falcon.Request) -> ParsedQS: """ Get `feeds` and `num_keep` from request query string. :param req: the Falcon request from which to parse the query string. """ qs = falcon.uri.parse_query_string(req.query_string) feeds = qs.get('f', []) n = qs.get('n', 0) full = qs.get('full', False) if not isinstance(feeds, list): feeds = [feeds] # NOQA return ParsedQS(feeds, int(n), bool(full))
FuncDef, FuncBase, ARG_STAR, ARG_STAR2, ARG_NAMED, ARG_NAMED_OPT, ) from mypy.stubgenc import parse_all_signatures, find_unique_signatures, generate_stub_for_c_module from mypy.stubutil import is_c_module, write_header from mypy.options import Options as MypyOptions Options = NamedTuple('Options', [ ('pyversion', Tuple[int, int]), ('no_import', bool), ('doc_dir', str), ('search_path', List[str]), ('interpreter', str), ('modules', List[str]), ('ignore_errors', bool), ('recursive', bool), ]) class CantImport(Exception): pass def generate_stub_for_module(module: str, output_dir: str, quiet: bool = False, add_header: bool = False, sigs: Dict[str, str] = {},
from pyramids.config import ModelConfig from pyramids.loader import ModelLoader from pyramids.model import Model from pyramids.plugin import Plugin from pyramids.tokenization import Tokenizer __all__ = [ 'PLUGIN_ENTRY_POINT', 'get_available_tokenizers', 'get_available_models', 'get_tokenizer', 'get_model_loader', 'load_model', ] PluginEntry = NamedTuple('PluginEntry', [('provider', str), ('name', str)]) PLUGIN_ENTRY_POINT = 'pyramids.plugins' LOGGER = logging.getLogger(__name__) def get_available_tokenizers(language_name: str = None, iso639_1: str = None, iso639_2: str = None) -> Set[PluginEntry]: results = set() for plugin_name in _PLUGINS: plugin: Plugin = _PLUGINS[plugin_name] for name, language in plugin.provided_tokenizer_types.items(): if language_name is not None and language.name != language_name: continue
from typing import NamedTuple HttpMethods = NamedTuple('HttpMethods', [ ('GET', str), ('HEAD', str), ('POST', str), ('PUT', str), ('DELETE', str), ('CONNECT', str), ('OPTIONS', str), ('TRACE', str), ('PATCH', str), ]) httpMethods = HttpMethods( f'GET', f'HEAD', f'POST', f'PUT', f'DELETE', f'CONNECT', f'OPTIONS', f'TRACE', f'PATCH', )
# add_head: Function which takes an embedding layer of shape [batch, row, # column, depth] and returns an output head of shape [batch, row, column, # num_classes]. # shuffle: Whether to shuffle the batch. # num_classes: Number of pixel classes to predict. # loss: The loss function to use. # is_train: Whether we're training this graph. # pylint: disable=invalid-name GetInputTargetAndPredictedParameters = NamedTuple( 'GetInputTargetAndPredictedParameters', [ ('dp', data_provider.DataParameters), ('ap', Optional[augment.AugmentParameters]), ('extract_patch_size', int), ('stride', int), ('stitch_patch_size', int), ('bp', Optional[util.BatchParameters]), ('core_model', Callable), ('add_head', Callable), ('shuffle', bool), ('num_classes', int), ('loss', Callable), ('is_train', bool), ]) # pylint: enable=invalid-name @tensorcheck.well_defined() def model(core_model: Callable, add_head: Callable, pp: model_util.PredictionParameters, is_train: bool,
from UM.Message import Message from UM.i18n import i18nCatalog from cura.CuraApplication import CuraApplication from cura.LayerDataBuilder import LayerDataBuilder from cura.LayerDataDecorator import LayerDataDecorator from cura.LayerPolygon import LayerPolygon from cura.Scene.CuraSceneNode import CuraSceneNode from cura.Scene.GCodeListDecorator import GCodeListDecorator from cura.Settings.ExtruderManager import ExtruderManager catalog = i18nCatalog("cura") PositionOptional = NamedTuple("PositionOptional", [("x", Optional[float]), ("y", Optional[float]), ("z", Optional[float]), ("f", Optional[float]), ("e", Optional[float])]) Position = NamedTuple("Position", [("x", float), ("y", float), ("z", float), ("f", float), ("e", List[float])]) class FlavorParser: """This parser is intended to interpret the common firmware codes among all the different flavors""" MAX_EXTRUDER_COUNT = 16 def __init__(self) -> None: CuraApplication.getInstance().hideMessageSignal.connect( self._onHideMessage) self._cancelled = False
def __init__(self, sensors_names): self.SensorTuple = NamedTuple('SensorTuple', [(name, Sensor) for name, s in sensors_names]) self.SensorReadingTuple = NamedTuple('SensorReadingTuple', [(name, float) for name, s in sensors_names]) self.sensors = self.SensorTuple(*[s for n, s in sensors_names])
_Config = NamedTuple( '_Config', [ # The OAuth client id string, such as '<USERNAME>@AMER.OAUTHAP'. ('client_id', str), # A redirect URI, such as 'https://127.0.0.1:8444'. Note that this must # match that with which you created your app in the Ameritrade API # interface. ('redirect_uri', str), # The location of the key PEM file. ('key_file', str), # The location of the certificate PEM file. ('certificate_file', str), # The location of the JSON file to store the OAuth token in between # invocations. ('secrets_file', str), # Timeout (in seconds) to wait for OAuth token response. ('timeout', int), # Safe-mode that disallows any methods that modify state. Only allows # getters to read data from the account. ('readonly', bool), # Cache directory; this string value must be set to a non-null directory # path (created on-demand if it does not already exist), if the 'read_cache' # or 'write_cache' options are set to true. # This is intended to be used during development of scripts in order to # avoid hitting the API so much while iterating over code. The cache is # indexed by method name and set of arguments. ('cache_dir', str), # FLags that decide whether we're reading from the cache or writing # to/updating the cache contents (if reading, on a cache miss). ('read_cache', bool), ('write_cache', bool), # Authenticate or refresh secrets lazily, upon first attribute access. ('lazy', bool), # Enable debug traces. ('debug', bool), ])
from uchroma.util import ArgsDict, camel_to_snake, max_keylen from .cmd import UChromaConsoleUtil PYTHON_ARGCOMPLETE_OK = 1 ENTER = u'\033(0' EXIT = u'\033(B' CHAR_HORIZ = u'\x71' CHAR_VERT = ENTER + u'\x78' + EXIT CHAR_CROSS = u'\x6e' RemoteTraits = NamedTuple('RemoteTraits', [('name', str), ('description', str), ('author', str), ('version', str), ('traits', HasTraits)]) def color_block(*values): output = Colr('') for value in values: col = to_color(value) output = output.center(9, text=col.html, fore=ColorUtils.inverse(col).intTuple, back=col.intTuple) return str(output) class AbstractCommand(object):
class Rules: CompiledNegatedRules = NamedTuple("CompiledNegatedRules", (("false", numpy.ndarray), ("true", numpy.ndarray))) """ Each ndarray contains the rule indices which are **false** given the corresponding feature, threshold value and the comparison type ("false" and "true"). """ CompiledFeatureRules = NamedTuple( "CompiledRule", (("values", numpy.ndarray), ("negated", Tuple[CompiledNegatedRules, ...]))) CompiledRulesType = Dict[int, CompiledFeatureRules] _log = logging.getLogger("Rules") def __init__(self, rules: List[Rule], origin: Mapping[str, Any]): """ Initializes the rules so that it is possible to call predict() afterwards. :param rules: the list of rules to assign. :param origin: the dictionary of parameters used to train the rules. """ super().__init__() assert rules is not None, "rules may not be None" self._rules = rules self._compiled = self._compile(rules) self._origin = origin def __str__(self): return "%d rules, avg.len. %.1f" % (len( self._rules), self.avg_rule_len) def __len__(self): return len(self._rules) def predict( self, X: numpy.ndarray, return_winner_indices=False ) -> Union[numpy.ndarray, Tuple[numpy.ndarray, numpy.ndarray]]: """ Evaluates the rules against the given features. :param X: input features. :param return_winner_indices: whether to return the winning rule index for each sample. :return: array of the same length as X with predictions or tuple of two arrays of the same\ length as X containing (predictions, winner rule indices). """ self._log.debug("predicting %d samples using %d rules", len(X), len(self._rules)) rules = self._rules _compute_triggered = self._compute_triggered prediction = numpy.zeros(len(X), dtype=numpy.int32) if return_winner_indices: winner_indices = numpy.zeros(len(X), dtype=numpy.int32) for xi, x in enumerate(X): ris = _compute_triggered(self._compiled, rules, x) if len(ris) == 0: # self._log.warning("no rule!") continue if len(ris) > 1: confs = numpy.zeros(len(ris), dtype=numpy.float32) for i, ri in enumerate(ris): confs[i] = rules[ri].stats.conf winner_index = ris[numpy.argmax(confs)] else: winner_index = ris[0] prediction[xi] = rules[winner_index].stats.cls if return_winner_indices: winner_indices[xi] = winner_index if return_winner_indices: return prediction, winner_indices return prediction @property def rules(self) -> List[Rule]: return self._rules @property def origin(self) -> Mapping[str, Any]: return self._origin @property def avg_rule_len(self) -> float: if not self._rules: return 0 return sum(len(r.attrs) for r in self._rules) / len(self._rules) @classmethod def _compile(cls, rules: Sequence[Rule]) -> CompiledRulesType: cls._log.debug("compiling %d rules", len(rules)) attrs = defaultdict(lambda: defaultdict(lambda: [[], []])) for i, (branch, _) in enumerate(rules): for rule in branch: attrs[rule.feature][rule.threshold][int(rule.cmp)].append(i) compiled_attrs = {} for key, attr in attrs.items(): vals = sorted(attr) false_rules = set() true_rules = set() vr = [[None, None] for _ in vals] for i in range(len(vals)): false_rules.update(attr[vals[i]][False]) true_rules.update(attr[vals[len(vals) - i - 1]][True]) vr[i][False] = numpy.array(sorted(false_rules)) vr[len(vr) - i - 1][True] = numpy.array(sorted(true_rules)) compiled_attrs[key] = cls.CompiledFeatureRules( numpy.array(vals, dtype=numpy.float32), tuple(cls.CompiledNegatedRules(*v) for v in vr)) return compiled_attrs @classmethod def _compute_triggered(cls, compiled_rules: CompiledRulesType, rules: Sequence[Rule], x: numpy.ndarray) -> numpy.ndarray: searchsorted = numpy.searchsorted triggered = numpy.full(len(rules), 0xff, dtype=numpy.int8) for i, v in enumerate(x): try: vals, arules = compiled_rules[i] except KeyError: continue border = searchsorted(vals, v) if border > 0: indices = arules[border - 1][False] if len(indices): triggered[indices] = 0 if border < len(arules): indices = arules[border][True] if len(indices): triggered[indices] = 0 return numpy.nonzero(triggered)[0]
QAbstractButton, QWIDGETSIZE_MAX, ) from AnyQt.QtGui import (QIcon, QFontMetrics, QPainter, QPalette, QBrush, QPen, QColor, QFont) from AnyQt.QtCore import (Qt, QObject, QSize, QRect, QPoint, QSignalMapper) from AnyQt.QtCore import Signal, Property from ..utils import set_flag from .utils import brush_darker, ScrollBar __all__ = ["ToolBox"] _ToolBoxPage = NamedTuple("_ToolBoxPage", [ ("index", int), ("widget", QWidget), ("action", QAction), ("button", QAbstractButton), ]) class ToolBoxTabButton(QToolButton): """ A tab button for an item in a :class:`ToolBox`. """ def setNativeStyling(self, state): # type: (bool) -> None """ Render tab buttons as native (or css styled) :class:`QToolButtons`. If set to `False` (default) the button is pained using a custom paint routine. """
import cmk.gui.config as config import cmk.gui.htmllib as htmllib import cmk.gui.login as login from cmk.gui.globals import AppContext, RequestContext from cmk.gui.http import Request from cmk.gui.plugins.userdb import htpasswd from cmk.gui.utils import get_random_string from cmk.gui.watolib.users import delete_users, edit_users from cmk.gui.wsgi import make_app SPEC_LOCK = threading.Lock() Automation = NamedTuple("Automation", [ ("automation", MagicMock), ("local_automation", MagicMock), ("remote_automation", MagicMock), ("responses", Any), ]) HTTPMethod = Literal[ "get", "put", "post", "delete", "GET", "PUT", "POST", "DELETE", ] # yapf: disable @pytest.fixture(scope='function') def register_builtin_html(): """This fixture registers a global htmllib.html() instance just like the regular GUI""" environ = create_environ() with AppContext(DummyApplication(environ, None)), \ RequestContext(htmllib.html(Request(environ))): yield
""" # TODO: support a setter for `msg` to create an instance of a type # according to `msg_type` typename = MESSAGE_RESPONSE schema = ( (f.MSG_TYPE.nm, ChooseField(values=MessageReq.allowed_types)), (f.PARAMS.nm, AnyMapField()), (f.MSG.nm, AnyField()) ) ThreePhaseType = (PrePrepare, Prepare, Commit) ThreePhaseMsg = TypeVar("3PhaseMsg", *ThreePhaseType) ThreePhaseKey = NamedTuple("ThreePhaseKey", [ f.VIEW_NO, f.PP_SEQ_NO ]) class BatchCommitted(MessageBase): """ Purpose: pass to Observable after each batch is committed (so that Observable can propagate the data to Observers using ObservedData msg) """ typename = BATCH_COMMITTED schema = ( (f.REQUESTS.nm, IterableField(ClientMessageValidator( operation_schema_is_strict=OPERATION_SCHEMA_IS_STRICT))), (f.LEDGER_ID.nm, LedgerIdField()), (f.INST_ID.nm, NonNegativeNumberField()),
class HookDefinition( NamedTuple( "_HookDefinition", [ ("name", str), ("hook_fn", Callable), ("required_resource_keys", AbstractSet[str]), ("decorated_fn", Callable), ], )): """Define a hook which can be triggered during a op execution (e.g. a callback on the step execution failure event during a op execution). Args: name (str): The name of this hook. hook_fn (Callable): The callback function that will be triggered. required_resource_keys (Optional[AbstractSet[str]]): Keys for the resources required by the hook. """ def __new__( cls, name: str, hook_fn: Callable[..., Any], required_resource_keys: Optional[AbstractSet[str]] = None, decorated_fn: Optional[Callable[..., Any]] = None, ): return super(HookDefinition, cls).__new__( cls, name=check_valid_name(name), hook_fn=check.callable_param(hook_fn, "hook_fn"), required_resource_keys=frozenset( check.opt_set_param(required_resource_keys, "required_resource_keys", of_type=str)), decorated_fn=check.callable_param(decorated_fn, "decorated_fn"), ) def __call__(self, *args, **kwargs): """This is invoked when the hook is used as a decorator. We currently support hooks to decorate the following: - PipelineDefinition: when the hook decorates a job definition, it will be added to all the op invocations within the job. Example: .. code-block:: python @success_hook def slack_message_on_success(_): ... @slack_message_on_success @job def a_job(): foo(bar()) """ from ..execution.context.hook import HookContext from .graph_definition import GraphDefinition from .hook_invocation import hook_invocation_result from .pipeline_definition import PipelineDefinition if len(args) > 0 and isinstance(args[0], (PipelineDefinition, GraphDefinition)): # when it decorates a pipeline, we apply this hook to all the solid invocations within # the pipeline. return args[0].with_hooks({self}) else: if not self.decorated_fn: raise DagsterInvalidInvocationError( "Only hook definitions created using one of the hook decorators can be invoked." ) fxn_args = get_function_params(self.decorated_fn) # If decorated fxn has two arguments, then this is an event list hook fxn, and parameter # names are always context and event_list if len(fxn_args) == 2: context_arg_name = fxn_args[0].name event_list_arg_name = fxn_args[1].name if len(args) + len(kwargs) != 2: raise DagsterInvalidInvocationError( "Decorated function expects two parameters, context and event_list, but " f"{len(args) + len(kwargs)} were provided.") if args: context = check.opt_inst_param(args[0], "context", HookContext) event_list = check.opt_list_param( args[1] if len(args) > 1 else kwargs[event_list_arg_name], event_list_arg_name, ) else: if context_arg_name not in kwargs: raise DagsterInvalidInvocationError( f"Could not find expected argument '{context_arg_name}'. Provided " f"kwargs: {list(kwargs.keys())}") if event_list_arg_name not in kwargs: raise DagsterInvalidInvocationError( f"Could not find expected argument '{event_list_arg_name}'. Provided " f"kwargs: {list(kwargs.keys())}") context = check.opt_inst_param(kwargs[context_arg_name], context_arg_name, HookContext) event_list = check.opt_list_param( kwargs[event_list_arg_name], event_list_arg_name) return hook_invocation_result(self, context, event_list) else: context_arg_name = fxn_args[0].name if len(args) + len(kwargs) != 1: raise DagsterInvalidInvocationError( f"Decorated function expects one parameter, {context_arg_name}, but " f"{len(args) + len(kwargs)} were provided.") if args: context = check.opt_inst_param(args[0], context_arg_name, HookContext) else: if context_arg_name not in kwargs: raise DagsterInvalidInvocationError( f"Could not find expected argument '{context_arg_name}'. Provided " f"kwargs: {list(kwargs.keys())}") context = check.opt_inst_param(kwargs[context_arg_name], context_arg_name, HookContext) return hook_invocation_result(self, context)
from . import modelinfo from .details import make_kernel_args, dispersion_mesh # Hack: load in any custom distributions # Uses ~/.sasview/weights/*.py unless SASMODELS_WEIGHTS is set in the environ. # Override with weights.load_weights(pattern="<weights_path>/*.py") weights.load_weights() # pylint: disable=unused-import try: from typing import (Dict, Mapping, Any, Sequence, Tuple, NamedTuple, List, Optional, Union, Callable) from .modelinfo import ModelInfo, Parameter from .kernel import KernelModel MultiplicityInfoType = NamedTuple('MultiplicityInfo', [("number", int), ("control", str), ("choices", List[str]), ("x_axis_label", str)]) SasviewModelType = Callable[[int], "SasviewModel"] except ImportError: pass # pylint: enable=unused-import logger = logging.getLogger(__name__) calculation_lock = thread.allocate_lock() #: True if pre-existing plugins, with the old names and parameters, should #: continue to be supported. SUPPORT_OLD_STYLE_PLUGINS = True # TODO: separate x_axis_label from multiplicity info
#!/usr/bin/env python3 import json from statistics import mean, median, stdev import sys import time from typing import NamedTuple import aqi import click from pygeodesy.ellipsoidalVincenty import LatLon import requests Sensor = NamedTuple('Sensor', [ ('id', int), ('label', str), ('distance_m', float), ]) @click.group() def main(): pass @main.command() @click.option('--debug', is_flag=True, default=False) @click.option('--max-count', type=int, default=8) @click.option('--max-distance-km', type=float, default=2) @click.argument('output_file', type=click.File('w', encoding='utf-8'), required=True)
import random from typing import NamedTuple import numpy as np import settings EMPTY = 0 TIC = 7 TAC = 8 DRAW = 100 Move = NamedTuple('TicTacToeMove', row=int, col=int) MoveHistory = NamedTuple('MoveHistory', state=np.array, move=Move) class TicTacToeGameEngine: _num_rows: int _num_columns: int _first_move: int _next_move: int _state: np.array _state_history: [np.array] _game_result: int def __init__(self, num_rows=3, num_columns=3, starting_move=None): self._num_rows = num_rows self._num_columns = num_columns