id
int64
11
59.9k
original
stringlengths
33
150k
modified
stringlengths
37
150k
8,510
def status_show(context, data_dict): '''Return a dictionary with information about the site's configuration. :rtype: dictionary ''' plugins = config.get('ckan.plugins') extensions = "" if plugins == None else plugins.split() return { 'site_title': config.get('ckan.site_title'), 'site_description': config.get('ckan.site_description'), 'site_url': config.get('ckan.site_url'), 'ckan_version': ckan.__version__, 'error_emails_to': config.get('email_to'), 'locale_default': config.get('ckan.locale_default'), 'extensions': extensions, }
def status_show(context, data_dict): '''Return a dictionary with information about the site's configuration. :rtype: dictionary ''' plugins = config.get('ckan.plugins') extensions = plugins.split() if plugins else [] return { 'site_title': config.get('ckan.site_title'), 'site_description': config.get('ckan.site_description'), 'site_url': config.get('ckan.site_url'), 'ckan_version': ckan.__version__, 'error_emails_to': config.get('email_to'), 'locale_default': config.get('ckan.locale_default'), 'extensions': extensions, }
50,162
def get_mypy_type_of_runtime_value(runtime: Any) -> Optional[mypy.types.Type]: """Returns a mypy type object representing the type of ``runtime``. Returns None if we can't find something that works. """ if runtime is None: return mypy.types.NoneType() if isinstance(runtime, property): # Give up on properties to avoid issues with things that are typed as attributes. return None def anytype() -> mypy.types.AnyType: return mypy.types.AnyType(mypy.types.TypeOfAny.unannotated) if isinstance( runtime, (types.FunctionType, types.BuiltinFunctionType, types.MethodType, types.BuiltinMethodType), ): builtins = get_stub("builtins") assert builtins is not None type_info = builtins.names["function"].node assert isinstance(type_info, nodes.TypeInfo) fallback = mypy.types.Instance(type_info, [anytype()]) signature = safe_inspect_signature(runtime) if signature: arg_types = [] arg_kinds = [] arg_names = [] for arg in signature.parameters.values(): arg_types.append(anytype()) arg_names.append( None if arg.kind == inspect.Parameter.POSITIONAL_ONLY else arg.name ) has_default = arg.default == inspect.Parameter.empty if arg.kind == inspect.Parameter.POSITIONAL_ONLY: arg_kinds.append(nodes.ARG_POS if has_default else nodes.ARG_OPT) elif arg.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD: arg_kinds.append(nodes.ARG_POS if has_default else nodes.ARG_OPT) elif arg.kind == inspect.Parameter.KEYWORD_ONLY: arg_kinds.append(nodes.ARG_NAMED if has_default else nodes.ARG_NAMED_OPT) elif arg.kind == inspect.Parameter.VAR_POSITIONAL: arg_kinds.append(nodes.ARG_STAR) elif arg.kind == inspect.Parameter.VAR_KEYWORD: arg_kinds.append(nodes.ARG_STAR2) else: raise AssertionError else: arg_types = [anytype(), anytype()] arg_kinds = [nodes.ARG_STAR, nodes.ARG_STAR2] arg_names = [None, None] return mypy.types.CallableType( arg_types, arg_kinds, arg_names, ret_type=anytype(), fallback=fallback, is_ellipsis_args=True, ) # Try and look up a stub for the runtime object if isinstance(runtime, type): runtime_type = runtime # This might be a class else: runtime_type = type(runtime) # Or an instance stub = get_stub(runtime_type.__module__) if stub is None: return None type_name = runtime_type.__name__ if type_name not in stub.names: return None type_info = stub.names[type_name].node if isinstance(type_info, nodes.Var): return type_info.type if not isinstance(type_info, nodes.TypeInfo): return None if isinstance(runtime, tuple): # Special case tuples so we construct a valid mypy.types.TupleType optional_items = [get_mypy_type_of_runtime_value(v) for v in runtime] items = [(i if i is not None else anytype()) for i in optional_items] fallback = mypy.types.Instance(type_info, [anytype()]) return mypy.types.TupleType(items, fallback) fallback = mypy.types.Instance(type_info, [anytype() for _ in type_info.type_vars]) value: Union[bool, int, str] if isinstance(runtime, bytes): value = bytes_to_human_readable_repr(runtime) elif isinstance(runtime, enum.Enum): value = runtime.name elif isinstance(runtime, (bool, int, str)): value = runtime else: if isinstance(runtime, type): return mypy.types.TypeType(fallback) return fallback return mypy.types.LiteralType(value=value, fallback=fallback)
def get_mypy_type_of_runtime_value(runtime: Any) -> Optional[mypy.types.Type]: """Returns a mypy type object representing the type of ``runtime``. Returns None if we can't find something that works. """ if runtime is None: return mypy.types.NoneType() if isinstance(runtime, property): # Give up on properties to avoid issues with things that are typed as attributes. return None def anytype() -> mypy.types.AnyType: return mypy.types.AnyType(mypy.types.TypeOfAny.unannotated) if isinstance( runtime, (types.FunctionType, types.BuiltinFunctionType, types.MethodType, types.BuiltinMethodType), ): builtins = get_stub("builtins") assert builtins is not None type_info = builtins.names["function"].node assert isinstance(type_info, nodes.TypeInfo) fallback = mypy.types.Instance(type_info, [anytype()]) signature = safe_inspect_signature(runtime) if signature: arg_types = [] arg_kinds = [] arg_names = [] for arg in signature.parameters.values(): arg_types.append(anytype()) arg_names.append( None if arg.kind == inspect.Parameter.POSITIONAL_ONLY else arg.name ) has_default = arg.default == inspect.Parameter.empty if arg.kind == inspect.Parameter.POSITIONAL_ONLY: arg_kinds.append(nodes.ARG_POS if has_default else nodes.ARG_OPT) elif arg.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD: arg_kinds.append(nodes.ARG_POS if has_default else nodes.ARG_OPT) elif arg.kind == inspect.Parameter.KEYWORD_ONLY: arg_kinds.append(nodes.ARG_NAMED if has_default else nodes.ARG_NAMED_OPT) elif arg.kind == inspect.Parameter.VAR_POSITIONAL: arg_kinds.append(nodes.ARG_STAR) elif arg.kind == inspect.Parameter.VAR_KEYWORD: arg_kinds.append(nodes.ARG_STAR2) else: raise AssertionError else: arg_types = [anytype(), anytype()] arg_kinds = [nodes.ARG_STAR, nodes.ARG_STAR2] arg_names = [None, None] return mypy.types.CallableType( arg_types, arg_kinds, arg_names, ret_type=anytype(), fallback=fallback, is_ellipsis_args=True, ) # Try and look up a stub for the runtime object if isinstance(runtime, type): runtime_type = runtime # This might be a class else: runtime_type = type(runtime) # Or an instance stub = get_stub(runtime_type.__module__) if stub is None: return None type_name = runtime_type.__name__ if type_name not in stub.names: return None type_info = stub.names[type_name].node if isinstance(type_info, nodes.Var): return type_info.type if not isinstance(type_info, nodes.TypeInfo): return None if isinstance(runtime, tuple): # Special case tuples so we construct a valid mypy.types.TupleType optional_items = [get_mypy_type_of_runtime_value(v) for v in runtime] items = [(i if i is not None else anytype()) for i in optional_items] fallback = mypy.types.Instance(type_info, [anytype()]) return mypy.types.TupleType(items, fallback) fallback = mypy.types.Instance(type_info, [anytype() for _ in type_info.type_vars]) value: Union[bool, int, str] if isinstance(runtime, bytes): value = bytes_to_human_readable_repr(runtime) elif isinstance(runtime, enum.Enum): value = runtime.name elif isinstance(runtime, (bool, int, str)): value = runtime elif isinstance(runtime, type): return mypy.types.TypeType(fallback) else: return fallback return mypy.types.LiteralType(value=value, fallback=fallback)
14,112
def test_from_wkb__hex(): geometry_hex = ["0101000000CDCCCCCCCCCC1440CDCCCCCCCC0C4A40"] res = from_wkb(geometry_hex) assert isinstance(res, GeometryArray) # array res = from_wkb(np.array(geometry_hex, dtype=object)) assert isinstance(res, GeometryArray)
def test_from_wkb_hex(): geometry_hex = ["0101000000CDCCCCCCCCCC1440CDCCCCCCCC0C4A40"] res = from_wkb(geometry_hex) assert isinstance(res, GeometryArray) # array res = from_wkb(np.array(geometry_hex, dtype=object)) assert isinstance(res, GeometryArray)
8,639
def list_aliases(options): """ Show aliases that exist. """ data = _get_alias_details(options['node-directory']) if options['json']: output = _escape_format(json.dumps(data, indent=4).decode("utf-8")) else: def dircap(details): return ( details['readonly'] if options['readonly-uri'] else details['readwrite'] ).decode("utf-8") max_width = max([len(quote_output(name)) for name in data.keys()] + [0]) fmt = "%" + str(max_width) + "s: %s" output = "\n".join(list( fmt % (name, dircap(details)) for name, details in data.items() )) if output: # Show whatever we computed. Skip this if there is no output to avoid # a spurious blank line. show_output(options.stdout, output) return 0
def list_aliases(options): """ Show aliases that exist. """ data = _get_alias_details(options['node-directory']) if options['json']: output = _escape_format(json.dumps(data, indent=4, ensure_ascii=False)) else: def dircap(details): return ( details['readonly'] if options['readonly-uri'] else details['readwrite'] ).decode("utf-8") max_width = max([len(quote_output(name)) for name in data.keys()] + [0]) fmt = "%" + str(max_width) + "s: %s" output = "\n".join(list( fmt % (name, dircap(details)) for name, details in data.items() )) if output: # Show whatever we computed. Skip this if there is no output to avoid # a spurious blank line. show_output(options.stdout, output) return 0
385
def sample_smc( draws=2000, kernel=IMH, *, start=None, model=None, random_seed=None, chains=None, cores=None, compute_convergence_checks=True, return_inferencedata=True, idata_kwargs=None, progressbar=True, **kernel_kwargs, ): r""" Sequential Monte Carlo based sampling. Parameters ---------- draws: int The number of samples to draw from the posterior (i.e. last stage). And also the number of independent chains. Defaults to 2000. kernel: SMC Kernel used. Defaults to pm.smc.IMH (Independent Metropolis Hastings) start: dict, or array of dict Starting point in parameter space. It should be a list of dict with length `chains`. When None (default) the starting point is sampled from the prior distribution. model: Model (optional if in ``with`` context)). random_seed: int random seed chains : int The number of chains to sample. Running independent chains is important for some convergence statistics. If ``None`` (default), then set to either ``cores`` or 2, whichever is larger. cores : int The number of chains to run in parallel. If ``None``, set to the number of CPUs in the system. compute_convergence_checks : bool Whether to compute sampler statistics like ``R hat`` and ``effective_n``. Defaults to ``True``. return_inferencedata : bool, default=True Whether to return the trace as an :class:`arviz:arviz.InferenceData` (True) object or a `MultiTrace` (False) Defaults to ``True``. idata_kwargs : dict, optional Keyword arguments for :func:`pymc.to_inference_data` progressbar : bool, optional default=True Whether or not to display a progress bar in the command line. **kernel_kwargs: keyword arguments passed to the SMC kernel. The default IMH kernel takes the following keywords: threshold: float Determines the change of beta from stage to stage, i.e. indirectly the number of stages, the higher the value of `threshold` the higher the number of stages. Defaults to 0.5. It should be between 0 and 1. correlation_threshold: float The lower the value the higher the number of MCMC steps computed automatically. Defaults to 0.01. It should be between 0 and 1. Keyword arguments for other kernels should be checked in the respective docstrings Notes ----- SMC works by moving through successive stages. At each stage the inverse temperature :math:`\beta` is increased a little bit (starting from 0 up to 1). When :math:`\beta` = 0 we have the prior distribution and when :math:`\beta` =1 we have the posterior distribution. So in more general terms we are always computing samples from a tempered posterior that we can write as: .. math:: p(\theta \mid y)_{\beta} = p(y \mid \theta)^{\beta} p(\theta) A summary of the algorithm is: 1. Initialize :math:`\beta` at zero and stage at zero. 2. Generate N samples :math:`S_{\beta}` from the prior (because when :math `\beta = 0` the tempered posterior is the prior). 3. Increase :math:`\beta` in order to make the effective sample size equals some predefined value (we use :math:`Nt`, where :math:`t` is 0.5 by default). 4. Compute a set of N importance weights W. The weights are computed as the ratio of the likelihoods of a sample at stage i+1 and stage i. 5. Obtain :math:`S_{w}` by re-sampling according to W. 6. Use W to compute the mean and covariance for the proposal distribution, a MVNormal. 7. Run N independent MCMC chains, starting each one from a different sample in :math:`S_{w}`. For the IMH kernel, the mean of the proposal distribution is the mean of the previous posterior stage and not the current point in parameter space. 8. The N chains are run until the autocorrelation with the samples from the previous stops decreasing given a certain threshold. 9. Repeat from step 3 until :math:`\beta \ge 1`. 10. The final result is a collection of N samples from the posterior. References ---------- .. [Minson2013] Minson, S. E. and Simons, M. and Beck, J. L., (2013), Bayesian inversion for finite fault earthquake source models I- Theory and algorithm. Geophysical Journal International, 2013, 194(3), pp.1701-1726, `link <https://gji.oxfordjournals.org/content/194/3/1701.full>`__ .. [Ching2007] Ching, J. and Chen, Y. (2007). Transitional Markov Chain Monte Carlo Method for Bayesian Model Updating, Model Class Selection, and Model Averaging. J. Eng. Mech., 10.1061/(ASCE)0733-9399(2007)133:7(816), 816-832. `link <http://ascelibrary.org/doi/abs/10.1061/%28ASCE%290733-9399 %282007%29133:7%28816%29>`__ """ if isinstance(kernel, str) and kernel.lower() in ("abc", "metropolis"): warnings.warn( f'The kernel string argument "{kernel}" in sample_smc has been deprecated. ' f"It is no longer needed to distinguish between `abc` and `metropolis`", FutureWarning, stacklevel=2, ) kernel = IMH if kernel_kwargs.pop("save_sim_data", None) is not None: warnings.warn( "save_sim_data has been deprecated. Use pm.sample_posterior_predictive " "to obtain the same type of samples.", FutureWarning, stacklevel=2, ) if kernel_kwargs.pop("save_log_pseudolikelihood", None) is not None: warnings.warn( "save_log_pseudolikelihood has been deprecated. This information is " "now saved as log_likelihood in models with Simulator distributions.", FutureWarning, stacklevel=2, ) parallel = kernel_kwargs.pop("parallel", None) if parallel is not None: warnings.warn( "The argument parallel is deprecated, use the argument cores instead.", FutureWarning, stacklevel=2, ) if parallel is False: cores = 1 if cores is None: cores = _cpu_count() if chains is None: chains = max(2, cores) else: cores = min(chains, cores) if random_seed == -1: raise FutureWarning( f"random_seed should be a non-negative integer or None, got: {random_seed}" "This will raise a ValueError in the Future" ) random_seed = None if isinstance(random_seed, int) or random_seed is None: rng = np.random.default_rng(seed=random_seed) random_seed = list(rng.integers(2**30, size=chains)) elif isinstance(random_seed, Iterable): if len(random_seed) != chains: raise ValueError(f"Length of seeds ({len(seeds)}) must match number of chains {chains}") else: raise TypeError("Invalid value for `random_seed`. Must be tuple, list, int or None") model = modelcontext(model) _log = logging.getLogger("pymc") _log.info("Initializing SMC sampler...") _log.info( f"Sampling {chains} chain{'s' if chains > 1 else ''} " f"in {cores} job{'s' if cores > 1 else ''}" ) params = ( draws, kernel, start, model, ) t1 = time.time() if cores > 1: results = run_chains_parallel( chains, progressbar, _sample_smc_int, params, random_seed, kernel_kwargs, cores ) else: results = run_chains_sequential( chains, progressbar, _sample_smc_int, params, random_seed, kernel_kwargs ) ( traces, sample_stats, sample_settings, ) = zip(*results) trace = MultiTrace(traces) _t_sampling = time.time() - t1 sample_stats, idata = _save_sample_stats( sample_settings, sample_stats, chains, trace, return_inferencedata, _t_sampling, idata_kwargs, model, ) if compute_convergence_checks: _compute_convergence_checks(idata, draws, model, trace) return idata if return_inferencedata else trace
def sample_smc( draws=2000, kernel=IMH, *, start=None, model=None, random_seed=None, chains=None, cores=None, compute_convergence_checks=True, return_inferencedata=True, idata_kwargs=None, progressbar=True, **kernel_kwargs, ): r""" Sequential Monte Carlo based sampling. Parameters ---------- draws: int The number of samples to draw from the posterior (i.e. last stage). And also the number of independent chains. Defaults to 2000. kernel: SMC Kernel used. Defaults to pm.smc.IMH (Independent Metropolis Hastings) start: dict, or array of dict Starting point in parameter space. It should be a list of dict with length `chains`. When None (default) the starting point is sampled from the prior distribution. model: Model (optional if in ``with`` context)). random_seed: int random seed chains : int The number of chains to sample. Running independent chains is important for some convergence statistics. If ``None`` (default), then set to either ``cores`` or 2, whichever is larger. cores : int The number of chains to run in parallel. If ``None``, set to the number of CPUs in the system. compute_convergence_checks : bool Whether to compute sampler statistics like ``R hat`` and ``effective_n``. Defaults to ``True``. return_inferencedata : bool, default=True Whether to return the trace as an :class:`arviz:arviz.InferenceData` (True) object or a `MultiTrace` (False) Defaults to ``True``. idata_kwargs : dict, optional Keyword arguments for :func:`pymc.to_inference_data` progressbar : bool, optional default=True Whether or not to display a progress bar in the command line. **kernel_kwargs: keyword arguments passed to the SMC kernel. The default IMH kernel takes the following keywords: threshold: float Determines the change of beta from stage to stage, i.e. indirectly the number of stages, the higher the value of `threshold` the higher the number of stages. Defaults to 0.5. It should be between 0 and 1. correlation_threshold: float The lower the value the higher the number of MCMC steps computed automatically. Defaults to 0.01. It should be between 0 and 1. Keyword arguments for other kernels should be checked in the respective docstrings Notes ----- SMC works by moving through successive stages. At each stage the inverse temperature :math:`\beta` is increased a little bit (starting from 0 up to 1). When :math:`\beta` = 0 we have the prior distribution and when :math:`\beta` =1 we have the posterior distribution. So in more general terms we are always computing samples from a tempered posterior that we can write as: .. math:: p(\theta \mid y)_{\beta} = p(y \mid \theta)^{\beta} p(\theta) A summary of the algorithm is: 1. Initialize :math:`\beta` at zero and stage at zero. 2. Generate N samples :math:`S_{\beta}` from the prior (because when :math `\beta = 0` the tempered posterior is the prior). 3. Increase :math:`\beta` in order to make the effective sample size equals some predefined value (we use :math:`Nt`, where :math:`t` is 0.5 by default). 4. Compute a set of N importance weights W. The weights are computed as the ratio of the likelihoods of a sample at stage i+1 and stage i. 5. Obtain :math:`S_{w}` by re-sampling according to W. 6. Use W to compute the mean and covariance for the proposal distribution, a MVNormal. 7. Run N independent MCMC chains, starting each one from a different sample in :math:`S_{w}`. For the IMH kernel, the mean of the proposal distribution is the mean of the previous posterior stage and not the current point in parameter space. 8. The N chains are run until the autocorrelation with the samples from the previous stage stops decreasing given a certain threshold. 9. Repeat from step 3 until :math:`\beta \ge 1`. 10. The final result is a collection of N samples from the posterior. References ---------- .. [Minson2013] Minson, S. E. and Simons, M. and Beck, J. L., (2013), Bayesian inversion for finite fault earthquake source models I- Theory and algorithm. Geophysical Journal International, 2013, 194(3), pp.1701-1726, `link <https://gji.oxfordjournals.org/content/194/3/1701.full>`__ .. [Ching2007] Ching, J. and Chen, Y. (2007). Transitional Markov Chain Monte Carlo Method for Bayesian Model Updating, Model Class Selection, and Model Averaging. J. Eng. Mech., 10.1061/(ASCE)0733-9399(2007)133:7(816), 816-832. `link <http://ascelibrary.org/doi/abs/10.1061/%28ASCE%290733-9399 %282007%29133:7%28816%29>`__ """ if isinstance(kernel, str) and kernel.lower() in ("abc", "metropolis"): warnings.warn( f'The kernel string argument "{kernel}" in sample_smc has been deprecated. ' f"It is no longer needed to distinguish between `abc` and `metropolis`", FutureWarning, stacklevel=2, ) kernel = IMH if kernel_kwargs.pop("save_sim_data", None) is not None: warnings.warn( "save_sim_data has been deprecated. Use pm.sample_posterior_predictive " "to obtain the same type of samples.", FutureWarning, stacklevel=2, ) if kernel_kwargs.pop("save_log_pseudolikelihood", None) is not None: warnings.warn( "save_log_pseudolikelihood has been deprecated. This information is " "now saved as log_likelihood in models with Simulator distributions.", FutureWarning, stacklevel=2, ) parallel = kernel_kwargs.pop("parallel", None) if parallel is not None: warnings.warn( "The argument parallel is deprecated, use the argument cores instead.", FutureWarning, stacklevel=2, ) if parallel is False: cores = 1 if cores is None: cores = _cpu_count() if chains is None: chains = max(2, cores) else: cores = min(chains, cores) if random_seed == -1: raise FutureWarning( f"random_seed should be a non-negative integer or None, got: {random_seed}" "This will raise a ValueError in the Future" ) random_seed = None if isinstance(random_seed, int) or random_seed is None: rng = np.random.default_rng(seed=random_seed) random_seed = list(rng.integers(2**30, size=chains)) elif isinstance(random_seed, Iterable): if len(random_seed) != chains: raise ValueError(f"Length of seeds ({len(seeds)}) must match number of chains {chains}") else: raise TypeError("Invalid value for `random_seed`. Must be tuple, list, int or None") model = modelcontext(model) _log = logging.getLogger("pymc") _log.info("Initializing SMC sampler...") _log.info( f"Sampling {chains} chain{'s' if chains > 1 else ''} " f"in {cores} job{'s' if cores > 1 else ''}" ) params = ( draws, kernel, start, model, ) t1 = time.time() if cores > 1: results = run_chains_parallel( chains, progressbar, _sample_smc_int, params, random_seed, kernel_kwargs, cores ) else: results = run_chains_sequential( chains, progressbar, _sample_smc_int, params, random_seed, kernel_kwargs ) ( traces, sample_stats, sample_settings, ) = zip(*results) trace = MultiTrace(traces) _t_sampling = time.time() - t1 sample_stats, idata = _save_sample_stats( sample_settings, sample_stats, chains, trace, return_inferencedata, _t_sampling, idata_kwargs, model, ) if compute_convergence_checks: _compute_convergence_checks(idata, draws, model, trace) return idata if return_inferencedata else trace
2,711
def _assert_all_finite( X, allow_nan=False, msg_dtype=None, estimator_name=None, input_name="" ): """Like assert_all_finite, but only for ndarray.""" if _get_config()["assume_finite"]: return X = np.asanyarray(X) # First try an O(n) time, O(1) space solution for the common case that # everything is finite; fall back to O(n) space np.isfinite to prevent # false positives from overflow in sum method. The sum is also calculated # safely to reduce dtype induced overflows. is_float = X.dtype.kind in "fc" with np.errstate(over="ignore"): first_pass_isfinite = is_float and np.isfinite(np.sum(X)) if first_pass_isfinite: pass elif is_float: has_inf = np.isinf(X).any() has_nan = np.isnan(X).any() if has_inf or not allow_nan and has_nan: if not allow_nan and has_nan: type_err = "NaN" else: msg_dtype = msg_dtype if msg_dtype is not None else X.dtype type_err = f"infinity or a value too large for {msg_dtype!r}" padded_input_name = input_name + " " if input_name else "" msg_err = f"Input {padded_input_name}contains {type_err}." if not allow_nan and estimator_name and input_name == "X" and has_nan: # Improve the error message on how to handle missing values in # scikit-learn. msg_err += ( f"\n{estimator_name} does not accept missing values" " encoded as NaN natively. For supervised learning, you might want" " to consider sklearn.ensemble.HistGradientBoostingClassifier and" " Regressor which accept missing values encoded as NaNs natively." " Alternatively, it is possible to preprocess the data, for" " instance by using an imputer transformer in a pipeline or drop" " samples with missing values. See" " https://scikit-learn.org/stable/modules/impute.html" " You can find a list of all estimators that handle NaN values" " at the following page:" " https://scikit-learn.org/stable/modules/impute.html" "#estimators-that-handle-nan-values" ) raise ValueError(msg_err) # for object dtype data, we only check for NaNs (GH-13254) elif X.dtype == np.dtype("object") and not allow_nan: if _object_dtype_isnan(X).any(): raise ValueError("Input contains NaN")
def _assert_all_finite( X, allow_nan=False, msg_dtype=None, estimator_name=None, input_name="" ): """Like assert_all_finite, but only for ndarray.""" if _get_config()["assume_finite"]: return X = np.asanyarray(X) # First try an O(n) time, O(1) space solution for the common case that # everything is finite; fall back to O(n) space np.isfinite to prevent # false positives from overflow in sum method. is_float = X.dtype.kind in "fc" with np.errstate(over="ignore"): first_pass_isfinite = is_float and np.isfinite(np.sum(X)) if first_pass_isfinite: pass elif is_float: has_inf = np.isinf(X).any() has_nan = np.isnan(X).any() if has_inf or not allow_nan and has_nan: if not allow_nan and has_nan: type_err = "NaN" else: msg_dtype = msg_dtype if msg_dtype is not None else X.dtype type_err = f"infinity or a value too large for {msg_dtype!r}" padded_input_name = input_name + " " if input_name else "" msg_err = f"Input {padded_input_name}contains {type_err}." if not allow_nan and estimator_name and input_name == "X" and has_nan: # Improve the error message on how to handle missing values in # scikit-learn. msg_err += ( f"\n{estimator_name} does not accept missing values" " encoded as NaN natively. For supervised learning, you might want" " to consider sklearn.ensemble.HistGradientBoostingClassifier and" " Regressor which accept missing values encoded as NaNs natively." " Alternatively, it is possible to preprocess the data, for" " instance by using an imputer transformer in a pipeline or drop" " samples with missing values. See" " https://scikit-learn.org/stable/modules/impute.html" " You can find a list of all estimators that handle NaN values" " at the following page:" " https://scikit-learn.org/stable/modules/impute.html" "#estimators-that-handle-nan-values" ) raise ValueError(msg_err) # for object dtype data, we only check for NaNs (GH-13254) elif X.dtype == np.dtype("object") and not allow_nan: if _object_dtype_isnan(X).any(): raise ValueError("Input contains NaN")
25,145
def _to_literal(node): # Can raise SyntaxError or ValueError from ast.literal_eval # Is this the stupidest idea or the simplest idea? return ast.literal_eval(node.as_string())
def _to_literal(node: nodes.Compare): # Can raise SyntaxError or ValueError from ast.literal_eval # Is this the stupidest idea or the simplest idea? return ast.literal_eval(node.as_string())
8,079
def get_body_heliographic_stonyhurst(body, time='now', observer=None): """ Return a `~sunpy.coordinates.frames.HeliographicStonyhurst` frame for the location of a solar-system body at a specified time. Parameters ---------- body : `str` The solar-system body for which to calculate positions time : various Time to use as `~astropy.time.Time` or in a parse_time-compatible format observer : `~astropy.coordinates.SkyCoord` If not None, the returned coordinate is the apparent location (i.e., factors in light travel time) Returns ------- out : `~sunpy.coordinates.frames.HeliographicStonyhurst` Location of the solar-system body in the `~sunpy.coordinates.HeliographicStonyhurst` frame """ obstime = parse_time(time) if observer is None: body_icrs = get_body_barycentric(body, obstime) else: observer_icrs = SkyCoord(observer).icrs.cartesian # This implementation is modeled after Astropy's `_get_apparent_body_position` light_travel_time = 0.*u.s emitted_time = obstime delta_light_travel_time = 1.*u.s # placeholder value while np.any(np.fabs(delta_light_travel_time) > 1.0e-8*u.s): body_icrs = get_body_barycentric(body, emitted_time) distance = (body_icrs - observer_icrs).norm() delta_light_travel_time = light_travel_time - distance / speed_of_light light_travel_time = distance / speed_of_light emitted_time = obstime - light_travel_time print('Apparent location factors in {} seconds of light travel time'.format(light_travel_time.to('s').value)) body_hgs = ICRS(body_icrs).transform_to(HGS(obstime=obstime)) return body_hgs
def get_body_heliographic_stonyhurst(body, time='now', observer=None): """ Return a `~sunpy.coordinates.frames.HeliographicStonyhurst` frame for the location of a solar-system body at a specified time. Parameters ---------- body : `str` The solar-system body for which to calculate positions time : various Time to use as `~astropy.time.Time` or in a parse_time-compatible format observer : `~astropy.coordinates.SkyCoord` If not None, the returned coordinate is the apparent location (i.e., factors in light travel time) Returns ------- out : `~sunpy.coordinates.frames.HeliographicStonyhurst` Location of the solar-system body in the `~sunpy.coordinates.HeliographicStonyhurst` frame """ obstime = parse_time(time) if observer is None: body_icrs = get_body_barycentric(body, obstime) else: observer_icrs = SkyCoord(observer).icrs.cartesian # This implementation is modeled after Astropy's `_get_apparent_body_position` light_travel_time = 0. * u.s emitted_time = obstime delta_light_travel_time = 1.*u.s # placeholder value while np.any(np.fabs(delta_light_travel_time) > 1.0e-8*u.s): body_icrs = get_body_barycentric(body, emitted_time) distance = (body_icrs - observer_icrs).norm() delta_light_travel_time = light_travel_time - distance / speed_of_light light_travel_time = distance / speed_of_light emitted_time = obstime - light_travel_time print('Apparent location factors in {} seconds of light travel time'.format(light_travel_time.to('s').value)) body_hgs = ICRS(body_icrs).transform_to(HGS(obstime=obstime)) return body_hgs
3,188
def merge_attached_breadcrumbs(mpack_breadcrumbs, data): # Merge msgpack breadcrumb file. if mpack_breadcrumbs.size > MAX_MSGPACK_BREADCRUMB_SIZE_BYTES: return try: unpacker = msgpack.Unpacker(mpack_breadcrumbs) breadcrumbs = list(unpacker) except (UnpackException, ExtraData) as e: minidumps_logger.exception(e) return if not breadcrumbs: return current_crumbs = data.get('breadcrumbs') if not current_crumbs: data['breadcrumbs'] = breadcrumbs return current_crumb = next((c for c in reversed(current_crumbs) if isinstance(c, dict) and c.get('timestamp') is not None), None) new_crumb = next((c for c in reversed(breadcrumbs) if isinstance( c, dict) and c.get('timestamp') is not None), None) # cap the breadcrumbs to the highest count of either file cap = max(len(current_crumbs), len(breadcrumbs)) if current_crumb is not None and new_crumb is not None: if dp.parse(current_crumb['timestamp']) > dp.parse(new_crumb['timestamp']): data['breadcrumbs'] = breadcrumbs + current_crumbs else: data['breadcrumbs'] = current_crumbs + breadcrumbs else: data['breadcrumbs'] = current_crumbs + breadcrumbs data['breadcrumbs'] = data['breadcrumbs'][len(data['breadcrumbs']) - cap:]
def merge_attached_breadcrumbs(mpack_breadcrumbs, data): # Merge msgpack breadcrumb file. if mpack_breadcrumbs.size > MAX_MSGPACK_BREADCRUMB_SIZE_BYTES: return try: unpacker = msgpack.Unpacker(mpack_breadcrumbs) breadcrumbs = list(unpacker) except (UnpackException, ExtraData) as e: minidumps_logger.exception(e) return if not breadcrumbs: return current_crumbs = data.get('breadcrumbs') if not current_crumbs: data['breadcrumbs'] = breadcrumbs return current_crumb = next((c for c in reversed(current_crumbs) if isinstance(c, dict) and c.get('timestamp') is not None), None) new_crumb = next((c for c in reversed(breadcrumbs) if isinstance( c, dict) and c.get('timestamp') is not None), None) # cap the breadcrumbs to the highest count of either file cap = max(len(current_crumbs), len(breadcrumbs)) if current_crumb is not None and new_crumb is not None: if dp.parse(current_crumb['timestamp']) > dp.parse(new_crumb['timestamp']): data['breadcrumbs'] = breadcrumbs + current_crumbs else: data['breadcrumbs'] = current_crumbs + breadcrumbs else: data['breadcrumbs'] = current_crumbs + breadcrumbs data['breadcrumbs'] = data['breadcrumbs'][:-cap]
57,987
def remove_duplicates_from_list_arg(args, field): """ Removes duplicates from a dict after calling argToList. For example: args: {'ids': "1,2,1"} , field='ids' The return output will be ["1","2"] :type args: dict :param args: Args to be converted (required) :type field: str :param field: Field in args to be converted into list without duplicates (required) :return: A python list of args without duplicates :rtype: ``list`` """ convert_to_list = argToList(args.get(field)) return list(set(convert_to_list))
def remove_duplicates_from_list_arg(args, field): """ Removes duplicates from a dict after calling argToList. For example: args: {'ids': "1,2,1"}, field='ids' The return output will be ["1", "2"] :type args: dict :param args: Args to be converted (required) :type field: str :param field: Field in args to be converted into list without duplicates (required) :return: A python list of args without duplicates :rtype: ``list`` """ convert_to_list = argToList(args.get(field)) return list(set(convert_to_list))
25,191
def test_deprecation_of_doc_attribute() -> None: code = textwrap.dedent( """\ def func(): "Docstring" return 1 """ ) node: nodes.FunctionDef = extract_node(code) # type: ignore[assignment] with pytest.warns(DeprecationWarning) as records: assert node.doc == "Docstring" assert len(records) == 1 with pytest.warns(DeprecationWarning) as records: node.doc = None assert len(records) == 1 code = textwrap.dedent( """\ class MyClass(): '''Docstring''' """ ) node: nodes.ClassDef = extract_node(code) # type: ignore[assignment] with pytest.warns(DeprecationWarning) as records: assert node.doc == "Docstring" assert len(records) == 1 with pytest.warns(DeprecationWarning) as records: node.doc = None assert len(records) == 1 code = textwrap.dedent( """\ '''Docstring''' """ ) node = parse(code) with pytest.warns(DeprecationWarning) as records: assert node.doc == "Docstring" assert len(records) == 1 with pytest.warns(DeprecationWarning) as records: node.doc = None assert len(records) == 1 # If 'doc' isn't passed to Module, ClassDef, FunctionDef, # no DeprecationWarning should be raised doc_node = nodes.Const("Docstring") with warnings.catch_warnings(): # Modify warnings filter to raise error for DeprecationWarning warnings.simplefilter("error", DeprecationWarning) node_module = nodes.Module(name="MyModule") node_module.postinit(body=[], doc_node=doc_node) assert node_module.doc_node == doc_node node_class = nodes.ClassDef(name="MyClass") node_class.postinit(bases=[], body=[], decorators=[], doc_node=doc_node) assert node_class.doc_node == doc_node node_func = nodes.FunctionDef(name="MyFunction") node_func.postinit(args=nodes.Arguments(), body=[], doc_node=doc_node) assert node_func.doc_node == doc_node # Test 'doc' attribute if only 'doc_node' is passed with pytest.warns(DeprecationWarning) as records: assert node_module.doc == "Docstring" assert len(records) == 1 with pytest.warns(DeprecationWarning) as records: assert node_class.doc == "Docstring" assert len(records) == 1 with pytest.warns(DeprecationWarning) as records: assert node_func.doc == "Docstring" assert len(records) == 1 # If 'doc' is passed Module, ClassDef, FunctionDef, # a DeprecationWarning should be raised doc_node = nodes.Const("Docstring") with pytest.warns(DeprecationWarning) as records: node_module = nodes.Module(name="MyModule", doc="Docstring") node_class = nodes.ClassDef(name="MyClass", doc="Docstring") node_func = nodes.FunctionDef(name="MyFunction", doc="Docstring") assert len(records) == 3
def test_deprecation_of_doc_attribute() -> None: code = textwrap.dedent( """\ def func(): "Docstring" return 1 """ ) node: nodes.FunctionDef = extract_node(code) # type: ignore[assignment] with pytest.warns(DeprecationWarning) as records: assert node.doc == "Docstring" assert len(records) == 1 with pytest.warns(DeprecationWarning) as records: node.doc = None assert len(records) == 1 code = textwrap.dedent( """\ class MyClass(): '''Docstring''' """ ) node: nodes.ClassDef = extract_node(code) # type: ignore[assignment] with pytest.warns(DeprecationWarning) as records: assert node.doc == "Docstring" assert len(records) == 1 with pytest.warns(DeprecationWarning) as records: node.doc = None assert len(records) == 1 code = textwrap.dedent( """\ '''Docstring''' """ ) node = parse(code) with pytest.warns(DeprecationWarning) as records: assert node.doc == "Docstring" assert len(records) == 1 with pytest.warns(DeprecationWarning) as records: node.doc = None assert len(records) == 1 # If 'doc' isn't passed to Module, ClassDef, FunctionDef, # no DeprecationWarning should be raised doc_node = nodes.Const("Docstring") with warnings.catch_warnings(): # Modify warnings filter to raise error for DeprecationWarning warnings.simplefilter("error", DeprecationWarning) node_module = nodes.Module(name="MyModule") node_module.postinit(body=[], doc_node=doc_node) assert node_module.doc_node == doc_node node_class = nodes.ClassDef(name="MyClass") node_class.postinit(bases=[], body=[], decorators=[], doc_node=doc_node) assert node_class.doc_node == doc_node node_func = nodes.FunctionDef(name="MyFunction") node_func.postinit(args=nodes.Arguments(), body=[], doc_node=doc_node) assert node_func.doc_node == doc_node # Test 'doc' attribute if only 'doc_node' is passed with pytest.warns(DeprecationWarning) as records: assert node_module.doc == "Docstring" assert len(records) == 1 with pytest.warns(DeprecationWarning) as records: assert node_class.doc == "Docstring" assert len(records) == 1 with pytest.warns(DeprecationWarning) as records: assert node_func.doc == "Docstring" assert len(records) == 1 # If 'doc' is passed to Module, ClassDef, FunctionDef, # a DeprecationWarning should be raised doc_node = nodes.Const("Docstring") with pytest.warns(DeprecationWarning) as records: node_module = nodes.Module(name="MyModule", doc="Docstring") node_class = nodes.ClassDef(name="MyClass", doc="Docstring") node_func = nodes.FunctionDef(name="MyFunction", doc="Docstring") assert len(records) == 3
30,289
def get_service(serviceName, version, additional_scopes=None, delegated_user=None): credentials = get_credentials(additional_scopes=additional_scopes, delegated_user=delegated_user) if PROXY: http_client = credentials.authorize(get_http_client_with_proxy()) return discovery.build(serviceName, version, http=http_client) return discovery.build(serviceName, version, credentials=credentials)
def get_service(service_name, version, additional_scopes=None, delegated_user=None): credentials = get_credentials(additional_scopes=additional_scopes, delegated_user=delegated_user) if PROXY: http_client = credentials.authorize(get_http_client_with_proxy()) return discovery.build(serviceName, version, http=http_client) return discovery.build(serviceName, version, credentials=credentials)
32,788
def patch(): if getattr(pynamodb.connection.base, '_datadog_patch', False): return setattr(pynamodb.connection.base, '_datadog_patch', True) wrapt.wrap_function_wrapper('pynamodb.connection.base', 'Connection._make_api_call', patched_api_call) Pin(service=None, app='aws').onto(pynamodb.connection.base.Connection)
def patch(): if getattr(pynamodb.connection.base, '_datadog_patch', False): return setattr(pynamodb.connection.base, '_datadog_patch', True) wrapt.wrap_function_wrapper('pynamodb.connection.base', 'Connection._make_api_call', patched_api_call) Pin(service=None).onto(pynamodb.connection.base.Connection)
2,648
def test_safe_indexing_pandas_no_settingwithcopy_warning(): # Using safe_indexing with an array-like indexer gives a copy of the # DataFrame -> ensure it doesn't raise a warning if modified pd = pytest.importorskip("pandas") X = pd.DataFrame({"a": [1, 2, 3], "b": [3, 4, 5]}) subset = _safe_indexing(X, [0, 1], axis=0) with warnings.catch_warnings(): warnings.simplefilter("error", SettingWithCopyWarning) subset.iloc[0, 0] = 10 # The original dataframe is unaffected by the assignment on the subset: assert X.iloc[0, 0] == 1
def test_safe_indexing_pandas_no_settingwithcopy_warning(): # Using safe_indexing with an array-like indexer gives a copy of the # DataFrame -> ensure it doesn't raise a warning if modified pd = pytest.importorskip("pandas") X = pd.DataFrame({"a": [1, 2, 3], "b": [3, 4, 5]}) subset = _safe_indexing(X, [0, 1], axis=0) with warnings.catch_warnings(): warnings.simplefilter("error", pd.core.common.SettingWithCopyWarning) subset.iloc[0, 0] = 10 # The original dataframe is unaffected by the assignment on the subset: assert X.iloc[0, 0] == 1
15,155
def _identify_config_schema(module: ModuleType) -> Optional[str]: """Extract the schema and identify list or dict based.""" if not hasattr(module.CONFIG_SCHEMA, "schema"): # type: ignore return None schema = module.CONFIG_SCHEMA.schema # type: ignore if isinstance(schema, vol.All): for subschema in schema.validators: if isinstance(subschema, dict): schema = subschema break else: return None try: key = next(k for k in schema if k == module.DOMAIN) # type: ignore except (TypeError, AttributeError, StopIteration): return None except Exception: # pylint: disable=broad-except _LOGGER.exception("Unexpected error identifying config schema") return None if hasattr(key, "default") and not isinstance( key.default, vol.schema_builder.Undefined ): default_value = module.CONFIG_SCHEMA({module.DOMAIN: key.default()})[ # type: ignore module.DOMAIN # type: ignore ] if isinstance(default_value, dict): return "dict" if isinstance(default_value, list): return "list" return None domain_schema = schema[key] t_schema = str(domain_schema) if t_schema.startswith("{") or "schema_with_slug_keys" in t_schema: return "dict" if t_schema.startswith(("[", "All(<function ensure_list")): return "list" return None
def _identify_config_schema(module: ModuleType) -> Optional[str]: """Extract the schema and identify list or dict based.""" if not isinstance(module.CONFIG_SCHEMA, vol.Schema): return None schema = module.CONFIG_SCHEMA.schema # type: ignore if isinstance(schema, vol.All): for subschema in schema.validators: if isinstance(subschema, dict): schema = subschema break else: return None try: key = next(k for k in schema if k == module.DOMAIN) # type: ignore except (TypeError, AttributeError, StopIteration): return None except Exception: # pylint: disable=broad-except _LOGGER.exception("Unexpected error identifying config schema") return None if hasattr(key, "default") and not isinstance( key.default, vol.schema_builder.Undefined ): default_value = module.CONFIG_SCHEMA({module.DOMAIN: key.default()})[ # type: ignore module.DOMAIN # type: ignore ] if isinstance(default_value, dict): return "dict" if isinstance(default_value, list): return "list" return None domain_schema = schema[key] t_schema = str(domain_schema) if t_schema.startswith("{") or "schema_with_slug_keys" in t_schema: return "dict" if t_schema.startswith(("[", "All(<function ensure_list")): return "list" return None
57,498
def field_type_schema( field: ModelField, *, by_alias: bool, model_name_map: Dict[TypeModelOrEnum, str], ref_template: str, schema_overrides: bool = False, ref_prefix: Optional[str] = None, known_models: TypeModelSet, ) -> Tuple[Dict[str, Any], Dict[str, Any], Set[str]]: """ Used by ``field_schema()``, you probably should be using that function. Take a single ``field`` and generate the schema for its type only, not including additional information as title, etc. Also return additional schema definitions, from sub-models. """ definitions = {} nested_models: Set[str] = set() f_schema: Dict[str, Any] if field.shape in {SHAPE_LIST, SHAPE_TUPLE_ELLIPSIS, SHAPE_SEQUENCE, SHAPE_SET, SHAPE_FROZENSET, SHAPE_ITERABLE}: items_schema, f_definitions, f_nested_models = field_singleton_schema( field, by_alias=by_alias, model_name_map=model_name_map, ref_prefix=ref_prefix, ref_template=ref_template, known_models=known_models, ) definitions.update(f_definitions) nested_models.update(f_nested_models) f_schema = {'type': 'array', 'items': items_schema} if field.shape in {SHAPE_SET, SHAPE_FROZENSET}: f_schema['uniqueItems'] = True elif field.shape == SHAPE_MAPPING: f_schema = {'type': 'object'} key_field = cast(ModelField, field.key_field) regex = getattr(key_field.type_, 'regex', None) items_schema, f_definitions, f_nested_models = field_singleton_schema( field, by_alias=by_alias, model_name_map=model_name_map, ref_prefix=ref_prefix, ref_template=ref_template, known_models=known_models, ) definitions.update(f_definitions) nested_models.update(f_nested_models) if regex: # Dict keys have a regex pattern # items_schema might be a schema or empty dict, add it either way f_schema['patternProperties'] = {regex.pattern: items_schema} elif items_schema: # The dict values are not simply Any, so they need a schema f_schema['additionalProperties'] = items_schema elif field.shape == SHAPE_TUPLE: sub_schema = [] sub_fields = cast(List[ModelField], field.sub_fields) for sf in sub_fields: sf_schema, sf_definitions, sf_nested_models = field_type_schema( sf, by_alias=by_alias, model_name_map=model_name_map, ref_prefix=ref_prefix, ref_template=ref_template, known_models=known_models, ) definitions.update(sf_definitions) nested_models.update(sf_nested_models) sub_schema.append(sf_schema) if len(sub_schema) == 1: sub_schema = sub_schema[0] # type: ignore f_schema = {'type': 'array', 'items': sub_schema} else: assert field.shape in {SHAPE_SINGLETON, SHAPE_GENERIC}, field.shape f_schema, f_definitions, f_nested_models = field_singleton_schema( field, by_alias=by_alias, model_name_map=model_name_map, schema_overrides=schema_overrides, ref_prefix=ref_prefix, ref_template=ref_template, known_models=known_models, ) definitions.update(f_definitions) nested_models.update(f_nested_models) # check field type to avoid repeated calls to the same __modify_schema__ method if field.type_ != field.outer_type_: if field.shape == SHAPE_GENERIC: modify_schema = getattr(field.type_, '__modify_schema__', None) else: modify_schema = getattr(field.outer_type_, '__modify_schema__', None) if modify_schema: modify_schema(f_schema) return f_schema, definitions, nested_models
def field_type_schema( field: ModelField, *, by_alias: bool, model_name_map: Dict[TypeModelOrEnum, str], ref_template: str, schema_overrides: bool = False, ref_prefix: Optional[str] = None, known_models: TypeModelSet, ) -> Tuple[Dict[str, Any], Dict[str, Any], Set[str]]: """ Used by ``field_schema()``, you probably should be using that function. Take a single ``field`` and generate the schema for its type only, not including additional information as title, etc. Also return additional schema definitions, from sub-models. """ definitions = {} nested_models: Set[str] = set() f_schema: Dict[str, Any] if field.shape in {SHAPE_LIST, SHAPE_TUPLE_ELLIPSIS, SHAPE_SEQUENCE, SHAPE_SET, SHAPE_FROZENSET, SHAPE_ITERABLE}: items_schema, f_definitions, f_nested_models = field_singleton_schema( field, by_alias=by_alias, model_name_map=model_name_map, ref_prefix=ref_prefix, ref_template=ref_template, known_models=known_models, ) definitions.update(f_definitions) nested_models.update(f_nested_models) f_schema = {'type': 'array', 'items': items_schema} if field.shape in {SHAPE_SET, SHAPE_FROZENSET}: f_schema['uniqueItems'] = True elif field.shape == SHAPE_MAPPING: f_schema = {'type': 'object'} key_field = cast(ModelField, field.key_field) regex = getattr(key_field.type_, 'regex', None) items_schema, f_definitions, f_nested_models = field_singleton_schema( field, by_alias=by_alias, model_name_map=model_name_map, ref_prefix=ref_prefix, ref_template=ref_template, known_models=known_models, ) definitions.update(f_definitions) nested_models.update(f_nested_models) if regex: # Dict keys have a regex pattern # items_schema might be a schema or empty dict, add it either way f_schema['patternProperties'] = {regex.pattern: items_schema} elif items_schema: # The dict values are not simply Any, so they need a schema f_schema['additionalProperties'] = items_schema elif field.shape == SHAPE_TUPLE: sub_schema = [] sub_fields = cast(List[ModelField], field.sub_fields) for sf in sub_fields: sf_schema, sf_definitions, sf_nested_models = field_type_schema( sf, by_alias=by_alias, model_name_map=model_name_map, ref_prefix=ref_prefix, ref_template=ref_template, known_models=known_models, ) definitions.update(sf_definitions) nested_models.update(sf_nested_models) sub_schema.append(sf_schema) if len(sub_schema) == 1: sub_schema = sub_schema[0] # type: ignore f_schema = {'type': 'array', 'items': sub_schema} else: assert field.shape in {SHAPE_SINGLETON, SHAPE_GENERIC}, field.shape f_schema, f_definitions, f_nested_models = field_singleton_schema( field, by_alias=by_alias, model_name_map=model_name_map, schema_overrides=schema_overrides, ref_prefix=ref_prefix, ref_template=ref_template, known_models=known_models, ) definitions.update(f_definitions) nested_models.update(f_nested_models) # check field type to avoid repeated calls to the same __modify_schema__ method if field.type_ != field.outer_type_: if field.shape == SHAPE_GENERIC: field_type = field.type_ else: field_type = field.outer_type_ modify_schema = getattr(field_type, '__modify_schema__', None) if modify_schema: modify_schema(f_schema) return f_schema, definitions, nested_models
55,730
def view_labels( data=None, *, num_colors=50, properties=None, seed=0.5, name=None, metadata=None, scale=None, translate=None, opacity=0.7, blending='translucent', visible=True, multiscale=None, title='napari', ndisplay=2, order=None, axis_labels=None, show=True, color=None, ): """Create a viewer and add a labels (or segmentation) layer. An image-like layer where every pixel contains an integer ID corresponding to the region it belongs to. Using the viewer's label editing tools (painting, erasing) will modify the input-array in-place. To avoid this, pass a copy as follows: viewer = napari.view_labels(data.copy(), name="sample") # do some painting/editing Get the painted labels as follows: result = viewer.layers["sample"].data Parameters ---------- data : array or list of array Labels data as an array or multiscale. num_colors : int Number of unique colors to use in colormap. properties : dict {str: array (N,)}, DataFrame Properties for each label. Each property should be an array of length N, where N is the number of labels, and the first property corresponds to background. seed : float Seed for colormap random generator. name : str Name of the layer. metadata : dict Layer metadata. scale : tuple of float Scale factors for the layer. translate : tuple of float Translation values for the layer. opacity : float Opacity of the layer visual, between 0.0 and 1.0. blending : str One of a list of preset blending modes that determines how RGB and alpha values of the layer visual get mixed. Allowed values are {'opaque', 'translucent', and 'additive'}. visible : bool Whether the layer visual is currently being displayed. multiscale : bool Whether the data is a multiscale image or not. Multiscale data is represented by a list of array like image data. If not specified by the user and if the data is a list of arrays that decrease in shape then it will be taken to be multiscale. The first image in the list should be the largest. title : string The title of the viewer window. ndisplay : {2, 3} Number of displayed dimensions. order : tuple of int Order in which dimensions are displayed where the last two or last three dimensions correspond to row x column or plane x row x column if ndisplay is 2 or 3. axis_labels : list of str Dimension names. show : bool, optional Whether to show the viewer after instantiation. by default True. color : dict of int to str Custom label to color mapping Returns ------- viewer : :class:`napari.Viewer` The newly-created viewer. """ viewer = Viewer( title=title, ndisplay=ndisplay, order=order, axis_labels=axis_labels, show=show, ) viewer.add_labels( data=data, multiscale=multiscale, num_colors=num_colors, properties=properties, seed=seed, name=name, metadata=metadata, scale=scale, translate=translate, opacity=opacity, blending=blending, visible=visible, color=color, ) return viewer
def view_labels( data=None, *, num_colors=50, properties=None, seed=0.5, name=None, metadata=None, scale=None, translate=None, opacity=0.7, blending='translucent', visible=True, multiscale=None, title='napari', ndisplay=2, order=None, axis_labels=None, show=True, color=None, ): """Create a viewer and add a labels (or segmentation) layer. An image-like layer where every pixel contains an integer ID corresponding to the region it belongs to. Using the viewer's label editing tools (painting, erasing) will modify the input-array in-place. To avoid this, pass a copy as follows: viewer = napari.view_labels(data.copy(), name="sample") # do some painting/editing Get the painted labels as follows: result = viewer.layers["sample"].data Parameters ---------- data : array or list of array Labels data as an array or multiscale. num_colors : int Number of unique colors to use in colormap. properties : dict {str: array (N,)}, DataFrame Properties for each label. Each property should be an array of length N, where N is the number of labels, and the first property corresponds to background. seed : float Seed for colormap random generator. name : str Name of the layer. metadata : dict Layer metadata. scale : tuple of float Scale factors for the layer. translate : tuple of float Translation values for the layer. opacity : float Opacity of the layer visual, between 0.0 and 1.0. blending : str One of a list of preset blending modes that determines how RGB and alpha values of the layer visual get mixed. Allowed values are {'opaque', 'translucent', and 'additive'}. visible : bool Whether the layer visual is currently being displayed. multiscale : bool Whether the data is a multiscale image or not. Multiscale data is represented by a list of array like image data. If not specified by the user and if the data is a list of arrays that decrease in shape then it will be taken to be multiscale. The first image in the list should be the largest. title : string The title of the viewer window. ndisplay : {2, 3} Number of displayed dimensions. order : tuple of int Order in which dimensions are displayed where the last two or last three dimensions correspond to row x column or plane x row x column if ndisplay is 2 or 3. axis_labels : list of str Dimension names. show : bool, optional Whether to show the viewer after instantiation. by default True. color : dict of int to str or array Custom label to color mapping. Values must be valid color names or RGBA arrays. Returns ------- viewer : :class:`napari.Viewer` The newly-created viewer. """ viewer = Viewer( title=title, ndisplay=ndisplay, order=order, axis_labels=axis_labels, show=show, ) viewer.add_labels( data=data, multiscale=multiscale, num_colors=num_colors, properties=properties, seed=seed, name=name, metadata=metadata, scale=scale, translate=translate, opacity=opacity, blending=blending, visible=visible, color=color, ) return viewer
41,473
def eval_func(op, argop, dataop, d): def func(p): tensorlib, _ = get_backend() xx = tensorlib.tolist(p) if isinstance(p, tf.Tensor) else p yy = tensorlib.tolist(d) if isinstance(d, tf.Tensor) else d value = tensorlib.session.run(op, feed_dict={argop: xx, dataop: yy}) return value return func
def eval_func(op, argop, dataop, data): def func(p): tensorlib, _ = get_backend() xx = tensorlib.tolist(p) if isinstance(p, tf.Tensor) else p yy = tensorlib.tolist(d) if isinstance(d, tf.Tensor) else d value = tensorlib.session.run(op, feed_dict={argop: xx, dataop: yy}) return value return func
7,281
def choose(p, shape): """ Function to return Bernoulli trials at a given probability of a given size. This function is meant as a lower-memory alternative to calls such as `np.random.choice([True, False], size=image.shape, p=[p, 1-p])`. While `np.random.choice` can handle many classes, for the 2-class case (Bernoulli trials), this function is much more efficient. Parameters ---------- p : float The probability that any given trial returns `True`. shape : int or tuple of ints The shape of the ndarray to return. Returns ------- out : ndarray[bool] The results of Bernoulli trials in the given `size` where success occurs with probability `p`. """ if p == 0: return np.zeros(shape, dtype=bool) if p == 1: return ~np.zeros(shape, dtype=bool) return np.random.random(shape) <= p
def _bernoulli(p, shape): """ Function to return Bernoulli trials at a given probability of a given size. This function is meant as a lower-memory alternative to calls such as `np.random.choice([True, False], size=image.shape, p=[p, 1-p])`. While `np.random.choice` can handle many classes, for the 2-class case (Bernoulli trials), this function is much more efficient. Parameters ---------- p : float The probability that any given trial returns `True`. shape : int or tuple of ints The shape of the ndarray to return. Returns ------- out : ndarray[bool] The results of Bernoulli trials in the given `size` where success occurs with probability `p`. """ if p == 0: return np.zeros(shape, dtype=bool) if p == 1: return ~np.zeros(shape, dtype=bool) return np.random.random(shape) <= p
44,034
def Interferometer(theta, phi, varphi, wires, mesh="rectangular", beamsplitter="pennylane"): r"""General linear interferometer, an array of beamsplitters and phase shifters. For :math:`M` wires, the general interferometer is specified by providing :math:`M(M-1)/2` transmittivity angles :math:`\theta` and the same number of phase angles :math:`\phi`, as well as :math:`M-1` additional rotation parameters :math:`\varphi`. By specifying the keyword argument ``mesh``, the scheme used to implement the interferometer may be adjusted: * ``mesh='rectangular'`` (default): uses the scheme described in `Clements et al. <https://dx.doi.org/10.1364/OPTICA.3.001460>`__, resulting in a *rectangular* array of :math:`M(M-1)/2` beamsplitters arranged in :math:`M` slices and ordered from left to right and top to bottom in each slice. The first beamsplitter acts on wires :math:`0` and :math:`1`: .. figure:: ../../_static/clements.png :align: center :width: 30% :target: javascript:void(0); * ``mesh='triangular'``: uses the scheme described in `Reck et al. <https://dx.doi.org/10.1103/PhysRevLett.73.58>`__, resulting in a *triangular* array of :math:`M(M-1)/2` beamsplitters arranged in :math:`2M-3` slices and ordered from left to right and top to bottom. The first and fourth beamsplitters act on wires :math:`M-1` and :math:`M`, the second on :math:`M-2` and :math:`M-1`, and the third on :math:`M-3` and :math:`M-2`, and so on. .. figure:: ../../_static/reck.png :align: center :width: 30% :target: javascript:void(0); In both schemes, the network of :class:`~pennylane.ops.Beamsplitter` operations is followed by :math:`M` local :class:`~pennylane.ops.Rotation` Operations. The rectangular decomposition is generally advantageous, as it has a lower circuit depth (:math:`M` vs :math:`2M-3`) and optical depth than the triangular decomposition, resulting in reduced optical loss. This is an example of a 4-mode interferometer with beamsplitters :math:`B` and rotations :math:`R`, using ``mesh='rectangular'``: .. figure:: ../../_static/layer_interferometer.png :align: center :width: 60% :target: javascript:void(0); .. note:: The decomposition as formulated in `Clements et al. <https://dx.doi.org/10.1364/OPTICA.3.001460>`__ uses a different convention for a beamsplitter :math:`T(\theta, \phi)` than PennyLane, namely: .. math:: T(\theta, \phi) = BS(\theta, 0) R(\phi) For the universality of the decomposition, the used convention is irrelevant, but for a given set of angles the resulting interferometers will be different. If an interferometer consistent with the convention from `Clements et al. <https://dx.doi.org/10.1364/OPTICA.3.001460>`__ is needed, the optional keyword argument ``beamsplitter='clements'`` can be specified. This will result in each :class:`~pennylane.ops.Beamsplitter` being preceded by a :class:`~pennylane.ops.Rotation` and thus increase the number of elementary operations in the circuit. Args: theta (tensor_like): size :math:`(M(M-1)/2,)` tensor of transmittivity angles :math:`\theta` phi (tensor_like): size :math:`(M(M-1)/2,)` tensor of phase angles :math:`\phi` varphi (tensor_like): size :math:`(M,)` tensor of rotation angles :math:`\varphi` wires (Iterable or Wires): Wires that the template acts on. Accepts an iterable of numbers or strings, or a Wires object. mesh (string): the type of mesh to use beamsplitter (str): if ``clements``, the beamsplitter convention from Clements et al. 2016 (https://dx.doi.org/10.1364/OPTICA.3.001460) is used; if ``pennylane``, the beamsplitter is implemented via PennyLane's ``Beamsplitter`` operation. Raises: ValueError: if inputs do not have the correct format Example: The template requires :math:`3` sets of parameters. The ``mesh`` and ``beamsplitter`` arguments are optional and have ``'rectangular'`` and ``'pennylane'`` as default values. .. code-block:: python dev = qml.device('default.gaussian', wires=4) @qml.qnode(dev) def circuit(): qml.Interferometer(*params, wires=range(4)) return qml.expval(qml.Identity(0)) shapes = [[6, ], [6, ], [4, ]] params = [] for shape in shapes: params.append(np.random.random(shape)) Using these random parameters, the resulting circuit is: >>> print(qml.draw(circuit)()) 0: ──╭BS(0.0522, 0.0472)────────────────────╭BS(0.438, 0.222)───R(0.606)────────────────────┤ ⟨I⟩ 1: ──╰BS(0.0522, 0.0472)──╭BS(0.994, 0.59)──╰BS(0.438, 0.222)──╭BS(0.823, 0.623)──R(0.221)──┤ 2: ──╭BS(0.636, 0.298)────╰BS(0.994, 0.59)──╭BS(0.0818, 0.72)──╰BS(0.823, 0.623)──R(0.807)──┤ 3: ──╰BS(0.636, 0.298)──────────────────────╰BS(0.0818, 0.72)───R(0.854)────────────────────┤ Using different values for optional arguments: .. code-block:: python @qml.qnode(dev) def circuit(): qml.Interferometer(*params, wires=range(4), mesh='triangular', beamsplitter='clements') return qml.expval(qml.Identity(0)) shapes = [[6, ], [6, ], [4, ]] params = [] for shape in shapes: params.append(np.random.random(shape)) The resulting circuit in this case is: >>> print(qml.draw(circuit)()) 0: ──R(0.713)──────────────────────────────────╭BS(0.213, 0)───R(0.681)──────────────────────────────────────────────────────────┤ ⟨I⟩ 1: ──R(0.00912)─────────────────╭BS(0.239, 0)──╰BS(0.213, 0)───R(0.388)──────╭BS(0.622, 0)──R(0.567)─────────────────────────────┤ 2: ──R(0.43)─────╭BS(0.534, 0)──╰BS(0.239, 0)───R(0.189)──────╭BS(0.809, 0)──╰BS(0.622, 0)──R(0.309)──╭BS(0.00845, 0)──R(0.757)──┤ 3: ──────────────╰BS(0.534, 0)────────────────────────────────╰BS(0.809, 0)───────────────────────────╰BS(0.00845, 0)──R(0.527)──┤ """ wires = Wires(wires) M = len(wires) shape_varphi = _preprocess(theta, phi, varphi, wires) with qml.tape.OperationRecorder() as rec: if M == 1: # the interferometer is a single rotation Rotation(varphi[0], wires=wires[0]) else: n = 0 # keep track of free parameters if mesh == "rectangular": # Apply the Clements beamsplitter array # The array depth is N for l in range(M): for k, (w1, w2) in enumerate(zip(wires[:-1], wires[1:])): # skip even or odd pairs depending on layer if (l + k) % 2 != 1: if beamsplitter == "clements": Rotation(phi[n], wires=Wires(w1)) Beamsplitter(theta[n], 0, wires=Wires([w1, w2])) elif beamsplitter == "pennylane": Beamsplitter(theta[n], phi[n], wires=Wires([w1, w2])) else: raise ValueError(f"did not recognize beamsplitter {beamsplitter}") n += 1 elif mesh == "triangular": # apply the Reck beamsplitter array # The array depth is 2*N-3 for l in range(2 * M - 3): for k in range(abs(l + 1 - (M - 1)), M - 1, 2): if beamsplitter == "clements": Rotation(phi[n], wires=wires[k]) Beamsplitter(theta[n], 0, wires=wires.subset([k, k + 1])) elif beamsplitter == "pennylane": Beamsplitter(theta[n], phi[n], wires=wires.subset([k, k + 1])) else: raise ValueError(f"did not recognize beamsplitter {beamsplitter} ") n += 1 else: raise ValueError(f"did not recognize mesh {mesh}") # apply the final local phase shifts to all modes for i in range(shape_varphi[0]): act_on = wires[i] Rotation(varphi[i], wires=act_on) return rec.queue
def Interferometer(theta, phi, varphi, wires, mesh="rectangular", beamsplitter="pennylane"): r"""General linear interferometer, an array of beamsplitters and phase shifters. For :math:`M` wires, the general interferometer is specified by providing :math:`M(M-1)/2` transmittivity angles :math:`\theta` and the same number of phase angles :math:`\phi`, as well as :math:`M-1` additional rotation parameters :math:`\varphi`. By specifying the keyword argument ``mesh``, the scheme used to implement the interferometer may be adjusted: * ``mesh='rectangular'`` (default): uses the scheme described in `Clements et al. <https://dx.doi.org/10.1364/OPTICA.3.001460>`__, resulting in a *rectangular* array of :math:`M(M-1)/2` beamsplitters arranged in :math:`M` slices and ordered from left to right and top to bottom in each slice. The first beamsplitter acts on wires :math:`0` and :math:`1`: .. figure:: ../../_static/clements.png :align: center :width: 30% :target: javascript:void(0); * ``mesh='triangular'``: uses the scheme described in `Reck et al. <https://dx.doi.org/10.1103/PhysRevLett.73.58>`__, resulting in a *triangular* array of :math:`M(M-1)/2` beamsplitters arranged in :math:`2M-3` slices and ordered from left to right and top to bottom. The first and fourth beamsplitters act on wires :math:`M-1` and :math:`M`, the second on :math:`M-2` and :math:`M-1`, and the third on :math:`M-3` and :math:`M-2`, and so on. .. figure:: ../../_static/reck.png :align: center :width: 30% :target: javascript:void(0); In both schemes, the network of :class:`~pennylane.ops.Beamsplitter` operations is followed by :math:`M` local :class:`~pennylane.ops.Rotation` Operations. The rectangular decomposition is generally advantageous, as it has a lower circuit depth (:math:`M` vs :math:`2M-3`) and optical depth than the triangular decomposition, resulting in reduced optical loss. This is an example of a 4-mode interferometer with beamsplitters :math:`B` and rotations :math:`R`, using ``mesh='rectangular'``: .. figure:: ../../_static/layer_interferometer.png :align: center :width: 60% :target: javascript:void(0); .. note:: The decomposition as formulated in `Clements et al. <https://dx.doi.org/10.1364/OPTICA.3.001460>`__ uses a different convention for a beamsplitter :math:`T(\theta, \phi)` than PennyLane, namely: .. math:: T(\theta, \phi) = BS(\theta, 0) R(\phi) For the universality of the decomposition, the used convention is irrelevant, but for a given set of angles the resulting interferometers will be different. If an interferometer consistent with the convention from `Clements et al. <https://dx.doi.org/10.1364/OPTICA.3.001460>`__ is needed, the optional keyword argument ``beamsplitter='clements'`` can be specified. This will result in each :class:`~pennylane.ops.Beamsplitter` being preceded by a :class:`~pennylane.ops.Rotation` and thus increase the number of elementary operations in the circuit. Args: theta (tensor_like): size :math:`(M(M-1)/2,)` tensor of transmittivity angles :math:`\theta` phi (tensor_like): size :math:`(M(M-1)/2,)` tensor of phase angles :math:`\phi` varphi (tensor_like): size :math:`(M,)` tensor of rotation angles :math:`\varphi` wires (Iterable or Wires): Wires that the template acts on. Accepts an iterable of numbers or strings, or a Wires object. mesh (string): the type of mesh to use beamsplitter (str): if ``clements``, the beamsplitter convention from Clements et al. 2016 (https://dx.doi.org/10.1364/OPTICA.3.001460) is used; if ``pennylane``, the beamsplitter is implemented via PennyLane's ``Beamsplitter`` operation. Raises: ValueError: if inputs do not have the correct format Example: The template requires :math:`3` sets of parameters. The ``mesh`` and ``beamsplitter`` keyword arguments are optional and have ``'rectangular'`` and ``'pennylane'`` as default values. .. code-block:: python dev = qml.device('default.gaussian', wires=4) @qml.qnode(dev) def circuit(): qml.Interferometer(*params, wires=range(4)) return qml.expval(qml.Identity(0)) shapes = [[6, ], [6, ], [4, ]] params = [] for shape in shapes: params.append(np.random.random(shape)) Using these random parameters, the resulting circuit is: >>> print(qml.draw(circuit)()) 0: ──╭BS(0.0522, 0.0472)────────────────────╭BS(0.438, 0.222)───R(0.606)────────────────────┤ ⟨I⟩ 1: ──╰BS(0.0522, 0.0472)──╭BS(0.994, 0.59)──╰BS(0.438, 0.222)──╭BS(0.823, 0.623)──R(0.221)──┤ 2: ──╭BS(0.636, 0.298)────╰BS(0.994, 0.59)──╭BS(0.0818, 0.72)──╰BS(0.823, 0.623)──R(0.807)──┤ 3: ──╰BS(0.636, 0.298)──────────────────────╰BS(0.0818, 0.72)───R(0.854)────────────────────┤ Using different values for optional arguments: .. code-block:: python @qml.qnode(dev) def circuit(): qml.Interferometer(*params, wires=range(4), mesh='triangular', beamsplitter='clements') return qml.expval(qml.Identity(0)) shapes = [[6, ], [6, ], [4, ]] params = [] for shape in shapes: params.append(np.random.random(shape)) The resulting circuit in this case is: >>> print(qml.draw(circuit)()) 0: ──R(0.713)──────────────────────────────────╭BS(0.213, 0)───R(0.681)──────────────────────────────────────────────────────────┤ ⟨I⟩ 1: ──R(0.00912)─────────────────╭BS(0.239, 0)──╰BS(0.213, 0)───R(0.388)──────╭BS(0.622, 0)──R(0.567)─────────────────────────────┤ 2: ──R(0.43)─────╭BS(0.534, 0)──╰BS(0.239, 0)───R(0.189)──────╭BS(0.809, 0)──╰BS(0.622, 0)──R(0.309)──╭BS(0.00845, 0)──R(0.757)──┤ 3: ──────────────╰BS(0.534, 0)────────────────────────────────╰BS(0.809, 0)───────────────────────────╰BS(0.00845, 0)──R(0.527)──┤ """ wires = Wires(wires) M = len(wires) shape_varphi = _preprocess(theta, phi, varphi, wires) with qml.tape.OperationRecorder() as rec: if M == 1: # the interferometer is a single rotation Rotation(varphi[0], wires=wires[0]) else: n = 0 # keep track of free parameters if mesh == "rectangular": # Apply the Clements beamsplitter array # The array depth is N for l in range(M): for k, (w1, w2) in enumerate(zip(wires[:-1], wires[1:])): # skip even or odd pairs depending on layer if (l + k) % 2 != 1: if beamsplitter == "clements": Rotation(phi[n], wires=Wires(w1)) Beamsplitter(theta[n], 0, wires=Wires([w1, w2])) elif beamsplitter == "pennylane": Beamsplitter(theta[n], phi[n], wires=Wires([w1, w2])) else: raise ValueError(f"did not recognize beamsplitter {beamsplitter}") n += 1 elif mesh == "triangular": # apply the Reck beamsplitter array # The array depth is 2*N-3 for l in range(2 * M - 3): for k in range(abs(l + 1 - (M - 1)), M - 1, 2): if beamsplitter == "clements": Rotation(phi[n], wires=wires[k]) Beamsplitter(theta[n], 0, wires=wires.subset([k, k + 1])) elif beamsplitter == "pennylane": Beamsplitter(theta[n], phi[n], wires=wires.subset([k, k + 1])) else: raise ValueError(f"did not recognize beamsplitter {beamsplitter} ") n += 1 else: raise ValueError(f"did not recognize mesh {mesh}") # apply the final local phase shifts to all modes for i in range(shape_varphi[0]): act_on = wires[i] Rotation(varphi[i], wires=act_on) return rec.queue
42,085
def _get_contour_plot( study: Study, params: Optional[List[str]] = None, target: Optional[Callable[[FrozenTrial], float]] = None, target_name: str = "Objective Value", ) -> "go.Figure": layout = go.Layout(title="Contour Plot") trials = _filter_nonfinite( [trial for trial in study.trials if trial.state == TrialState.COMPLETE], target=target ) if len(trials) == 0: _logger.warning("Your study does not have any completed trials.") return go.Figure(data=[], layout=layout) all_params = {p_name for t in trials for p_name in t.params.keys()} if params is None: sorted_params = sorted(all_params) elif len(params) <= 1: _logger.warning("The length of params must be greater than 1.") return go.Figure(data=[], layout=layout) else: for input_p_name in params: if input_p_name not in all_params: raise ValueError("Parameter {} does not exist in your study.".format(input_p_name)) sorted_params = sorted(set(params)) padding_ratio = 0.05 param_values_range = {} for p_name in sorted_params: values = _get_param_values(trials, p_name) min_value = min(values) max_value = max(values) if _is_log_scale(trials, p_name): padding = (math.log10(max_value) - math.log10(min_value)) * padding_ratio min_value = math.pow(10, math.log10(min_value) - padding) max_value = math.pow(10, math.log10(max_value) + padding) elif _is_numerical(trials, p_name): padding = (max_value - min_value) * padding_ratio min_value = min_value - padding max_value = max_value + padding else: # Plotly>=4.12.0 draws contours using the indices of categorical variables instead of # raw values and the range should be updated based on the cardinality of categorical # variables. See https://github.com/optuna/optuna/issues/1967. if version.parse(plotly.__version__) >= version.parse("4.12.0"): span = len(set(values)) - 1 padding = span * padding_ratio min_value = -padding max_value = span + padding param_values_range[p_name] = (min_value, max_value) reverse_scale = _is_reverse_scale(study, target) if len(sorted_params) == 2: x_param = sorted_params[0] y_param = sorted_params[1] sub_plots = _generate_contour_subplot( trials, x_param, y_param, reverse_scale, param_values_range, target, target_name ) figure = go.Figure(data=sub_plots, layout=layout) figure.update_xaxes(title_text=x_param, range=param_values_range[x_param]) figure.update_yaxes(title_text=y_param, range=param_values_range[y_param]) if not _is_numerical(trials, x_param): figure.update_xaxes(type="category") if not _is_numerical(trials, y_param): figure.update_yaxes(type="category") if _is_log_scale(trials, x_param): log_range = [math.log10(p) for p in param_values_range[x_param]] figure.update_xaxes(range=log_range, type="log") if _is_log_scale(trials, y_param): log_range = [math.log10(p) for p in param_values_range[y_param]] figure.update_yaxes(range=log_range, type="log") else: figure = make_subplots( rows=len(sorted_params), cols=len(sorted_params), shared_xaxes=True, shared_yaxes=True ) figure.update_layout(layout) showscale = True # showscale option only needs to be specified once for x_i, x_param in enumerate(sorted_params): for y_i, y_param in enumerate(sorted_params): if x_param == y_param: figure.add_trace(go.Scatter(), row=y_i + 1, col=x_i + 1) else: sub_plots = _generate_contour_subplot( trials, x_param, y_param, reverse_scale, param_values_range, target, target_name, ) contour = sub_plots[0] scatter = sub_plots[1] contour.update(showscale=showscale) # showscale's default is True if showscale: showscale = False figure.add_trace(contour, row=y_i + 1, col=x_i + 1) figure.add_trace(scatter, row=y_i + 1, col=x_i + 1) figure.update_xaxes(range=param_values_range[x_param], row=y_i + 1, col=x_i + 1) figure.update_yaxes(range=param_values_range[y_param], row=y_i + 1, col=x_i + 1) if not _is_numerical(trials, x_param): figure.update_xaxes(type="category", row=y_i + 1, col=x_i + 1) if not _is_numerical(trials, y_param): figure.update_yaxes(type="category", row=y_i + 1, col=x_i + 1) if _is_log_scale(trials, x_param): log_range = [math.log10(p) for p in param_values_range[x_param]] figure.update_xaxes(range=log_range, type="log", row=y_i + 1, col=x_i + 1) if _is_log_scale(trials, y_param): log_range = [math.log10(p) for p in param_values_range[y_param]] figure.update_yaxes(range=log_range, type="log", row=y_i + 1, col=x_i + 1) if x_i == 0: figure.update_yaxes(title_text=y_param, row=y_i + 1, col=x_i + 1) if y_i == len(sorted_params) - 1: figure.update_xaxes(title_text=x_param, row=y_i + 1, col=x_i + 1) return figure
def _get_contour_plot( study: Study, params: Optional[List[str]] = None, target: Optional[Callable[[FrozenTrial], float]] = None, target_name: str = "Objective Value", ) -> "go.Figure": layout = go.Layout(title="Contour Plot") trials = _filter_nonfinite( study.get_trials(deepcopy=False, states=(TrialState.COMPLETE,)), target=target ) if len(trials) == 0: _logger.warning("Your study does not have any completed trials.") return go.Figure(data=[], layout=layout) all_params = {p_name for t in trials for p_name in t.params.keys()} if params is None: sorted_params = sorted(all_params) elif len(params) <= 1: _logger.warning("The length of params must be greater than 1.") return go.Figure(data=[], layout=layout) else: for input_p_name in params: if input_p_name not in all_params: raise ValueError("Parameter {} does not exist in your study.".format(input_p_name)) sorted_params = sorted(set(params)) padding_ratio = 0.05 param_values_range = {} for p_name in sorted_params: values = _get_param_values(trials, p_name) min_value = min(values) max_value = max(values) if _is_log_scale(trials, p_name): padding = (math.log10(max_value) - math.log10(min_value)) * padding_ratio min_value = math.pow(10, math.log10(min_value) - padding) max_value = math.pow(10, math.log10(max_value) + padding) elif _is_numerical(trials, p_name): padding = (max_value - min_value) * padding_ratio min_value = min_value - padding max_value = max_value + padding else: # Plotly>=4.12.0 draws contours using the indices of categorical variables instead of # raw values and the range should be updated based on the cardinality of categorical # variables. See https://github.com/optuna/optuna/issues/1967. if version.parse(plotly.__version__) >= version.parse("4.12.0"): span = len(set(values)) - 1 padding = span * padding_ratio min_value = -padding max_value = span + padding param_values_range[p_name] = (min_value, max_value) reverse_scale = _is_reverse_scale(study, target) if len(sorted_params) == 2: x_param = sorted_params[0] y_param = sorted_params[1] sub_plots = _generate_contour_subplot( trials, x_param, y_param, reverse_scale, param_values_range, target, target_name ) figure = go.Figure(data=sub_plots, layout=layout) figure.update_xaxes(title_text=x_param, range=param_values_range[x_param]) figure.update_yaxes(title_text=y_param, range=param_values_range[y_param]) if not _is_numerical(trials, x_param): figure.update_xaxes(type="category") if not _is_numerical(trials, y_param): figure.update_yaxes(type="category") if _is_log_scale(trials, x_param): log_range = [math.log10(p) for p in param_values_range[x_param]] figure.update_xaxes(range=log_range, type="log") if _is_log_scale(trials, y_param): log_range = [math.log10(p) for p in param_values_range[y_param]] figure.update_yaxes(range=log_range, type="log") else: figure = make_subplots( rows=len(sorted_params), cols=len(sorted_params), shared_xaxes=True, shared_yaxes=True ) figure.update_layout(layout) showscale = True # showscale option only needs to be specified once for x_i, x_param in enumerate(sorted_params): for y_i, y_param in enumerate(sorted_params): if x_param == y_param: figure.add_trace(go.Scatter(), row=y_i + 1, col=x_i + 1) else: sub_plots = _generate_contour_subplot( trials, x_param, y_param, reverse_scale, param_values_range, target, target_name, ) contour = sub_plots[0] scatter = sub_plots[1] contour.update(showscale=showscale) # showscale's default is True if showscale: showscale = False figure.add_trace(contour, row=y_i + 1, col=x_i + 1) figure.add_trace(scatter, row=y_i + 1, col=x_i + 1) figure.update_xaxes(range=param_values_range[x_param], row=y_i + 1, col=x_i + 1) figure.update_yaxes(range=param_values_range[y_param], row=y_i + 1, col=x_i + 1) if not _is_numerical(trials, x_param): figure.update_xaxes(type="category", row=y_i + 1, col=x_i + 1) if not _is_numerical(trials, y_param): figure.update_yaxes(type="category", row=y_i + 1, col=x_i + 1) if _is_log_scale(trials, x_param): log_range = [math.log10(p) for p in param_values_range[x_param]] figure.update_xaxes(range=log_range, type="log", row=y_i + 1, col=x_i + 1) if _is_log_scale(trials, y_param): log_range = [math.log10(p) for p in param_values_range[y_param]] figure.update_yaxes(range=log_range, type="log", row=y_i + 1, col=x_i + 1) if x_i == 0: figure.update_yaxes(title_text=y_param, row=y_i + 1, col=x_i + 1) if y_i == len(sorted_params) - 1: figure.update_xaxes(title_text=x_param, row=y_i + 1, col=x_i + 1) return figure
33,451
def error_code_to_str(code: Optional[int]) -> str: """ Converts a given error code (errno) to a useful and human readable string. :param code: a possibly invalid/unknown error code :returns: a string explaining and containing the given error code, or a string explaining that the errorcode is unknown if that is the case """ name = errno.errorcode.get(code, "UNKNOWN") if code is not None else "UNKNOWN" description = os.strerror(code) if code is not None else "NO DESCRIPTION AVAILABLE" return f"{name} (errno {code}): {description}"
def error_code_to_str(code: Optional[int]) -> str: """ Converts a given error code (errno) to a useful and human readable string. :param code: a possibly invalid/unknown error code :returns: a string explaining and containing the given error code, or a string explaining that the errorcode is unknown if that is the case """ name = errno.errorcode.get(code, "UNKNOWN") description = os.strerror(code) if code is not None else "NO DESCRIPTION AVAILABLE" return f"{name} (errno {code}): {description}"
5,564
def drop_traitlets_dir(self): """Exclude members inherited from HasTraits and '_'/'__' members for dir().""" traits_dir = dir(HasTraits) class_dir = dir(type(self)) return [name for name in class_dir if name not in traits_dir if not name.startswith('_')]
def drop_traitlets_dir(self): """Exclude members inherited from HasTraits and '_'/'__' members for dir().""" traits_dir = dir(HasTraits) class_dir = dir(type(self)) return filter(lambda name: not (name in traits_dir or name.startswith('_')), class_dir)
23,663
def extract_metadata_from_dataset(ds): metadata = {} for v in list(ds.variables): metadata[v] = { 'name': ds[v].name, 'long_name': ds[v].long_name} if v.lower() != 'time': metadata[v].update({'units': ds[v].units}) metadata['dims'] = dict(ds.dims) metadata.update(ds.attrs) # add arbitrary metadata return metadata
def extract_metadata_from_dataset(ds): metadata = {} for v in list(ds.variables): metadata[v] = { 'name': ds[v].name, 'long_name': ds[v].long_name} if v.lower() != 'time': metadata[v]['units'] = ds[v].units metadata['dims'] = dict(ds.dims) metadata.update(ds.attrs) # add arbitrary metadata return metadata
2,512
def test_svc_nonfinite_params(): # Check SVC throws ValueError when dealing with non-finite parameter values X = np.array( [ (1.30830774e307, 6.02217328e307), (1.54166067e308, 1.75812744e308), (5.57938866e307, 4.13840113e307), (1.36302835e308, 1.07968131e308), (1.58772669e308, 1.19380571e307), (2.20362426e307, 1.58814671e308), (1.06216028e308, 1.14258583e308), (7.18031911e307, 1.69661213e308), (7.91182553e307, 5.12892426e307), (5.58470885e307, 9.13566765e306), ] ) y = np.array([0, 0, 1, 0, 0, 0, 1, 0, 1, 0]) clf = svm.SVC() msg = "Iterative parameter estimation led to non-finite values" with pytest.raises(ValueError, match=msg): clf.fit(X, y)
def test_svc_nonfinite_params(): # SVC must throw ValueError when dealing with non-finite parameter values X = np.array( [ (1.30830774e307, 6.02217328e307), (1.54166067e308, 1.75812744e308), (5.57938866e307, 4.13840113e307), (1.36302835e308, 1.07968131e308), (1.58772669e308, 1.19380571e307), (2.20362426e307, 1.58814671e308), (1.06216028e308, 1.14258583e308), (7.18031911e307, 1.69661213e308), (7.91182553e307, 5.12892426e307), (5.58470885e307, 9.13566765e306), ] ) y = np.array([0, 0, 1, 0, 0, 0, 1, 0, 1, 0]) clf = svm.SVC() msg = "Iterative parameter estimation led to non-finite values" with pytest.raises(ValueError, match=msg): clf.fit(X, y)
14,917
def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Emoncms sensor.""" apikey = config.get(CONF_API_KEY) url = config.get(CONF_URL) sensorid = config.get(CONF_ID) value_template = config.get(CONF_VALUE_TEMPLATE) unit_of_measurement = "" exclude_feeds = config.get(CONF_EXCLUDE_FEEDID) include_only_feeds = config.get(CONF_ONLY_INCLUDE_FEEDID) sensor_names = config.get(CONF_SENSOR_NAMES) interval = config.get(CONF_SCAN_INTERVAL) if value_template is not None: value_template.hass = hass data = EmonCmsData(hass, url, apikey, interval) data.update() if data.data is None: return False sensors = [] for elem in data.data: if exclude_feeds is not None: if int(elem["id"]) in exclude_feeds: continue if include_only_feeds is not None: if int(elem["id"]) not in include_only_feeds: continue name = None if sensor_names is not None: name = sensor_names.get(int(elem["id"]), None) # Use specified Unit in preference to Emoncms Feed Unit else default unit # For backward compatibility if config.get(CONF_UNIT_OF_MEASUREMENT) != "": unit_of_measurement = config.get(CONF_UNIT_OF_MEASUREMENT) elif 'unit' in elem and elem["unit"] != "": unit_of_measurement = elem["unit"] else: unit_of_measurement = DEFAULT_UNIT sensors.append( EmonCmsSensor( hass, data, name, value_template, unit_of_measurement, str(sensorid), elem, ) ) add_entities(sensors)
def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Emoncms sensor.""" apikey = config.get(CONF_API_KEY) url = config.get(CONF_URL) sensorid = config.get(CONF_ID) value_template = config.get(CONF_VALUE_TEMPLATE) unit_of_measurement = "" exclude_feeds = config.get(CONF_EXCLUDE_FEEDID) include_only_feeds = config.get(CONF_ONLY_INCLUDE_FEEDID) sensor_names = config.get(CONF_SENSOR_NAMES) interval = config.get(CONF_SCAN_INTERVAL) if value_template is not None: value_template.hass = hass data = EmonCmsData(hass, url, apikey, interval) data.update() if data.data is None: return False sensors = [] for elem in data.data: if exclude_feeds is not None: if int(elem["id"]) in exclude_feeds: continue if include_only_feeds is not None: if int(elem["id"]) not in include_only_feeds: continue name = None if sensor_names is not None: name = sensor_names.get(int(elem["id"]), None) # Use specified Unit in preference to Emoncms Feed Unit else default unit # For backward compatibility if config.get(CONF_UNIT_OF_MEASUREMENT) != "": unit_of_measurement = config.get(CONF_UNIT_OF_MEASUREMENT) if elem.get("unit"): unit_of_measurement = elem["unit"] else: unit_of_measurement = DEFAULT_UNIT sensors.append( EmonCmsSensor( hass, data, name, value_template, unit_of_measurement, str(sensorid), elem, ) ) add_entities(sensors)
44,515
def filter_docstring_args( signature: inspect.Signature, docstring: str, is_init_signature: bool = False, ) -> Dict[str, str]: """Removes unused params from docstring Args section. Args: signature (inspect.Signature): Model Builder SDK Method Signature. docstring (str): Model Builder SDK Method docstring from method.__doc__ is_init_signature (bool): is this constructor signature Returns: Dictionary of Arg names as keys and descriptions as values. """ try: parsed_docstring = docstring_parser.parse(docstring) except ValueError: return {} args_dict = {p.arg_name: p.description for p in parsed_docstring.params} new_args_dict = {} for param in signature.parameters.values(): if param.name not in PARAMS_TO_REMOVE: new_arg_name = param.name # change resource name signatures to resource types # to match new param.names ie: model_name -> model if is_init_signature and is_resource_name_parameter_name(param.name ): new_arg_name = param.name[:-len('_name')] # check if there was an arg description for this parameter. if args_dict.get(param.name, False): new_args_dict[new_arg_name] = args_dict.get(param.name) return new_args_dict
def filter_docstring_args( signature: inspect.Signature, docstring: str, is_init_signature: bool = False, ) -> Dict[str, str]: """Removes unused params from docstring Args section. Args: signature (inspect.Signature): Model Builder SDK Method Signature. docstring (str): Model Builder SDK Method docstring from method.__doc__ is_init_signature (bool): is this constructor signature Returns: Dictionary of Arg names as keys and descriptions as values. """ try: parsed_docstring = docstring_parser.parse(docstring) except ValueError: return {} args_dict = {p.arg_name: p.description for p in parsed_docstring.params} new_args_dict = {} for param in signature.parameters.values(): if param.name not in PARAMS_TO_REMOVE: new_arg_name = param.name # change resource name signatures to resource types # to match new param.names ie: model_name -> model if is_init_signature and is_resource_name_parameter_name(param.name ): new_arg_name = param.name[:-len('_name')] # check if there was an arg description for this parameter. if args_dict.get(param.name): new_args_dict[new_arg_name] = args_dict.get(param.name) return new_args_dict
2,548
def test_make_blobs_memory_usage(): try: import memory_profiler has_memory_profiler = True except: has_memory_profiler = False if not has_memory_profiler: pytest.skip("memory_profiler is not available.") blobs_opts = { "n_samples": 10 ** 4, "n_features": 10 ** 4, "centers": 10, "random_state": 10, "return_centers": True, "shuffle": False, } # maximum memory usage in MB actual_memory_usage, (X, y, c) = memory_profiler.memory_usage( (partial(make_blobs, **blobs_opts), ()), max_iterations=1, max_usage=True, retval=True, ) memory_usage_X = ( blobs_opts["n_samples"] * blobs_opts["n_features"] * X.dtype.itemsize ) memory_usage_y = blobs_opts["n_samples"] * y.dtype.itemsize memory_usage_c = blobs_opts["centers"] * blobs_opts["n_features"] * c.dtype.itemsize calc_memory_useage_mb = (memory_usage_X + memory_usage_y + memory_usage_c) / 1048576 # make sure actual memory usage is relatively close to theratical amount assert actual_memory_usage < calc_memory_useage_mb * 1.3
def test_make_blobs_memory_usage(): try: import memory_profiler has_memory_profiler = True except: has_memory_profiler = False if not has_memory_profiler: pytest.skip("memory_profiler is not available.") blobs_opts = { "n_samples": 10 ** 4, "n_features": 10 ** 4, "centers": 10, "random_state": 10, "return_centers": True, "shuffle": False, } # maximum memory usage in MiB actual_memory_usage, (X, y, c) = memory_profiler.memory_usage( (partial(make_blobs, **blobs_opts), ()), max_iterations=1, max_usage=True, retval=True, ) memory_usage_X = ( blobs_opts["n_samples"] * blobs_opts["n_features"] * X.dtype.itemsize ) memory_usage_y = blobs_opts["n_samples"] * y.dtype.itemsize memory_usage_c = blobs_opts["centers"] * blobs_opts["n_features"] * c.dtype.itemsize calc_memory_useage_mb = (memory_usage_X + memory_usage_y + memory_usage_c) / 1048576 # make sure actual memory usage is relatively close to theratical amount assert actual_memory_usage < calc_memory_useage_mb * 1.3
30,110
def test_multi_index_load_from_directory_3(runtmp): # check that force=False fails properly when confrunted with non-JSON # files that are legit sourmash files... c = runtmp dirname = utils.get_test_data('prot') count = 0 for root, dirs, files in os.walk(dirname): for name in files: print(f"at {name}") fullname = os.path.join(root, name) copyto = c.output(f"file{count}.sig") shutil.copyfile(fullname, copyto) count += 1 with pytest.raises(ValueError): mi = MultiIndex.load_from_directory(c.location, force=False)
def test_multi_index_load_from_directory_3(runtmp): # check that force=False fails properly when confronted with non-JSON # files that are legit sourmash files... c = runtmp dirname = utils.get_test_data('prot') count = 0 for root, dirs, files in os.walk(dirname): for name in files: print(f"at {name}") fullname = os.path.join(root, name) copyto = c.output(f"file{count}.sig") shutil.copyfile(fullname, copyto) count += 1 with pytest.raises(ValueError): mi = MultiIndex.load_from_directory(c.location, force=False)
39,366
def to_surf_mesh(actor, surf, mapper, prop, add_attr={}): """Convert a pyvista surface to a buffer geometry. General Notes ------------- * THREE.BufferGeometry expects position and index attributes representing a triangulated mesh points and face indices or just a position array representing individual faces of a mesh. * The normals attribute is needed for physically based rendering, but not for the other mesh types. * Colors must be a RGB array with one value per point. Shading Notes ------------- To match VTK, the following materials are used to match VTK's shading: * MeshPhysicalMaterial when physically based rendering is enabled * MeshPhongMaterial when physically based rendering is disabled, but lighting is enabled. * MeshBasicMaterial when lighting is disabled. """ # convert to an all-triangular surface if surf.is_all_triangles(): trimesh = surf else: trimesh = surf.triangulate() position = array_to_float_buffer(trimesh.points) # convert to minimum index type face_ind = trimesh.faces.reshape(-1, 4)[:, 1:] index = cast_to_min_size(face_ind, trimesh.n_points) attr = {'position': position, 'index': index, } if prop.GetInterpolation(): # something other than flat shading attr['normal'] = buffer_normals(trimesh) # extract point/cell scalars for coloring colors = None scalar_mode = mapper.GetScalarModeAsString() if scalar_mode == 'UsePointData': colors = map_scalars(mapper, trimesh.point_data.active_scalars) elif scalar_mode == 'UseCellData': # special handling for RGBA if mapper.GetColorMode() == 2: scalars = trimesh.cell_data.active_scalars.repeat(3, axis=0) scalars = scalars.astype(np.float32, copy=False) colors = scalars[:, :3]/255 # ignore alpha else: # must repeat for each triangle scalars = trimesh.cell_data.active_scalars.repeat(3) colors = map_scalars(mapper, scalars) position = array_to_float_buffer(trimesh.points[face_ind]) attr = {'position': position} # add colors to the buffer geometry attributes if colors is not None: attr['color'] = array_to_float_buffer(colors) # texture coordinates t_coords = trimesh.active_t_coords if t_coords is not None: attr['uv'] = array_to_float_buffer(t_coords) # TODO: Convert PBR textures # base_color_texture = prop.GetTexture("albedoTex") # orm_texture = prop.GetTexture("materialTex") # anisotropy_texture = prop.GetTexture("anisotropyTex") # normal_texture = prop.GetTexture("normalTex") # emissive_texture = prop.GetTexture("emissiveTex") # coatnormal_texture = prop.GetTexture("coatNormalTex") if prop.GetNumberOfTextures(): # pragma: no cover warnings.warn('pythreejs converter does not support PBR textures (yet).') # create base buffer geometry surf_geo = tjs.BufferGeometry(attributes=attr) # add texture to the surface buffer if available texture = actor.GetTexture() tjs_texture = None if texture is not None: wrapped_tex = pv.wrap(texture.GetInput()) data = wrapped_tex.active_scalars dim = (wrapped_tex.dimensions[0], wrapped_tex.dimensions[1], data.shape[1]) data = data.reshape(dim) fmt = "RGBFormat" if data.shape[1] == 3 else "RGBAFormat" # Create data texture and catch invalid warning with warnings.catch_warnings(): warnings.filterwarnings("ignore", message="Given trait value dtype") tjs_texture = tjs.DataTexture(data=data, format="RGBFormat", type="UnsignedByteType") # these attributes are always used regardless of the material shared_attr = { 'vertexColors': get_coloring(mapper, trimesh), 'wireframe': prop.GetRepresentation() == 1, 'opacity': prop.GetOpacity(), 'wireframeLinewidth': prop.GetLineWidth(), # 'side': 'DoubleSide' # enabling seems to mess with textures } if colors is None: shared_attr['color'] = color_to_hex(prop.GetColor()) if tjs_texture is not None: shared_attr['map'] = tjs_texture else: shared_attr['side'] = 'DoubleSide' if prop.GetOpacity() < 1.0: shared_attr['transparent'] = True if prop.GetInterpolation() == 3: # using physically based rendering material = tjs.MeshPhysicalMaterial(flatShading=False, roughness=prop.GetRoughness(), metalness=prop.GetMetallic(), reflectivity=0, **shared_attr, **add_attr) elif prop.GetLighting(): # specular disabled to fix lighting issues material = tjs.MeshPhongMaterial(shininess=0, flatShading=prop.GetInterpolation() == 0, specular=color_to_hex((0, 0, 0)), reflectivity=0, **shared_attr, **add_attr) else: # no lighting material = tjs.MeshBasicMaterial(**shared_attr, **add_attr) return tjs.Mesh(geometry=surf_geo, material=material)
def to_surf_mesh(actor, surf, mapper, prop, add_attr={}): """Convert a pyvista surface to a buffer geometry. General Notes ------------- * THREE.BufferGeometry expects position and index attributes representing a triangulated mesh points and face indices or just a position array representing individual faces of a mesh. * The normals attribute is needed for physically based rendering, but not for the other mesh types. * Colors must be a RGB array with one value per point. Shading Notes ------------- To match VTK, the following materials are used to match VTK's shading: * MeshPhysicalMaterial when physically based rendering is enabled * MeshPhongMaterial when physically based rendering is disabled, but lighting is enabled. * MeshBasicMaterial when lighting is disabled. """ # convert to an all-triangular surface if surf.is_all_triangles(): trimesh = surf else: trimesh = surf.triangulate() position = array_to_float_buffer(trimesh.points) # convert to minimum index type face_ind = trimesh.faces.reshape(-1, 4)[:, 1:] index = cast_to_min_size(face_ind, trimesh.n_points) attr = {'position': position, 'index': index, } if prop.GetInterpolation(): # something other than flat shading attr['normal'] = buffer_normals(trimesh) # extract point/cell scalars for coloring colors = None scalar_mode = mapper.GetScalarModeAsString() if scalar_mode == 'UsePointData': colors = map_scalars(mapper, trimesh.point_data.active_scalars) elif scalar_mode == 'UseCellData': # special handling for RGBA if mapper.GetColorMode() == 2: scalars = trimesh.cell_data.active_scalars.repeat(3, axis=0) scalars = scalars.astype(np.float32, copy=False) colors = scalars[:, :3]/255 # ignore alpha else: # must repeat for each triangle scalars = trimesh.cell_data.active_scalars.repeat(3) colors = map_scalars(mapper, scalars) position = array_to_float_buffer(trimesh.points[face_ind]) attr = {'position': position} # add colors to the buffer geometry attributes if colors is not None: attr['color'] = array_to_float_buffer(colors) # texture coordinates t_coords = trimesh.active_t_coords if t_coords is not None: attr['uv'] = array_to_float_buffer(t_coords) # TODO: Convert PBR textures # base_color_texture = prop.GetTexture("albedoTex") # orm_texture = prop.GetTexture("materialTex") # anisotropy_texture = prop.GetTexture("anisotropyTex") # normal_texture = prop.GetTexture("normalTex") # emissive_texture = prop.GetTexture("emissiveTex") # coatnormal_texture = prop.GetTexture("coatNormalTex") if prop.GetNumberOfTextures(): # pragma: no cover warnings.warn('pythreejs converter does not support PBR textures (yet).') # create base buffer geometry surf_geo = tjs.BufferGeometry(attributes=attr) # add texture to the surface buffer if available texture = actor.GetTexture() tjs_texture = None if texture is not None: wrapped_tex = pv.wrap(texture.GetInput()) data = wrapped_tex.active_scalars dim = (wrapped_tex.dimensions[0], wrapped_tex.dimensions[1], data.shape[1]) data = data.reshape(dim) fmt = "RGBFormat" if data.shape[1] == 3 else "RGBAFormat" # Create data texture and catch invalid warning with warnings.catch_warnings(): warnings.filterwarnings("ignore", message="Given trait value dtype") tjs_texture = tjs.DataTexture(data=data, format="RGBFormat", type="UnsignedByteType") # these attributes are always used regardless of the material shared_attr = { 'vertexColors': get_coloring(mapper, trimesh), 'wireframe': prop.GetRepresentation() == 1, 'opacity': prop.GetOpacity(), 'wireframeLinewidth': prop.GetLineWidth(), # 'side': 'DoubleSide' # enabling seems to mess with textures } if colors is None: shared_attr['color'] = color_to_hex(prop.GetColor()) if tjs_texture is not None: shared_attr['map'] = tjs_texture else: shared_attr['side'] = 'DoubleSide' if prop.GetOpacity() < 1.0: shared_attr['transparent'] = True if prop.GetInterpolation() == 3: # using physically based rendering material = tjs.MeshPhysicalMaterial(flatShading=False, roughness=prop.GetRoughness(), metalness=prop.GetMetallic(), reflectivity=0, **shared_attr, **add_attr) elif prop.GetLighting(): # specular disabled to fix lighting issues material = tjs.MeshPhongMaterial(shininess=0, flatShading=prop.GetInterpolation() == 0, specular=color_to_hex((0, 0, 0)), reflectivity=0, **shared_attr, **add_attr) else: # no lighting material = tjs.MeshBasicMaterial(**shared_attr, **add_attr) return tjs.Mesh(geometry=surf_geo, material=material)
27,458
def run_conda_forge_specific(meta, recipe_dir, lints, hints): gh = github.Github(os.environ["GH_TOKEN"]) package_section = get_section(meta, "package", lints) extra_section = get_section(meta, "extra", lints) sources_section = get_section(meta, "source", lints) recipe_dirname = os.path.basename(recipe_dir) if recipe_dir else "recipe" recipe_name = package_section.get("name", "").strip() is_staged_recipes = recipe_dirname != "recipe" # 1: Check that the recipe does not exist in conda-forge or bioconda if is_staged_recipes and recipe_name: cf = gh.get_user(os.getenv("GH_ORG", "conda-forge")) for name in set( [ recipe_name, recipe_name.replace("-", "_"), recipe_name.replace("_", "-"), ] ): try: if cf.get_repo("{}-feedstock".format(name)): existing_recipe_name = name feedstock_exists = True break else: feedstock_exists = False except github.UnknownObjectException as e: feedstock_exists = False if feedstock_exists and existing_recipe_name == recipe_name: lints.append("Feedstock with the same name exists in conda-forge.") elif feedstock_exists: hints.append( "Feedstock with the name {} exists in conda-forge. Is it the same as this package ({})?".format( existing_recipe_name, recipe_name, ) ) bio = gh.get_user("bioconda").get_repo("bioconda-recipes") try: bio.get_dir_contents("recipes/{}".format(recipe_name)) except github.UnknownObjectException as e: pass else: hints.append( "Recipe with the same name exists in bioconda: " "please discuss with @conda-forge/bioconda-recipes." ) url = None for source_section in sources_section: if ( "url" in source_section and isinstance(source_section["url"], str) and source_section["url"].startswith( "https://pypi.io/packages/source/" ) ): url = source_section["url"] if url: # get pypi name from urls like "https://pypi.io/packages/source/b/build/build-0.4.0.tar.gz" pypi_name = url.split("/")[6] mapping_request = requests.get( "https://raw.githubusercontent.com/regro/cf-graph-countyfair/master/mappings/pypi/name_mapping.yaml" ) if mapping_request.status_code == 200: mapping_raw_yaml = mapping_request.content mapping = get_yaml().load(mapping_raw_yaml) for pkg in mapping: if pkg.get("pypi_name", "") == pypi_name: conda_name = pkg["conda_name"] hints.append( f"A conda package with same name ({conda_name}) already exists." ) # 2: Check that the recipe maintainers exists: maintainers = extra_section.get("recipe-maintainers", []) for maintainer in maintainers: if "/" in maintainer: # It's a team. Checking for existence is expensive. Skip for now continue try: gh.get_user(maintainer) except github.UnknownObjectException as e: lints.append( 'Recipe maintainer "{}" does not exist'.format(maintainer) ) # 3: if the recipe dir is inside the example dir if recipe_dir is not None and "recipes/example/" in recipe_dir: lints.append( "Please move the recipe out of the example dir and " "into its own dir." ) # 4: Do not delete example recipe if is_staged_recipes and recipe_dir is not None: example_meta_fname = os.path.abspath( os.path.join(recipe_dir, "..", "example", "meta.yaml") ) if not os.path.exists(example_meta_fname): msg = ( "Please do not delete the example recipe found in " "`recipes/example/meta.yaml`." ) if msg not in lints: lints.append(msg)
def run_conda_forge_specific(meta, recipe_dir, lints, hints): gh = github.Github(os.environ["GH_TOKEN"]) package_section = get_section(meta, "package", lints) extra_section = get_section(meta, "extra", lints) sources_section = get_section(meta, "source", lints) recipe_dirname = os.path.basename(recipe_dir) if recipe_dir else "recipe" recipe_name = package_section.get("name", "").strip() is_staged_recipes = recipe_dirname != "recipe" # 1: Check that the recipe does not exist in conda-forge or bioconda if is_staged_recipes and recipe_name: cf = gh.get_user(os.getenv("GH_ORG", "conda-forge")) for name in set( [ recipe_name, recipe_name.replace("-", "_"), recipe_name.replace("_", "-"), ] ): try: if cf.get_repo("{}-feedstock".format(name)): existing_recipe_name = name feedstock_exists = True break else: feedstock_exists = False except github.UnknownObjectException as e: feedstock_exists = False if feedstock_exists and existing_recipe_name == recipe_name: lints.append("Feedstock with the same name exists in conda-forge.") elif feedstock_exists: hints.append( "Feedstock with the name {} exists in conda-forge. Is it the same as this package ({})?".format( existing_recipe_name, recipe_name, ) ) bio = gh.get_user("bioconda").get_repo("bioconda-recipes") try: bio.get_dir_contents("recipes/{}".format(recipe_name)) except github.UnknownObjectException as e: pass else: hints.append( "Recipe with the same name exists in bioconda: " "please discuss with @conda-forge/bioconda-recipes." ) url = None for source_section in sources_section: if str(source_section.get("url")).startswith("https://pypi.io/packages/source/"): url = source_section["url"] if url: # get pypi name from urls like "https://pypi.io/packages/source/b/build/build-0.4.0.tar.gz" pypi_name = url.split("/")[6] mapping_request = requests.get( "https://raw.githubusercontent.com/regro/cf-graph-countyfair/master/mappings/pypi/name_mapping.yaml" ) if mapping_request.status_code == 200: mapping_raw_yaml = mapping_request.content mapping = get_yaml().load(mapping_raw_yaml) for pkg in mapping: if pkg.get("pypi_name", "") == pypi_name: conda_name = pkg["conda_name"] hints.append( f"A conda package with same name ({conda_name}) already exists." ) # 2: Check that the recipe maintainers exists: maintainers = extra_section.get("recipe-maintainers", []) for maintainer in maintainers: if "/" in maintainer: # It's a team. Checking for existence is expensive. Skip for now continue try: gh.get_user(maintainer) except github.UnknownObjectException as e: lints.append( 'Recipe maintainer "{}" does not exist'.format(maintainer) ) # 3: if the recipe dir is inside the example dir if recipe_dir is not None and "recipes/example/" in recipe_dir: lints.append( "Please move the recipe out of the example dir and " "into its own dir." ) # 4: Do not delete example recipe if is_staged_recipes and recipe_dir is not None: example_meta_fname = os.path.abspath( os.path.join(recipe_dir, "..", "example", "meta.yaml") ) if not os.path.exists(example_meta_fname): msg = ( "Please do not delete the example recipe found in " "`recipes/example/meta.yaml`." ) if msg not in lints: lints.append(msg)
33,110
def edge_colors( et: pd.DataFrame, nt: pd.Series, color_by: Hashable, node_color_by: Hashable, ): """Default edge line color function.""" if color_by in ("source_node_color", "target_node_color"): edge_select_by = color_by.split("_")[0] return encodings.data_color( et[edge_select_by].apply(nt[node_color_by].get), nt[node_color_by], ) elif color_by: return encodings.data_color(et[color_by], et[color_by]) return pd.Series(["black"] * len(et), name="color_by")
def edge_colors( et: pd.DataFrame, nt: pd.DataFrame, color_by: Hashable, node_color_by: Hashable, ): """Default edge line color function.""" if color_by in ("source_node_color", "target_node_color"): edge_select_by = color_by.split("_")[0] return encodings.data_color( et[edge_select_by].apply(nt[node_color_by].get), nt[node_color_by], ) elif color_by: return encodings.data_color(et[color_by], et[color_by]) return pd.Series(["black"] * len(et), name="color_by")
5,057
def test_subfigure_spanning(): # test that subfigures get laid out properly... fig = plt.figure(constrained_layout=True) gs = fig.add_gridspec(3, 3) sub_figs = [] sub_figs += [fig.add_subfigure(gs[0, 0])] sub_figs += [fig.add_subfigure(gs[0:2, 1])] sub_figs += [fig.add_subfigure(gs[2, 1:3])] w = 640 h = 480 minp = sub_figs[0].bbox.min exp = np.array([0., h*2/3]) np.testing.assert_allclose(minp, exp) maxp = sub_figs[0].bbox.max exp = np.array([w / 3, h]) np.testing.assert_allclose(maxp, exp) minp = sub_figs[1].bbox.min exp = np.array([w / 3, h * 1 / 3]) np.testing.assert_allclose(minp, exp) maxp = sub_figs[1].bbox.max exp = np.array([w * 2 / 3, h]) np.testing.assert_allclose(maxp, exp) minp = sub_figs[2].bbox.min exp = np.array([w / 3, 0]) np.testing.assert_allclose(minp, exp) maxp = sub_figs[2].bbox.max exp = np.array([w, h * 1 / 3]) np.testing.assert_allclose(maxp, exp)
def test_subfigure_spanning(): # test that subfigures get laid out properly... fig = plt.figure(constrained_layout=True) gs = fig.add_gridspec(3, 3) sub_figs = [] sub_figs += [fig.add_subfigure(gs[0, 0])] sub_figs += [fig.add_subfigure(gs[0:2, 1])] sub_figs += [fig.add_subfigure(gs[2, 1:3])] w = 640 h = 480 minp = sub_figs[0].bbox.min exp = np.array([0., h * 2/3]) np.testing.assert_allclose(minp, exp) maxp = sub_figs[0].bbox.max exp = np.array([w / 3, h]) np.testing.assert_allclose(maxp, exp) minp = sub_figs[1].bbox.min exp = np.array([w / 3, h * 1 / 3]) np.testing.assert_allclose(minp, exp) maxp = sub_figs[1].bbox.max exp = np.array([w * 2 / 3, h]) np.testing.assert_allclose(maxp, exp) minp = sub_figs[2].bbox.min exp = np.array([w / 3, 0]) np.testing.assert_allclose(minp, exp) maxp = sub_figs[2].bbox.max exp = np.array([w, h * 1 / 3]) np.testing.assert_allclose(maxp, exp)
4,072
def resource_find(filename, use_cache=True): '''Search for a resource in the list of paths. Use resource_add_path to add a custom path to the search. By default, results are cached for 60 seconds. This can be disabled using use_cache=False. .. versionchanged:: 2.0.0rc5 A default cache and the `use_cache` parameter were added. ''' if not filename: return found_filename = None if use_cache: found_filename = Cache.get('kv.resourcefind', filename) if found_filename: return found_filename if filename[:8] == 'atlas://': found_filename = filename else: abspath_filename = abspath(filename) if exists(abspath_filename): found_filename = abspath(filename) else: for path in reversed(resource_paths): abspath_filename = abspath(join(path, filename)) if exists(abspath_filename): found_filename = abspath_filename break if not found_filename and filename.startswith("data:"): found_filename = filename if use_cache: Cache.append('kv.resourcefind', filename, found_filename) return found_filename
def resource_find(filename, use_cache=True): '''Search for a resource in the list of paths. Use resource_add_path to add a custom path to the search. By default, results are cached for 60 seconds. This can be disabled using use_cache=False. .. versionchanged:: 2.0.0 A default cache and the `use_cache` parameter were added. ''' if not filename: return found_filename = None if use_cache: found_filename = Cache.get('kv.resourcefind', filename) if found_filename: return found_filename if filename[:8] == 'atlas://': found_filename = filename else: abspath_filename = abspath(filename) if exists(abspath_filename): found_filename = abspath(filename) else: for path in reversed(resource_paths): abspath_filename = abspath(join(path, filename)) if exists(abspath_filename): found_filename = abspath_filename break if not found_filename and filename.startswith("data:"): found_filename = filename if use_cache: Cache.append('kv.resourcefind', filename, found_filename) return found_filename
42,907
def graph_embed_deprecated(A, max_mean_photon=1.0, make_traceless=False, rtol=1e-05, atol=1e-08): r"""Embed a graph into a Gaussian state. Given a graph in terms of a symmetric adjacency matrix (in general with arbitrary complex off-diagonal and real diagonal entries), returns the squeezing parameters and interferometer necessary for creating the Gaussian state whose off-diagonal parts are proportional to that matrix. Uses :func:`takagi`. Args: A (array[complex]): square, symmetric (weighted) adjacency matrix of the graph max_mean_photon (float): Threshold value. It guarantees that the mode with the largest squeezing has ``max_mean_photon`` as the mean photon number i.e., :math:`sinh(r_{max})^2 ==` ``max_mean_photon``. make_traceless (bool): Removes the trace of the input matrix, by performing the transformation :math:`\tilde{A} = A-\mathrm{tr}(A) \I/n`. This may reduce the amount of squeezing needed to encode the graph. rtol (float): relative tolerance used when checking if the input matrix is symmetric. atol (float): absolute tolerance used when checking if the input matrix is symmetric. Returns: tuple[array, array]: squeezing parameters of the input state to the interferometer, and the unitary matrix representing the interferometer """ (m, n) = A.shape if m != n: raise ValueError("The matrix is not square.") if not np.allclose(A, np.transpose(A), rtol=rtol, atol=atol): raise ValueError("The matrix is not symmetric.") if make_traceless: A = A - np.trace(A) * np.identity(n) / n s, U = takagi(A, tol=atol) sc = np.sqrt(1.0 + 1.0 / max_mean_photon) vals = -np.arctanh(s / (s[0] * sc)) return vals, U
def graph_embed_deprecated(A, max_mean_photon=1.0, make_traceless=False, rtol=1e-05, atol=1e-08): r"""Embed a graph into a Gaussian state. Given a graph in terms of a symmetric adjacency matrix (in general with arbitrary complex off-diagonal and real diagonal entries), returns the squeezing parameters and interferometer necessary for creating the Gaussian state whose off-diagonal parts are proportional to that matrix. Uses :func:`takagi`. Args: A (array[complex]): square, symmetric (weighted) adjacency matrix of the graph max_mean_photon (float): Threshold value. It guarantees that the mode with the largest squeezing has ``max_mean_photon`` as the mean photon number i.e., :math:`sinh(r_{max})^2 ==` ``max_mean_photon``. make_traceless (bool): Removes the trace of the input matrix, by performing the transformation :math:`\tilde{A} = A-\mathrm{tr}(A) \I/n`. This may reduce the amount of squeezing needed to encode the graph. rtol (float): relative tolerance used when checking if the input matrix is symmetric. atol (float): absolute tolerance used when checking if the input matrix is symmetric Returns: tuple[array, array]: squeezing parameters of the input state to the interferometer, and the unitary matrix representing the interferometer """ (m, n) = A.shape if m != n: raise ValueError("The matrix is not square.") if not np.allclose(A, np.transpose(A), rtol=rtol, atol=atol): raise ValueError("The matrix is not symmetric.") if make_traceless: A = A - np.trace(A) * np.identity(n) / n s, U = takagi(A, tol=atol) sc = np.sqrt(1.0 + 1.0 / max_mean_photon) vals = -np.arctanh(s / (s[0] * sc)) return vals, U
7,191
def test_resize_local_mean_nd(): for dim in range(1, 6): shape = 2 + np.arange(dim) * 2 x = np.ones(shape) out_shape = np.asarray(shape) * 1.5 resized = resize_local_mean(x, out_shape) expected_shape = 1.5 * shape assert_equal(resized.shape, expected_shape) assert np.all(resized == 1)
def test_resize_local_mean_nd(): for dim in range(1, 6): shape = 2 + np.arange(dim) * 2 x = np.ones(shape) out_shape = np.asarray(shape) * 1.5 resized = resize_local_mean(x, out_shape) expected_shape = 1.5 * shape assert_equal(resized.shape, expected_shape) assert_array_equal(resized, 1)
34,315
def validate_files(args) -> NoReturn: """Validate all files needed for training a model. Fails with a non-zero exit code if there are any errors in the data.""" from rasa.core.validator import Validator from rasa.importers.rasa import RasaFileImporter loop = asyncio.get_event_loop() file_importer = RasaFileImporter( domain_path=args.domain, training_data_paths=args.data ) validator = loop.run_until_complete(Validator.from_importer(file_importer)) domain_is_valid = validator.verify_domain_validity() if not domain_is_valid: sys.exit(1) everything_is_alright = validator.verify_all(not args.fail_on_warnings) if not args.max_history: logger.info( "Will not test for inconsistencies in stories since " "you did not provide --max-history." ) if args.max_history: # Only run story structure validation if everything else is fine # since this might take a while everything_is_alright = validator.verify_story_structure( not args.fail_on_warnings, max_history=args.max_history ) sys.exit(0) if everything_is_alright else sys.exit(1)
def validate_files(args) -> NoReturn: """Validate all files needed for training a model. Fails with a non-zero exit code if there are any errors in the data.""" from rasa.core.validator import Validator from rasa.importers.rasa import RasaFileImporter loop = asyncio.get_event_loop() file_importer = RasaFileImporter( domain_path=args.domain, training_data_paths=args.data ) validator = loop.run_until_complete(Validator.from_importer(file_importer)) domain_is_valid = validator.verify_domain_validity() if not domain_is_valid: sys.exit(1) everything_is_alright = validator.verify_all(not args.fail_on_warnings) if not args.max_history: logger.info( "Will not test for inconsistencies in stories since " "you did not provide --max-history." ) else: # Only run story structure validation if everything else is fine # since this might take a while everything_is_alright = validator.verify_story_structure( not args.fail_on_warnings, max_history=args.max_history ) sys.exit(0) if everything_is_alright else sys.exit(1)
43,047
def TimeEvolution(t: float, w: np.ndarray): r"""Generates a custom ``sf`` operation for performing the transformation :math:`e^{-i\hat{H}t/\hbar}` on a given state. The custom operation returned by this function can be used as part of a Strawberry Fields :class:`~.Program` just like any other operation from the :mod:`~.ops` module. **Example usage:** >>> modes = 2 >>> p = sf.Program(modes) >>> with p.context as q: >>> sf.ops.Fock(1) | q[0] >>> sf.ops.Interferometer(Ul.T) | q >>> TimeEvolution(t, w) | q >>> sf.ops.Interferometer(Ul) | q Args: t (float): time in femtoseconds w (array): normal mode frequencies :math:`\omega` in units of :math:`\mbox{cm}^{-1}` that compose the Hamiltonian :math:`\hat{H} = \sum_i \hbar \omega_i a_i^\dagger a_i` Returns: an ``sf`` operation for enacting the dynamics transformation Return type: op """ # pylint: disable=expression-not-assigned n_modes = len(w) @operation(n_modes) def op(q): theta = -w * 100.0 * c * 1.0e-15 * t * (2.0 * pi) for i in range(n_modes): sf.ops.Rgate(theta[i]) | q[i] return op()
def TimeEvolution(t: float, w: np.ndarray): r"""Generates a custom ``sf`` operation for performing the transformation :math:`e^{-i\hat{H}t/\hbar}` on a given state. This operation can be used as part of a Strawberry Fields :class:`~.Program` just like any :class:`~.Program` just like any other operation from the :mod:`~.ops` module. **Example usage:** >>> modes = 2 >>> p = sf.Program(modes) >>> with p.context as q: >>> sf.ops.Fock(1) | q[0] >>> sf.ops.Interferometer(Ul.T) | q >>> TimeEvolution(t, w) | q >>> sf.ops.Interferometer(Ul) | q Args: t (float): time in femtoseconds w (array): normal mode frequencies :math:`\omega` in units of :math:`\mbox{cm}^{-1}` that compose the Hamiltonian :math:`\hat{H} = \sum_i \hbar \omega_i a_i^\dagger a_i` Returns: an ``sf`` operation for enacting the dynamics transformation Return type: op """ # pylint: disable=expression-not-assigned n_modes = len(w) @operation(n_modes) def op(q): theta = -w * 100.0 * c * 1.0e-15 * t * (2.0 * pi) for i in range(n_modes): sf.ops.Rgate(theta[i]) | q[i] return op()
45,640
def decode_description(description): """ Parses the first line of a FASTA file using the specifications of several different database headers (in _databases). :param (string) description: The header line with the initial '>' removed. :rtype (dict): A dictionary for which each key-value pair comprises a property specified by the database used and the value of that property given by the header. If the database is not recognized, the keys are given as 'desc-n' where n is the position of the property. """ if len(description) == 0: return {'-1': 'no description'} decoded = {} desc = description.split('|') if desc[0] in _databases: db_info = _databases[desc[0]] if desc[0] in ['sp', 'tr']: decoded['accession'] = desc[1] # using regex to get the other information rs = re.search( r'([^\s]+)(.*)\ OS=(.*)\ OX=(.*)\ GN=(.*)\ PE=(.*)\ SV=(.*)$', string=desc[2] ) for i in range(2, len(db_info)): decoded[db_info[i]] = rs.group(i) else: # shift by one, since first section in header describes # the database for i in range(len(desc)-1): decoded[db_info[i]] = desc[i+1] else: if len(desc) > 1: for i in range(len(desc)-1): decoded[str(i)] = desc[i+1] else: decoded['Header'] = desc[0] return decoded
def decode_description(description): """ Parse the first line of a FASTA file using the specifications of several different database headers (in _databases). :param (string) description: The header line with the initial '>' removed. :rtype (dict): A dictionary for which each key-value pair comprises a property specified by the database used and the value of that property given by the header. If the database is not recognized, the keys are given as 'desc-n' where n is the position of the property. """ if len(description) == 0: return {'-1': 'no description'} decoded = {} desc = description.split('|') if desc[0] in _databases: db_info = _databases[desc[0]] if desc[0] in ['sp', 'tr']: decoded['accession'] = desc[1] # using regex to get the other information rs = re.search( r'([^\s]+)(.*)\ OS=(.*)\ OX=(.*)\ GN=(.*)\ PE=(.*)\ SV=(.*)$', string=desc[2] ) for i in range(2, len(db_info)): decoded[db_info[i]] = rs.group(i) else: # shift by one, since first section in header describes # the database for i in range(len(desc)-1): decoded[db_info[i]] = desc[i+1] else: if len(desc) > 1: for i in range(len(desc)-1): decoded[str(i)] = desc[i+1] else: decoded['Header'] = desc[0] return decoded
14,334
def test(glyphsets, glyphs=None, names=None): if names is None: names = glyphsets if glyphs is None: glyphs = glyphsets[0].keys() hist = [] for glyph_name in glyphs: #print() #print(glyph_name) try: allVectors = [] allNodeTypes = [] for glyphset,name in zip(glyphsets, names): #print('.', end='') glyph = glyphset[glyph_name] perContourPen = PerContourOrComponentPen(RecordingPen, glyphset=glyphset) glyph.draw(perContourPen) contourPens = perContourPen.value del perContourPen contourVectors = [] nodeTypes = [] allNodeTypes.append(nodeTypes) allVectors.append(contourVectors) for contour in contourPens: nodeTypes.append(tuple([ instruction[0] for instruction in contour.value ])) stats = StatisticsPen(glyphset=glyphset) contour.replay(stats) size = abs(stats.area) ** .5 * .5 vector = ( int(size), int(stats.meanX), int(stats.meanY), int(stats.stddevX * 2), int(stats.stddevY * 2), int(stats.correlation * size), ) contourVectors.append(vector) #print(vector) # Check each master against the next one in the list. for i,(m0,m1) in enumerate(zip(allNodeTypes[:-1],allNodeTypes[1:])): if len(m0) != len(m1): print('%s: %s+%s: Glyphs not compatible (wrong number of paths %i+%i)!!!!!' % (glyph_name, names[i], names[i+1], len(m0), len(m1))) if m0 == m1: continue for pathIx, (nodes1, nodes2) in enumerate(zip(m0,m1)): if nodes1 == nodes2: continue print('%s: %s+%s: Glyphs not compatible at path %i!!!!!' % (glyph_name, names[i], names[i+1], pathIx)) if len(nodes1) != len(nodes2): print("%s has %i nodes, %s has %i nodes" % (names[i], len(nodes1), names[i+1], len(nodes2))) continue for nodeIx, (n1, n2) in enumerate(zip(nodes1, nodes2)): if n1 != n2: print("At node %i, %s has %s, %s has %s" % (nodeIx, names[i], n1, names[i+1], n2)) continue for i,(m0,m1) in enumerate(zip(allVectors[:-1],allVectors[1:])): if len(m0) != len(m1): print('%s: %s+%s: Glyphs not compatible!!!!!' % (glyph_name, names[i], names[i+1])) continue if not m0: continue costs = [[_vlen(_vdiff(v0,v1)) for v1 in m1] for v0 in m0] matching, matching_cost = min_cost_perfect_bipartite_matching(costs) if matching != list(range(len(m0))): print('%s: %s+%s: Glyph has wrong contour/component order: %s' % (glyph_name, names[i], names[i+1], matching)) #, m0, m1) break upem = 2048 item_cost = round((matching_cost / len(m0) / len(m0[0])) ** .5 / upem * 100) hist.append(item_cost) threshold = 7 if item_cost >= threshold: print('%s: %s+%s: Glyph has very high cost: %d%%' % (glyph_name, names[i], names[i+1], item_cost)) except ValueError as e: print('%s: %s: math error %s; skipping glyph.' % (glyph_name, name, e)) print(contour.value) #raise
def test(glyphsets, glyphs=None, names=None): if names is None: names = glyphsets if glyphs is None: glyphs = glyphsets[0].keys() hist = [] for glyph_name in glyphs: #print() #print(glyph_name) try: allVectors = [] allNodeTypes = [] for glyphset,name in zip(glyphsets, names): #print('.', end='') glyph = glyphset[glyph_name] perContourPen = PerContourOrComponentPen(RecordingPen, glyphset=glyphset) glyph.draw(perContourPen) contourPens = perContourPen.value del perContourPen contourVectors = [] nodeTypes = [] allNodeTypes.append(nodeTypes) allVectors.append(contourVectors) for contour in contourPens: nodeTypes.append(tuple([ instruction[0] for instruction in contour.value ])) stats = StatisticsPen(glyphset=glyphset) contour.replay(stats) size = abs(stats.area) ** .5 * .5 vector = ( int(size), int(stats.meanX), int(stats.meanY), int(stats.stddevX * 2), int(stats.stddevY * 2), int(stats.correlation * size), ) contourVectors.append(vector) #print(vector) # Check each master against the next one in the list. for i, (m0, m1) in enumerate(zip(allNodeTypes[:-1], allNodeTypes[1:])): if len(m0) != len(m1): print('%s: %s+%s: Glyphs not compatible (wrong number of paths %i+%i)!!!!!' % (glyph_name, names[i], names[i+1], len(m0), len(m1))) if m0 == m1: continue for pathIx, (nodes1, nodes2) in enumerate(zip(m0,m1)): if nodes1 == nodes2: continue print('%s: %s+%s: Glyphs not compatible at path %i!!!!!' % (glyph_name, names[i], names[i+1], pathIx)) if len(nodes1) != len(nodes2): print("%s has %i nodes, %s has %i nodes" % (names[i], len(nodes1), names[i+1], len(nodes2))) continue for nodeIx, (n1, n2) in enumerate(zip(nodes1, nodes2)): if n1 != n2: print("At node %i, %s has %s, %s has %s" % (nodeIx, names[i], n1, names[i+1], n2)) continue for i,(m0,m1) in enumerate(zip(allVectors[:-1],allVectors[1:])): if len(m0) != len(m1): print('%s: %s+%s: Glyphs not compatible!!!!!' % (glyph_name, names[i], names[i+1])) continue if not m0: continue costs = [[_vlen(_vdiff(v0,v1)) for v1 in m1] for v0 in m0] matching, matching_cost = min_cost_perfect_bipartite_matching(costs) if matching != list(range(len(m0))): print('%s: %s+%s: Glyph has wrong contour/component order: %s' % (glyph_name, names[i], names[i+1], matching)) #, m0, m1) break upem = 2048 item_cost = round((matching_cost / len(m0) / len(m0[0])) ** .5 / upem * 100) hist.append(item_cost) threshold = 7 if item_cost >= threshold: print('%s: %s+%s: Glyph has very high cost: %d%%' % (glyph_name, names[i], names[i+1], item_cost)) except ValueError as e: print('%s: %s: math error %s; skipping glyph.' % (glyph_name, name, e)) print(contour.value) #raise
22,416
def filter_output(tool, output, incoming): for filter in output.filters: try: if not eval(filter.text.strip(), globals(), incoming): return True # do not create this dataset except Exception as e: log.info('Tool %s output %s: dataset output filter (%s) failed: %s' % (tool.id, output.name, filter.text, e)) return False
def filter_output(tool, output, incoming): for filter in output.filters: try: if not eval(filter.text.strip(), globals(), incoming): return True # do not create this dataset except Exception as e: log.info(f'Tool {tool.id} output {output.name}: dataset output filter ({filter.text}) failed: {e}') return False
52,306
def _parse_accept_header(accept): """ Parse the Accept header *accept*, returning a list with 3-tuples of [(str(media_type), dict(params), float(q_value)),] ordered by q values. If the accept header includes vendor-specific types like:: application/vnd.yourcompany.yourproduct-v1.1+json It will actually convert the vendor and version into parameters and convert the content type into `application/json` so appropriate content negotiation decisions can be made. Default `q` for values that are not specified is 1.0 From: https://gist.github.com/samuraisam/2714195 """ result = [] for media_range in accept.split(","): parts = media_range.split(";") media_type = parts.pop(0).strip() media_params = [] # convert vendor-specific content types into something useful (see # docstring) typ, subtyp = media_type.split('/') # check for a + in the sub-type if '+' in subtyp: # if it exists, determine if the subtype is a vendor-specific type vnd, sep, extra = subtyp.partition('+') if vnd.startswith('vnd'): # and then... if it ends in something like "-v1.1" parse the # version out if '-v' in vnd: vnd, sep, rest = vnd.rpartition('-v') if len(rest): # add the version as a media param try: version = media_params.append(('version', float(rest))) except ValueError: version = 1.0 # could not be parsed # add the vendor code as a media param media_params.append(('vendor', vnd)) # and re-write media_type to something like application/json so # it can be used usefully when looking up emitters media_type = '{}/{}'.format(typ, extra) q = 1.0 for part in parts: (key, value) = part.lstrip().split("=", 1) key = key.strip() value = value.strip() if key == "q": q = float(value) else: media_params.append((key, value)) result.append((media_type, dict(media_params), q)) result.sort(key=itemgetter(2)) return result
def _parse_accept_header(accept): """ Parse the Accept header *accept* Return a list with 3-tuples of [(str(media_type), dict(params), float(q_value)),] ordered by q values. If the accept header includes vendor-specific types like:: application/vnd.yourcompany.yourproduct-v1.1+json It will actually convert the vendor and version into parameters and convert the content type into `application/json` so appropriate content negotiation decisions can be made. Default `q` for values that are not specified is 1.0 From: https://gist.github.com/samuraisam/2714195 """ result = [] for media_range in accept.split(","): parts = media_range.split(";") media_type = parts.pop(0).strip() media_params = [] # convert vendor-specific content types into something useful (see # docstring) typ, subtyp = media_type.split('/') # check for a + in the sub-type if '+' in subtyp: # if it exists, determine if the subtype is a vendor-specific type vnd, sep, extra = subtyp.partition('+') if vnd.startswith('vnd'): # and then... if it ends in something like "-v1.1" parse the # version out if '-v' in vnd: vnd, sep, rest = vnd.rpartition('-v') if len(rest): # add the version as a media param try: version = media_params.append(('version', float(rest))) except ValueError: version = 1.0 # could not be parsed # add the vendor code as a media param media_params.append(('vendor', vnd)) # and re-write media_type to something like application/json so # it can be used usefully when looking up emitters media_type = '{}/{}'.format(typ, extra) q = 1.0 for part in parts: (key, value) = part.lstrip().split("=", 1) key = key.strip() value = value.strip() if key == "q": q = float(value) else: media_params.append((key, value)) result.append((media_type, dict(media_params), q)) result.sort(key=itemgetter(2)) return result
29,880
def linear_mixed_model(y, x, z_t=None, k=None, p_path=None, overwrite=False, standardize=True, mean_impute=True): r"""Initialize a linear mixed model from a matrix table. .. warning:: This functionality is no longer implemented/supported as of Hail 0.2.94. """ raise NotImplementedError("linear_mixed_modelv is no longer implemented/supported as of Hail 0.2.94")
def linear_mixed_model(y, x, z_t=None, k=None, p_path=None, overwrite=False, standardize=True, mean_impute=True): r"""Initialize a linear mixed model from a matrix table. .. warning:: This functionality is no longer implemented/supported as of Hail 0.2.94. """ raise NotImplementedError("linear_mixed_model is no longer implemented/supported as of Hail 0.2.94")
45,720
def initialize_forecast_exporter_netcdf( outpath, outfnprefix, startdate, timestep, n_timesteps, shape, metadata, n_ens_members=1, incremental=None, **kwargs, ): """Initialize a netCDF forecast exporter. All outputs are written to a single file named as '<outfnprefix>_.nc'. Parameters ---------- outpath: str Output path. outfnprefix: str Prefix for output file names. startdate: datetime.datetime Start date of the forecast. timestep: int Time step of the forecast (minutes). n_timesteps: int Number of time steps in the forecast this argument is ignored if incremental is set to 'timestep'. shape: tuple of int Two-element tuple defining the shape (height,width) of the forecast grids. metadata: dict Metadata dictionary containing the projection, x1, x2, y1, y2, unit attributes (projection and variable units) described in the documentation of :py:mod:`pysteps.io.importers`. n_ens_members: int Number of ensemble members in the forecast. This argument is ignored if incremental is set to 'member'. incremental: {None,'timestep','member'}, optional Allow incremental writing of datasets into the netCDF files.\n The available options are: 'timestep' = write a forecast or a forecast ensemble for a given time step; 'member' = write a forecast sequence for a given ensemble member. If set to None, incremental writing is disabled. Returns ------- exporter: dict The return value is a dictionary containing an exporter object. This c an be used with :py:func:`pysteps.io.exporters.export_forecast_dataset` to write datasets into the given file format. """ if not NETCDF4_IMPORTED: raise MissingOptionalDependency( "netCDF4 package is required for netcdf " "exporters but it is not installed" ) if not PYPROJ_IMPORTED: raise MissingOptionalDependency( "pyproj package is required for netcdf " "exporters but it is not installed" ) if not isinstance(startdate, datetime): raise ValueError("argument 'stardate' must be a python datetime object") if incremental not in [None, "timestep", "member"]: raise ValueError( f"unknown option {incremental}: incremental must be " + "'timestep' or 'member'" ) if incremental == "timestep": n_timesteps = None elif incremental == "member": n_ens_members = None elif incremental is not None: raise ValueError( f"unknown argument value incremental='{str(incremental)}': " + "must be 'timestep' or 'member'" ) n_ens_gt_one = False if n_ens_members is not None: if n_ens_members > 1: n_ens_gt_one = True exporter = {} outfn = os.path.join(outpath, outfnprefix + ".nc") ncf = netCDF4.Dataset(outfn, "w", format="NETCDF4") ncf.Conventions = "CF-1.7" ncf.title = "pysteps-generated nowcast" ncf.institution = "the pySTEPS community (https://pysteps.github.io)" ncf.source = "pysteps" # TODO(exporters): Add pySTEPS version here ncf.history = "" ncf.references = "" ncf.comment = "" h, w = shape ncf.createDimension("ens_number", size=n_ens_members) ncf.createDimension("time", size=n_timesteps) ncf.createDimension("y", size=h) ncf.createDimension("x", size=w) if metadata["unit"] == "mm/h": var_name = "precip_intensity" var_standard_name = None var_long_name = "instantaneous precipitation rate" var_unit = "mm h-1" elif metadata["unit"] == "mm": var_name = "precip_accum" var_standard_name = None var_long_name = "accumulated precipitation" var_unit = "mm" elif metadata["unit"] == "dBZ": var_name = "reflectivity" var_long_name = "equivalent reflectivity factor" var_standard_name = "equivalent_reflectivity_factor" var_unit = "dBZ" else: raise ValueError("unknown unit %s" % metadata["unit"]) xr = np.linspace(*metadata["bounding_box"][:2], w + 1)[:-1] xr += 0.5 * (xr[1] - xr[0]) yr = np.linspace(*metadata["bounding_box"][2:], h + 1)[:-1] yr += 0.5 * (yr[1] - yr[0]) # flip yr vector if yorigin is upper if metadata["yorigin"] == "upper": yr = np.flip(yr) var_xc = ncf.createVariable("x", np.float32, dimensions=("x",)) var_xc[:] = xr var_xc.axis = "X" var_xc.standard_name = "projection_x_coordinate" var_xc.long_name = "x-coordinate in Cartesian system" var_xc.units = metadata.get("cartesian_unit", "m") var_yc = ncf.createVariable("y", np.float32, dimensions=("y",)) var_yc[:] = yr var_yc.axis = "Y" var_yc.standard_name = "projection_y_coordinate" var_yc.long_name = "y-coordinate in Cartesian system" var_yc.units = metadata.get("cartesian_unit") x_2d, y_2d = np.meshgrid(xr, yr) pr = pyproj.Proj(metadata["projection"]) lon, lat = pr(x_2d.flatten(), y_2d.flatten(), inverse=True) var_lon = ncf.createVariable("lon", float, dimensions=("y", "x")) var_lon[:] = lon.reshape(shape) var_lon.standard_name = "longitude" var_lon.long_name = "longitude coordinate" # TODO(exporters): Don't hard-code the unit. var_lon.units = "degrees_east" var_lat = ncf.createVariable("lat", float, dimensions=("y", "x")) var_lat[:] = lat.reshape(shape) var_lat.standard_name = "latitude" var_lat.long_name = "latitude coordinate" # TODO(exporters): Don't hard-code the unit. var_lat.units = "degrees_north" ncf.projection = metadata["projection"] ( grid_mapping_var_name, grid_mapping_name, grid_mapping_params, ) = _convert_proj4_to_grid_mapping(metadata["projection"]) # skip writing the grid mapping if a matching name was not found if grid_mapping_var_name is not None: var_gm = ncf.createVariable(grid_mapping_var_name, int, dimensions=()) var_gm.grid_mapping_name = grid_mapping_name for i in grid_mapping_params.items(): var_gm.setncattr(i[0], i[1]) if incremental == "member" or n_ens_gt_one: var_ens_num = ncf.createVariable("ens_number", int, dimensions=("ens_number",)) if incremental != "member": var_ens_num[:] = list(range(1, n_ens_members + 1)) var_ens_num.long_name = "ensemble member" var_ens_num.standard_name = "realization" var_ens_num.units = "" var_time = ncf.createVariable("time", int, dimensions=("time",)) if incremental != "timestep": var_time[:] = [i * timestep * 60 for i in range(1, n_timesteps + 1)] var_time.long_name = "forecast time" var_time.units = f"seconds since {startdate: %Y-%m-%d %H:%M:%S}" if incremental == "member" or n_ens_gt_one: var_f = ncf.createVariable( var_name, np.float32, dimensions=("ens_number", "time", "y", "x"), zlib=True, complevel=9, ) else: var_f = ncf.createVariable( var_name, np.float32, dimensions=("time", "y", "x"), zlib=True, complevel=9 ) if var_standard_name is not None: var_f.standard_name = var_standard_name var_f.long_name = var_long_name var_f.coordinates = "y x" var_f.units = var_unit if grid_mapping_var_name is not None: var_f.grid_mapping = grid_mapping_var_name exporter["method"] = "netcdf" exporter["ncfile"] = ncf exporter["var_F"] = var_f if incremental == "member" or n_ens_gt_one: exporter["var_ens_num"] = var_ens_num exporter["var_time"] = var_time exporter["var_name"] = var_name exporter["startdate"] = startdate exporter["timestep"] = timestep exporter["metadata"] = metadata exporter["incremental"] = incremental exporter["num_timesteps"] = n_timesteps exporter["num_ens_members"] = n_ens_members exporter["shape"] = shape return exporter
def initialize_forecast_exporter_netcdf( outpath, outfnprefix, startdate, timestep, n_timesteps, shape, metadata, n_ens_members=1, incremental=None, **kwargs, ): """Initialize a netCDF forecast exporter. All outputs are written to a single file named as '<outfnprefix>_.nc'. Parameters ---------- outpath: str Output path. outfnprefix: str Prefix for output file names. startdate: datetime.datetime Start date of the forecast. timestep: int Time step of the forecast (minutes). n_timesteps: int Number of time steps in the forecast this argument is ignored if incremental is set to 'timestep'. shape: tuple of int Two-element tuple defining the shape (height,width) of the forecast grids. metadata: dict Metadata dictionary containing the projection, x1, x2, y1, y2, unit attributes (projection and variable units) described in the documentation of :py:mod:`pysteps.io.importers`. n_ens_members: int Number of ensemble members in the forecast. This argument is ignored if incremental is set to 'member'. incremental: {None,'timestep','member'}, optional Allow incremental writing of datasets into the netCDF files.\n The available options are: 'timestep' = write a forecast or a forecast ensemble for a given time step; 'member' = write a forecast sequence for a given ensemble member. If set to None, incremental writing is disabled. Returns ------- exporter: dict The return value is a dictionary containing an exporter object. This c an be used with :py:func:`pysteps.io.exporters.export_forecast_dataset` to write datasets into the given file format. """ if not NETCDF4_IMPORTED: raise MissingOptionalDependency( "netCDF4 package is required for netcdf " "exporters but it is not installed" ) if not PYPROJ_IMPORTED: raise MissingOptionalDependency( "pyproj package is required for netcdf " "exporters but it is not installed" ) if not isinstance(startdate, datetime): raise ValueError("argument 'stardate' must be a python datetime object") if incremental not in [None, "timestep", "member"]: raise ValueError( f"unknown option {incremental}: incremental must be " + "'timestep' or 'member'" ) if incremental == "timestep": n_timesteps = None elif incremental == "member": n_ens_members = None elif incremental is not None: raise ValueError( f"unknown argument value incremental='{str(incremental)}': " + "must be 'timestep' or 'member'" ) n_ens_gt_one = False if n_ens_members is not None: if n_ens_members > 1: n_ens_gt_one = True exporter = {} outfn = os.path.join(outpath, outfnprefix + ".nc") ncf = netCDF4.Dataset(outfn, "w", format="NETCDF4") ncf.Conventions = "CF-1.7" ncf.title = "pysteps-generated nowcast" ncf.institution = "the pySTEPS community (https://pysteps.github.io)" ncf.source = "pysteps" # TODO(exporters): Add pySTEPS version here ncf.history = "" ncf.references = "" ncf.comment = "" h, w = shape ncf.createDimension("ens_number", size=n_ens_members) ncf.createDimension("time", size=n_timesteps) ncf.createDimension("y", size=h) ncf.createDimension("x", size=w) if metadata["unit"] == "mm/h": var_name = "precip_intensity" var_standard_name = None var_long_name = "instantaneous precipitation rate" var_unit = "mm h-1" elif metadata["unit"] == "mm": var_name = "precip_accum" var_standard_name = None var_long_name = "accumulated precipitation" var_unit = "mm" elif metadata["unit"] == "dBZ": var_name = "reflectivity" var_long_name = "equivalent reflectivity factor" var_standard_name = "equivalent_reflectivity_factor" var_unit = "dBZ" else: raise ValueError("unknown unit %s" % metadata["unit"]) xr = np.linspace(*metadata["bounding_box"][:2], w + 1)[:-1] xr += 0.5 * (xr[1] - xr[0]) yr = np.linspace(*metadata["bounding_box"][2:], h + 1)[:-1] yr += 0.5 * (yr[1] - yr[0]) # flip yr vector if yorigin is upper if metadata["yorigin"] == "upper": yr = np.flip(yr) var_xc = ncf.createVariable("x", np.float32, dimensions=("x",)) var_xc[:] = xr var_xc.axis = "X" var_xc.standard_name = "projection_x_coordinate" var_xc.long_name = "x-coordinate in Cartesian system" var_xc.units = metadata.get("cartesian_unit", "m") var_yc = ncf.createVariable("y", np.float32, dimensions=("y",)) var_yc[:] = yr var_yc.axis = "Y" var_yc.standard_name = "projection_y_coordinate" var_yc.long_name = "y-coordinate in Cartesian system" var_yc.units = metadata.get("cartesian_unit", "m") x_2d, y_2d = np.meshgrid(xr, yr) pr = pyproj.Proj(metadata["projection"]) lon, lat = pr(x_2d.flatten(), y_2d.flatten(), inverse=True) var_lon = ncf.createVariable("lon", float, dimensions=("y", "x")) var_lon[:] = lon.reshape(shape) var_lon.standard_name = "longitude" var_lon.long_name = "longitude coordinate" # TODO(exporters): Don't hard-code the unit. var_lon.units = "degrees_east" var_lat = ncf.createVariable("lat", float, dimensions=("y", "x")) var_lat[:] = lat.reshape(shape) var_lat.standard_name = "latitude" var_lat.long_name = "latitude coordinate" # TODO(exporters): Don't hard-code the unit. var_lat.units = "degrees_north" ncf.projection = metadata["projection"] ( grid_mapping_var_name, grid_mapping_name, grid_mapping_params, ) = _convert_proj4_to_grid_mapping(metadata["projection"]) # skip writing the grid mapping if a matching name was not found if grid_mapping_var_name is not None: var_gm = ncf.createVariable(grid_mapping_var_name, int, dimensions=()) var_gm.grid_mapping_name = grid_mapping_name for i in grid_mapping_params.items(): var_gm.setncattr(i[0], i[1]) if incremental == "member" or n_ens_gt_one: var_ens_num = ncf.createVariable("ens_number", int, dimensions=("ens_number",)) if incremental != "member": var_ens_num[:] = list(range(1, n_ens_members + 1)) var_ens_num.long_name = "ensemble member" var_ens_num.standard_name = "realization" var_ens_num.units = "" var_time = ncf.createVariable("time", int, dimensions=("time",)) if incremental != "timestep": var_time[:] = [i * timestep * 60 for i in range(1, n_timesteps + 1)] var_time.long_name = "forecast time" var_time.units = f"seconds since {startdate: %Y-%m-%d %H:%M:%S}" if incremental == "member" or n_ens_gt_one: var_f = ncf.createVariable( var_name, np.float32, dimensions=("ens_number", "time", "y", "x"), zlib=True, complevel=9, ) else: var_f = ncf.createVariable( var_name, np.float32, dimensions=("time", "y", "x"), zlib=True, complevel=9 ) if var_standard_name is not None: var_f.standard_name = var_standard_name var_f.long_name = var_long_name var_f.coordinates = "y x" var_f.units = var_unit if grid_mapping_var_name is not None: var_f.grid_mapping = grid_mapping_var_name exporter["method"] = "netcdf" exporter["ncfile"] = ncf exporter["var_F"] = var_f if incremental == "member" or n_ens_gt_one: exporter["var_ens_num"] = var_ens_num exporter["var_time"] = var_time exporter["var_name"] = var_name exporter["startdate"] = startdate exporter["timestep"] = timestep exporter["metadata"] = metadata exporter["incremental"] = incremental exporter["num_timesteps"] = n_timesteps exporter["num_ens_members"] = n_ens_members exporter["shape"] = shape return exporter
21,476
def measure_func(name=None): """ Used to decorator an async function with a `Measure` context manager. Usage: @measure_func async def foo(...): ... Which is analogous to: async def foo(...): with Measure(...): ... """ def wrapper(func): block_name = func.__name__ if name is None else name @wraps(func) async def measured_func(self, *args, **kwargs): with Measure(self.clock, block_name): r = await func(self, *args, **kwargs) return r return measured_func return wrapper
def measure_func(name=None): """ Used to decorator an async function with a `Measure` context manager. Usage: @measure_func() async def foo(...): ... Which is analogous to: async def foo(...): with Measure(...): ... """ def wrapper(func): block_name = func.__name__ if name is None else name @wraps(func) async def measured_func(self, *args, **kwargs): with Measure(self.clock, block_name): r = await func(self, *args, **kwargs) return r return measured_func return wrapper
20,917
def pre_init_hook_for_submodules(cr, model, field): """Moves images from single to multi mode. Feel free to use this as a ``pre_init_hook`` for submodules. :param str model: Model name, like ``product.template``. :param str field: Binary field that had the images in that :param:`model`, like ``image``. """ env = api.Environment(cr, SUPERUSER_ID, dict()) with cr.savepoint(): cr.execute( """ INSERT INTO base_multi_image_image ( owner_id, owner_model, storage, file_db_store ) SELECT id, %(model)s, 'db', %(field)s FROM %(table)s WHERE %(field)s IS NOT NULL """, {"table": AsIs(env[model]._table), "field": AsIs(field), "model": (model,)} )
def pre_init_hook_for_submodules(cr, model, field): """Moves images from single to multi mode. Feel free to use this as a ``pre_init_hook`` for submodules. :param str model: Model name, like ``product.template``. :param str field: Binary field that had the images in that :param:`model`, like ``image``. """ env = api.Environment(cr, SUPERUSER_ID, dict()) with cr.savepoint(): cr.execute( """ INSERT INTO base_multi_image_image ( owner_id, owner_model, storage, file_db_store ) SELECT id, %(model)s, 'db', %(field)s FROM %(table)s WHERE %(field)s IS NOT NULL """, {"table": AsIs(env[model]._table), "field": AsIs(field), "model": model} )
41,207
def decompose_clifford_tableau_to_operations( qubits: List['cirq.Qid'], clifford_tableau: qis.CliffordTableau ) -> List[ops.Operation]: """Decompose an n-qubit Clifford Tableau into a list of one/two qubit operations. Args: qubits: The list of qubits being operated on. clifford_tableau: The Clifford Tableau for decomposition. Returns: A list of operations reconstructs the same Clifford tableau. """ if len(qubits) != clifford_tableau.n: raise ValueError( f"The number of qubits must be the same as the number of Clifford Tableau." ) assert ( clifford_tableau._validate() ), "The provided clifford_tableau must satisfy the symplectic property." t: qis.CliffordTableau = clifford_tableau.copy() operations: List[ops.Operation] = [] args = sim.ActOnCliffordTableauArgs( tableau=t, axes=[], prng=np.random.RandomState(), log_of_measurement_results={} ) _X_with_ops = functools.partial(_X, args=args, operations=operations, qubits=qubits) _Z_with_ops = functools.partial(_Z, args=args, operations=operations, qubits=qubits) _H_with_ops = functools.partial(_H, args=args, operations=operations, qubits=qubits) _S_with_ops = functools.partial(_Sdg, args=args, operations=operations, qubits=qubits) _CNOT_with_ops = functools.partial(_CNOT, args=args, operations=operations, qubits=qubits) _SWAP_with_ops = functools.partial(_SWAP, args=args, operations=operations, qubits=qubits) # The procedure is based on Theorem 8 in # [1] S. Aaronson, D. Gottesman, *Improved Simulation of Stabilizer Circuits*, # Phys. Rev. A 70, 052328 (2004). https://arxiv.org/abs/quant-ph/0406196 # with modification by doing it row-by-row instead. # Suppose we have a Clifford Tableau: # Xs Zs # Destabilizers: [ A | B ] # Stabilizers: [ C | D ] for i in range(t.n): # Step 1a: Make the diagonal element of A as 1 by Hadamard gate if necessary. if not t.xs[i, i] and t.zs[i, i]: _H_with_ops(i) # Step 1b: Make the diagonal element of A as 1 by swapping gate if necessary. if not t.xs[i, i]: for j in range(i + 1, t.n): if t.xs[i, j]: _SWAP_with_ops(i, j) break # Step 1c: We may still not be able to find non-zero element in whole Xs row. Then, # apply swap + Hadamard from zs. It is guaranteed to find one by lemma 5 in [1]. if not t.xs[i, i]: for j in range(i + 1, t.n): if t.zs[i, j]: _H_with_ops(j) _SWAP_with_ops(i, j) break # Step 2: Eliminate the elements in A By CNOT and phase gate (i-th row) # first i rows of destabilizers: [ I 0 | 0 0 ] _ = [_CNOT_with_ops(i, j) for j in range(i + 1, t.n) if t.xs[i, j]] if np.any(t.zs[i, i:]): if not t.zs[i, i]: _S_with_ops(i) _ = [_CNOT_with_ops(j, i) for j in range(i + 1, t.n) if t.zs[i, j]] _S_with_ops(i) # Step 3: Eliminate the elements in D By CNOT and phase gate (i-th row) # first i rows of stabilizers: [ 0 0 | I 0 ] _ = [_CNOT_with_ops(j, i) for j in range(i + 1, t.n) if t.zs[i + t.n, j]] if np.any(t.xs[i + t.n, i:]): # Swap xs and zs _H_with_ops(i) _ = [_CNOT_with_ops(i, j) for j in range(i + 1, t.n) if t.xs[i + t.n, j]] if t.zs[i + t.n, i]: _S_with_ops(i) _H_with_ops(i) # Step 4: Correct the phase of tableau _ = [_Z_with_ops(i) for i, p in enumerate(t.rs[: t.n]) if p] _ = [_X_with_ops(i) for i, p in enumerate(t.rs[t.n :]) if p] # Step 5: invert the operations by reversing the orde: (AB)^{+} = B^{+} A^{+}. # Note only S gate is not self-adjoint. return operations[::-1]
def decompose_clifford_tableau_to_operations( qubits: List['cirq.Qid'], clifford_tableau: qis.CliffordTableau ) -> List[ops.Operation]: """Decompose an n-qubit Clifford Tableau into a list of one/two qubit operations. Args: qubits: The list of qubits being operated on. clifford_tableau: The Clifford Tableau for decomposition. Returns: A list of operations reconstructs the same Clifford tableau. """ if len(qubits) != clifford_tableau.n: raise ValueError( f"The number of qubits must be the same as the number of Clifford Tableau." ) assert ( clifford_tableau._validate() ), "The provided clifford_tableau must satisfy the symplectic property." t: qis.CliffordTableau = clifford_tableau.copy() operations: List[ops.Operation] = [] args = sim.ActOnCliffordTableauArgs( tableau=t, axes=[], prng=np.random.RandomState(), log_of_measurement_results={} ) _X_with_ops = functools.partial(_X, args=args, operations=operations, qubits=qubits) _Z_with_ops = functools.partial(_Z, args=args, operations=operations, qubits=qubits) _H_with_ops = functools.partial(_H, args=args, operations=operations, qubits=qubits) _S_with_ops = functools.partial(_Sdg, args=args, operations=operations, qubits=qubits) _CNOT_with_ops = functools.partial(_CNOT, args=args, operations=operations, qubits=qubits) _SWAP_with_ops = functools.partial(_SWAP, args=args, operations=operations, qubits=qubits) # The procedure is based on Theorem 8 in # [1] S. Aaronson, D. Gottesman, *Improved Simulation of Stabilizer Circuits*, # Phys. Rev. A 70, 052328 (2004). https://arxiv.org/abs/quant-ph/0406196 # with modification by doing it row-by-row instead. # Suppose we have a Clifford Tableau: # Xs Zs # Destabilizers: [ A | B ] # Stabilizers: [ C | D ] for i in range(t.n): # Step 1a: Make the diagonal element of A as 1 by Hadamard gate if necessary. if not t.xs[i, i] and t.zs[i, i]: _H_with_ops(i) # Step 1b: Make the diagonal element of A equal to 1 by SWAP gate if necessary. if not t.xs[i, i]: for j in range(i + 1, t.n): if t.xs[i, j]: _SWAP_with_ops(i, j) break # Step 1c: We may still not be able to find non-zero element in whole Xs row. Then, # apply swap + Hadamard from zs. It is guaranteed to find one by lemma 5 in [1]. if not t.xs[i, i]: for j in range(i + 1, t.n): if t.zs[i, j]: _H_with_ops(j) _SWAP_with_ops(i, j) break # Step 2: Eliminate the elements in A By CNOT and phase gate (i-th row) # first i rows of destabilizers: [ I 0 | 0 0 ] _ = [_CNOT_with_ops(i, j) for j in range(i + 1, t.n) if t.xs[i, j]] if np.any(t.zs[i, i:]): if not t.zs[i, i]: _S_with_ops(i) _ = [_CNOT_with_ops(j, i) for j in range(i + 1, t.n) if t.zs[i, j]] _S_with_ops(i) # Step 3: Eliminate the elements in D By CNOT and phase gate (i-th row) # first i rows of stabilizers: [ 0 0 | I 0 ] _ = [_CNOT_with_ops(j, i) for j in range(i + 1, t.n) if t.zs[i + t.n, j]] if np.any(t.xs[i + t.n, i:]): # Swap xs and zs _H_with_ops(i) _ = [_CNOT_with_ops(i, j) for j in range(i + 1, t.n) if t.xs[i + t.n, j]] if t.zs[i + t.n, i]: _S_with_ops(i) _H_with_ops(i) # Step 4: Correct the phase of tableau _ = [_Z_with_ops(i) for i, p in enumerate(t.rs[: t.n]) if p] _ = [_X_with_ops(i) for i, p in enumerate(t.rs[t.n :]) if p] # Step 5: invert the operations by reversing the orde: (AB)^{+} = B^{+} A^{+}. # Note only S gate is not self-adjoint. return operations[::-1]
917
def test_issue_22058(): sol = solveset(-sqrt(t)*x**2 + 2*x + sqrt(t), x, S.Reals) # doesn't fail (and following numerical check) assert sol.xreplace({t: 1}) == {1 + sqrt(2), 1 - sqrt(2)}
def test_issue_22058(): sol = solveset(-sqrt(t)*x**2 + 2*x + sqrt(t), x, S.Reals) # doesn't fail (and following numerical check) assert sol.xreplace({t: 1}) == {1 - sqrt(2), 1 + sqrt(2)}, sol.xreplace({t: 1})
14,494
def _items_sorter( sort_keys: bool, key_order: Optional[Sequence[str]], drop_missing: bool, ) -> Callable[[EventDict], List[Tuple[str, Any]]]: """ Return a function to sort items from an `event_dict`. See :class:`KeyValueRenderer` for an explanation of the parameters. """ # Use an optimized version for each case. if key_order and sort_keys: def ordered_items(event_dict: EventDict) -> List[Tuple[str, Any]]: items = [] for key in key_order: # type: ignore value = event_dict.pop(key, None) if value is not None or not drop_missing: items.append((key, value)) items += sorted(event_dict.items()) return items elif key_order: def ordered_items(event_dict: EventDict) -> List[Tuple[str, Any]]: items = [] for key in key_order: # type: ignore value = event_dict.pop(key, None) if value is not None or not drop_missing: items.append((key, value)) items += event_dict.items() return items elif sort_keys: def ordered_items(event_dict: EventDict) -> List[Tuple[str, Any]]: return sorted(event_dict.items()) else: ordered_items = operator.methodcaller("items") # type: ignore return ordered_items
def _items_sorter( sort_keys: bool, key_order: Optional[Sequence[str]], drop_missing: bool, ) -> Callable[[EventDict], List[Tuple[str, Any]]]: """ Return a function to sort items from an `event_dict`. See `KeyValueRenderer` for an explanation of the parameters. """ # Use an optimized version for each case. if key_order and sort_keys: def ordered_items(event_dict: EventDict) -> List[Tuple[str, Any]]: items = [] for key in key_order: # type: ignore value = event_dict.pop(key, None) if value is not None or not drop_missing: items.append((key, value)) items += sorted(event_dict.items()) return items elif key_order: def ordered_items(event_dict: EventDict) -> List[Tuple[str, Any]]: items = [] for key in key_order: # type: ignore value = event_dict.pop(key, None) if value is not None or not drop_missing: items.append((key, value)) items += event_dict.items() return items elif sort_keys: def ordered_items(event_dict: EventDict) -> List[Tuple[str, Any]]: return sorted(event_dict.items()) else: ordered_items = operator.methodcaller("items") # type: ignore return ordered_items
6,813
def expand_relative_urls(html): # expand relative urls url = get_url() if url.endswith("/"): url = url[:-1] def _expand_relative_urls(match): to_expand = list(match.groups()) if not to_expand[2].startswith('mailto') and not to_expand[2].startswith('data:'): if not to_expand[2].startswith("/"): to_expand[2] = "/" + to_expand[2] to_expand.insert(2, url) if 'url' in to_expand[0] and to_expand[1].startswith('(') and to_expand[-1].endswith(')'): # background-image: url('/assets/...') - workaround for wkhtmltopdf print-media-type to_expand.append(' !important') return "".join(to_expand) html = re.sub('(href|src){1}([\s]*=[\s]*[\'"]?)((?!http)[^\'" >]+)([\'"]?)', _expand_relative_urls, html) # background-image: url('/assets/...') html = re.sub('(:[\s]?url)(\([\'"]?)((?!http)[^\'" >]+)([\'"]?)', _expand_relative_urls, html) return html
def expand_relative_urls(html): # expand relative urls url = get_url() if url.endswith("/"): url = url[:-1] def _expand_relative_urls(match): to_expand = list(match.groups()) if not to_expand[2].startswith('mailto') and not to_expand[2].startswith('data:'): if not to_expand[2].startswith("/"): to_expand[2] = "/" + to_expand[2] to_expand.insert(2, url) if 'url' in to_expand[0] and to_expand[1].startswith('(') and to_expand[-1].endswith(')'): # background-image: url('/assets/...') - workaround for wkhtmltopdf print-media-type to_expand.append(' !important') return "".join(to_expand) html = re.sub('(href|src){1}([\s]*=[\s]*[\'"]?)((?!http)[^\'" >]+)([\'"]?)', _expand_relative_urls, html) # background-image: url('/assets/...') html = re.sub('(:[\s]?url)(\([\'"]?)((?!http)[^\'" >]+)([\'"]?\))', _expand_relative_urls, html) return html
30,914
def build_human_readable(entry_context: dict) -> str: human_readable = "" entry_context = entry_context.get("TroubleShout", {}) # Engine docker container engine: dict = dict_safe_get(entry_context, ['Engine', 'SSL/TLS'], {}, dict) human_readable += "## Docker container engine - custom certificate\n" readable_engine_issuer = [item.get('Decode').get('Issuer') for item in engine.get('CustomCertificateAuthorities', {})] readable_engine_subject = [item.get('Decode').get('Subject') for item in engine.get('CustomCertificateAuthorities', {})] readable_engine_vars = engine.get('ShellVariables') human_readable += tableToMarkdown(name="Enviorment variables", t=readable_engine_vars) human_readable += tableToMarkdown(name="Issuer", t=readable_engine_issuer, removeNull=True) human_readable += tableToMarkdown(name="Subject", t=readable_engine_subject, removeNull=True) # Endpoint endpoint: dict = entry_context.get('Endpoint', {}).get('SSL/TLS', {}) readable_endpoint_issuer = [item.get('Decode').get('Issuer') for item in endpoint.get('Certificates', {})] readable_endpoint_subject = [item.get('Decode').get('Subject') for item in endpoint.get('Certificates', {})] human_readable += f"\n\n## Endpoint certificate - {endpoint.get('Identifier')}\n" human_readable += tableToMarkdown(name="Issuer", t=readable_endpoint_issuer, removeNull=True) human_readable += tableToMarkdown(name="Subject", t=readable_endpoint_subject, removeNull=True) human_readable += "\n" return human_readable
def build_human_readable(entry_context: dict) -> str: human_readable = "" entry_context = entry_context.get("TroubleShout", {}) # Engine docker container engine: dict = dict_safe_get(entry_context, ['Engine', 'SSL/TLS'], {}, dict) human_readable += "## Docker container engine - custom certificate\n" readable_engine_issuer = [dict_safe_get(item, ('Decode', 'Issuer')) for item in engine.get('CustomCertificateAuthorities', {})] readable_engine_subject = [item.get('Decode').get('Subject') for item in engine.get('CustomCertificateAuthorities', {})] readable_engine_vars = engine.get('ShellVariables') human_readable += tableToMarkdown(name="Enviorment variables", t=readable_engine_vars) human_readable += tableToMarkdown(name="Issuer", t=readable_engine_issuer, removeNull=True) human_readable += tableToMarkdown(name="Subject", t=readable_engine_subject, removeNull=True) # Endpoint endpoint: dict = entry_context.get('Endpoint', {}).get('SSL/TLS', {}) readable_endpoint_issuer = [item.get('Decode').get('Issuer') for item in endpoint.get('Certificates', {})] readable_endpoint_subject = [item.get('Decode').get('Subject') for item in endpoint.get('Certificates', {})] human_readable += f"\n\n## Endpoint certificate - {endpoint.get('Identifier')}\n" human_readable += tableToMarkdown(name="Issuer", t=readable_endpoint_issuer, removeNull=True) human_readable += tableToMarkdown(name="Subject", t=readable_endpoint_subject, removeNull=True) human_readable += "\n" return human_readable
52,465
def test_span_group_copy(doc): doc.spans["test"] = [doc[0:1], doc[2:4]] doc_copy = doc.copy() # check that the spans were indeed copied assert len(doc_copy.spans) > 0 doc.spans["test"].append(doc[3:4]) # check that the copy spans were not modified and this is an isolated doc assert len(doc.spans["test"]) != len(doc_copy.spans["test"])
def test_span_group_copy(doc): doc.spans["test"] = [doc[0:1], doc[2:4]] assert len(doc.spans["test"]) == 2 doc_copy = doc.copy() # check that the spans were indeed copied assert len(doc_copy.spans["test"]) == 2 # add a new span to the original doc doc.spans["test"].append(doc[3:4]) assert len(doc.spans["test"]) == 3 # check that the copy spans were not modified and this is an isolated doc assert len(doc_copy.spans["test"]) == 2
22,719
def _prepare_environ(workspace): new_environ = os.environ.copy() new_environ['TMPDIR'] = workspace # So, pytest is nice, and a little to for our usage. # In order to help user to call seamlessly any piece of python code without requiring to # install it as a full-fledged setuptools distribution for instance, it injects the current # path into the PYTHONPATH environment variable. This allows the python interpreter to import # as modules any python file available in current working directory. # See https://docs.pytest.org/en/3.2.5/pythonpath.html for the explanation and description. # However this behavior is not good in integration tests, in particular the nginx oldest ones. # Indeed during these kind of tests certbot is installed as a transitive dependency to # certbot-nginx. Here is the trick: this certbot version is not necessarily the same than # the certbot codebase lying in current working directory. For instance in oldest tests # certbot==0.36.0 may be installed while the codebase corresponds to certbot==0.37.0.dev0. # If at this point PYTHONPATH is set up like pytest does, invoking certbot will import the # modules from the codebase (0.37.0.dev0), not from the required/installed version (0.36.0). # This will lead to funny and totally incomprehensible errors. To avoid that, we ensure that if # PYTHONPATH is set, it does not contain the current working directory. if new_environ.get('PYTHONPATH'): # certbot_integration_tests.__file__ is: # '/path/to/certbot/certbot-ci/certbot_integration_tests/__init__.pyc' # ... and we want '/path/to/certbot' certbot_root = os.path.dirname(os.path.dirname(os.path.dirname(certbot_integration_tests.__file__))) python_paths = [path for path in new_environ['PYTHONPATH'].split(':') if path != certbot_root] new_environ['PYTHONPATH'] = ':'.join(python_paths) return new_environ
def _prepare_environ(workspace): new_environ = os.environ.copy() new_environ['TMPDIR'] = workspace # So, pytest is nice, and a little to for our usage. # In order to help user to call seamlessly any piece of python code without requiring to # install it as a full-fledged setuptools distribution for instance, it injects the current # path into the PYTHONPATH environment variable. This allows the python interpreter to import # as modules any python file available at this path. # See https://docs.pytest.org/en/3.2.5/pythonpath.html for the explanation and description. # However this behavior is not good in integration tests, in particular the nginx oldest ones. # Indeed during these kind of tests certbot is installed as a transitive dependency to # certbot-nginx. Here is the trick: this certbot version is not necessarily the same than # the certbot codebase lying in current working directory. For instance in oldest tests # certbot==0.36.0 may be installed while the codebase corresponds to certbot==0.37.0.dev0. # If at this point PYTHONPATH is set up like pytest does, invoking certbot will import the # modules from the codebase (0.37.0.dev0), not from the required/installed version (0.36.0). # This will lead to funny and totally incomprehensible errors. To avoid that, we ensure that if # PYTHONPATH is set, it does not contain the current working directory. if new_environ.get('PYTHONPATH'): # certbot_integration_tests.__file__ is: # '/path/to/certbot/certbot-ci/certbot_integration_tests/__init__.pyc' # ... and we want '/path/to/certbot' certbot_root = os.path.dirname(os.path.dirname(os.path.dirname(certbot_integration_tests.__file__))) python_paths = [path for path in new_environ['PYTHONPATH'].split(':') if path != certbot_root] new_environ['PYTHONPATH'] = ':'.join(python_paths) return new_environ
9,205
def getPSF(SCA, bandpass, SCA_pos=None, pupil_bin=4, n_waves=None, extra_aberrations=None, wavelength=None, gsparams=None, logger=None, high_accuracy=None, approximate_struts=None): """Get a single PSF for Roman ST observations. The user must provide the SCA and bandpass; the latter is used when setting up the pupil plane configuration and when interpolating chromatic information, if requested. This routine carries out linear interpolation of the aberrations within a given SCA, based on the Roman (then WFIRST) Cycle 7 specification of the aberrations as a function of focal plane position, more specifically from ``Roman_Phase-A_SRR_WFC_Zernike_and_Field_Data_170727.xlsm`` downloaded from https://roman.gsfc.nasa.gov/science/Roman_Reference_Information.html. Phase B updates that became available in mid-2019 have not yet been incorporated into this module. (Note: the files at that url still use the old WFIRST name. We have renamed them to use the new name of the telescope, Roman, after downloading.) The mask images for the Roman pupil plane are available at from the Roman Reference Information page: https://roman.gsfc.nasa.gov/science/Roman_Reference_Information.html. There are separate files for each SCA, since the view of the spider pattern varies somwhat across the field of view of the wide field camera. Furthermore, the effect of the obscuration is somewhat different at longer wavelengths, so F184 has a different set fo files than the other filters. cf. the ``galsm.roman.longwave_bands`` and ``galsim.roman.shortwave_bands`` attributes, which define which bands use which pupil plane images. To avoid using the full pupil plane configuration, use the optional keyword ``pupil_bin``. The full pupil-plane images are 4096 x 4096, which is more detail than is typically needed for most applications. The default binning is 4x4, which results in an image that is 1024 x 1024. This provides enough detail for most purposes and is much faster to render than using the full pupil plane image. Using pupil_bin=8 (resulting in a 512 x 512 image) still provides fairly reasonable results and is even faster to render, but it is not recommended to use higher binning than that, as the diffraction spikes will be noticeably degraded. Also note that currently the orientation of the struts is fixed, rather than rotating depending on the orientation of the focal plane. Rotation of the PSF can easily be affected by the user via:: psf = galsim.roman.getPSF(...).rotate(angle) which will rotate the entire PSF (including the diffraction spikes and all other features). The calculation takes advantage of the fact that the diffraction limit and aberrations have a simple, understood wavelength-dependence. (The Roman project webpage for Cycle 7 does in fact provide aberrations as a function of wavelength, but the deviation from the expected chromatic dependence is sub-percent so we neglect it here.) For reference, the script used to parse the Zernikes given on the webpage and create the files in the GalSim repository can be found in ``devel/external/parse_roman_zernikes_1217.py``. The resulting chromatic object can be used to draw into any of the Roman bandpasses, though the pupil plane configuration will only be correct for those bands in the same range (i.e., long- or short-wavelength bands). For applications that require very high accuracy in the modeling of the PSF, with very limited aliasing, you may want to lower the folding_threshold in the gsparams. Otherwise very bright stars will show some reflections in the spider pattern and possibly some boxiness at the outskirts of the PSF. Using ``gsparams = GSParams(folding_threshold=2.e-3)`` generally provides good results even for very bright (e.g. mag=10) stars. In these cases, you probably also want to reduce ``pupil_bin`` somewhat from the default value of 4. By default, no additional aberrations are included above the basic design. However, users can provide an optional keyword ``extra_aberrations`` that will be included on top of those that are part of the design. This should be in the same format as for the ChromaticOpticalPSF class, with units of waves at the fiducial wavelength, 1293 nm. Currently, only aberrations up to order 22 (Noll convention) are simulated. For Roman, the tolerance for additional aberrations was a total of 90 nanometers RMS as of mid-2015, distributed largely among coma, astigmatism, trefoil, and spherical aberrations (NOT defocus). This information might serve as a guide for reasonable ``extra_aberrations`` inputs. The reference for that number is an earlier Cycle 5 document: http://roman.gsfc.nasa.gov/science/sdt_public/wps/references/instrument/README_AFTA_C5_WFC_Zernike_and_Field_Data.pdf However, the default (non-extra) aberrations are from Cycle 7 material linked earlier in this docstring. Jitter and charge diffusion are, by default, not included. Users who wish to include these can find some guidelines for typical length scales of the Gaussians that can represent these effects, and convolve the ChromaticOpticalPSF with appropriate achromatic Gaussians. The PSFs are always defined assuming the user will specify length scales in arcsec. Users may find they do not have to call `getPSF` for all objects in their simulations; for a given SCA and position within the SCA, and a given pupil plane configuration and wavelength information, it should be possible to reuse the PSFs. Parameters: SCA: Single value specifying the SCA for which the PSF should be loaded. bandpass: Single string specifying the bandpass to use when defining the pupil plane configuration and/or interpolation of chromatic PSFs. You may also pass a string 'long' or 'short' for this argument, in which case, the correct pupil plane configuration will be used for long- or short-wavelength bands (F184 is long, all else is short). In this case, no interpolation can be used, since it is defined using the extent of the chosen bandpass. If ``wavelength`` is given, then bandpass may be None, which will use the short-wavelength pupil plane image. SCA_pos: Single galsim.PositionD indicating the position within the SCA for which the PSF should be created. If None, the exact center of the SCA is chosen. [default: None] pupil_bin: The binning to apply to the pupil plane image. (See discussion above.) [default: 4] n_waves: Number of wavelengths to use for setting up interpolation of the chromatic PSF objects, which can lead to much faster image rendering. If None, then no interpolation is used. Note that users who want to interpolate can always set up the interpolation later on even if they do not do so when calling `getPSF`. [default: None] extra_aberrations: Array of extra aberrations to include in the PSF model, on top of those that are part of the Roman design. These should be provided in units of waves at the fiducial wavelength of 1293 nm, as an array of length 23 with entries 4 through 22 corresponding to defocus through the 22nd Zernike in the Noll convention. [default: None] wavelength: An option to get an achromatic PSF for a single wavelength, for users who do not care about chromaticity of the PSF. If None, then the fully chromatic PSF is returned. Alternatively the user should supply either (a) a wavelength in nanometers, and they will get achromatic OpticalPSF objects for that wavelength, or (b) a bandpass object, in which case they will get achromatic OpticalPSF objects defined at the effective wavelength of that bandpass. [default: False] gsparams: An optional GSParams argument. See the docstring for GSParams for details. [default: None] Returns: A single PSF object (either a ChromaticOpticalPSF or an OpticalPSF depending on the inputs). """ from ..position import PositionD from ..errors import GalSimValueError, GalSimRangeError from ..bandpass import Bandpass from . import n_pix, n_sca, longwave_bands, shortwave_bands # Deprecated options if high_accuracy: if approximate_struts: from ..deprecated import depr from ..gsparams import GSParams depr('high_accuracy=True,approximate_struts=True', 2.3, 'pupil_bin=4, gsparams=galsim.GSParams(folding_threshold=2.e-3)', 'Note: this is not actually equivalent to the old behavior, but it should ' 'be both faster and more accurate than the corresponding PSF in v2.2.') # Set folding_threshold 2.5x smaller than default. gsparams = GSParams.check(gsparams, folding_threshold=2.e-3) pupil_bin = 4 else: from ..deprecated import depr from ..gsparams import GSParams depr('high_accuracy=True', 2.3, 'pupil_bin=1, gsparams=galsim.GSParams(folding_threshold=2.e-3)', 'Note: this is not actually equivalent to the old behavior, but it should ' 'be both faster and more accurate than the corresponding PSF in v2.2.') # Set folding_threshold 2.5x smaller than default. gsparams = GSParams.check(gsparams, folding_threshold=2.e-3) pupil_bin = 1 elif approximate_struts: from ..deprecated import depr from ..gsparams import GSParams depr('approximate_struts=True', 2.3, 'pupil_bin=8', 'Note: this is not actually equivalent to the old behavior, but it should ' 'be both faster and more accurate than the corresponding PSF in v2.2.') pupil_bin = 8 elif approximate_struts is False or high_accuracy is False: # If they are explicitly given, rather than default (None), then trigger this. from ..deprecated import depr from ..gsparams import GSParams depr('approximate_struts=False, high_accuracy=False', 2.3, 'pupil_bin=4', 'Note: this is not actually equivalent to the old behavior, but it should ' 'be both faster and more accurate than the corresponding PSF in v2.2.') pupil_bin = 4 if SCA <= 0 or SCA > n_sca: raise GalSimRangeError("Invalid SCA.", SCA, 1, n_sca) # SCA_pos: if None, then all should just be center of the SCA. if SCA_pos is None: SCA_pos = PositionD(n_pix/2, n_pix/2) # Parse the bandpasses to see which pupil plane image is needed pupil_plane_type = None if bandpass in longwave_bands or bandpass=='long': pupil_plane_type = 'long' elif bandpass in shortwave_bands or bandpass=='short': pupil_plane_type = 'short' elif bandpass is None and n_waves is None: pupil_plane_type = 'short' else: raise GalSimValueError("Bandpass not a valid Roman bandpass or 'short'/'long'.", bandpass, default_bandpass_list) # If bandpass is 'short'/'long', then make sure that interpolation is not called for, since that # requires an actual bandpass. if bandpass in ['short','long'] and n_waves is not None: raise GalSimValueError("Cannot use bandpass='short'/'long' with interpolation.", bandpass) if not isinstance(wavelength, (Bandpass, float, type(None))): raise TypeError("wavelength should either be a Bandpass, float, or None.") # Now call _get_single_PSF(). psf = _get_single_PSF(SCA, bandpass, SCA_pos, pupil_bin, n_waves, extra_aberrations, wavelength, pupil_plane_type, gsparams) return psf
def getPSF(SCA, bandpass, SCA_pos=None, pupil_bin=4, n_waves=None, extra_aberrations=None, wavelength=None, gsparams=None, logger=None, high_accuracy=None, approximate_struts=None): """Get a single PSF for Roman ST observations. The user must provide the SCA and bandpass; the latter is used when setting up the pupil plane configuration and when interpolating chromatic information, if requested. This routine carries out linear interpolation of the aberrations within a given SCA, based on the Roman (then WFIRST) Cycle 7 specification of the aberrations as a function of focal plane position, more specifically from ``Roman_Phase-A_SRR_WFC_Zernike_and_Field_Data_170727.xlsm`` downloaded from https://roman.gsfc.nasa.gov/science/Roman_Reference_Information.html. Phase B updates that became available in mid-2019 have not yet been incorporated into this module. (Note: the files at that url still use the old WFIRST name. We have renamed them to use the new name of the telescope, Roman, after downloading.) The mask images for the Roman pupil plane are available at from the Roman Reference Information page: https://roman.gsfc.nasa.gov/science/Roman_Reference_Information.html. There are separate files for each SCA, since the view of the spider pattern varies somewhat across the field of view of the wide field camera. Furthermore, the effect of the obscuration is somewhat different at longer wavelengths, so F184 has a different set fo files than the other filters. cf. the ``galsm.roman.longwave_bands`` and ``galsim.roman.shortwave_bands`` attributes, which define which bands use which pupil plane images. To avoid using the full pupil plane configuration, use the optional keyword ``pupil_bin``. The full pupil-plane images are 4096 x 4096, which is more detail than is typically needed for most applications. The default binning is 4x4, which results in an image that is 1024 x 1024. This provides enough detail for most purposes and is much faster to render than using the full pupil plane image. Using pupil_bin=8 (resulting in a 512 x 512 image) still provides fairly reasonable results and is even faster to render, but it is not recommended to use higher binning than that, as the diffraction spikes will be noticeably degraded. Also note that currently the orientation of the struts is fixed, rather than rotating depending on the orientation of the focal plane. Rotation of the PSF can easily be affected by the user via:: psf = galsim.roman.getPSF(...).rotate(angle) which will rotate the entire PSF (including the diffraction spikes and all other features). The calculation takes advantage of the fact that the diffraction limit and aberrations have a simple, understood wavelength-dependence. (The Roman project webpage for Cycle 7 does in fact provide aberrations as a function of wavelength, but the deviation from the expected chromatic dependence is sub-percent so we neglect it here.) For reference, the script used to parse the Zernikes given on the webpage and create the files in the GalSim repository can be found in ``devel/external/parse_roman_zernikes_1217.py``. The resulting chromatic object can be used to draw into any of the Roman bandpasses, though the pupil plane configuration will only be correct for those bands in the same range (i.e., long- or short-wavelength bands). For applications that require very high accuracy in the modeling of the PSF, with very limited aliasing, you may want to lower the folding_threshold in the gsparams. Otherwise very bright stars will show some reflections in the spider pattern and possibly some boxiness at the outskirts of the PSF. Using ``gsparams = GSParams(folding_threshold=2.e-3)`` generally provides good results even for very bright (e.g. mag=10) stars. In these cases, you probably also want to reduce ``pupil_bin`` somewhat from the default value of 4. By default, no additional aberrations are included above the basic design. However, users can provide an optional keyword ``extra_aberrations`` that will be included on top of those that are part of the design. This should be in the same format as for the ChromaticOpticalPSF class, with units of waves at the fiducial wavelength, 1293 nm. Currently, only aberrations up to order 22 (Noll convention) are simulated. For Roman, the tolerance for additional aberrations was a total of 90 nanometers RMS as of mid-2015, distributed largely among coma, astigmatism, trefoil, and spherical aberrations (NOT defocus). This information might serve as a guide for reasonable ``extra_aberrations`` inputs. The reference for that number is an earlier Cycle 5 document: http://roman.gsfc.nasa.gov/science/sdt_public/wps/references/instrument/README_AFTA_C5_WFC_Zernike_and_Field_Data.pdf However, the default (non-extra) aberrations are from Cycle 7 material linked earlier in this docstring. Jitter and charge diffusion are, by default, not included. Users who wish to include these can find some guidelines for typical length scales of the Gaussians that can represent these effects, and convolve the ChromaticOpticalPSF with appropriate achromatic Gaussians. The PSFs are always defined assuming the user will specify length scales in arcsec. Users may find they do not have to call `getPSF` for all objects in their simulations; for a given SCA and position within the SCA, and a given pupil plane configuration and wavelength information, it should be possible to reuse the PSFs. Parameters: SCA: Single value specifying the SCA for which the PSF should be loaded. bandpass: Single string specifying the bandpass to use when defining the pupil plane configuration and/or interpolation of chromatic PSFs. You may also pass a string 'long' or 'short' for this argument, in which case, the correct pupil plane configuration will be used for long- or short-wavelength bands (F184 is long, all else is short). In this case, no interpolation can be used, since it is defined using the extent of the chosen bandpass. If ``wavelength`` is given, then bandpass may be None, which will use the short-wavelength pupil plane image. SCA_pos: Single galsim.PositionD indicating the position within the SCA for which the PSF should be created. If None, the exact center of the SCA is chosen. [default: None] pupil_bin: The binning to apply to the pupil plane image. (See discussion above.) [default: 4] n_waves: Number of wavelengths to use for setting up interpolation of the chromatic PSF objects, which can lead to much faster image rendering. If None, then no interpolation is used. Note that users who want to interpolate can always set up the interpolation later on even if they do not do so when calling `getPSF`. [default: None] extra_aberrations: Array of extra aberrations to include in the PSF model, on top of those that are part of the Roman design. These should be provided in units of waves at the fiducial wavelength of 1293 nm, as an array of length 23 with entries 4 through 22 corresponding to defocus through the 22nd Zernike in the Noll convention. [default: None] wavelength: An option to get an achromatic PSF for a single wavelength, for users who do not care about chromaticity of the PSF. If None, then the fully chromatic PSF is returned. Alternatively the user should supply either (a) a wavelength in nanometers, and they will get achromatic OpticalPSF objects for that wavelength, or (b) a bandpass object, in which case they will get achromatic OpticalPSF objects defined at the effective wavelength of that bandpass. [default: False] gsparams: An optional GSParams argument. See the docstring for GSParams for details. [default: None] Returns: A single PSF object (either a ChromaticOpticalPSF or an OpticalPSF depending on the inputs). """ from ..position import PositionD from ..errors import GalSimValueError, GalSimRangeError from ..bandpass import Bandpass from . import n_pix, n_sca, longwave_bands, shortwave_bands # Deprecated options if high_accuracy: if approximate_struts: from ..deprecated import depr from ..gsparams import GSParams depr('high_accuracy=True,approximate_struts=True', 2.3, 'pupil_bin=4, gsparams=galsim.GSParams(folding_threshold=2.e-3)', 'Note: this is not actually equivalent to the old behavior, but it should ' 'be both faster and more accurate than the corresponding PSF in v2.2.') # Set folding_threshold 2.5x smaller than default. gsparams = GSParams.check(gsparams, folding_threshold=2.e-3) pupil_bin = 4 else: from ..deprecated import depr from ..gsparams import GSParams depr('high_accuracy=True', 2.3, 'pupil_bin=1, gsparams=galsim.GSParams(folding_threshold=2.e-3)', 'Note: this is not actually equivalent to the old behavior, but it should ' 'be both faster and more accurate than the corresponding PSF in v2.2.') # Set folding_threshold 2.5x smaller than default. gsparams = GSParams.check(gsparams, folding_threshold=2.e-3) pupil_bin = 1 elif approximate_struts: from ..deprecated import depr from ..gsparams import GSParams depr('approximate_struts=True', 2.3, 'pupil_bin=8', 'Note: this is not actually equivalent to the old behavior, but it should ' 'be both faster and more accurate than the corresponding PSF in v2.2.') pupil_bin = 8 elif approximate_struts is False or high_accuracy is False: # If they are explicitly given, rather than default (None), then trigger this. from ..deprecated import depr from ..gsparams import GSParams depr('approximate_struts=False, high_accuracy=False', 2.3, 'pupil_bin=4', 'Note: this is not actually equivalent to the old behavior, but it should ' 'be both faster and more accurate than the corresponding PSF in v2.2.') pupil_bin = 4 if SCA <= 0 or SCA > n_sca: raise GalSimRangeError("Invalid SCA.", SCA, 1, n_sca) # SCA_pos: if None, then all should just be center of the SCA. if SCA_pos is None: SCA_pos = PositionD(n_pix/2, n_pix/2) # Parse the bandpasses to see which pupil plane image is needed pupil_plane_type = None if bandpass in longwave_bands or bandpass=='long': pupil_plane_type = 'long' elif bandpass in shortwave_bands or bandpass=='short': pupil_plane_type = 'short' elif bandpass is None and n_waves is None: pupil_plane_type = 'short' else: raise GalSimValueError("Bandpass not a valid Roman bandpass or 'short'/'long'.", bandpass, default_bandpass_list) # If bandpass is 'short'/'long', then make sure that interpolation is not called for, since that # requires an actual bandpass. if bandpass in ['short','long'] and n_waves is not None: raise GalSimValueError("Cannot use bandpass='short'/'long' with interpolation.", bandpass) if not isinstance(wavelength, (Bandpass, float, type(None))): raise TypeError("wavelength should either be a Bandpass, float, or None.") # Now call _get_single_PSF(). psf = _get_single_PSF(SCA, bandpass, SCA_pos, pupil_bin, n_waves, extra_aberrations, wavelength, pupil_plane_type, gsparams) return psf
58,301
def build_auxiliary_output_path(args: Union[argparse.Namespace, MkosiArgs], suffix: str, can_compress: bool = False) -> Path: output = strip_suffixes(args.output) compression = f".{should_compress_output(args)}" if can_compress and should_compress_output(args) else '' return output.with_name(f"{output.name}{suffix}{compression}")
def build_auxiliary_output_path(args: Union[argparse.Namespace, MkosiArgs], suffix: str, can_compress: bool = False) -> Path: output = strip_suffixes(args.output) should_compress = should_compress_output(args) compression = f".{should_compress}" if can_compress and should_compress else '' return output.with_name(f"{output.name}{suffix}{compression}")
33,130
def l96s_tay2_step(x, t, dt, s): """Steps forward state of L96s model by order 2.0 Taylor scheme This is the method that must be used to generate the truth twin for this model due to the high-accuracy with respect to convergence in the strong sense. The ensemble model twin will be generated by the general integration functionality, with the diffusion set appropriately. This is the basic formulation which makes a Fourier truncation at p=1 for the simple form of the order 2.0 method. See `bib.grudzien2020numerical` for full details of the scheme and other versions.""" # Infer system dimension sys_dim = len(x) # Compute the deterministic dxdt and the jacobian equations dx = dxdt(x) dxF = d2x_dtdx(x) # coefficients defined based on the p=1 Fourier truncation rho = 1.0/12.0 - 0.5 * np.pi**(-2) alpha = np.pi**2 / 180.0 - 0.5 * np.pi**(-2) # draw standard normal sample to define the # recursive Stratonovich integral coefficients rndm = np.random.standard_normal([5, sys_dim]) xi = rndm[0, :] mu = rndm[1, :] phi = rndm[2, :] zeta = rndm[3, :] eta = rndm[4, :] # define the auxiliary functions of random Fourier coefficients, a and b a = -2.0 * np.sqrt(dt * rho) * mu - np.sqrt(2.0*dt) * zeta / np.pi b = np.sqrt(dt * alpha) * phi + np.sqrt(dt / (2.0 * np.pi**2) ) * eta # vector of first order Stratonovich integrals J_pdelta = (dt/2.0) * (np.sqrt(dt) * xi + a) def Psi(l1, l2): # psi will be a generic function of the indicies l1 and l2, we will define # psi plus and psi minus via this psi = dt**2 * xi[l1] * xi[l2] / 3.0 + dt * a[l1] * a[l2] / 2.0 \ + dt**(1.5) * (xi[l1] * a[l2] + xi[l2] * a[l1]) / 4.0 \ - dt**(1.5) * (xi[l1] * b[l2] + xi[l2] * b[l1]) / (2.0 * np.pi) return psi # we define the approximations of the second order Stratonovich integral psi_plus = np.array([Psi((i-1) % sys_dim, (i+1) % sys_dim) for i in range(sys_dim)]) psi_minus = np.array([Psi((i-2) % sys_dim, (i-1) % sys_dim) for i in range(sys_dim)]) # the final vectorized step forward is given as x = x + dx * dt + dt**2 * 0.5 * dxF @ dx # deterministic taylor step x += s * np.sqrt(dt) * xi # stochastic euler step x += s * dxF @ J_pdelta # stochastic first order taylor step x += s**2 * (psi_plus - psi_minus) # stochastic second order taylor step return x
def l96s_tay2_step(x, t, dt, s): """Steps forward state of L96s model by order 2.0 Taylor scheme This is the method that must be used to generate the truth twin for this model due to the high-accuracy with respect to convergence in the strong sense. The ensemble model uses general integration functionality, with the diffusion set appropriately. This is the basic formulation which makes a Fourier truncation at p=1 for the simple form of the order 2.0 method. See `bib.grudzien2020numerical` for full details of the scheme and other versions.""" # Infer system dimension sys_dim = len(x) # Compute the deterministic dxdt and the jacobian equations dx = dxdt(x) dxF = d2x_dtdx(x) # coefficients defined based on the p=1 Fourier truncation rho = 1.0/12.0 - 0.5 * np.pi**(-2) alpha = np.pi**2 / 180.0 - 0.5 * np.pi**(-2) # draw standard normal sample to define the # recursive Stratonovich integral coefficients rndm = np.random.standard_normal([5, sys_dim]) xi = rndm[0, :] mu = rndm[1, :] phi = rndm[2, :] zeta = rndm[3, :] eta = rndm[4, :] # define the auxiliary functions of random Fourier coefficients, a and b a = -2.0 * np.sqrt(dt * rho) * mu - np.sqrt(2.0*dt) * zeta / np.pi b = np.sqrt(dt * alpha) * phi + np.sqrt(dt / (2.0 * np.pi**2) ) * eta # vector of first order Stratonovich integrals J_pdelta = (dt/2.0) * (np.sqrt(dt) * xi + a) def Psi(l1, l2): # psi will be a generic function of the indicies l1 and l2, we will define # psi plus and psi minus via this psi = dt**2 * xi[l1] * xi[l2] / 3.0 + dt * a[l1] * a[l2] / 2.0 \ + dt**(1.5) * (xi[l1] * a[l2] + xi[l2] * a[l1]) / 4.0 \ - dt**(1.5) * (xi[l1] * b[l2] + xi[l2] * b[l1]) / (2.0 * np.pi) return psi # we define the approximations of the second order Stratonovich integral psi_plus = np.array([Psi((i-1) % sys_dim, (i+1) % sys_dim) for i in range(sys_dim)]) psi_minus = np.array([Psi((i-2) % sys_dim, (i-1) % sys_dim) for i in range(sys_dim)]) # the final vectorized step forward is given as x = x + dx * dt + dt**2 * 0.5 * dxF @ dx # deterministic taylor step x += s * np.sqrt(dt) * xi # stochastic euler step x += s * dxF @ J_pdelta # stochastic first order taylor step x += s**2 * (psi_plus - psi_minus) # stochastic second order taylor step return x
59,431
def _parse_pulse_args(backend, qubit_lo_freq, meas_lo_freq, qubit_lo_range, meas_lo_range, schedule_los, meas_level, meas_return, meas_map, memory_slot_size, rep_time, rep_delay, parametric_pulses, **run_config): """Build a pulse RunConfig replacing unset arguments with defaults derived from the `backend`. See `assemble` for more information on the required arguments. Returns: RunConfig: a run config, which is a standardized object that configures the qobj and determines the runtime environment. Raises: SchemaValidationError: if the given meas_level, rep_time, rep_delay is not allowed for the given `backend`. """ # grab relevant info from backend if it exists backend_config = None backend_default = None if backend: backend_default = backend.defaults() backend_config = backend.configuration() if meas_level not in getattr(backend_config, 'meas_levels', [MeasLevel.CLASSIFIED]): raise SchemaValidationError( ('meas_level = {} not supported for backend {}, only {} is supported' ).format(meas_level, backend_config.backend_name, backend_config.meas_levels) ) if rep_time not in getattr(backend_config, 'rep_times', None): raise SchemaValidationError( ('rep_time = {} not supported for backend {}, only {} is supported' ).format(rep_time, backend_config.backend_name, backend_config.rep_times) ) if rep_delay not in getattr(backend_config, 'rep_delays', None): raise SchemaValidationError( ('rep_delay = {} not supported for backend {}, only {} is supported' ).format(rep_delay, backend_config.backend_name, backend_config.rep_delays) ) meas_map = meas_map or getattr(backend_config, 'meas_map', None) schedule_los = schedule_los or [] if isinstance(schedule_los, (LoConfig, dict)): schedule_los = [schedule_los] # Convert to LoConfig if LO configuration supplied as dictionary schedule_los = [lo_config if isinstance(lo_config, LoConfig) else LoConfig(lo_config) for lo_config in schedule_los] if not qubit_lo_freq and hasattr(backend_default, 'qubit_freq_est'): qubit_lo_freq = backend_default.qubit_freq_est if not meas_lo_freq and hasattr(backend_default, 'meas_freq_est'): meas_lo_freq = backend_default.meas_freq_est qubit_lo_range = qubit_lo_range or getattr(backend_config, 'qubit_lo_range', None) meas_lo_range = meas_lo_range or getattr(backend_config, 'meas_lo_range', None) dynamic_reprate_enabled = getattr(backend_config, 'dynamic_reprate_enabled', False) rep_time = rep_time or getattr(backend_config, 'rep_times', None) if rep_time: if dynamic_reprate_enabled: warnings.warn("Dynamic rep rates are supported on this backend. 'rep_delay' will be " "used instead, if specified.", RuntimeWarning) if isinstance(rep_time, list): rep_time = rep_time[0] rep_time = int(rep_time * 1e6) # convert sec to μs rep_delay = rep_delay or getattr(backend_config, 'rep_delays', None) if rep_delay: if not dynamic_reprate_enabled: warnings.warn("Dynamic rep rates not supported on this backend. 'rep_time' will be " "used instead.", RuntimeWarning) if isinstance(rep_delay, list): rep_delay = rep_delay[0] rep_delay = rep_delay * 1e6 # convert sec to μs parametric_pulses = parametric_pulses or getattr(backend_config, 'parametric_pulses', []) # create run configuration and populate run_config_dict = dict(qubit_lo_freq=qubit_lo_freq, meas_lo_freq=meas_lo_freq, qubit_lo_range=qubit_lo_range, meas_lo_range=meas_lo_range, schedule_los=schedule_los, meas_level=meas_level, meas_return=meas_return, meas_map=meas_map, memory_slot_size=memory_slot_size, rep_time=rep_time, rep_delay=rep_delay, parametric_pulses=parametric_pulses, **run_config) run_config = RunConfig(**{k: v for k, v in run_config_dict.items() if v is not None}) return run_config
def _parse_pulse_args(backend, qubit_lo_freq, meas_lo_freq, qubit_lo_range, meas_lo_range, schedule_los, meas_level, meas_return, meas_map, memory_slot_size, rep_time, rep_delay, parametric_pulses, **run_config): """Build a pulse RunConfig replacing unset arguments with defaults derived from the `backend`. See `assemble` for more information on the required arguments. Returns: RunConfig: a run config, which is a standardized object that configures the qobj and determines the runtime environment. Raises: SchemaValidationError: if the given ``meas_level``, ``rep_time`` or ``rep_delay`` is not allowed for the given ``backend``. """ # grab relevant info from backend if it exists backend_config = None backend_default = None if backend: backend_default = backend.defaults() backend_config = backend.configuration() if meas_level not in getattr(backend_config, 'meas_levels', [MeasLevel.CLASSIFIED]): raise SchemaValidationError( ('meas_level = {} not supported for backend {}, only {} is supported' ).format(meas_level, backend_config.backend_name, backend_config.meas_levels) ) if rep_time not in getattr(backend_config, 'rep_times', None): raise SchemaValidationError( ('rep_time = {} not supported for backend {}, only {} is supported' ).format(rep_time, backend_config.backend_name, backend_config.rep_times) ) if rep_delay not in getattr(backend_config, 'rep_delays', None): raise SchemaValidationError( ('rep_delay = {} not supported for backend {}, only {} is supported' ).format(rep_delay, backend_config.backend_name, backend_config.rep_delays) ) meas_map = meas_map or getattr(backend_config, 'meas_map', None) schedule_los = schedule_los or [] if isinstance(schedule_los, (LoConfig, dict)): schedule_los = [schedule_los] # Convert to LoConfig if LO configuration supplied as dictionary schedule_los = [lo_config if isinstance(lo_config, LoConfig) else LoConfig(lo_config) for lo_config in schedule_los] if not qubit_lo_freq and hasattr(backend_default, 'qubit_freq_est'): qubit_lo_freq = backend_default.qubit_freq_est if not meas_lo_freq and hasattr(backend_default, 'meas_freq_est'): meas_lo_freq = backend_default.meas_freq_est qubit_lo_range = qubit_lo_range or getattr(backend_config, 'qubit_lo_range', None) meas_lo_range = meas_lo_range or getattr(backend_config, 'meas_lo_range', None) dynamic_reprate_enabled = getattr(backend_config, 'dynamic_reprate_enabled', False) rep_time = rep_time or getattr(backend_config, 'rep_times', None) if rep_time: if dynamic_reprate_enabled: warnings.warn("Dynamic rep rates are supported on this backend. 'rep_delay' will be " "used instead, if specified.", RuntimeWarning) if isinstance(rep_time, list): rep_time = rep_time[0] rep_time = int(rep_time * 1e6) # convert sec to μs rep_delay = rep_delay or getattr(backend_config, 'rep_delays', None) if rep_delay: if not dynamic_reprate_enabled: warnings.warn("Dynamic rep rates not supported on this backend. 'rep_time' will be " "used instead.", RuntimeWarning) if isinstance(rep_delay, list): rep_delay = rep_delay[0] rep_delay = rep_delay * 1e6 # convert sec to μs parametric_pulses = parametric_pulses or getattr(backend_config, 'parametric_pulses', []) # create run configuration and populate run_config_dict = dict(qubit_lo_freq=qubit_lo_freq, meas_lo_freq=meas_lo_freq, qubit_lo_range=qubit_lo_range, meas_lo_range=meas_lo_range, schedule_los=schedule_los, meas_level=meas_level, meas_return=meas_return, meas_map=meas_map, memory_slot_size=memory_slot_size, rep_time=rep_time, rep_delay=rep_delay, parametric_pulses=parametric_pulses, **run_config) run_config = RunConfig(**{k: v for k, v in run_config_dict.items() if v is not None}) return run_config
45,469
def mask_secrets(key: str, value: str) -> str: key = key.lower() if any( [ "key" in key, "token" in key, "password" in key, "secret" in key, ] ): return "*" * 8 return value
def mask_secrets(key: str, value: str) -> str: key = key.lower() if any(k in key for k in ["key", "token", "password", "secret"]): return "*" * 8 return value
5,782
def _milp_iv(c, integrality, bounds, constraints, options): # objective IV c = np.atleast_1d(c).astype(np.double) if c.ndim != 1: message = "`c` must be a one-dimensional array." raise ValueError(message) # integrality IV message = ("`integrality` must contain integers 0-3 and be broadcastable " "to `c.shape`.") if integrality is None: integrality = 0 try: integrality = np.broadcast_to(integrality, c.shape).astype(np.uint8) except ValueError: raise ValueError(message) if integrality.min() < 0 or integrality.max() > 3: raise ValueError(message) # bounds IV if bounds is None: bounds = Bounds(0, np.inf) elif not isinstance(bounds, Bounds): message = "`bounds` must be an instance of `scipy.optimize.Bounds`." try: bounds = Bounds(*bounds) except TypeError: raise ValueError(message) try: lb = np.broadcast_to(bounds.lb, c.shape).astype(np.double) ub = np.broadcast_to(bounds.ub, c.shape).astype(np.double) except (ValueError, TypeError): message = ("`bounds.lb` and `bounds.ub` must contain reals and " "be broadcastable to `c.shape`.") raise ValueError(message) # constraints IV if not constraints: # constraints is None, empty sequence, False, 0, etc. constraints = [LinearConstraint(np.empty((0, c.size)), np.empty((0,)), np.empty((0,)))] A, b_l, b_u = _constraints_to_components(constraints) if A.shape != (b_l.size, c.size): message = "The shape of `A` must be (len(b_l), len(c))." raise ValueError(message) indptr, indices, data = A.indptr, A.indices, A.data.astype(np.double) # options IV options = options or {} supported_options = {'disp', 'presolve', 'time_limit'} unsupported_options = set(options).difference(supported_options) if unsupported_options: message = (f"Unrecognized options detected: {unsupported_options}. " "These will be passed to HiGHS verbatim.") warnings.warn(message, RuntimeWarning, stacklevel=3) options_iv = {'log_to_console': options.get("disp", False)} options_iv.update(options) return c, integrality, lb, ub, indptr, indices, data, b_l, b_u, options_iv
def _milp_iv(c, integrality, bounds, constraints, options): # objective IV c = np.atleast_1d(c).astype(np.double) if c.ndim != 1: message = "`c` must be a one-dimensional array." raise ValueError(message) # integrality IV message = ("`integrality` must contain integers 0-3 and be broadcastable " "to `c.shape`.") if integrality is None: integrality = 0 try: integrality = np.broadcast_to(integrality, c.shape).astype(np.uint8) except ValueError: raise ValueError(message) if integrality.min() < 0 or integrality.max() > 3: raise ValueError(message) # bounds IV if bounds is None: bounds = Bounds(0, np.inf) elif not isinstance(bounds, Bounds): message = "`bounds` must be an instance of `scipy.optimize.Bounds`." try: bounds = Bounds(*bounds) except TypeError: raise ValueError(message) try: lb = np.broadcast_to(bounds.lb, c.shape).astype(np.double) ub = np.broadcast_to(bounds.ub, c.shape).astype(np.double) except (ValueError, TypeError): message = ("`bounds.lb` and `bounds.ub` must contain reals and " "be broadcastable to `c.shape`.") raise ValueError(message) # constraints IV if not constraints: constraints = [LinearConstraint(np.empty((0, c.size)), np.empty((0,)), np.empty((0,)))] A, b_l, b_u = _constraints_to_components(constraints) if A.shape != (b_l.size, c.size): message = "The shape of `A` must be (len(b_l), len(c))." raise ValueError(message) indptr, indices, data = A.indptr, A.indices, A.data.astype(np.double) # options IV options = options or {} supported_options = {'disp', 'presolve', 'time_limit'} unsupported_options = set(options).difference(supported_options) if unsupported_options: message = (f"Unrecognized options detected: {unsupported_options}. " "These will be passed to HiGHS verbatim.") warnings.warn(message, RuntimeWarning, stacklevel=3) options_iv = {'log_to_console': options.get("disp", False)} options_iv.update(options) return c, integrality, lb, ub, indptr, indices, data, b_l, b_u, options_iv
14,483
def _perform_mockings() -> None: """Mock modules and roles.""" for role_name in options.mock_roles: if re.match(r"\w+\.\w+\.\w+", role_name): namespace, collection, role_dir = role_name.split(".") path = f".cache/collections/ansible_collections/{ namespace }/{ collection }/roles/{ role_dir }/" else: path = f".cache/roles/{role_name}" os.makedirs(path, exist_ok=True) if options.mock_modules: for module_name in options.mock_modules: _make_module_stub(module_name) # if inside a collection repo, symlink it to simulate its installed state if not os.path.exists("galaxy.yml"): return yaml = yaml_from_file("galaxy.yml") namespace = yaml.get('namespace', None) collection = yaml.get('name', None) if not namespace or not collection: return p = pathlib.Path( f"{options.project_dir}/.cache/collections/ansible_collections/{ namespace }" ) p.mkdir(parents=True, exist_ok=True) link_path = p / collection if not link_path.exists(): link_path.symlink_to(pathlib.Path("../../../..", target_is_directory=True))
def _perform_mockings() -> None: """Mock modules and roles.""" for role_name in options.mock_roles: if re.match(r"\w+\.\w+\.\w+", role_name): namespace, collection, role_dir = role_name.split(".") path = f".cache/collections/ansible_collections/{ namespace }/{ collection }/roles/{ role_dir }/" else: path = f".cache/roles/{role_name}" os.makedirs(path, exist_ok=True) if options.mock_modules: for module_name in options.mock_modules: _make_module_stub(module_name) # if inside a collection repo, symlink it to simulate its installed state if not os.path.exists("galaxy.yml"): return yaml = yaml_from_file("galaxy.yml") namespace = yaml.get('namespace', None) collection = yaml.get('name', None) if not namespace or not collection: return p = pathlib.Path( f"{options.project_dir}/.cache/collections/ansible_collections/{ namespace }" ) p.mkdir(parents=True, exist_ok=True) link_path = p / collection if not link_path.exists(): link_path.symlink_to(pathlib.Path(options.project_dir, target_is_directory=True))
38,996
def _add_pydantic_validation_attributes( dc_cls: Type['Dataclass'], config: Optional[Type['BaseConfig']], validate_on_init: bool, dc_cls_doc: Optional[str] = None, ) -> None: """ We need to replace the right method. If no `__post_init__` has been set in the stdlib dataclass it won't even exist (code is generated on the fly by `dataclasses`) By default, we run validation after `__init__` or `__post_init__` if defined """ if hasattr(dc_cls, '__post_init__'): init = dc_cls.__init__ post_init = dc_cls.__post_init__ @wraps(init) def new_init( self: 'Dataclass', *args: Any, __pydantic_run_validation__: bool = validate_on_init, **kwargs: Any ) -> None: self.__post_init__ = partial( # type: ignore[assignment] self.__post_init__, __pydantic_run_validation__=__pydantic_run_validation__ ) init(self, *args, **kwargs) @wraps(post_init) def new_post_init( self: 'Dataclass', *args: Any, __pydantic_run_validation__: bool = validate_on_init, **kwargs: Any ) -> None: post_init(self, *args, **kwargs) if __pydantic_run_validation__: self.__pydantic_validate_values__() if hasattr(self, '__post_init_post_parse__'): self.__post_init_post_parse__(*args, **kwargs) setattr(dc_cls, '__init__', new_init) setattr(dc_cls, '__post_init__', new_post_init) else: init = dc_cls.__init__ @wraps(init) def new_init( self: 'Dataclass', *args: Any, __pydantic_run_validation__: bool = validate_on_init, **kwargs: Any ) -> None: init(self, *args, **kwargs) if __pydantic_run_validation__: self.__pydantic_validate_values__() if hasattr(self, '__post_init_post_parse__'): # We need to find again the initvars. To do that we use `__dataclass_fields__` instead of # public method `dataclasses.fields` import dataclasses # get all initvars and their default values initvars_and_values: Dict[str, Any] = {} for i, f in enumerate(self.__class__.__dataclass_fields__.values()): if f._field_type is dataclasses._FIELD_INITVAR: # type: ignore[attr-defined] try: # set arg value by default initvars_and_values[f.name] = args[i] except IndexError: initvars_and_values[f.name] = f.default initvars_and_values.update(kwargs) self.__post_init_post_parse__(**initvars_and_values) setattr(dc_cls, '__init__', new_init) setattr(dc_cls, '__processed__', ClassAttribute('__processed__', True)) setattr(dc_cls, '__pydantic_initialised__', False) setattr(dc_cls, '__pydantic_model__', create_pydantic_model_from_dataclass(dc_cls, config, dc_cls_doc)) setattr(dc_cls, '__pydantic_validate_values__', _dataclass_validate_values) setattr(dc_cls, '__validate__', classmethod(_validate_dataclass)) setattr(dc_cls, '__get_validators__', classmethod(_get_validators)) if dc_cls.__pydantic_model__.__config__.validate_assignment and not dc_cls.__dataclass_params__.frozen: setattr(dc_cls, '__setattr__', _dataclass_validate_assignment_setattr)
def _add_pydantic_validation_attributes( dc_cls: Type['Dataclass'], config: Optional[Type['BaseConfig']], validate_on_init: bool, dc_cls_doc: str, ) -> None: """ We need to replace the right method. If no `__post_init__` has been set in the stdlib dataclass it won't even exist (code is generated on the fly by `dataclasses`) By default, we run validation after `__init__` or `__post_init__` if defined """ if hasattr(dc_cls, '__post_init__'): init = dc_cls.__init__ post_init = dc_cls.__post_init__ @wraps(init) def new_init( self: 'Dataclass', *args: Any, __pydantic_run_validation__: bool = validate_on_init, **kwargs: Any ) -> None: self.__post_init__ = partial( # type: ignore[assignment] self.__post_init__, __pydantic_run_validation__=__pydantic_run_validation__ ) init(self, *args, **kwargs) @wraps(post_init) def new_post_init( self: 'Dataclass', *args: Any, __pydantic_run_validation__: bool = validate_on_init, **kwargs: Any ) -> None: post_init(self, *args, **kwargs) if __pydantic_run_validation__: self.__pydantic_validate_values__() if hasattr(self, '__post_init_post_parse__'): self.__post_init_post_parse__(*args, **kwargs) setattr(dc_cls, '__init__', new_init) setattr(dc_cls, '__post_init__', new_post_init) else: init = dc_cls.__init__ @wraps(init) def new_init( self: 'Dataclass', *args: Any, __pydantic_run_validation__: bool = validate_on_init, **kwargs: Any ) -> None: init(self, *args, **kwargs) if __pydantic_run_validation__: self.__pydantic_validate_values__() if hasattr(self, '__post_init_post_parse__'): # We need to find again the initvars. To do that we use `__dataclass_fields__` instead of # public method `dataclasses.fields` import dataclasses # get all initvars and their default values initvars_and_values: Dict[str, Any] = {} for i, f in enumerate(self.__class__.__dataclass_fields__.values()): if f._field_type is dataclasses._FIELD_INITVAR: # type: ignore[attr-defined] try: # set arg value by default initvars_and_values[f.name] = args[i] except IndexError: initvars_and_values[f.name] = f.default initvars_and_values.update(kwargs) self.__post_init_post_parse__(**initvars_and_values) setattr(dc_cls, '__init__', new_init) setattr(dc_cls, '__processed__', ClassAttribute('__processed__', True)) setattr(dc_cls, '__pydantic_initialised__', False) setattr(dc_cls, '__pydantic_model__', create_pydantic_model_from_dataclass(dc_cls, config, dc_cls_doc)) setattr(dc_cls, '__pydantic_validate_values__', _dataclass_validate_values) setattr(dc_cls, '__validate__', classmethod(_validate_dataclass)) setattr(dc_cls, '__get_validators__', classmethod(_get_validators)) if dc_cls.__pydantic_model__.__config__.validate_assignment and not dc_cls.__dataclass_params__.frozen: setattr(dc_cls, '__setattr__', _dataclass_validate_assignment_setattr)
14,877
def setup_schluter(hass, config, api, authenticator): """Set up the Schluter component.""" authentication = None try: authentication = authenticator.authenticate() except RequestException as ex: _LOGGER.error("Unable to connect to Schluter service: %s", str(ex)) hass.components.persistent_notification.create( "Error: {}<br />" "You will need to restart hass after fixing." "".format(ex), title=NOTIFICATION_TITLE, notification_id=NOTIFICATION_ID, ) state = authentication.state if state == AuthenticationState.AUTHENTICATED: hass.data[DATA_SCHLUTER] = SchluterData(hass, api, authentication.session_id) for component in PLATFORMS: discovery.load_platform(hass, component, DOMAIN, {}, config) return True if state == AuthenticationState.BAD_PASSWORD: _LOGGER.error("Invalid password provided") return False if state == AuthenticationState.BAD_EMAIL: _LOGGER.error("Invalid email provided") return False return False
def setup_schluter(hass, config, api, authenticator): """Set up the Schluter component.""" authentication = None try: authentication = authenticator.authenticate() except RequestException as ex: _LOGGER.error("Unable to connect to Schluter service: %s", ex) hass.components.persistent_notification.create( "Error: {}<br />" "You will need to restart hass after fixing." "".format(ex), title=NOTIFICATION_TITLE, notification_id=NOTIFICATION_ID, ) state = authentication.state if state == AuthenticationState.AUTHENTICATED: hass.data[DATA_SCHLUTER] = SchluterData(hass, api, authentication.session_id) for component in PLATFORMS: discovery.load_platform(hass, component, DOMAIN, {}, config) return True if state == AuthenticationState.BAD_PASSWORD: _LOGGER.error("Invalid password provided") return False if state == AuthenticationState.BAD_EMAIL: _LOGGER.error("Invalid email provided") return False return False
5,124
def test_no_definintion(): fig = Figure() axs = fig.subplots(4, 4, subplot_kw=dict(projection="polar")) for ax in axs.flat: ax.set(xticks=[], yticks=[]) ax.plot([1, 2]) fig.suptitle("hello, world") buf = io.StringIO() fig.savefig(buf, format='eps') buf.seek(0) wds = [ln.partition(' ')[0] for ln in buf.readlines() if ln.startswith('/')] assert max(Counter(wds).values()) == 1
def test_no_duplicate_definition(): fig = Figure() axs = fig.subplots(4, 4, subplot_kw=dict(projection="polar")) for ax in axs.flat: ax.set(xticks=[], yticks=[]) ax.plot([1, 2]) fig.suptitle("hello, world") buf = io.StringIO() fig.savefig(buf, format='eps') buf.seek(0) wds = [ln.partition(' ')[0] for ln in buf.readlines() if ln.startswith('/')] assert max(Counter(wds).values()) == 1
21,247
def _argparse_volumes(volumes_arg: str) -> List: """Custom argparse handling for volumes :param volumes_arg: The volume argparse for harvard imports :return: Range of values """ if ":" not in volumes_arg: return [volumes_arg] volumes = [int(e) if e.strip() else 2000 for e in volumes_arg.split(":")] if len(volumes) == 1: start = stop = volumes[0] else: start, stop = volumes[0], volumes[1] + 1 return [*range(start, stop)]
def _argparse_volumes(volumes_arg: str) -> List: """Custom argparse handling for volumes :param volumes_arg: The volume argparse for harvard imports :return: Range of values """ if ":" not in volumes_arg: return [volumes_arg] volumes = [int(e) if e.strip() else 2000 for e in volumes_arg.split(":")] if len(volumes) == 1: start = stop = volumes[0] else: start, stop = volumes[0], volumes[1] + 1 return list(range(start, stop))
7,637
def digest_file(fpath, hash_algo: str): """ Reads and digests a file according to specified hashing-algorith. :param hash_algo: any algo contained in :mod:`hashlib` :return: <hash_algo>=<hex_digest> From http://stackoverflow.com/a/21565932/548792 """ blocksize = 2 ** 16 digester = getattr(hashlib, hash_algo)() with open(fpath, "rb") as f: for block in iter(lambda: f.read(blocksize), b""): digester.update(block) return f"{hash_algo}={digester.hexdigest()}"
def digest_file(fpath, hash_algo: str): """ Reads and digests a file according to specified hashing-algorith. :param hash_algo: any algo contained in :mod:`hashlib` :return: <hash_algo>=<hex_digest> From http://stackoverflow.com/a/21565932/548792 """ blocksize = 2 ** 16 digester = hashlib.new(hash_algo) with open(fpath, "rb") as f: for block in iter(lambda: f.read(blocksize), b""): digester.update(block) return f"{hash_algo}={digester.hexdigest()}"
30,294
def add_tag_to_model(model_id, tags, model="intelligence"): """ Adds tag to specific Threat Model. By default is set to intelligence (indicators). """ data = { 'tags': [{'name': t.strip(), 'tlp': 'red'} for t in tags.split(',')] } res = http_request("POST", F"v1/{model}/{model_id}/tag/", params=CREDENTIALS, data=json.dumps(data)) if str(res.get('success', '')).lower() == 'true': return_outputs(F"Added successfully tags: {tags} to {model} with {model_id}", None, res) else: return_outputs(F"Failed to add {tags} to {model} with {model_id}", None, res)
def add_tag_to_model(model_id='', tags=None, model="intelligence"): """ Adds tag to specific Threat Model. By default is set to intelligence (indicators). """ data = { 'tags': [{'name': t.strip(), 'tlp': 'red'} for t in tags.split(',')] } res = http_request("POST", F"v1/{model}/{model_id}/tag/", params=CREDENTIALS, data=json.dumps(data)) if str(res.get('success', '')).lower() == 'true': return_outputs(F"Added successfully tags: {tags} to {model} with {model_id}", None, res) else: return_outputs(F"Failed to add {tags} to {model} with {model_id}", None, res)
12,279
def save_qasm(qc, file_loc): ''' Save QASM output of circuit object to file. Parameters ---------- qc: QubitCircuit circuit object to produce QASM output for. ''' qasm_out = QasmOutput("2.0") lines = qasm_out._qasm_output(qc) with open(file_loc, "w") as f: for line in lines: f.write("{}\n".format(line))
def save_qasm(qc, file_loc): ''' Save QASM output of circuit object to file. Parameters ---------- qc: :class:`.QubitCircuit` circuit object to produce QASM output for. ''' qasm_out = QasmOutput("2.0") lines = qasm_out._qasm_output(qc) with open(file_loc, "w") as f: for line in lines: f.write("{}\n".format(line))
32,569
def filter_dict_null(d): if isinstance(d, dict): return dict((k, v) for k, v in list(d.items()) if v is not None) return d
def filter_dict_null(d): if isinstance(d, dict): return {k: v for k, v in d.items() if v is not None} return d
59,821
def create_signature_help(response: Optional[dict]) -> Optional[SignatureHelp]: if response is None: return None raw_signatures = response.get("signatures") signatures = [] if isinstance(raw_signatures, list): signatures = [parse_signature_information(signature) for signature in raw_signatures] if signatures: active_signature = response.get("activeSignature", -1) active_parameter = response.get("activeParameter", -1) if not 0 <= active_signature < len(signatures): debug("activeSignature {} not a valid index for signatures length {}".format( active_signature, len(signatures))) active_signature = 0 return SignatureHelp(signatures, active_signature, active_parameter) return None
def create_signature_help(response: Optional[dict]) -> Optional[SignatureHelp]: if response is None: return None signatures = response.get("signatures") or [] signatures = [parse_signature_information(signature) for signature in signatures] if signatures: active_signature = response.get("activeSignature", -1) active_parameter = response.get("activeParameter", -1) if not 0 <= active_signature < len(signatures): debug("activeSignature {} not a valid index for signatures length {}".format( active_signature, len(signatures))) active_signature = 0 return SignatureHelp(signatures, active_signature, active_parameter) return None
31,794
def item_to_incident(item): if not (occured := item.get('timestamp_occured_iso8601')): occured = convert_timestamp_to_iso86( item.get('timestamp_occured', ''), item.get("time_offset", 'Z') ) incident = { 'Type': 'AlienVault USM', 'name': 'Alarm: ' + item.get('uuid'), 'occurred': occured, 'rawJSON': json.dumps(item), } return incident
def item_to_incident(item): if not (occured := item.get('timestamp_occured_iso8601')): occured = convert_timestamp_to_iso86( item.get('timestamp_occured', ''), item.get("time_offset", 'Z') ) incident = { 'Type': 'AlienVault USM', 'name': 'Alarm: ' + item.get('uuid'), 'occurred': occurred, 'rawJSON': json.dumps(item), } return incident
13,657
def _post_processing(samples, svs, itpl_part, d_nsp, L_rk_tol): """Compute coefficients/partition to construct minimal interpolant.""" num_vars = len(svs) max_idx = np.argmax([*(len(ip) for ip in itpl_part)]) max_rks = [] for i in range(num_vars): max_rk = 0 # we don't need to compute this max rank since we exploit nullspace structure if i == max_idx: max_rks.append(len(itpl_part[max_idx])-1) continue shapes = [] for j in range(num_vars): if i != j: shapes.append(samples.shape[j]) # compute max ranks of all possible 1-D Loewner matrices for idc in itertools.product(*(range(s) for s in shapes)): l_idc = list(idc) l_idc.insert(i, slice(None)) L = nd_loewner(samples[tuple(l_idc)], [svs[i]], [itpl_part[i]]) rk = np.linalg.matrix_rank(L, tol=L_rk_tol) if rk > max_rk: max_rk = rk max_rks.append(max_rk) # exploit nullspace structure to obtain final max rank denom = np.prod([*(len(itpl_part[k])-max_rks[k] for k in range(len(itpl_part)))]) if denom == 0 or d_nsp % denom != 0: return None, None max_rks[max_idx] = len(itpl_part[max_idx]) - d_nsp / denom max_rks[max_idx] = round(max_rks[max_idx]) for i in range(len(max_rks)): itpl_part[i] = itpl_part[i][0:max_rks[i]+1] # solve LS problem L = full_nd_loewner(samples, svs, itpl_part) _, S, V = np.linalg.svd(L) VH = np.conj(V.T) coefs = VH[:, -1:] return coefs, itpl_part
def _post_processing(samples, svs, itpl_part, d_nsp, L_rk_tol): """Compute coefficients/partition to construct minimal interpolant.""" num_vars = len(svs) max_idx = np.argmax([*(len(ip) for ip in itpl_part)]) max_rks = [] for i in range(num_vars): max_rk = 0 # we don't need to compute this max rank since we exploit nullspace structure if i == max_idx: max_rks.append(len(itpl_part[max_idx])-1) continue shapes = [] for j in range(num_vars): if i != j: shapes.append(samples.shape[j]) # compute max ranks of all possible 1-D Loewner matrices for idc in itertools.product(*(range(s) for s in shapes)): l_idc = list(idc) l_idc.insert(i, slice(None)) L = nd_loewner(samples[tuple(l_idc)], [svs[i]], [itpl_part[i]]) rk = np.linalg.matrix_rank(L, tol=L_rk_tol) if rk > max_rk: max_rk = rk max_rks.append(max_rk) # exploit nullspace structure to obtain final max rank denom = np.prod([len(itpl_part[k])-max_rks[k] for k in range(len(itpl_part))]) if denom == 0 or d_nsp % denom != 0: return None, None max_rks[max_idx] = len(itpl_part[max_idx]) - d_nsp / denom max_rks[max_idx] = round(max_rks[max_idx]) for i in range(len(max_rks)): itpl_part[i] = itpl_part[i][0:max_rks[i]+1] # solve LS problem L = full_nd_loewner(samples, svs, itpl_part) _, S, V = np.linalg.svd(L) VH = np.conj(V.T) coefs = VH[:, -1:] return coefs, itpl_part
57,779
def main(): try: indicator = demisto.args()['indicator'] resp = demisto.executeCommand("getIndicator", {'value': indicator}) if isError(resp) or not resp: demisto.results(resp) sys.exit(0) data = resp[0].get("Contents") if not data: demisto.results("No results.") sys.exit(0) for entry in data: for results, outputs in iterate_indicator_entry(indicator, entry): return_results(results) appendContext(DbotScoreKey, outputs) except Exception as error: return_error(str(error), error)
def main(): try: indicator = demisto.args()['indicator'] resp = demisto.executeCommand("getIndicator", {'value': indicator}) if isError(resp) or not resp: demisto.results(resp) sys.exit(0) data = resp[0].get("Contents") if not data: demisto.results("No results.") sys.exit(0) for entry in data: for results, dbot_score in iterate_indicator_entry(indicator, entry): return_results(results) appendContext(DbotScoreKey, dbot_score) for dbot_score, results in iterate_indicator_entry(indicator, entry): return_results(results) appendContext(DbotScoreKey, dbot_score) except Exception as error: return_error(str(error), error)
58,888
def csys(self, kcn="", **kwargs): """Activates a previously defined coordinate system. APDL Command: CSYS Parameters ---------- kcn Specifies the active coordinate system, as follows: 0 (default) - Cartesian 1 - Cylindrical with global Cartesian Z as the axis of rotation 2 - Spherical 4 or WP - Working Plane 5 - Cylindrical with global Cartesian Y as the axis of rotation 11 or greater - Any previously defined local coordinate system Notes ----- The CSYS command activates a previously defined coordinate system for geometry input and generation. The LOCAL, CLOCAL, CS, CSKP, and CSWPLA commands also activate coordinate systems as they are defined. To set the active element coordinate system attribute pointer, issue the ESYS command. The active coordinate system for files created via the CDWRITE command is Cartesian >>> mapdl.csys(0) This command is valid in any processor. >>> mapdl.csys(4) >>> # or >>> mapdl.csys('WP') activates working plane tracking, which updates the coordinate system to follow working plane changes. To deactivate working plane tracking, activate any other coordinate system. >>> mapdl.csys(5) is a cylindrical coordinate system with global Cartesian Y as the axis. The local x, y and z axes are radial, θ, and axial (respectively). The R-Theta plane is the global X-Z plane, as it is for an axisymmetric model. Thus, at `θ = 0.0`, `mapdl.csys(5)` has a specific orientation: the local x is in the global +X direction, local y is in the global -Z direction, and local z (the cylindrical axis) is in the global +Y direction. Examples -------- Suppose we want to create a cylindrical surface in cylindrical y (5) with a radius of 6 and spanning `30 < θ < -90` and `0 < z < 4` >>> mapdl.csys(5) >>> mapdl.k(1, 6, 30) >>> mapdl.k(2, 6, -90) >>> mapdl.k(3, 6, -90, 4) >>> mapdl.k(4, 6, 30, 4) >>> mapdl.a(1, 2, 3, 4) >>> mapdl.aplot() """ command = "CSYS,%s" % (str(kcn)) return self.run(command, **kwargs)
def csys(self, kcn="", **kwargs): """Activates a previously defined coordinate system. APDL Command: CSYS Parameters ---------- kcn Specifies the active coordinate system, as follows: 0 (default) - Cartesian 1 - Cylindrical with global Cartesian Z as the axis of rotation 2 - Spherical 4 or WP - Working Plane 5 - Cylindrical with global Cartesian Y as the axis of rotation 11 or greater - Any previously defined local coordinate system Notes ----- The CSYS command activates a previously defined coordinate system for geometry input and generation. The LOCAL, CLOCAL, CS, CSKP, and CSWPLA commands also activate coordinate systems as they are defined. To set the active element coordinate system attribute pointer, issue the ESYS command. The active coordinate system for files created via the CDWRITE command is Cartesian >>> mapdl.csys(0) This command is valid in any processor. >>> mapdl.csys(4) >>> # or >>> mapdl.csys('WP') activates working plane tracking, which updates the coordinate system to follow working plane changes. To deactivate working plane tracking, activate any other coordinate system. >>> mapdl.csys(5) is a cylindrical coordinate system with global Cartesian Y as the axis. The local x, y and z axes are radial, θ, and axial (respectively). The R-Theta plane is the global X-Z plane, as it is for an axisymmetric model. Thus, at `θ = 0.0`, `mapdl.csys(5)` has a specific orientation: the local x is in the global +X direction, local y is in the global -Z direction, and local z (the cylindrical axis) is in the global +Y direction. Examples -------- Create a cylindrical surface in cylindrical y (CSYS=5) with a radius of 6 and spanning `30 < θ < -90` and `0 < z < 4`. >>> mapdl.csys(5) >>> mapdl.k(1, 6, 30) >>> mapdl.k(2, 6, -90) >>> mapdl.k(3, 6, -90, 4) >>> mapdl.k(4, 6, 30, 4) >>> mapdl.a(1, 2, 3, 4) >>> mapdl.aplot() """ command = "CSYS,%s" % (str(kcn)) return self.run(command, **kwargs)
41,701
def test_generate_packages_json(tmp_path): # Set up directory to store dummy package files for SHA-256 hash verification if not os.path.exists(tmp_path): os.makedirs(tmp_path) pkg_map = buildall.generate_dependency_graph(PACKAGES_DIR, {"pkg_1", "pkg_2"}) for pkg in pkg_map.values(): pkg.file_name = pkg.file_name or pkg.name + ".file" # Write dummy package file for SHA-256 hash verification with open(os.path.join(tmp_path, pkg.file_name), "w") as f: f.write(pkg.name) package_data = buildall.generate_packages_json(tmp_path, pkg_map) assert set(package_data.keys()) == {"info", "packages"} assert package_data["info"] == {"arch": "wasm32", "platform": "Emscripten-1.0"} assert set(package_data["packages"]) == { "pkg_1", "pkg_1_1", "pkg_2", "pkg_3", "pkg_3_1", } assert package_data["packages"]["pkg_1"] == { "name": "pkg_1", "version": "1.0.0", "file_name": "pkg_1.file", "depends": ["pkg_1_1", "pkg_3"], "imports": ["pkg_1"], "install_dir": "site", "sha_256": "c1e38241013b5663e902fff97eb8585e98e6df446585da1dcf2ad121b52c2143", }
def test_generate_packages_json(tmp_path): """Set up directory to store dummy package files for SHA-256 hash verification""" pkg_map = buildall.generate_dependency_graph(PACKAGES_DIR, {"pkg_1", "pkg_2"}) for pkg in pkg_map.values(): pkg.file_name = pkg.file_name or pkg.name + ".file" # Write dummy package file for SHA-256 hash verification with open(os.path.join(tmp_path, pkg.file_name), "w") as f: f.write(pkg.name) package_data = buildall.generate_packages_json(tmp_path, pkg_map) assert set(package_data.keys()) == {"info", "packages"} assert package_data["info"] == {"arch": "wasm32", "platform": "Emscripten-1.0"} assert set(package_data["packages"]) == { "pkg_1", "pkg_1_1", "pkg_2", "pkg_3", "pkg_3_1", } assert package_data["packages"]["pkg_1"] == { "name": "pkg_1", "version": "1.0.0", "file_name": "pkg_1.file", "depends": ["pkg_1_1", "pkg_3"], "imports": ["pkg_1"], "install_dir": "site", "sha_256": "c1e38241013b5663e902fff97eb8585e98e6df446585da1dcf2ad121b52c2143", }
3,208
def in_iexact(column, values): """Operator to test if any of the given values are (case-insensitively) matching to values in the given column.""" from operator import or_ query = u"{}__iexact".format(column) return reduce(or_, [Q(**{query: v}) for v in values])
def in_iexact(column, values): """Operator to test if any of the given values are (case-insensitive) matching to values in the given column.""" from operator import or_ query = u"{}__iexact".format(column) return reduce(or_, [Q(**{query: v}) for v in values])
13,038
def parse_description_json_field(apps, schema): Category = apps.get_model("product", "Category") for category in Category.objects.iterator(): category.description_plaintext = parse_draftjs_content_to_string( category.description ) category.save()
def parse_description_json_field(apps, schema): Category = apps.get_model("product", "Category") for category in Category.objects.iterator(): category.description_plaintext = parse_draftjs_content_to_string( category.description ) category.save(update_fields=["description_plaintext"])
26,628
def string_comma_to_list(message: str) -> List[str]: """ Split string to list """ if not message: return [] return message.split(",")
def string_comma_to_list(message: str) -> List[str]: """ Split string to list """ if not message: return [] return message.split(",") if message else []
31,163
def create_alert(display_name: str, attributes=None): """ Create an alert using IdentityIQ SCIM API's. Command: identityiq-create-alert :type display_name: ``str`` :param display_name: Display name of the alert. :type attributes: ``JSON`` :param attributes: List of JSON objects with the following structure. [ { 'key': '', 'value': '', 'type': '' } ] :return: Newly created alert object (JSON). """ if display_name is None: return None data = { 'displayName': display_name, 'type': 'PAN XSOAR', 'attributes': attributes } return send_request(IIQ_SCIM_ALERTS_URL, "POST", json.dumps(data))
def create_alert(display_name: str, attributes=None): """ Create an alert using IdentityIQ SCIM API's. Command: identityiq-create-alert :type display_name: ``str`` :param display_name: Display name of the alert. :type attributes: ``list`` :param attributes: List of JSON objects with the following structure. [ { 'key': '', 'value': '', 'type': '' } ] :return: Newly created alert object (JSON). """ if display_name is None: return None data = { 'displayName': display_name, 'type': 'PAN XSOAR', 'attributes': attributes } return send_request(IIQ_SCIM_ALERTS_URL, "POST", json.dumps(data))
37,044
def _text_checker(job, interval, _interval_set=False, quiet=False, to_file=None): """A text-based job status checker Args: job (BaseJob): The job to check. interval (int): The interval at which to check. _interval_set (bool): Was interval time set by user? quiet (bool): If True, do not print status messages. to_file (file): If file print status messages to it, else to stdout. """ _outstream = to_file if to_file else sys.stdout status = job.status() msg = status.value prev_msg = msg msg_len = len(msg) if not quiet: print('\r%s: %s' % ('Job Status', msg), end='', file=_outstream) while status.name not in ['DONE', 'CANCELLED', 'ERROR']: time.sleep(interval) status = job.status() msg = status.value if status.name == 'QUEUED': msg += ' (%s)' % job.queue_position() if not _interval_set: interval = max(job.queue_position(), 2) else: if not _interval_set: interval = 2 # Adjust length of message so there are no artifacts if len(msg) < msg_len: msg += ' ' * (msg_len - len(msg)) elif len(msg) > msg_len: msg_len = len(msg) if msg != prev_msg and not quiet: print('\r%s: %s' % ('Job Status', msg), end='', file=_outstream) prev_msg = msg if not quiet: print('', file=_outstream)
def _text_checker(job, interval, _interval_set=False, quiet=False, to_file=None): """A text-based job status checker Args: job (BaseJob): The job to check. interval (int): The interval at which to check. _interval_set (bool): Was interval time set by user? quiet (bool): If True, do not print status messages. output (file): The file like object to write status messages to. By default this is sys.stdout. """ _outstream = to_file if to_file else sys.stdout status = job.status() msg = status.value prev_msg = msg msg_len = len(msg) if not quiet: print('\r%s: %s' % ('Job Status', msg), end='', file=_outstream) while status.name not in ['DONE', 'CANCELLED', 'ERROR']: time.sleep(interval) status = job.status() msg = status.value if status.name == 'QUEUED': msg += ' (%s)' % job.queue_position() if not _interval_set: interval = max(job.queue_position(), 2) else: if not _interval_set: interval = 2 # Adjust length of message so there are no artifacts if len(msg) < msg_len: msg += ' ' * (msg_len - len(msg)) elif len(msg) > msg_len: msg_len = len(msg) if msg != prev_msg and not quiet: print('\r%s: %s' % ('Job Status', msg), end='', file=_outstream) prev_msg = msg if not quiet: print('', file=_outstream)
47,964
def draw_detections(frame, detections, palette, labels, threshold): size = frame.shape[:2] for detection in detections: if detection.score > threshold: xmin = max(int(detection.xmin), 0) ymin = max(int(detection.ymin), 0) xmax = min(int(detection.xmax), size[1]) ymax = min(int(detection.ymax), size[0]) class_id = int(detection.id) color = palette[class_id] det_label = labels[class_id] if labels and len(labels) >= class_id else '#{}'.format(class_id) cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), color, 2) cv2.putText(frame, '{} {:.1%}'.format(det_label, detection.score), (xmin, ymin - 7), cv2.FONT_HERSHEY_COMPLEX, 0.6, color, 1) if isinstance(detection, models.DetectionWithLandmarks): for landmark in detection.landmarks: cv2.circle(frame, (int(landmark[0]), int(landmark[1])), 2, (0, 255, 255), 2) y_scale, x_scale = [i / j for i, j in zip(size, (720, 1280))] scale = max(x_scale, y_scale, 1) frame = cv2.resize(frame, (int(size[1]/scale), int(size[0]/scale))) return frame
def draw_detections(frame, detections, palette, labels, threshold): size = frame.shape[:2] for detection in detections: if detection.score > threshold: xmin = max(int(detection.xmin), 0) ymin = max(int(detection.ymin), 0) xmax = min(int(detection.xmax), size[1]) ymax = min(int(detection.ymax), size[0]) class_id = int(detection.id) color = palette[class_id] det_label = labels[class_id] if labels and len(labels) >= class_id else '#{}'.format(class_id) cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), color, 2) cv2.putText(frame, '{} {:.1%}'.format(det_label, detection.score), (xmin, ymin - 7), cv2.FONT_HERSHEY_COMPLEX, 0.6, color, 1) if isinstance(detection, models.DetectionWithLandmarks): for landmark in detection.landmarks: cv2.circle(frame, (int(landmark[0]), int(landmark[1])), 2, (0, 255, 255), 2) scale = max(size[0] / 720, size[1] / 1280) frame = cv2.resize(frame, (int(size[1]/scale), int(size[0]/scale))) return frame
32,332
def split_context_path(path: str) -> Tuple[List[str], str]: """ Split a context path separated by a dot with a replacement name following a comma into the key tree the replacement name. :param path: The context path (with a optional replacement name) :return: The key tree and the replacement name. """ key_tree = [] key = [] itr = iter(path) for c in itr: if c == '\\': try: key.append(next(itr)) except StopIteration: key.append('\\') elif c == '.': key_tree.append(''.join(key)) key = [] else: key.append(c) names = ''.join(key).rsplit(',', 1) if len(names) == 2: key_tree.append(names[0]) return key_tree, names[1] elif len(names) == 1: key_tree.append(names[0]) return key_tree, names[0] else: raise ValueError(f'Invalid path: {path}')
def split_context_path(path: str) -> Tuple[List[str], str]: """ Split a context path separated by a dot with a replacement name following a comma into the key tree the replacement name. :param path: The context path (with an optional replacement name) :return: The key tree and the replacement name. """ key_tree = [] key = [] itr = iter(path) for c in itr: if c == '\\': try: key.append(next(itr)) except StopIteration: key.append('\\') elif c == '.': key_tree.append(''.join(key)) key = [] else: key.append(c) names = ''.join(key).rsplit(',', 1) if len(names) == 2: key_tree.append(names[0]) return key_tree, names[1] elif len(names) == 1: key_tree.append(names[0]) return key_tree, names[0] else: raise ValueError(f'Invalid path: {path}')
58,852
def _compile_with_cache_hip(source, options, arch, cache_dir, extra_source, backend='hiprtc', name_expressions=None, log_stream=None, cache_in_memory=False, use_converter=True): global _empty_file_preprocess_cache # TODO(leofang): this might be possible but is currently undocumented if _is_cudadevrt_needed(options): raise ValueError('separate compilation is not supported in HIP') # HIP's equivalent of -ftz=true, see ROCm-Developer-Tools/HIP#2252 # Notes: # - For hipcc, this should just work, as invalid options would cause errors # See https://clang.llvm.org/docs/ClangCommandLineReference.html. # - For hiprtc, this is a no-op until the compiler options like -D and -I # are accepted, see ROCm-Developer-Tools/HIP#2182 and # ROCm-Developer-Tools/HIP#2248 options += ('-fcuda-flush-denormals-to-zero',) # Workaround ROCm 4.3 LLVM_PATH issue in hipRTC #5689 rocm_build_version = driver.get_build_version() if rocm_build_version >= 40300000 and rocm_build_version < 40500000: options += ('-I' + get_rocm_path() + "/llvm/lib/clang/13.0.0/include/",) if cache_dir is None: cache_dir = get_cache_dir() # As of ROCm 3.5.0 hiprtc/hipcc can automatically pick up the # right arch without setting HCC_AMDGPU_TARGET, so we don't need # to tell the compiler which arch we are targeting. But, we still # need to know arch as part of the cache key: if arch is None: # On HIP, gcnArch is computed from "compute capability": # https://github.com/ROCm-Developer-Tools/HIP/blob/rocm-4.0.0/rocclr/hip_device.cpp#L202 arch = device.Device().compute_capability if use_converter: source = _convert_to_hip_source(source, extra_source, is_hiprtc=(backend == 'hiprtc')) env = (arch, options, _get_nvrtc_version(), backend) base = _empty_file_preprocess_cache.get(env, None) if base is None: # This is for checking HIPRTC/HIPCC compiler internal version if backend == 'hiprtc': base = _preprocess_hiprtc('', options) else: base = _preprocess_hipcc('', options) _empty_file_preprocess_cache[env] = base key_src = '%s %s %s %s' % (env, base, source, extra_source) key_src = key_src.encode('utf-8') name = '%s.hsaco' % hashlib.md5(key_src).hexdigest() mod = function.Module() if not cache_in_memory: # Read from disk cache if not os.path.isdir(cache_dir): os.makedirs(cache_dir, exist_ok=True) # To handle conflicts in concurrent situation, we adopt lock-free # method to avoid performance degradation. # We force recompiling to retrieve C++ mangled names if so desired. path = os.path.join(cache_dir, name) if os.path.exists(path) and not name_expressions: with open(path, 'rb') as f: data = f.read() if len(data) >= 32: hash_value = data[:32] binary = data[32:] binary_hash = hashlib.md5(binary).hexdigest().encode('ascii') if hash_value == binary_hash: mod.load(binary) return mod else: # Enforce compiling -- the resulting kernel will be cached elsewhere, # so we do nothing pass if backend == 'hiprtc': # compile_using_nvrtc calls hiprtc for hip builds binary, mapping = compile_using_nvrtc( source, options, arch, name + '.cu', name_expressions, log_stream, cache_in_memory) mod._set_mapping(mapping) else: binary = compile_using_hipcc(source, options, arch, log_stream) if not cache_in_memory: # Write to disk cache binary_hash = hashlib.md5(binary).hexdigest().encode('ascii') # shutil.move is not atomic operation, so it could result in a # corrupted file. We detect it by appending md5 hash at the beginning # of each cache file. If the file is corrupted, it will be ignored # next time it is read. with tempfile.NamedTemporaryFile(dir=cache_dir, delete=False) as tf: tf.write(binary_hash) tf.write(binary) temp_path = tf.name shutil.move(temp_path, path) # Save .cu source file along with .hsaco if _get_bool_env_variable('CUPY_CACHE_SAVE_CUDA_SOURCE', False): with open(path + '.cpp', 'w') as f: f.write(source) else: # we don't do any disk I/O pass mod.load(binary) return mod
def _compile_with_cache_hip(source, options, arch, cache_dir, extra_source, backend='hiprtc', name_expressions=None, log_stream=None, cache_in_memory=False, use_converter=True): global _empty_file_preprocess_cache # TODO(leofang): this might be possible but is currently undocumented if _is_cudadevrt_needed(options): raise ValueError('separate compilation is not supported in HIP') # HIP's equivalent of -ftz=true, see ROCm-Developer-Tools/HIP#2252 # Notes: # - For hipcc, this should just work, as invalid options would cause errors # See https://clang.llvm.org/docs/ClangCommandLineReference.html. # - For hiprtc, this is a no-op until the compiler options like -D and -I # are accepted, see ROCm-Developer-Tools/HIP#2182 and # ROCm-Developer-Tools/HIP#2248 options += ('-fcuda-flush-denormals-to-zero',) # Workaround ROCm 4.3 LLVM_PATH issue in hipRTC #5689 rocm_build_version = driver.get_build_version() if rocm_build_version >= 40300000 and rocm_build_version < 40500000: options += ( '-I' + get_rocm_path() + '/llvm/lib/clang/13.0.0/include/',) if cache_dir is None: cache_dir = get_cache_dir() # As of ROCm 3.5.0 hiprtc/hipcc can automatically pick up the # right arch without setting HCC_AMDGPU_TARGET, so we don't need # to tell the compiler which arch we are targeting. But, we still # need to know arch as part of the cache key: if arch is None: # On HIP, gcnArch is computed from "compute capability": # https://github.com/ROCm-Developer-Tools/HIP/blob/rocm-4.0.0/rocclr/hip_device.cpp#L202 arch = device.Device().compute_capability if use_converter: source = _convert_to_hip_source(source, extra_source, is_hiprtc=(backend == 'hiprtc')) env = (arch, options, _get_nvrtc_version(), backend) base = _empty_file_preprocess_cache.get(env, None) if base is None: # This is for checking HIPRTC/HIPCC compiler internal version if backend == 'hiprtc': base = _preprocess_hiprtc('', options) else: base = _preprocess_hipcc('', options) _empty_file_preprocess_cache[env] = base key_src = '%s %s %s %s' % (env, base, source, extra_source) key_src = key_src.encode('utf-8') name = '%s.hsaco' % hashlib.md5(key_src).hexdigest() mod = function.Module() if not cache_in_memory: # Read from disk cache if not os.path.isdir(cache_dir): os.makedirs(cache_dir, exist_ok=True) # To handle conflicts in concurrent situation, we adopt lock-free # method to avoid performance degradation. # We force recompiling to retrieve C++ mangled names if so desired. path = os.path.join(cache_dir, name) if os.path.exists(path) and not name_expressions: with open(path, 'rb') as f: data = f.read() if len(data) >= 32: hash_value = data[:32] binary = data[32:] binary_hash = hashlib.md5(binary).hexdigest().encode('ascii') if hash_value == binary_hash: mod.load(binary) return mod else: # Enforce compiling -- the resulting kernel will be cached elsewhere, # so we do nothing pass if backend == 'hiprtc': # compile_using_nvrtc calls hiprtc for hip builds binary, mapping = compile_using_nvrtc( source, options, arch, name + '.cu', name_expressions, log_stream, cache_in_memory) mod._set_mapping(mapping) else: binary = compile_using_hipcc(source, options, arch, log_stream) if not cache_in_memory: # Write to disk cache binary_hash = hashlib.md5(binary).hexdigest().encode('ascii') # shutil.move is not atomic operation, so it could result in a # corrupted file. We detect it by appending md5 hash at the beginning # of each cache file. If the file is corrupted, it will be ignored # next time it is read. with tempfile.NamedTemporaryFile(dir=cache_dir, delete=False) as tf: tf.write(binary_hash) tf.write(binary) temp_path = tf.name shutil.move(temp_path, path) # Save .cu source file along with .hsaco if _get_bool_env_variable('CUPY_CACHE_SAVE_CUDA_SOURCE', False): with open(path + '.cpp', 'w') as f: f.write(source) else: # we don't do any disk I/O pass mod.load(binary) return mod
58,621
def convert_ndarray_to_torch_tensor( ndarray: np.ndarray, dtype: Optional[torch.dtype] = None, device: Optional[str] = None, ) -> torch.Tensor: """Convert a NumPy ndarray to a Torch Tensor. Args: ndarray: A NumPy ndarray that we wish to convert to a Torch Tensor. dtype: A Torch dtype for the created tensor; if None, the dtype will be inferred from the NumPy ndarray data. Returns: A Torch Tensor. """ ndarray = _unwrap_ndarray_object_type_if_needed(ndarray) # NOTE: PyTorch raises a `UserWarning` if `ndarray` isn't writeable. See #28003. if not ndarray.flags["WRITEABLE"]: ndarray = np.copy(ndarray) return torch.as_tensor(ndarray, dtype=dtype, device=device)
def convert_ndarray_to_torch_tensor( ndarray: np.ndarray, dtype: Optional[torch.dtype] = None, device: Optional[str] = None, ) -> torch.Tensor: """Convert a NumPy ndarray to a Torch Tensor. Args: ndarray: A NumPy ndarray that we wish to convert to a Torch Tensor. dtype: A Torch dtype for the created tensor; if None, the dtype will be inferred from the NumPy ndarray data. Returns: A Torch Tensor. """ ndarray = _unwrap_ndarray_object_type_if_needed(ndarray) with warnings.catch_warnings(): warnings.simplefilter("ignore") tensor = torch.as_tensor(ndarray, dtype=dtype, device=device) return tensor
922
def substitution(system, symbols, result=[{}], known_symbols=[], exclude=[], all_symbols=None): r""" Solves the `system` using substitution method. It is used in :func:`~.nonlinsolve`. This will be called from :func:`~.nonlinsolve` when any equation(s) is non polynomial equation. Parameters ========== system : list of equations The target system of equations symbols : list of symbols to be solved. The variable(s) for which the system is solved known_symbols : list of solved symbols Values are known for these variable(s) result : An empty list or list of dict If No symbol values is known then empty list otherwise symbol as keys and corresponding value in dict. exclude : Set of expression. Mostly denominator expression(s) of the equations of the system. Final solution should not satisfy these expressions. all_symbols : known_symbols + symbols(unsolved). Returns ======= A FiniteSet of ordered tuple of values of `all_symbols` for which the `system` has solution. Order of values in the tuple is same as symbols present in the parameter `all_symbols`. If parameter `all_symbols` is None then same as symbols present in the parameter `symbols`. Please note that general FiniteSet is unordered, the solution returned here is not simply a FiniteSet of solutions, rather it is a FiniteSet of ordered tuple, i.e. the first & only argument to FiniteSet is a tuple of solutions, which is ordered, & hence the returned solution is ordered. Also note that solution could also have been returned as an ordered tuple, FiniteSet is just a wrapper `{}` around the tuple. It has no other significance except for the fact it is just used to maintain a consistent output format throughout the solveset. Raises ====== ValueError The input is not valid. The symbols are not given. AttributeError The input symbols are not :class:`~.Symbol` type. Examples ======== >>> from sympy.core.symbol import symbols >>> x, y = symbols('x, y', real=True) >>> from sympy.solvers.solveset import substitution >>> substitution([x + y], [x], [{y: 1}], [y], set([]), [x, y]) {(-1, 1)} * When you want soln should not satisfy eq $x + 1 = 0$ >>> substitution([x + y], [x], [{y: 1}], [y], set([x + 1]), [y, x]) EmptySet >>> substitution([x + y], [x], [{y: 1}], [y], set([x - 1]), [y, x]) {(1, -1)} >>> substitution([x + y - 1, y - x**2 + 5], [x, y]) {(-3, 4), (2, -1)} * Returns both real and complex solution >>> x, y, z = symbols('x, y, z') >>> from sympy import exp, sin >>> substitution([exp(x) - sin(y), y**2 - 4], [x, y]) {(ImageSet(Lambda(_n, I*(2*_n*pi + pi) + log(sin(2))), Integers), -2), (ImageSet(Lambda(_n, 2*_n*I*pi + log(sin(2))), Integers), 2)} >>> eqs = [z**2 + exp(2*x) - sin(y), -3 + exp(-y)] >>> substitution(eqs, [y, z]) {(-log(3), -sqrt(-exp(2*x) - sin(log(3)))), (-log(3), sqrt(-exp(2*x) - sin(log(3)))), (ImageSet(Lambda(_n, 2*_n*I*pi - log(3)), Integers), ImageSet(Lambda(_n, -sqrt(-exp(2*x) + sin(2*_n*I*pi - log(3)))), Integers)), (ImageSet(Lambda(_n, 2*_n*I*pi - log(3)), Integers), ImageSet(Lambda(_n, sqrt(-exp(2*x) + sin(2*_n*I*pi - log(3)))), Integers))} """ if not system: return S.EmptySet if not symbols: msg = ('Symbols must be given, for which solution of the ' 'system is to be found.') raise ValueError(filldedent(msg)) if not is_sequence(symbols): msg = ('symbols should be given as a sequence, e.g. a list.' 'Not type %s: %s') raise TypeError(filldedent(msg % (type(symbols), symbols))) if not getattr(symbols[0], 'is_Symbol', False): msg = ('Iterable of symbols must be given as ' 'second argument, not type %s: %s') raise ValueError(filldedent(msg % (type(symbols[0]), symbols[0]))) # By default `all_symbols` will be same as `symbols` if all_symbols is None: all_symbols = symbols old_result = result # storing complements and intersection for particular symbol complements = {} intersections = {} # when total_solveset_call equals total_conditionset # it means that solveset failed to solve all eqs. total_conditionset = -1 total_solveset_call = -1 def _unsolved_syms(eq, sort=False): """Returns the unsolved symbol present in the equation `eq`. """ free = eq.free_symbols unsolved = (free - set(known_symbols)) & set(all_symbols) if sort: unsolved = list(unsolved) unsolved.sort(key=default_sort_key) return unsolved # end of _unsolved_syms() # sort such that equation with the fewest potential symbols is first. # means eq with less number of variable first in the list. eqs_in_better_order = list( ordered(system, lambda _: len(_unsolved_syms(_)))) def add_intersection_complement(result, intersection_dict, complement_dict): # If solveset has returned some intersection/complement # for any symbol, it will be added in the final solution. final_result = [] for res in result: res_copy = res for key_res, value_res in res.items(): intersect_set, complement_set = None, None for key_sym, value_sym in intersection_dict.items(): if key_sym == key_res: intersect_set = value_sym for key_sym, value_sym in complement_dict.items(): if key_sym == key_res: complement_set = value_sym if intersect_set or complement_set: new_value = FiniteSet(value_res) if intersect_set and intersect_set != S.Complexes: new_value = Intersection(new_value, intersect_set) if complement_set: new_value = Complement(new_value, complement_set) if new_value is S.EmptySet: res_copy = None break elif new_value.is_FiniteSet and len(new_value) == 1: res_copy[key_res] = set(new_value).pop() else: res_copy[key_res] = new_value if res_copy is not None: final_result.append(res_copy) return final_result # end of def add_intersection_complement() def _extract_main_soln(sym, sol, soln_imageset): """Separate the Complements, Intersections, ImageSet lambda expr and its base_set. This function returns the unmasks sol from different classes of sets and also returns the appended ImageSet elements in a soln_imageset (dict: where key as unmasked element and value as ImageSet). """ # if there is union, then need to check # Complement, Intersection, Imageset. # Order should not be changed. if isinstance(sol, ConditionSet): # extracts any solution in ConditionSet sol = sol.base_set if isinstance(sol, Complement): # extract solution and complement complements[sym] = sol.args[1] sol = sol.args[0] # complement will be added at the end # using `add_intersection_complement` method # if there is union of Imageset or other in soln. # no testcase is written for this if block if isinstance(sol, Union): sol_args = sol.args sol = S.EmptySet # We need in sequence so append finteset elements # and then imageset or other. for sol_arg2 in sol_args: if isinstance(sol_arg2, FiniteSet): sol += sol_arg2 else: # ImageSet, Intersection, complement then # append them directly sol += FiniteSet(sol_arg2) if isinstance(sol, Intersection): # Interval/Set will be at 0th index always if sol.args[0] not in (S.Reals, S.Complexes): # Sometimes solveset returns soln with intersection # S.Reals or S.Complexes. We don't consider that # intersection. intersections[sym] = sol.args[0] sol = sol.args[1] # after intersection and complement Imageset should # be checked. if isinstance(sol, ImageSet): soln_imagest = sol expr2 = sol.lamda.expr sol = FiniteSet(expr2) soln_imageset[expr2] = soln_imagest if not isinstance(sol, FiniteSet): sol = FiniteSet(sol) return sol, soln_imageset # end of def _extract_main_soln() # helper function for _append_new_soln def _check_exclude(rnew, imgset_yes): rnew_ = rnew if imgset_yes: # replace all dummy variables (Imageset lambda variables) # with zero before `checksol`. Considering fundamental soln # for `checksol`. rnew_copy = rnew.copy() dummy_n = imgset_yes[0] for key_res, value_res in rnew_copy.items(): rnew_copy[key_res] = value_res.subs(dummy_n, 0) rnew_ = rnew_copy # satisfy_exclude == true if it satisfies the expr of `exclude` list. try: # something like : `Mod(-log(3), 2*I*pi)` can't be # simplified right now, so `checksol` returns `TypeError`. # when this issue is fixed this try block should be # removed. Mod(-log(3), 2*I*pi) == -log(3) satisfy_exclude = any( checksol(d, rnew_) for d in exclude) except TypeError: satisfy_exclude = None return satisfy_exclude # end of def _check_exclude() # helper function for _append_new_soln def _restore_imgset(rnew, original_imageset, newresult): restore_sym = set(rnew.keys()) & \ set(original_imageset.keys()) for key_sym in restore_sym: img = original_imageset[key_sym] rnew[key_sym] = img if rnew not in newresult: newresult.append(rnew) # end of def _restore_imgset() def _append_eq(eq, result, res, delete_soln, n=None): u = Dummy('u') if n: eq = eq.subs(n, 0) satisfy = eq if eq in (True, False) else checksol(u, u, eq, minimal=True) if satisfy is False: delete_soln = True res = {} else: result.append(res) return result, res, delete_soln def _append_new_soln(rnew, sym, sol, imgset_yes, soln_imageset, original_imageset, newresult, eq=None): """If `rnew` (A dict <symbol: soln>) contains valid soln append it to `newresult` list. `imgset_yes` is (base, dummy_var) if there was imageset in previously calculated result(otherwise empty tuple). `original_imageset` is dict of imageset expr and imageset from this result. `soln_imageset` dict of imageset expr and imageset of new soln. """ satisfy_exclude = _check_exclude(rnew, imgset_yes) delete_soln = False # soln should not satisfy expr present in `exclude` list. if not satisfy_exclude: local_n = None # if it is imageset if imgset_yes: local_n = imgset_yes[0] base = imgset_yes[1] if sym and sol: # when `sym` and `sol` is `None` means no new # soln. In that case we will append rnew directly after # substituting original imagesets in rnew values if present # (second last line of this function using _restore_imgset) dummy_list = list(sol.atoms(Dummy)) # use one dummy `n` which is in # previous imageset local_n_list = [ local_n for i in range( 0, len(dummy_list))] dummy_zip = zip(dummy_list, local_n_list) lam = Lambda(local_n, sol.subs(dummy_zip)) rnew[sym] = ImageSet(lam, base) if eq is not None: newresult, rnew, delete_soln = _append_eq( eq, newresult, rnew, delete_soln, local_n) elif eq is not None: newresult, rnew, delete_soln = _append_eq( eq, newresult, rnew, delete_soln) elif sol in soln_imageset.keys(): rnew[sym] = soln_imageset[sol] # restore original imageset _restore_imgset(rnew, original_imageset, newresult) else: newresult.append(rnew) elif satisfy_exclude: delete_soln = True rnew = {} _restore_imgset(rnew, original_imageset, newresult) return newresult, delete_soln # end of def _append_new_soln() def _new_order_result(result, eq): # separate first, second priority. `res` that makes `eq` value equals # to zero, should be used first then other result(second priority). # If it is not done then we may miss some soln. first_priority = [] second_priority = [] for res in result: if not any(isinstance(val, ImageSet) for val in res.values()): if eq.subs(res) == 0: first_priority.append(res) else: second_priority.append(res) if first_priority or second_priority: return first_priority + second_priority return result def _solve_using_known_values(result, solver): """Solves the system using already known solution (result contains the dict <symbol: value>). solver is :func:`~.solveset_complex` or :func:`~.solveset_real`. """ # stores imageset <expr: imageset(Lambda(n, expr), base)>. soln_imageset = {} total_solvest_call = 0 total_conditionst = 0 # sort such that equation with the fewest potential symbols is first. # means eq with less variable first for index, eq in enumerate(eqs_in_better_order): newresult = [] original_imageset = {} # if imageset expr is used to solve other symbol imgset_yes = False result = _new_order_result(result, eq) for res in result: got_symbol = set() # symbols solved in one iteration # find the imageset and use its expr. for key_res, value_res in res.items(): if isinstance(value_res, ImageSet): res[key_res] = value_res.lamda.expr original_imageset[key_res] = value_res dummy_n = value_res.lamda.expr.atoms(Dummy).pop() (base,) = value_res.base_sets imgset_yes = (dummy_n, base) # update eq with everything that is known so far eq2 = eq.subs(res).expand() unsolved_syms = _unsolved_syms(eq2, sort=True) if not unsolved_syms: if res: newresult, delete_res = _append_new_soln( res, None, None, imgset_yes, soln_imageset, original_imageset, newresult, eq2) if delete_res: # `delete_res` is true, means substituting `res` in # eq2 doesn't return `zero` or deleting the `res` # (a soln) since it staisfies expr of `exclude` # list. result.remove(res) continue # skip as it's independent of desired symbols depen1, depen2 = (eq2.rewrite(Add)).as_independent(*unsolved_syms) if (depen1.has(Abs) or depen2.has(Abs)) and solver == solveset_complex: # Absolute values cannot be inverted in the # complex domain continue soln_imageset = {} for sym in unsolved_syms: not_solvable = False try: soln = solver(eq2, sym) total_solvest_call += 1 soln_new = S.EmptySet if isinstance(soln, Complement): # separate solution and complement complements[sym] = soln.args[1] soln = soln.args[0] # complement will be added at the end if isinstance(soln, Intersection): # Interval will be at 0th index always if soln.args[0] != Interval(-oo, oo): # sometimes solveset returns soln # with intersection S.Reals, to confirm that # soln is in domain=S.Reals intersections[sym] = soln.args[0] soln_new += soln.args[1] soln = soln_new if soln_new else soln if index > 0 and solver == solveset_real: # one symbol's real soln, another symbol may have # corresponding complex soln. if not isinstance(soln, (ImageSet, ConditionSet)): soln += solveset_complex(eq2, sym) except NotImplementedError: # If sovleset is not able to solve equation `eq2`. Next # time we may get soln using next equation `eq2` continue if isinstance(soln, ConditionSet): if soln.base_set in (S.Reals, S.Complexes): soln = S.EmptySet # don't do `continue` we may get soln # in terms of other symbol(s) not_solvable = True total_conditionst += 1 else: soln = soln.base_set if soln is not S.EmptySet: soln, soln_imageset = _extract_main_soln( sym, soln, soln_imageset) for sol in soln: # sol is not a `Union` since we checked it # before this loop sol, soln_imageset = _extract_main_soln( sym, sol, soln_imageset) sol = set(sol).pop() free = sol.free_symbols if got_symbol and any( ss in free for ss in got_symbol ): # sol depends on previously solved symbols # then continue continue rnew = res.copy() # put each solution in res and append the new result # in the new result list (solution for symbol `s`) # along with old results. for k, v in res.items(): if isinstance(v, Expr) and isinstance(sol, Expr): # if any unsolved symbol is present # Then subs known value rnew[k] = v.subs(sym, sol) # and add this new solution if sol in soln_imageset.keys(): # replace all lambda variables with 0. imgst = soln_imageset[sol] rnew[sym] = imgst.lamda( *[0 for i in range(0, len( imgst.lamda.variables))]) else: rnew[sym] = sol newresult, delete_res = _append_new_soln( rnew, sym, sol, imgset_yes, soln_imageset, original_imageset, newresult) if delete_res: # deleting the `res` (a soln) since it staisfies # eq of `exclude` list result.remove(res) # solution got for sym if not not_solvable: got_symbol.add(sym) # next time use this new soln if newresult: result = newresult return result, total_solvest_call, total_conditionst # end def _solve_using_know_values() new_result_real, solve_call1, cnd_call1 = _solve_using_known_values( old_result, solveset_real) new_result_complex, solve_call2, cnd_call2 = _solve_using_known_values( old_result, solveset_complex) # If total_solveset_call is equal to total_conditionset # then solveset failed to solve all of the equations. # In this case we return a ConditionSet here. total_conditionset += (cnd_call1 + cnd_call2) total_solveset_call += (solve_call1 + solve_call2) if total_conditionset == total_solveset_call and total_solveset_call != -1: return _return_conditionset(eqs_in_better_order, all_symbols) # don't keep duplicate solutions filtered_complex = [] for i in list(new_result_complex): for j in list(new_result_real): if i.keys() != j.keys(): continue if all(a.dummy_eq(b) for a, b in zip(i.values(), j.values()) \ if type(a) != int or type(b) != int): break else: filtered_complex.append(i) # overall result result = new_result_real + filtered_complex result_all_variables = [] result_infinite = [] for res in result: if not res: # means {None : None} continue # If length < len(all_symbols) means infinite soln. # Some or all the soln is dependent on 1 symbol. # eg. {x: y+2} then final soln {x: y+2, y: y} if len(res) < len(all_symbols): solved_symbols = res.keys() unsolved = list(filter( lambda x: x not in solved_symbols, all_symbols)) for unsolved_sym in unsolved: res[unsolved_sym] = unsolved_sym result_infinite.append(res) if res not in result_all_variables: result_all_variables.append(res) if result_infinite: # we have general soln # eg : [{x: -1, y : 1}, {x : -y, y: y}] then # return [{x : -y, y : y}] result_all_variables = result_infinite if intersections or complements: result_all_variables = add_intersection_complement( result_all_variables, intersections, complements) # convert to ordered tuple result = S.EmptySet for r in result_all_variables: temp = [r[symb] for symb in all_symbols] result += FiniteSet(tuple(temp)) return result # end of def substitution()
def substitution(system, symbols, result=[{}], known_symbols=[], exclude=[], all_symbols=None): r""" Solves the `system` using substitution method. It is used in :func:`~.nonlinsolve`. This will be called from :func:`~.nonlinsolve` when any equation(s) is non polynomial equation. Parameters ========== system : list of equations The target system of equations symbols : list of symbols to be solved. The variable(s) for which the system is solved known_symbols : list of solved symbols Values are known for these variable(s) result : An empty list or list of dict If No symbol values is known then empty list otherwise symbol as keys and corresponding value in dict. exclude : Set of expression. Mostly denominator expression(s) of the equations of the system. Final solution should not satisfy these expressions. all_symbols : known_symbols + symbols(unsolved). Returns ======= A FiniteSet of ordered tuple of values of `all_symbols` for which the `system` has solution. Order of values in the tuple is same as symbols present in the parameter `all_symbols`. If parameter `all_symbols` is None then same as symbols present in the parameter `symbols`. Please note that general FiniteSet is unordered, the solution returned here is not simply a FiniteSet of solutions, rather it is a FiniteSet of ordered tuple, i.e. the first & only argument to FiniteSet is a tuple of solutions, which is ordered, & hence the returned solution is ordered. Also note that solution could also have been returned as an ordered tuple, FiniteSet is just a wrapper `{}` around the tuple. It has no other significance except for the fact it is just used to maintain a consistent output format throughout the solveset. Raises ====== ValueError The input is not valid. The symbols are not given. AttributeError The input symbols are not :class:`~.Symbol` type. Examples ======== >>> from sympy.core.symbol import symbols >>> x, y = symbols('x, y', real=True) >>> from sympy.solvers.solveset import substitution >>> substitution([x + y], [x], [{y: 1}], [y], set([]), [x, y]) {(-1, 1)} * When you want a soln not satisfying $x + 1 = 0$ >>> substitution([x + y], [x], [{y: 1}], [y], set([x + 1]), [y, x]) EmptySet >>> substitution([x + y], [x], [{y: 1}], [y], set([x - 1]), [y, x]) {(1, -1)} >>> substitution([x + y - 1, y - x**2 + 5], [x, y]) {(-3, 4), (2, -1)} * Returns both real and complex solution >>> x, y, z = symbols('x, y, z') >>> from sympy import exp, sin >>> substitution([exp(x) - sin(y), y**2 - 4], [x, y]) {(ImageSet(Lambda(_n, I*(2*_n*pi + pi) + log(sin(2))), Integers), -2), (ImageSet(Lambda(_n, 2*_n*I*pi + log(sin(2))), Integers), 2)} >>> eqs = [z**2 + exp(2*x) - sin(y), -3 + exp(-y)] >>> substitution(eqs, [y, z]) {(-log(3), -sqrt(-exp(2*x) - sin(log(3)))), (-log(3), sqrt(-exp(2*x) - sin(log(3)))), (ImageSet(Lambda(_n, 2*_n*I*pi - log(3)), Integers), ImageSet(Lambda(_n, -sqrt(-exp(2*x) + sin(2*_n*I*pi - log(3)))), Integers)), (ImageSet(Lambda(_n, 2*_n*I*pi - log(3)), Integers), ImageSet(Lambda(_n, sqrt(-exp(2*x) + sin(2*_n*I*pi - log(3)))), Integers))} """ if not system: return S.EmptySet if not symbols: msg = ('Symbols must be given, for which solution of the ' 'system is to be found.') raise ValueError(filldedent(msg)) if not is_sequence(symbols): msg = ('symbols should be given as a sequence, e.g. a list.' 'Not type %s: %s') raise TypeError(filldedent(msg % (type(symbols), symbols))) if not getattr(symbols[0], 'is_Symbol', False): msg = ('Iterable of symbols must be given as ' 'second argument, not type %s: %s') raise ValueError(filldedent(msg % (type(symbols[0]), symbols[0]))) # By default `all_symbols` will be same as `symbols` if all_symbols is None: all_symbols = symbols old_result = result # storing complements and intersection for particular symbol complements = {} intersections = {} # when total_solveset_call equals total_conditionset # it means that solveset failed to solve all eqs. total_conditionset = -1 total_solveset_call = -1 def _unsolved_syms(eq, sort=False): """Returns the unsolved symbol present in the equation `eq`. """ free = eq.free_symbols unsolved = (free - set(known_symbols)) & set(all_symbols) if sort: unsolved = list(unsolved) unsolved.sort(key=default_sort_key) return unsolved # end of _unsolved_syms() # sort such that equation with the fewest potential symbols is first. # means eq with less number of variable first in the list. eqs_in_better_order = list( ordered(system, lambda _: len(_unsolved_syms(_)))) def add_intersection_complement(result, intersection_dict, complement_dict): # If solveset has returned some intersection/complement # for any symbol, it will be added in the final solution. final_result = [] for res in result: res_copy = res for key_res, value_res in res.items(): intersect_set, complement_set = None, None for key_sym, value_sym in intersection_dict.items(): if key_sym == key_res: intersect_set = value_sym for key_sym, value_sym in complement_dict.items(): if key_sym == key_res: complement_set = value_sym if intersect_set or complement_set: new_value = FiniteSet(value_res) if intersect_set and intersect_set != S.Complexes: new_value = Intersection(new_value, intersect_set) if complement_set: new_value = Complement(new_value, complement_set) if new_value is S.EmptySet: res_copy = None break elif new_value.is_FiniteSet and len(new_value) == 1: res_copy[key_res] = set(new_value).pop() else: res_copy[key_res] = new_value if res_copy is not None: final_result.append(res_copy) return final_result # end of def add_intersection_complement() def _extract_main_soln(sym, sol, soln_imageset): """Separate the Complements, Intersections, ImageSet lambda expr and its base_set. This function returns the unmasks sol from different classes of sets and also returns the appended ImageSet elements in a soln_imageset (dict: where key as unmasked element and value as ImageSet). """ # if there is union, then need to check # Complement, Intersection, Imageset. # Order should not be changed. if isinstance(sol, ConditionSet): # extracts any solution in ConditionSet sol = sol.base_set if isinstance(sol, Complement): # extract solution and complement complements[sym] = sol.args[1] sol = sol.args[0] # complement will be added at the end # using `add_intersection_complement` method # if there is union of Imageset or other in soln. # no testcase is written for this if block if isinstance(sol, Union): sol_args = sol.args sol = S.EmptySet # We need in sequence so append finteset elements # and then imageset or other. for sol_arg2 in sol_args: if isinstance(sol_arg2, FiniteSet): sol += sol_arg2 else: # ImageSet, Intersection, complement then # append them directly sol += FiniteSet(sol_arg2) if isinstance(sol, Intersection): # Interval/Set will be at 0th index always if sol.args[0] not in (S.Reals, S.Complexes): # Sometimes solveset returns soln with intersection # S.Reals or S.Complexes. We don't consider that # intersection. intersections[sym] = sol.args[0] sol = sol.args[1] # after intersection and complement Imageset should # be checked. if isinstance(sol, ImageSet): soln_imagest = sol expr2 = sol.lamda.expr sol = FiniteSet(expr2) soln_imageset[expr2] = soln_imagest if not isinstance(sol, FiniteSet): sol = FiniteSet(sol) return sol, soln_imageset # end of def _extract_main_soln() # helper function for _append_new_soln def _check_exclude(rnew, imgset_yes): rnew_ = rnew if imgset_yes: # replace all dummy variables (Imageset lambda variables) # with zero before `checksol`. Considering fundamental soln # for `checksol`. rnew_copy = rnew.copy() dummy_n = imgset_yes[0] for key_res, value_res in rnew_copy.items(): rnew_copy[key_res] = value_res.subs(dummy_n, 0) rnew_ = rnew_copy # satisfy_exclude == true if it satisfies the expr of `exclude` list. try: # something like : `Mod(-log(3), 2*I*pi)` can't be # simplified right now, so `checksol` returns `TypeError`. # when this issue is fixed this try block should be # removed. Mod(-log(3), 2*I*pi) == -log(3) satisfy_exclude = any( checksol(d, rnew_) for d in exclude) except TypeError: satisfy_exclude = None return satisfy_exclude # end of def _check_exclude() # helper function for _append_new_soln def _restore_imgset(rnew, original_imageset, newresult): restore_sym = set(rnew.keys()) & \ set(original_imageset.keys()) for key_sym in restore_sym: img = original_imageset[key_sym] rnew[key_sym] = img if rnew not in newresult: newresult.append(rnew) # end of def _restore_imgset() def _append_eq(eq, result, res, delete_soln, n=None): u = Dummy('u') if n: eq = eq.subs(n, 0) satisfy = eq if eq in (True, False) else checksol(u, u, eq, minimal=True) if satisfy is False: delete_soln = True res = {} else: result.append(res) return result, res, delete_soln def _append_new_soln(rnew, sym, sol, imgset_yes, soln_imageset, original_imageset, newresult, eq=None): """If `rnew` (A dict <symbol: soln>) contains valid soln append it to `newresult` list. `imgset_yes` is (base, dummy_var) if there was imageset in previously calculated result(otherwise empty tuple). `original_imageset` is dict of imageset expr and imageset from this result. `soln_imageset` dict of imageset expr and imageset of new soln. """ satisfy_exclude = _check_exclude(rnew, imgset_yes) delete_soln = False # soln should not satisfy expr present in `exclude` list. if not satisfy_exclude: local_n = None # if it is imageset if imgset_yes: local_n = imgset_yes[0] base = imgset_yes[1] if sym and sol: # when `sym` and `sol` is `None` means no new # soln. In that case we will append rnew directly after # substituting original imagesets in rnew values if present # (second last line of this function using _restore_imgset) dummy_list = list(sol.atoms(Dummy)) # use one dummy `n` which is in # previous imageset local_n_list = [ local_n for i in range( 0, len(dummy_list))] dummy_zip = zip(dummy_list, local_n_list) lam = Lambda(local_n, sol.subs(dummy_zip)) rnew[sym] = ImageSet(lam, base) if eq is not None: newresult, rnew, delete_soln = _append_eq( eq, newresult, rnew, delete_soln, local_n) elif eq is not None: newresult, rnew, delete_soln = _append_eq( eq, newresult, rnew, delete_soln) elif sol in soln_imageset.keys(): rnew[sym] = soln_imageset[sol] # restore original imageset _restore_imgset(rnew, original_imageset, newresult) else: newresult.append(rnew) elif satisfy_exclude: delete_soln = True rnew = {} _restore_imgset(rnew, original_imageset, newresult) return newresult, delete_soln # end of def _append_new_soln() def _new_order_result(result, eq): # separate first, second priority. `res` that makes `eq` value equals # to zero, should be used first then other result(second priority). # If it is not done then we may miss some soln. first_priority = [] second_priority = [] for res in result: if not any(isinstance(val, ImageSet) for val in res.values()): if eq.subs(res) == 0: first_priority.append(res) else: second_priority.append(res) if first_priority or second_priority: return first_priority + second_priority return result def _solve_using_known_values(result, solver): """Solves the system using already known solution (result contains the dict <symbol: value>). solver is :func:`~.solveset_complex` or :func:`~.solveset_real`. """ # stores imageset <expr: imageset(Lambda(n, expr), base)>. soln_imageset = {} total_solvest_call = 0 total_conditionst = 0 # sort such that equation with the fewest potential symbols is first. # means eq with less variable first for index, eq in enumerate(eqs_in_better_order): newresult = [] original_imageset = {} # if imageset expr is used to solve other symbol imgset_yes = False result = _new_order_result(result, eq) for res in result: got_symbol = set() # symbols solved in one iteration # find the imageset and use its expr. for key_res, value_res in res.items(): if isinstance(value_res, ImageSet): res[key_res] = value_res.lamda.expr original_imageset[key_res] = value_res dummy_n = value_res.lamda.expr.atoms(Dummy).pop() (base,) = value_res.base_sets imgset_yes = (dummy_n, base) # update eq with everything that is known so far eq2 = eq.subs(res).expand() unsolved_syms = _unsolved_syms(eq2, sort=True) if not unsolved_syms: if res: newresult, delete_res = _append_new_soln( res, None, None, imgset_yes, soln_imageset, original_imageset, newresult, eq2) if delete_res: # `delete_res` is true, means substituting `res` in # eq2 doesn't return `zero` or deleting the `res` # (a soln) since it staisfies expr of `exclude` # list. result.remove(res) continue # skip as it's independent of desired symbols depen1, depen2 = (eq2.rewrite(Add)).as_independent(*unsolved_syms) if (depen1.has(Abs) or depen2.has(Abs)) and solver == solveset_complex: # Absolute values cannot be inverted in the # complex domain continue soln_imageset = {} for sym in unsolved_syms: not_solvable = False try: soln = solver(eq2, sym) total_solvest_call += 1 soln_new = S.EmptySet if isinstance(soln, Complement): # separate solution and complement complements[sym] = soln.args[1] soln = soln.args[0] # complement will be added at the end if isinstance(soln, Intersection): # Interval will be at 0th index always if soln.args[0] != Interval(-oo, oo): # sometimes solveset returns soln # with intersection S.Reals, to confirm that # soln is in domain=S.Reals intersections[sym] = soln.args[0] soln_new += soln.args[1] soln = soln_new if soln_new else soln if index > 0 and solver == solveset_real: # one symbol's real soln, another symbol may have # corresponding complex soln. if not isinstance(soln, (ImageSet, ConditionSet)): soln += solveset_complex(eq2, sym) except NotImplementedError: # If sovleset is not able to solve equation `eq2`. Next # time we may get soln using next equation `eq2` continue if isinstance(soln, ConditionSet): if soln.base_set in (S.Reals, S.Complexes): soln = S.EmptySet # don't do `continue` we may get soln # in terms of other symbol(s) not_solvable = True total_conditionst += 1 else: soln = soln.base_set if soln is not S.EmptySet: soln, soln_imageset = _extract_main_soln( sym, soln, soln_imageset) for sol in soln: # sol is not a `Union` since we checked it # before this loop sol, soln_imageset = _extract_main_soln( sym, sol, soln_imageset) sol = set(sol).pop() free = sol.free_symbols if got_symbol and any( ss in free for ss in got_symbol ): # sol depends on previously solved symbols # then continue continue rnew = res.copy() # put each solution in res and append the new result # in the new result list (solution for symbol `s`) # along with old results. for k, v in res.items(): if isinstance(v, Expr) and isinstance(sol, Expr): # if any unsolved symbol is present # Then subs known value rnew[k] = v.subs(sym, sol) # and add this new solution if sol in soln_imageset.keys(): # replace all lambda variables with 0. imgst = soln_imageset[sol] rnew[sym] = imgst.lamda( *[0 for i in range(0, len( imgst.lamda.variables))]) else: rnew[sym] = sol newresult, delete_res = _append_new_soln( rnew, sym, sol, imgset_yes, soln_imageset, original_imageset, newresult) if delete_res: # deleting the `res` (a soln) since it staisfies # eq of `exclude` list result.remove(res) # solution got for sym if not not_solvable: got_symbol.add(sym) # next time use this new soln if newresult: result = newresult return result, total_solvest_call, total_conditionst # end def _solve_using_know_values() new_result_real, solve_call1, cnd_call1 = _solve_using_known_values( old_result, solveset_real) new_result_complex, solve_call2, cnd_call2 = _solve_using_known_values( old_result, solveset_complex) # If total_solveset_call is equal to total_conditionset # then solveset failed to solve all of the equations. # In this case we return a ConditionSet here. total_conditionset += (cnd_call1 + cnd_call2) total_solveset_call += (solve_call1 + solve_call2) if total_conditionset == total_solveset_call and total_solveset_call != -1: return _return_conditionset(eqs_in_better_order, all_symbols) # don't keep duplicate solutions filtered_complex = [] for i in list(new_result_complex): for j in list(new_result_real): if i.keys() != j.keys(): continue if all(a.dummy_eq(b) for a, b in zip(i.values(), j.values()) \ if type(a) != int or type(b) != int): break else: filtered_complex.append(i) # overall result result = new_result_real + filtered_complex result_all_variables = [] result_infinite = [] for res in result: if not res: # means {None : None} continue # If length < len(all_symbols) means infinite soln. # Some or all the soln is dependent on 1 symbol. # eg. {x: y+2} then final soln {x: y+2, y: y} if len(res) < len(all_symbols): solved_symbols = res.keys() unsolved = list(filter( lambda x: x not in solved_symbols, all_symbols)) for unsolved_sym in unsolved: res[unsolved_sym] = unsolved_sym result_infinite.append(res) if res not in result_all_variables: result_all_variables.append(res) if result_infinite: # we have general soln # eg : [{x: -1, y : 1}, {x : -y, y: y}] then # return [{x : -y, y : y}] result_all_variables = result_infinite if intersections or complements: result_all_variables = add_intersection_complement( result_all_variables, intersections, complements) # convert to ordered tuple result = S.EmptySet for r in result_all_variables: temp = [r[symb] for symb in all_symbols] result += FiniteSet(tuple(temp)) return result # end of def substitution()
33,275
def _parsed_args(): """ parse commandline arguments with argparse """ parser = argparse.ArgumentParser( description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter ) parser.add_argument( '-i', '--input', type=str, required=True, help='path to input file', ) parser.add_argument( '-o', '--output', type=str, required=True, help='path to output file', ) parser.add_argument( '-I', '--input-adapter', type=str, default=None, help="Explicitly use this adapter for reading the input file", ) parser.add_argument( '-O', '--output-adapter', type=str, default=None, help="Explicitly use this adapter for writing the output file", ) parser.add_argument( '-T', '--tracks', type=str, default=None, help="Pick one or more tracks, by 0-based index, separated by commas.", ) parser.add_argument( '-m', '--media-linker', type=str, default="Default", help=( "Specify a media linker. 'Default' means use the " "$OTIO_DEFAULT_MEDIA_LINKER if set, 'None' or '' means explicitly " "disable the linker, and anything else is interpreted as the name" " of the media linker to use." ) ) parser.add_argument( '-a', '--adapter-arg', type=str, default=[], action='append', help='Extra arguments to be passed to input adapter in the form of ' 'key=value. Values are strings, numbers or Python literals: True, ' 'False, etc. Can be used multiple times: -a burrito="bar" -a taco=12.' ) parser.add_argument( '-A', '--output-adapter-arg', type=str, default=[], action='append', help='Extra arguments to be passed to output adapter in the form of ' 'key=value. Values are strings, numbers or Python literals: True, ' 'False, etc. Can be used multiple times: -a burrito="bar" -a taco=12.' ) return parser.parse_args()
def _parsed_args(): """ parse commandline arguments with argparse """ parser = argparse.ArgumentParser( description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter ) parser.add_argument( '-i', '--input', type=str, required=True, help='path to input file', ) parser.add_argument( '-o', '--output', type=str, required=True, help='path to output file', ) parser.add_argument( '-I', '--input-adapter', type=str, default=None, help="Explicitly use this adapter for reading the input file", ) parser.add_argument( '-O', '--output-adapter', type=str, default=None, help="Explicitly use this adapter for writing the output file", ) parser.add_argument( '-T', '--tracks', type=str, default=None, help="Pick one or more tracks, by 0-based index, separated by commas.", ) parser.add_argument( '-m', '--media-linker', type=str, default="Default", help=( "Specify a media linker. 'Default' means use the " "$OTIO_DEFAULT_MEDIA_LINKER if set, 'None' or '' means explicitly " "disable the linker, and anything else is interpreted as the name" " of the media linker to use." ) ) parser.add_argument( '-a', '--adapter-arg', type=str, default=[], action='append', help='Extra arguments to be passed to input adapter in the form of ' 'key=value. Values are strings, numbers or Python literals: True, ' 'False, etc. Can be used multiple times: -a burrito="bar" -a taco=12.' ) parser.add_argument( '-A', '--output-adapter-arg', type=str, default=[], action='append', help='Extra arguments to be passed to output adapter in the form of ' 'key=value. Values are strings, numbers or Python literals: True, ' 'False, etc. Can be used multiple times: -A burrito="bar" -A taco=12.' ) return parser.parse_args()
3,846
def to_pandas_edgelist( G, source="source", target="target", nodelist=None, dtype=None, order=None, edge_key=None, ): """Returns the graph edge list as a Pandas DataFrame. Parameters ---------- G : graph The NetworkX graph used to construct the Pandas DataFrame. source : str or int, optional A valid column name (string or integer) for the source nodes (for the directed case). target : str or int, optional A valid column name (string or integer) for the target nodes (for the directed case). nodelist : list, optional Use only nodes specified in nodelist dtype : dtype, default None Use to create the DataFrame. Data type to force. Only a single dtype is allowed. If None, infer. order : None An unused parameter mistakenly included in the function. This is deprecated and will be removed in NetworkX v3.0. edge_key : str or int or None, optional (default=None) A valid column name (string or integer) for the edge keys (for the multigraph case). If None, edge keys are not stored in the DataFrame. Returns ------- df : Pandas DataFrame Graph edge list Examples -------- >>> G = nx.Graph( ... [ ... ("A", "B", {"cost": 1, "weight": 7}), ... ("C", "E", {"cost": 9, "weight": 10}), ... ] ... ) >>> df = nx.to_pandas_edgelist(G, nodelist=["A", "C"]) >>> df[["source", "target", "cost", "weight"]] source target cost weight 0 A B 1 7 1 C E 9 10 >>> G = nx.MultiGraph([('A', 'B', {'cost': 1}), ('A', 'B', {'cost': 9})]) >>> df = nx.to_pandas_edgelist(G, nodelist=['A', 'C'], edge_key='ekey') >>> df[['source', 'target', 'cost', 'ekey']] source target cost ekey 0 A B 1 0 1 A B 9 1 """ import pandas as pd if nodelist is None: edgelist = G.edges(data=True) else: edgelist = G.edges(nodelist, data=True) source_nodes = [s for s, t, d in edgelist] target_nodes = [t for s, t, d in edgelist] all_attrs = set().union(*(d.keys() for s, t, d in edgelist)) if source in all_attrs: raise nx.NetworkXError(f"Source name '{source}' is an edge attr name") if target in all_attrs: raise nx.NetworkXError(f"Target name '{target}' is an edge attr name") nan = float("nan") edge_attr = {k: [d.get(k, nan) for s, t, d in edgelist] for k in all_attrs} if G.is_multigraph() and edge_key is not None: if edge_key in all_attrs: raise nx.NetworkXError(f"Edge key name '{edge_key}' is an edge attr name") edge_keys = [k for s, t, k in G.edges(keys=True)] edgelistdict = {source: source_nodes, target: target_nodes, edge_key: edge_keys} else: edgelistdict = {source: source_nodes, target: target_nodes} edgelistdict.update(edge_attr) return pd.DataFrame(edgelistdict, dtype=dtype)
def to_pandas_edgelist( G, source="source", target="target", nodelist=None, dtype=None, order=None, edge_key=None, ): """Returns the graph edge list as a Pandas DataFrame. Parameters ---------- G : graph The NetworkX graph used to construct the Pandas DataFrame. source : str or int, optional A valid column name (string or integer) for the source nodes (for the directed case). target : str or int, optional A valid column name (string or integer) for the target nodes (for the directed case). nodelist : list, optional Use only nodes specified in nodelist dtype : dtype, default None Use to create the DataFrame. Data type to force. Only a single dtype is allowed. If None, infer. order : None An unused parameter mistakenly included in the function. This is deprecated and will be removed in NetworkX v3.0. edge_key : str or int or None, optional (default=None) A valid column name (string or integer) for the edge keys (for the multigraph case). If None, edge keys are not stored in the DataFrame. Returns ------- df : Pandas DataFrame Graph edge list Examples -------- >>> G = nx.Graph( ... [ ... ("A", "B", {"cost": 1, "weight": 7}), ... ("C", "E", {"cost": 9, "weight": 10}), ... ] ... ) >>> df = nx.to_pandas_edgelist(G, nodelist=["A", "C"]) >>> df[["source", "target", "cost", "weight"]] source target cost weight 0 A B 1 7 1 C E 9 10 >>> G = nx.MultiGraph([('A', 'B', {'cost': 1}), ('A', 'B', {'cost': 9})]) >>> df = nx.to_pandas_edgelist(G, nodelist=['A', 'C'], edge_key='ekey') >>> df[['source', 'target', 'cost', 'ekey']] source target cost ekey 0 A B 1 0 1 A B 9 1 """ import pandas as pd if nodelist is None: edgelist = G.edges(data=True) else: edgelist = G.edges(nodelist, data=True) source_nodes = [s for s, t, d in edgelist] target_nodes = [t for s, t, d in edgelist] all_attrs = set().union(*(d.keys() for s, t, d in edgelist)) if source in all_attrs: raise nx.NetworkXError(f"Source name '{source}' is an edge attr name") if target in all_attrs: raise nx.NetworkXError(f"Target name '{target}' is an edge attr name") nan = float("nan") edge_attr = {k: [d.get(k, nan) for s, t, d in edgelist] for k in all_attrs} if G.is_multigraph() and edge_key is not None: if edge_key in all_attrs: raise nx.NetworkXError(f"Edge key name '{edge_key}' is an edge attr name") edge_keys = [k for _, _, k in G.edges(keys=True)] edgelistdict = {source: source_nodes, target: target_nodes, edge_key: edge_keys} else: edgelistdict = {source: source_nodes, target: target_nodes} edgelistdict.update(edge_attr) return pd.DataFrame(edgelistdict, dtype=dtype)
12,984
def test__update_configuration_structure_removes_old_keys( monkeypatch, plugin_configuration ): mocked_config = { name: value for name, value in PluginSample.CONFIG_STRUCTURE.items() if name != "Username" } monkeypatch.setattr(PluginSample, "CONFIG_STRUCTURE", mocked_config) configuration = PluginSample._update_configuration_structure( plugin_configuration.configuration ) assert all([config_field["name"] != "Username" for config_field in configuration])
def test_update_configuration_structure_removes_old_keys( monkeypatch, plugin_configuration ): mocked_config = { name: value for name, value in PluginSample.CONFIG_STRUCTURE.items() if name != "Username" } monkeypatch.setattr(PluginSample, "CONFIG_STRUCTURE", mocked_config) configuration = PluginSample._update_configuration_structure( plugin_configuration.configuration ) assert all([config_field["name"] != "Username" for config_field in configuration])
7,830
def get_rotation_matrix(rotation, order='xyz'): r"""Generate a 3x3 rotation matrix from input angles Parameters ---------- rotation : 3-tuple of float A 3-tuple of angles :math:`(\phi, \theta, \psi)` in degrees where the first element is the rotation about the x-axis in the fixed laboratory frame, the second element is the rotation about the y-axis in the fixed laboratory frame, and the third element is the rotation about the z-axis in the fixed laboratory frame. The rotations are active rotations. order : str, optinoal A string of 'x', 'y', and 'z' in some order specifying which rotation to perform first, second, and third. Defaults to 'xyz' which means, the rotation by angle phi about x will be applied first, followed by theta about y and then phi about z. This corresponds to an x-y-z extrinsic rotation as well as a z-y'-x'' intrinsic rotation using Tait-Bryan angles :math:`(\phi, \theta, \psi)`. """ check_type('surface rotation', rotation, Iterable, Real) check_length('surface rotation', rotation, 3) phi, theta, psi = np.array(rotation)*(np.pi/180.) cx, sx = np.cos(phi), np.sin(phi) cy, sy = np.cos(theta), np.sin(theta) cz, sz = np.cos(psi), np.sin(psi) R = {} R['x'] = np.array([[1., 0., 0.], [0., cx, -sx], [0., sx, cx]]) R['y'] = np.array([[cy, 0., sy], [0., 1., 0.], [-sy, 0., cy]]) R['z'] = np.array([[cz, -sz, 0.], [sz, cz, 0.], [0., 0., 1.]]) R1, R2, R3 = tuple(R[xi] for xi in order) return R3 @ R2 @ R1
def get_rotation_matrix(rotation, order='xyz'): r"""Generate a 3x3 rotation matrix from input angles Parameters ---------- rotation : 3-tuple of float A 3-tuple of angles :math:`(\phi, \theta, \psi)` in degrees where the first element is the rotation about the x-axis in the fixed laboratory frame, the second element is the rotation about the y-axis in the fixed laboratory frame, and the third element is the rotation about the z-axis in the fixed laboratory frame. The rotations are active rotations. order : str, optinoal A string of 'x', 'y', and 'z' in some order specifying which rotation to perform first, second, and third. Defaults to 'xyz' which means, the rotation by angle phi about x will be applied first, followed by theta about y and then phi about z. This corresponds to an x-y-z extrinsic rotation as well as a z-y'-x'' intrinsic rotation using Tait-Bryan angles :math:`(\phi, \theta, \psi)`. """ check_type('surface rotation', rotation, Iterable, Real) check_length('surface rotation', rotation, 3) phi, theta, psi = np.array(rotation)*(np.pi/180.) cx, sx = np.cos(phi), np.sin(phi) cy, sy = np.cos(theta), np.sin(theta) cz, sz = np.cos(psi), np.sin(psi) R = {} R['x'] = np.array([[1., 0., 0.], [0., cx, -sx], [0., sx, cx]]) R['y'] = np.array([[cy, 0., sy], [0., 1., 0.], [-sy, 0., cy]]) R['z'] = np.array([[cz, -sz, 0.], [sz, cz, 0.], [0., 0., 1.]]) R1, R2, R3 = (R[xi] for xi in order) return R3 @ R2 @ R1
1,339
def test_adaboost_regressor_sample_weight(): # check that giving weight will have an influence on the error computed # for a weak learner X, y = datasets.make_regression(n_features=50, random_state=0) # add an arbitrary outlier to make sure X = np.vstack([X, X.sum(axis=0)]) y = np.hstack([y, 10]) regr_no_outlier = AdaBoostRegressor( base_estimator=LinearRegression(), n_estimators=4, random_state=0 ) regr_with_weight = clone(regr_no_outlier) # fit 2 models: # - a model without the outlier # - a model containing the outlier but with a null sample-weight # Therefore, the error of the first weak learner will be identical. regr_no_outlier.fit(X[:-1], y[:-1]) sample_weight = np.array([1.] * (y.size - 1) + [0.]) regr_with_weight.fit(X, y, sample_weight=sample_weight) # check that the error is similar with 1 decimal assert (regr_no_outlier.estimator_errors_[0] == pytest.approx(regr_with_weight.estimator_errors_[0], abs=1e-1))
def test_adaboostregressor_sample_weight(): # check that giving weight will have an influence on the error computed # for a weak learner X, y = datasets.make_regression(n_features=50, random_state=0) # add an arbitrary outlier to make sure X = np.vstack([X, X.sum(axis=0)]) y = np.hstack([y, 10]) regr_no_outlier = AdaBoostRegressor( base_estimator=LinearRegression(), n_estimators=4, random_state=0 ) regr_with_weight = clone(regr_no_outlier) # fit 2 models: # - a model without the outlier # - a model containing the outlier but with a null sample-weight # Therefore, the error of the first weak learner will be identical. regr_no_outlier.fit(X[:-1], y[:-1]) sample_weight = np.array([1.] * (y.size - 1) + [0.]) regr_with_weight.fit(X, y, sample_weight=sample_weight) # check that the error is similar with 1 decimal assert (regr_no_outlier.estimator_errors_[0] == pytest.approx(regr_with_weight.estimator_errors_[0], abs=1e-1))
13,072
def _is_refund_ongoing(payment): """Return True if refund is ongoing for given payment.""" return ( payment.transactions.filter( kind__in=[TransactionKind.REFUND_ONGOING], is_success=True ).exists() if payment else False )
def _is_refund_ongoing(payment): """Return True if refund is ongoing for given payment.""" return ( payment.transactions.filter( kind=TransactionKind.REFUND_ONGOING, is_success=True ).exists() if payment else False )
39,395
def test_texture_repr(): texture = pyvista.Texture(examples.mapfile) tex_repr = str(repr(texture)) assert 'Cube Map:\tFalse' in tex_repr assert 'Components:\t3' in tex_repr assert 'Dimensions:\t2048, 1024\n' in tex_repr
def test_texture_repr(): texture = pyvista.Texture(examples.mapfile) tex_repr = repr(texture) assert 'Cube Map:\tFalse' in tex_repr assert 'Components:\t3' in tex_repr assert 'Dimensions:\t2048, 1024\n' in tex_repr
32,467
def parse_date_string(date_string, date_format='%Y-%m-%dT%H:%M:%S'): """ Parses the date_string function to the corresponding datetime object. Note: If possible (e.g. running Python 3), it is suggested to use dateutil.parser.parse or dateparser.parse functions instead. Examples: >>> parse_date_string('2019-09-17T06:16:39Z') datetime.datetime(2019, 9, 17, 6, 16, 39) >>> parse_date_string('2019-09-17T06:16:39.22Z') datetime.datetime(2019, 9, 17, 6, 16, 39, 220000) >>> parse_date_string('2019-09-17T06:16:39.4040+05:00', '%Y-%m-%dT%H:%M:%S+02:00') datetime.datetime(2019, 9, 17, 6, 16, 39, 404000) :type date_string: ``str`` :param date_string: The date string to parse. (required) :type date_format: ``str`` :param date_format: The date format of the date string. If the date format is known, it should be provided. (optional) :return: The parsed datetime. :rtype: ``(datetime.datetime, datetime.datetime)`` """ try: return datetime.strptime(date_string, date_format) except ValueError as e: error_message = str(e) date_format = '%Y-%m-%dT%H:%M:%S' time_data_regex = r'time data \'(.*?)\'' time_data_match = re.findall(time_data_regex, error_message) sliced_time_data = '' if time_data_match: # found time date which does not match date format # example of caught error message: # "time data '2019-09-17T06:16:39Z' does not match format '%Y-%m-%dT%H:%M:%S.%fZ'" time_data = time_data_match[0] # removing YYYY-MM-DDThh:mm:ss from the time data to keep only milliseconds and time zone sliced_time_data = time_data[19:] else: unconverted_data_remains_regex = r'unconverted data remains: (.*)' unconverted_data_remains_match = re.findall(unconverted_data_remains_regex, error_message) if unconverted_data_remains_match: # found unconverted_data_remains # example of caught error message: # "unconverted data remains: 22Z" sliced_time_data = unconverted_data_remains_match[0] if not sliced_time_data: # did not catch expected error raise ValueError(e) if '.' in sliced_time_data: # found milliseconds - appending ".%f" to date format date_format += '.%f' timezone_regex = r'[Zz+-].*' time_zone = re.findall(timezone_regex, sliced_time_data) if time_zone: # found timezone - appending it to the date format date_format += time_zone[0] # Make the fractions shorter less than 6 charactors # e.g. '2022-01-23T12:34:56.123456789+09:00' to '2022-01-23T12:34:56.123456+09:00' date_string = re.sub(r'(.*?\.[0-9]{6})[0-9]*([Zz]|[+-]\S+?)', '\\1\\2', date_string) return datetime.strptime(date_string, date_format)
def parse_date_string(date_string, date_format='%Y-%m-%dT%H:%M:%S'): """ Parses the date_string function to the corresponding datetime object. Note: If possible (e.g. running Python 3), it is suggested to use dateutil.parser.parse or dateparser.parse functions instead. Examples: >>> parse_date_string('2019-09-17T06:16:39Z') datetime.datetime(2019, 9, 17, 6, 16, 39) >>> parse_date_string('2019-09-17T06:16:39.22Z') datetime.datetime(2019, 9, 17, 6, 16, 39, 220000) >>> parse_date_string('2019-09-17T06:16:39.4040+05:00', '%Y-%m-%dT%H:%M:%S+02:00') datetime.datetime(2019, 9, 17, 6, 16, 39, 404000) :type date_string: ``str`` :param date_string: The date string to parse. (required) :type date_format: ``str`` :param date_format: The date format of the date string. If the date format is known, it should be provided. (optional) :return: The parsed datetime. :rtype: ``(datetime.datetime, datetime.datetime)`` """ try: return datetime.strptime(date_string, date_format) except ValueError as e: error_message = str(e) date_format = '%Y-%m-%dT%H:%M:%S' time_data_regex = r'time data \'(.*?)\'' time_data_match = re.findall(time_data_regex, error_message) sliced_time_data = '' if time_data_match: # found time date which does not match date format # example of caught error message: # "time data '2019-09-17T06:16:39Z' does not match format '%Y-%m-%dT%H:%M:%S.%fZ'" time_data = time_data_match[0] # removing YYYY-MM-DDThh:mm:ss from the time data to keep only milliseconds and time zone sliced_time_data = time_data[19:] else: unconverted_data_remains_regex = r'unconverted data remains: (.*)' unconverted_data_remains_match = re.findall(unconverted_data_remains_regex, error_message) if unconverted_data_remains_match: # found unconverted_data_remains # example of caught error message: # "unconverted data remains: 22Z" sliced_time_data = unconverted_data_remains_match[0] if not sliced_time_data: # did not catch expected error raise ValueError(e) if '.' in sliced_time_data: # found milliseconds - appending ".%f" to date format date_format += '.%f' timezone_regex = r'[Zz+-].*' time_zone = re.findall(timezone_regex, sliced_time_data) if time_zone: # found timezone - appending it to the date format date_format += time_zone[0] # Make the fractions shorter less than 6 charactors # e.g. '2022-01-23T12:34:56.123456789+09:00' to '2022-01-23T12:34:56.123456+09:00' date_string = re.sub(r'(.*?\.[0-9]{6})[0-9]*', '\\1', date_string) return datetime.strptime(date_string, date_format)
28,280
def _insert_into_data_dict( existing_values: np.ndarray, new_values: np.ndarray, write_status: Optional[int], shape: Optional[Tuple[int, ...]] ) -> Tuple[np.ndarray, Optional[int]]: if shape is None or write_status is None: try: data = np.append(existing_values, new_values, axis=0) except ValueError: # we cannot append into a ragged array so make that manually n_existing = existing_values.shape[0] n_new = new_values.shape[0] n_rows = n_existing + n_new data = np.ndarray((n_rows,), dtype=object) for i in range(n_existing): data[i] = np.atleast_1d(existing_values[i]) for i, j in enumerate(range(n_existing, n_existing+n_new)): data[j] = np.atleast_1d(new_values[i]) return data, None else: if existing_values.dtype.kind in ('U', 'S'): # string type arrays may be too small for the new data # read so rescale if needed. if new_values.dtype.itemsize > existing_values.dtype.itemsize: existing_values = existing_values.astype(new_values.dtype) n_values = new_values.size new_write_status = write_status+n_values if new_write_status > existing_values.size: log.warning(f"Incorrect shape of dataset: Dataset is expected to " f"contain {existing_values.size} points but trying to " f"add an amount of data that makes it contain {new_write_status} points. Cache will " f"be flattened into a 1D array") return (np.append(existing_values.flatten(), new_values.flatten(), axis=0), new_write_status) else: existing_values.ravel()[write_status:new_write_status] = new_values.ravel() return existing_values, new_write_status
def _insert_into_data_dict( existing_values: np.ndarray, new_values: np.ndarray, write_status: Optional[int], shape: Optional[Tuple[int, ...]] ) -> Tuple[np.ndarray, Optional[int]]: if shape is None or write_status is None: try: data = np.append(existing_values, new_values, axis=0) except ValueError: # we cannot append into a ragged array so make that manually n_existing = existing_values.shape[0] n_new = new_values.shape[0] n_rows = n_existing + n_new data = np.ndarray((n_rows,), dtype=object) data = np.ndarray((n_rows,), dtype=existing_values.dtype) for i in range(n_existing): data[i] = np.atleast_1d(existing_values[i]) for i, j in enumerate(range(n_existing, n_existing+n_new)): data[j] = np.atleast_1d(new_values[i]) return data, None else: if existing_values.dtype.kind in ('U', 'S'): # string type arrays may be too small for the new data # read so rescale if needed. if new_values.dtype.itemsize > existing_values.dtype.itemsize: existing_values = existing_values.astype(new_values.dtype) n_values = new_values.size new_write_status = write_status+n_values if new_write_status > existing_values.size: log.warning(f"Incorrect shape of dataset: Dataset is expected to " f"contain {existing_values.size} points but trying to " f"add an amount of data that makes it contain {new_write_status} points. Cache will " f"be flattened into a 1D array") return (np.append(existing_values.flatten(), new_values.flatten(), axis=0), new_write_status) else: existing_values.ravel()[write_status:new_write_status] = new_values.ravel() return existing_values, new_write_status
41,096
def get_parser(): """Construct the parser.""" parser = argparse.ArgumentParser( description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter, ) parser.add_argument( "--pretrained", type=str, help="Pretrained model." ) parser.add_argument( "--toolkit", type=str, help="Toolkit for Extracting X-vectors." ) parser.add_argument( "--verbose", type=int, default=1, help="Verbosity level." ) parser.add_argument( "--device", type=str, default='cuda:0', help="Verbosity level." ) parser.add_argument( "in_folder", type=Path, help="Path to the input data." ) parser.add_argument( "out_folder", type=Path, help="Output folder to save the xvectors.", ) return parser
def get_parser(): """Construct the parser.""" parser = argparse.ArgumentParser( description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter, ) parser.add_argument( "--pretrained_model", type=str, help="Pretrained model." ) parser.add_argument( "--toolkit", type=str, help="Toolkit for Extracting X-vectors." ) parser.add_argument( "--verbose", type=int, default=1, help="Verbosity level." ) parser.add_argument( "--device", type=str, default='cuda:0', help="Verbosity level." ) parser.add_argument( "in_folder", type=Path, help="Path to the input data." ) parser.add_argument( "out_folder", type=Path, help="Output folder to save the xvectors.", ) return parser
49,662
def evolve(inst, **changes): """ Create a new instance, based on *inst* with *changes* applied. :param inst: Instance of a class with ``attrs`` attributes. :param changes: Keyword changes in the new copy. Nested attrs classes ca be updated by passing (nested) dicts of values. :return: A copy of inst with *changes* incorporated. :raise TypeError: If *attr_name* couldn't be found in the class ``__init__``. :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs`` class. .. versionadded:: 17.1.0 """ cls = inst.__class__ attrs = fields(cls) for a in attrs: if not a.init: continue attr_name = a.name # To deal with private attributes. init_name = attr_name if attr_name[0] != "_" else attr_name[1:] value = getattr(inst, attr_name) if init_name not in changes: # Add original value to changes changes[init_name] = value elif has(value): # Evolve nested attrs classes changes[init_name] = evolve(value, **changes[init_name]) return cls(**changes)
def evolve(inst, **changes): """ Create a new instance, based on *inst* with *changes* applied. :param inst: Instance of a class with ``attrs`` attributes. :param changes: Keyword changes in the new copy. Nested ``attrs`` classes can be updated by passing (nested) dicts of values. :return: A copy of inst with *changes* incorporated. :raise TypeError: If *attr_name* couldn't be found in the class ``__init__``. :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs`` class. .. versionadded:: 17.1.0 """ cls = inst.__class__ attrs = fields(cls) for a in attrs: if not a.init: continue attr_name = a.name # To deal with private attributes. init_name = attr_name if attr_name[0] != "_" else attr_name[1:] value = getattr(inst, attr_name) if init_name not in changes: # Add original value to changes changes[init_name] = value elif has(value): # Evolve nested attrs classes changes[init_name] = evolve(value, **changes[init_name]) return cls(**changes)
31,352
def main() -> None: """main function, parses params and runs command functions :return: :rtype: """ ''' EXECUTION ''' #LOG('command is %s' % (demisto.command(), )) demisto.debug(f'Command being called is {demisto.command()}') try: LOG('Command being called is {command}'.format(command=demisto.command())) if demisto.command() == 'Picus-GetAccessToken': getAccessToken() elif demisto.command() == 'Picus-Vector-Compare': # Makes a comparison of the given vector's results token = getAccessToken() demisto.results(vectorCompare(token)) elif demisto.command() == 'Picus-Attack-Result-List': # Returns the list of the attack results\nhave optional parameters for pagination and filtration token = getAccessToken() demisto.results(attackResultList(token)) elif demisto.command() == 'Picus-Specific-Threats-Results': # Returns the list of the attack results of a single threat\nhave optional token = getAccessToken() demisto.results(specificThreatsResults(token)) elif demisto.command() == 'Picus-Peer-List': # Returns the peer list with current statuses token = getAccessToken() demisto.results(peerList(token)) elif demisto.command() == 'Picus-EMail-Peer-List': # Returns the E-Mail peer list with current statuses token = getAccessToken() demisto.results(eMailPeerList(token)) elif demisto.command() == 'Picus-Attack-All-Vectors': # Schedules given attack on all possible vectors token = getAccessToken() demisto.results(attackAllVectors(token)) elif demisto.command() == 'Picus-Attack-Single': # Schedules a single attack on requested vector token = getAccessToken() demisto.results(attackSingle(token)) elif demisto.command() == 'Picus-Trigger-Update': # Triggers the update mechanism manually, returns if the update-command is taken successfully token = getAccessToken() demisto.results(triggerUpdate(token)) elif demisto.command() == 'Picus-Version': # Returns the current version and the update time config token = getAccessToken() demisto.results(version(token)) elif demisto.command() == 'Picus-Threat-List': # Returns the list of the threats\nhave optional parameters for pagination and filtration token = getAccessToken() demisto.results(threatList(token)) elif demisto.command() == 'Picus-Mitigation-List': # Returns the list of the mitigations of threats\nhave optional parameters for pagination and filtration, this route may not be used associated with your license token = getAccessToken() demisto.results(mitigationList(token)) elif demisto.command() == 'Picus-Mitre-Matrix': # Returns the mitre matrix metadata\ntakes no parameters token = getAccessToken() demisto.results(mitreMatrix(token)) elif demisto.command() == 'Picus-Sigma-Rules-List': # Returns the list of the sigma rules of scenario actions\nhave optional parameters for pagination and filtration, this route may not be used associated with your license token = getAccessToken() demisto.results(sigmaRulesList(token)) elif demisto.command() == 'Picus-Vector-List': # Returns the list of the vectors all disabled and enabled ones\nhave optional parameters for pagination token = getAccessToken() demisto.results(vectorList(token)) elif demisto.command() == 'test-module': demisto.results(test_module()) # Log exceptions and return errors except Exception as e: demisto.error(traceback.format_exc()) # print the traceback return_error(f'Failed to execute {demisto.command()} command.\nError:\n{str(e)}')
def main() -> None: """main function, parses params and runs command functions :return: :rtype: """ ''' EXECUTION ''' #LOG('command is %s' % (demisto.command(), )) demisto.debug(f'Command being called is {demisto.command()}') try: LOG('Command being called is {command}'.format(command=demisto.command())) if demisto.command() == 'Picus-GetAccessToken': getAccessToken() elif demisto.command() == 'Picus-Vector-Compare': # Makes a comparison of the given vector's results token = getAccessToken() demisto.results(vectorCompare(token)) elif demisto.command() == 'Picus-Attack-Result-List': # Returns the list of the attack results\nhave optional parameters for pagination and filtration token = getAccessToken() demisto.results(attackResultList(token)) elif demisto.command() == 'Picus-Specific-Threats-Results': # Returns the list of the attack results of a single threat\nhave optional token = getAccessToken() demisto.results(specificThreatsResults(token)) elif demisto.command() == 'Picus-Peer-List': # Returns the peer list with current statuses token = getAccessToken() demisto.results(peerList(token)) elif demisto.command() == 'Picus-EMail-Peer-List': # Returns the E-Mail peer list with current statuses token = getAccessToken() demisto.results(eMailPeerList(token)) elif demisto.command() == 'Picus-Attack-All-Vectors': # Schedules given attack on all possible vectors token = getAccessToken() demisto.results(attackAllVectors(token)) elif demisto.command() == 'Picus-Attack-Single': # Schedules a single attack on requested vector token = getAccessToken() demisto.results(attackSingle(token)) elif demisto.command() == 'Picus-Trigger-Update': # Triggers the update mechanism manually, returns if the update-command is taken successfully token = getAccessToken() demisto.results(triggerUpdate(token)) elif demisto.command() == 'Picus-Version': # Returns the current version and the update time config token = getAccessToken() demisto.results(version(token)) elif demisto.command() == 'picus-threat-list': # Returns the list of the threats\nhave optional parameters for pagination and filtration token = getAccessToken() demisto.results(threatList(token)) elif demisto.command() == 'Picus-Mitigation-List': # Returns the list of the mitigations of threats\nhave optional parameters for pagination and filtration, this route may not be used associated with your license token = getAccessToken() demisto.results(mitigationList(token)) elif demisto.command() == 'Picus-Mitre-Matrix': # Returns the mitre matrix metadata\ntakes no parameters token = getAccessToken() demisto.results(mitreMatrix(token)) elif demisto.command() == 'Picus-Sigma-Rules-List': # Returns the list of the sigma rules of scenario actions\nhave optional parameters for pagination and filtration, this route may not be used associated with your license token = getAccessToken() demisto.results(sigmaRulesList(token)) elif demisto.command() == 'Picus-Vector-List': # Returns the list of the vectors all disabled and enabled ones\nhave optional parameters for pagination token = getAccessToken() demisto.results(vectorList(token)) elif demisto.command() == 'test-module': demisto.results(test_module()) # Log exceptions and return errors except Exception as e: demisto.error(traceback.format_exc()) # print the traceback return_error(f'Failed to execute {demisto.command()} command.\nError:\n{str(e)}')
7,271
def local_binary_pattern(image, P, R, method='default'): """Gray scale and rotation invariant LBP (Local Binary Patterns). LBP is an invariant descriptor that can be used for texture classification. Parameters ---------- image : (N, M) array Graylevel image. P : int Number of circularly symmetric neighbour set points (quantization of the angular space). R : float Radius of circle (spatial resolution of the operator). method : {'default', 'ror', 'uniform', 'var'} Method to determine the pattern: ``default`` Original local binary pattern which is gray scale but not rotation invariant. ``ror`` Extension of default implementation which is gray scale and rotation invariant. ``uniform`` Improved rotation invariance with uniform patterns and finer quantization of the angular space which is gray scale and rotation invariant. ``nri_uniform`` Non rotation-invariant uniform patterns variant which is only gray scale invariant [2]_. ``var`` Rotation invariant variance measures of the contrast of local image texture which is rotation but not gray scale invariant. Returns ------- output : (N, M) array LBP image. References ---------- .. [1] Multiresolution Gray-Scale and Rotation Invariant Texture Classification with Local Binary Patterns. Timo Ojala, Matti Pietikainen, Topi Maenpaa. http://www.ee.oulu.fi/research/mvmp/mvg/files/pdf/pdf_94.pdf, 2002. .. [2] Face recognition with local binary patterns. Timo Ahonen, Abdenour Hadid, Matti Pietikainen, http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.214.6851, 2004. """ check_nD(image, 2) methods = { 'default': ord('D'), 'ror': ord('R'), 'uniform': ord('U'), 'nri_uniform': ord('N'), 'var': ord('V') } image = np.ascontiguousarray(image, dtype=np.double) output = _local_binary_pattern(image, P, R, methods[method.lower()]) return output
def local_binary_pattern(image, P, R, method='default'): """Gray scale and rotation invariant LBP (Local Binary Patterns). LBP is an invariant descriptor that can be used for texture classification. Parameters ---------- image : (N, M) array Graylevel image. P : int Number of circularly symmetric neighbour set points (quantization of the angular space). R : float Radius of circle (spatial resolution of the operator). method : {'default', 'ror', 'uniform', 'var'} Method to determine the pattern: ``default`` Original local binary pattern which is gray scale but not rotation invariant. ``ror`` Extension of default implementation which is gray scale and rotation invariant. ``uniform`` Improved rotation invariance with uniform patterns and finer quantization of the angular space which is gray scale and rotation invariant. ``nri_uniform`` Non rotation-invariant uniform patterns variant which is only grayscale invariant [2]_. ``var`` Rotation invariant variance measures of the contrast of local image texture which is rotation but not gray scale invariant. Returns ------- output : (N, M) array LBP image. References ---------- .. [1] Multiresolution Gray-Scale and Rotation Invariant Texture Classification with Local Binary Patterns. Timo Ojala, Matti Pietikainen, Topi Maenpaa. http://www.ee.oulu.fi/research/mvmp/mvg/files/pdf/pdf_94.pdf, 2002. .. [2] Face recognition with local binary patterns. Timo Ahonen, Abdenour Hadid, Matti Pietikainen, http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.214.6851, 2004. """ check_nD(image, 2) methods = { 'default': ord('D'), 'ror': ord('R'), 'uniform': ord('U'), 'nri_uniform': ord('N'), 'var': ord('V') } image = np.ascontiguousarray(image, dtype=np.double) output = _local_binary_pattern(image, P, R, methods[method.lower()]) return output
41,687
def download_and_extract( buildpath: Path, srcpath: Path, src_metadata: Dict[str, Any], args ) -> Path: """ Download the source from specified in the meta data, then checksum it, then extract the archive into srcpath. buildpath -- The path to the build directory. Generally will be $(PYOIDE_ROOT)/packages/<package-name>/build/. srcpath -- The place we want the source to end up. Will generally be $(PYOIDE_ROOT)/packages/<package-name>/build/<package-name>-<package-version>. pkg -- The dictionary from parsing meta.yaml. """ response = request.urlopen(src_metadata["url"]) _, parameters = cgi.parse_header(response.headers.get("Content-Disposition", "")) if "filename" in parameters: tarballname = parameters["filename"] else: tarballname = Path(response.geturl()).name tarballpath = buildpath / tarballname if not tarballpath.is_file(): os.makedirs(os.path.dirname(tarballpath), exist_ok=True) with open(tarballpath, "wb") as f: f.write(response.read()) try: check_checksum(tarballpath, src_metadata) except Exception: tarballpath.unlink() raise if not srcpath.is_dir(): shutil.unpack_archive(str(tarballpath), str(buildpath)) extract_dir_name = src_metadata.get("extract_dir") if not extract_dir_name: extract_dir_name = trim_archive_extension(tarballname) return buildpath / extract_dir_name
def download_and_extract( buildpath: Path, srcpath: Path, src_metadata: Dict[str, Any], args ) -> Path: """ Download the source from specified in the meta data, then checksum it, then extract the archive into srcpath. buildpath -- The path to the build directory. Generally will be $(PYOIDE_ROOT)/packages/<package-name>/build/. srcpath -- The place we want the source to end up. Will generally be $(PYOIDE_ROOT)/packages/<package-name>/build/<package-name>-<package-version>. pkg -- The dictionary from parsing meta.yaml. """ response = request.urlopen(src_metadata["url"]) _, parameters = cgi.parse_header(response.headers.get("Content-Disposition", "")) if "filename" in parameters: tarballname = parameters["filename"] else: tarballname = Path(response.geturl()).name tarballpath = buildpath / tarballname if not tarballpath.is_file(): os.makedirs(tarballpath.parent, exist_ok=True) with open(tarballpath, "wb") as f: f.write(response.read()) try: check_checksum(tarballpath, src_metadata) except Exception: tarballpath.unlink() raise if not srcpath.is_dir(): shutil.unpack_archive(str(tarballpath), str(buildpath)) extract_dir_name = src_metadata.get("extract_dir") if not extract_dir_name: extract_dir_name = trim_archive_extension(tarballname) return buildpath / extract_dir_name
4,451
def test_foci_mapping(tmp_path): """Test mapping foci to the surface.""" tiny_brain, _ = tiny(tmp_path) foci_coords = tiny_brain.geo['lh'].coords[:2] + 0.01 tiny_brain.add_foci(foci_coords, map_surface='white') assert_array_equal(tiny_brain._data['lh']['foci'], tiny_brain.geo['lh'].coords[:2])
def test_foci_mapping(tmp_path, renderer_interactive_pyvistaqt): """Test mapping foci to the surface.""" tiny_brain, _ = tiny(tmp_path) foci_coords = tiny_brain.geo['lh'].coords[:2] + 0.01 tiny_brain.add_foci(foci_coords, map_surface='white') assert_array_equal(tiny_brain._data['lh']['foci'], tiny_brain.geo['lh'].coords[:2])
31,994
def create_time(given_time) -> str: """converts given argument time to iso format, if received None returns None""" if not given_time: return given_time datetime_time = arg_to_datetime(given_time) if not datetime_time: raise DemistoException("Time parameter supplied in invalid, please supply a valid argument") return datetime_time.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
def create_time(given_time) -> str: """converts given argument time to iso format, if received None returns None""" if not given_time: return given_time datetime_time = arg_to_datetime(given_time) if not datetime_time: raise DemistoException("Time parameter supplied in invalid, please supply a valid argument") return datetime_time.isoformat()