Datasets:

semeru

/

code-code-galeras-code-completion-from-docstring-3k-deduped

like 0

@Deprecated(message=deprecation_message) @dataclass

python/ray/util/ml_utils/checkpoint_manager.py

def _tune_legacy_checkpoint_score_attr(self) -> Optional[str]: if self.checkpoint_score_attribute is None: return self.checkpoint_score_attribute prefix = "" if self.checkpoint_score_order == MIN: prefix = "min-" return f"{prefix}{self.checkpoint_score_attribute}" # Alias for backwards compatibility deprecation_message = ( "`CheckpointStrategy` is deprecated and will be removed in " "the future. Please use `ray.air.config.CheckpointStrategy` " "instead." ) @Deprecated(message=deprecation_message) @da

[AIR] More checkpoint configurability, `Result` extension (#25943) This PR: * Allows the user to set `keep_checkpoints_num` and `checkpoint_score_attr` in `RunConfig` using the `CheckpointStrategy` dataclass * Adds two new fields to the `Result` object - `best_checkpoints` - a list of saved best checkpoints as determined by `CheckpointingConfig`.

_tune_legacy_checkpoint_score_attr

dc7ed086a5038775e378b32cb31fb4a79f418dd9

ray

checkpoint_manager.py

https://github.com/ray-project/ray.git

Python

def _tune_legacy_checkpoint_score_attr(self) -> Optional[str]: if self.checkpoint_score_attribute is None: return self.checkpoint_score_attribute prefix = "" if self.checkpoint_score_order == MIN: prefix = "min-" return f"{prefix}{self.checkpoint_score_attribute}" # Alias for backwards compatibility deprecation_message = ( "`CheckpointStrategy` is deprecated and will be removed in " "the future. Please use `ray.air.config.CheckpointStrategy` " "instead." ) @Deprecated(message=deprecation_message) @dataclass

tests/sentry/api/endpoints/test_project_details.py

def test_dynamic_sampling_bias_activation(self): project = self.project # force creation project.update_option( "sentry:dynamic_sampling_biases", [ {"id": "boostEnvironments", "active": False}, ], ) self.login_as(self.user) token = ApiToken.objects.create(user=self.user, scope_list=["project:write"]) authorization = f"Bearer {token.token}" url = reverse( "sentry-api-0-project-details", kwargs={ "organization_slug": self.project.organization.slug, "project_slug": self.project.slug,

ref(sampling): Prettify audit logs - Part 1 (#42534)

test_dynamic_sampling_bias_activation

b83aa7328d49e5b45357417c78b7d1a63bfb056e

sentry

test_project_details.py

https://github.com/getsentry/sentry.git

Python

def test_dynamic_sampling_bias_activation(self): project = self.project # force creation project.update_option( "sentry:dynamic_sampling_biases", [ {"id": "boostEnvironments", "active": False}, ], ) self.login_as(self.user) token = ApiToken.objects.create(user=self.user, scope_list=["project:write"]) authorization = f"Bearer {token.token}" url = reverse( "sentry-api-0-project-details", kwargs={ "organization_slug": self.project.organization.slug, "project_slug": self.project.slug, }, ) with Feature({self.new_ds_flag: True}): self.client.put( url, format="json", HTTP_AUTHORIZATION=authorization, data={ "dynamicSamplingBiases": [ {"id": "boostEnvironments", "active": True}, ] }, ) assert AuditLogEntry.objects.filter( organization=self.project.organization, event=audit_log.get_event_id("SAMPLING_BIAS_ENABLED"), ).exists()

lib/model/layers.py

def call(self, inputs, *args, **kwargs): input_shape = K.int_shape(inputs) if len(input_shape) != 4: raise ValueError('Inputs should have rank ' + str(4) + '; Received input shape:', str(input_shape)) if self.data_format == 'channels_first': batch_size, channels, height, width = input_shape if batch_size is None: batch_size = -1 r_height, r_width = self.size o_height, o_width = height * r_height, width * r_width o_channels = channels // (r_height * r_width) out = K.reshape(inputs, (batch_size, r_height, r_width, o_channels, height, width)) out = K.permute_dimensions(out, (0, 3, 4, 1, 5, 2)) out = K.reshape(out, (batch_size, o_channels, o_height, o_width)) elif self.data_format == 'channels_last': batch_size, height, width, channels = input_shape if batch_size is None: batch_size = -1 r_height, r_width = self.size o_height, o_width = height * r_height, width * r_width o_channels = channels // (r_height * r_width) out = K.reshape(inputs, (ba

Update code to support Tensorflow versions up to 2.8 (#1213) * Update maximum tf version in setup + requirements * - bump max version of tf version in launcher - standardise tf version check * update keras get_custom_objects for tf>2.6 * bugfix: force black text in GUI file dialogs (linux) * dssim loss - Move to stock tf.ssim function * Update optimizer imports for compatibility * fix logging for tf2.8 * Fix GUI graphing for TF2.8 * update tests * bump requirements.txt versions * Remove limit on nvidia-ml-py * Graphing bugfixes - Prevent live graph from displaying if data not yet available * bugfix: Live graph. Collect loss labels correctly * fix: live graph - swallow inconsistent loss errors * Bugfix: Prevent live graph from clearing during training * Fix graphing for AMD

call

c1512fd41d86ef47a5d1ce618d6d755ef7cbacdf

faceswap

layers.py

https://github.com/deepfakes/faceswap.git

Python

def call(self, inputs, *args, **kwargs): input_shape = K.int_shape(inputs) if len(input_shape) != 4: raise ValueError('Inputs should have rank ' + str(4) + '; Received input shape:', str(input_shape)) if self.data_format == 'channels_first': batch_size, channels, height, width = input_shape if batch_size is None: batch_size = -1 r_height, r_width = self.size o_height, o_width = height * r_height, width * r_width o_channels = channels // (r_height * r_width) out = K.reshape(inputs, (batch_size, r_height, r_width, o_channels, height, width)) out = K.permute_dimensions(out, (0, 3, 4, 1, 5, 2)) out = K.reshape(out, (batch_size, o_channels, o_height, o_width)) elif self.data_format == 'channels_last': batch_size, height, width, channels = input_shape if batch_size is None: batch_size = -1 r_height, r_width = self.size o_height, o_width = height * r_height, width * r_width o_channels = channels // (r_height * r_width) out = K.reshape(inputs, (batch_size, height, width, r_height, r_width, o_channels)) out = K.permute_dimensions(out, (0, 1, 3, 2, 4, 5)) out = K.reshape(out, (batch_size, o_height, o_width, o_channels)) return out

pandas/core/indexes/base.py

def to_native_types(self, slicer=None, **kwargs) -> np.ndarray: warnings.warn( "The 'to_native_types' method is deprecated and will be removed in " "a future version. Use 'astype(str)' instead.", FutureWarning, stacklevel=find_stack_level(inspect.currentframe()), ) values = self

PERF cache find_stack_level (#48023) cache stacklevel

to_native_types

2f8d0a36703e81e4dca52ca9fe4f58c910c1b304

pandas

base.py

https://github.com/pandas-dev/pandas.git

Python

def to_native_types(self, slicer=None, **kwargs) -> np.ndarray: warnings.warn( "The 'to_native_types' method is deprecated and will be removed in " "a future version. Use 'astype(str)' instead.", FutureWarning, stacklevel=find_stack_level(inspect.currentframe()), ) values = self if slicer is not None: values = values[slicer] return values._format_native_types(**kwargs)

networkx/algorithms/distance_measures.py

def periphery(G, e=None, usebounds=False, weight=None): if usebounds is True and e is None and not G.is_directed(): return _extrema_bounding(G, compute="periphery", weight=weight)

Add weight distance metrics (#5305) Adds the weight keyword argument to allow users to compute weighted distance metrics e.g. diameter, eccentricity, periphery, etc. The kwarg works in the same fashion as the weight param for shortest paths - i.e. if a string, look up with edge attr by key, if callable, compute the weight via the function. Default is None, meaning return unweighted result which is the current behavior. Co-authored-by: Dan Schult <dschult@colgate.edu> Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>

periphery

28f78cfa9a386620ee1179582fda1db5ffc59f84

networkx

distance_measures.py

https://github.com/networkx/networkx.git

Python

def periphery(G, e=None, usebounds=False, weight=None): if usebounds is True and e is None and not G.is_directed(): return _extrema_bounding(G, compute="periphery", weight=weight) if e is None: e = eccentricity(G, weight=weight) diameter = max(e.values()) p = [v for v in e if e[v] == diameter] return p

homeassistant/components/zwave_js/climate.py

def _current_mode_setpoint_enums(self) -> list[ThermostatSetpointType | None]: if self._current_mode is None: # Thermostat(valve) with no support for setting a mode is considered heating-only return [ThermostatSetpointType.HEATING] return THERMOSTA

Add type ignore error codes [N-Z] (#66779)

_current_mode_setpoint_enums

67e94f2b4ba614a37544f54ccb85984f0d600376

core

climate.py

https://github.com/home-assistant/core.git

Python

def _current_mode_setpoint_enums(self) -> list[ThermostatSetpointType | None]: if self._current_mode is None: # Thermostat(valve) with no support for setting a mode is considered heating-only return [ThermostatSetpointType.HEATING] return THERMOSTAT_MODE_SETPOINT_MAP.get(int(self._current_mode.value), []) # type: ignore[no-any-return]

.venv/lib/python3.8/site-packages/pip/_vendor/pyparsing.py

def line(loc, strg): lastCR = strg.rfind("\n", 0, loc) nextCR = strg.find("\n", loc) if nextCR >= 0: return strg[lastCR + 1:nextCR] else: return strg[lastCR + 1:]

upd; format

line

f638f5d0e6c8ebed0e69a6584bc7f003ec646580

transferlearning

pyparsing.py

https://github.com/jindongwang/transferlearning.git

Python

def line(loc, strg): lastCR = strg.rfind("\n", 0, loc) nextCR = strg.find("\n", loc) if nextCR >= 0: return strg[lastCR + 1:nextCR] else: return strg[lastCR + 1:]

lib/sysinfo.py

def _parse_configs(self, config_files): formatted = "" for cfile in config_files: fname = os.path.basename(cfile) ext = os.path.splitext(cfile)[1] formatted += f"\n--------- {fname} ---------\n" if ext == ".ini":

Allow decoding errors

_parse_configs

48c886b3dce3d3117ad16edaf35c8abd28dc51f5

faceswap

sysinfo.py

https://github.com/deepfakes/faceswap.git

Python

def _parse_configs(self, config_files): formatted = "" for cfile in config_files: fname = os.path.basename(cfile) ext = os.path.splitext(cfile)[1] formatted += f"\n--------- {fname} ---------\n" if ext == ".ini": formatted += self._parse_ini(cfile) elif fname == ".faceswap": formatted += self._parse_json(cfile) return formatted

src/textual/dom.py

def parent(self) -> DOMNode: if self._parent is None: raise NoParent(f"{self} has no parent") assert isinstance(self._parent, DOMNode) return self._parent

docstrings and tidy

parent

2635f58e7c3d10b161ee69a15ebfe6499ac26daa

textual

dom.py

https://github.com/Textualize/textual.git

Python

def parent(self) -> DOMNode: if self._parent is None: raise NoParent(f"{self} has no parent") assert isinstance(self._parent, DOMNode) return self._parent

pipenv/patched/notpip/_vendor/platformdirs/unix.py

def user_documents_dir(self) -> str: documents_dir = _get_user_dirs_folder("XDG_DOCUMENTS_DIR") if documents_dir is None: documents_dir = os.environ.get("XDG_DOCUMENTS_DIR", "").strip() if not documents_dir: documents_dir = os.path.ex

check point progress on only bringing in pip==22.0.4 (#4966) * vendor in pip==22.0.4 * updating vendor packaging version * update pipdeptree to fix pipenv graph with new version of pip. * Vendoring of pip-shims 0.7.0 * Vendoring of requirementslib 1.6.3 * Update pip index safety restrictions patch for pip==22.0.4 * Update patches * exclude pyptoject.toml from black to see if that helps. * Move this part of the hash collection back to the top (like prior implementation) because it affects the outcome of this test now in pip 22.0.4

user_documents_dir

f3166e673fe8d40277b804d35d77dcdb760fc3b3

pipenv

unix.py

https://github.com/pypa/pipenv.git

Python

def user_documents_dir(self) -> str: documents_dir = _get_user_dirs_folder("XDG_DOCUMENTS_DIR") if documents_dir is None: documents_dir = os.environ.get("XDG_DOCUMENTS_DIR", "").strip() if not documents_dir: documents_dir = os.path.expanduser("~/Documents") return documents_dir

sklearn/ensemble/tests/test_iforest.py

def test_iforest_sparse(global_random_seed): rng = check_random_state(global_random_seed) X_train, X_test = train_test_split(diabetes.data[:50], random_state=rng) grid = ParameterGrid({"m

TST use global_random_seed in sklearn/ensemble/tests/test_iforest.py (#22901) Co-authored-by: jeremie du boisberranger <jeremiedbb@yahoo.fr> Co-authored-by: Guillaume Lemaitre <g.lemaitre58@gmail.com> Co-authored-by: Olivier Grisel <olivier.grisel@ensta.org>

test_iforest_sparse

6ca1f5e4d0d16bc9a7f28582079a15e14f012719

scikit-learn

test_iforest.py

https://github.com/scikit-learn/scikit-learn.git

Python

def test_iforest_sparse(global_random_seed): rng = check_random_state(global_random_seed) X_train, X_test = train_test_split(diabetes.data[:50], random_state=rng) grid = ParameterGrid({"max_samples": [0.5, 1.0], "bootstrap": [True, False]}) for sparse_format in [csc_matrix, csr_matrix]: X_train_sparse = sparse_format(X_train) X_test_sparse = sparse_format(X_test) for params in grid: # Trained on sparse format sparse_classifier = IsolationForest( n_estimators=10, random_state=global_random_seed, **params ).fit(X_train_sparse) sparse_results = sparse_classifier.predict(X_test_sparse) # Trained on dense format dense_classifier = IsolationForest( n_estimators=10, random_state=global_random_seed, **params ).fit(X_train) dense_results = dense_classifier.predict(X_test) assert_array_equal(sparse_results, dense_results)

sklearn/metrics/_scorer.py

def get_scorer_names():

API get_scorer returns a copy and introduce get_scorer_names (#22866)

get_scorer_names

7dc97a378ecbfa056dd9cfa9d1ef4c07d2d0cc1f

scikit-learn

_scorer.py

https://github.com/scikit-learn/scikit-learn.git

Python

def get_scorer_names(): return sorted(_SCORERS.keys()) for name, metric in [ ("precision", precision_score), ("recall", recall_score), ("f1", f1_score), ("jaccard", jaccard_score), ]: _SCORERS[name] = make_scorer(metric, average="binary") for average in ["macro", "micro", "samples", "weighted"]: qualified_name = "{0}_{1}".format(name, average) _SCORERS[qualified_name] = make_scorer(metric, pos_label=None, average=average) SCORERS = _DeprecatedScorers(_SCORERS)

datasets/swda/swda.py

def _split_generators(self, dl_manager): # Download extract and return path of data file. dl_dir = dl_manager.download_and_extract(_URL) # Use swda/ folder. data_dir = os.path.join(dl_dir, "swda") # Handle partitions files: download extract and return paths of split files. downloaded_files = dl_manager.download(self._URLS) return [ # Return whole data path and train splits file downloaded path. datasets.SplitGenerator( name=datasets.Split.TRAIN, gen_kwargs={"data_dir": data_dir, "split_file": downloaded_files["train"]} ), # Return whole data path and dev splits file downloaded path. datasets.SplitGenerator( name=datasets.Split.VALIDATION, gen_kwargs={"data_dir": data_dir, "split_file": downloaded_files["dev"]}, ), # Return whole data path and train splits file downloaded path. datasets.SplitGenerator(

Support streaming swda dataset (#4914) * Support streaming swda dataset * Remove unused import

_split_generators

f10d38b8b60b09a633823a2fb2529c83933b9c80

datasets

swda.py

https://github.com/huggingface/datasets.git

Python

def _split_generators(self, dl_manager): # Download extract and return path of data file. dl_dir = dl_manager.download_and_extract(_URL) # Use swda/ folder. data_dir = os.path.join(dl_dir, "swda") # Handle partitions files: download extract and return paths of split files. downloaded_files = dl_manager.download(self._URLS) return [ # Return whole data path and train splits file downloaded path. datasets.SplitGenerator( name=datasets.Split.TRAIN, gen_kwargs={"data_dir": data_dir, "split_file": downloaded_files["train"]} ), # Return whole data path and dev splits file downloaded path. datasets.SplitGenerator( name=datasets.Split.VALIDATION, gen_kwargs={"data_dir": data_dir, "split_file": downloaded_files["dev"]}, ), # Return whole data path and train splits file downloaded path. datasets.SplitGenerator( name=datasets.Split.TEST, gen_kwargs={"data_dir": data_dir, "split_file": downloaded_files["test"]} ), ]

gamestonk_terminal/stocks/discovery/disc_controller.py

def print_help(self): help

Terminal Wide Rich (#1161) * My idea for how we handle Rich moving forward * remove independent consoles * FIxed pylint issues * add a few vars * Switched print to console * More transitions * Changed more prints * Replaced all prints * Fixing tabulate * Finished replace tabulate * Finished removing rich from Tabulate * add Panel around menu * add GST watermark under feature flag * Fixed 46 tests * Delete test_screener[False].yaml * Delete test_screener[True].yaml * Fixed the rest of the tests * add help and source color vars and use rgb * rich on stocks/options * update rich on disc, dps, sia * rich in gov, ins and scr menus * ba and ca menus with rich * Fixed import issue * Fixed some tests * removed termcolor * Removed prettytable * add rich to remaining stocks menus * FIxed linting issue * Added James' changes * Updated dependencies * Add rich to cryptocurrency menu * refactor economy and forex * refactor etf with rich * refactor mfunds * refactor rich rest * not specify style so default color works well on any background * Fixing mypy issues * Updated tests * More test fixes * James' test fixes * Updating tests : stocks/screener - fix cassettes using BR * Updating tests : crypto * Updating tests : disable DEBUG_MODE * Updating tests : stocks/fa/yfinance * minor fixes that escape * Improve the rich table function (that replaces tabulate :D ) * Fixed bad code * delete rogue file + dcf fix + NoConsole * sia mypy * fuck you linter * fuck you linter pt 2 * skip hehe * i hate the black linter * ubuntu mypy attempt * Update : rich_config + gtff * Updating tests : conftest * Updating tests : stocks * Update : rich_config * Updating : rich_config * make panel configurable for Theodore :b * colors update * Merged * Updating : rich_config + feature_flags * Updating : rich_config * Updating tests : stocks * Updating : feature_flags Co-authored-by: DidierRLopes <dro.lopes@campus.fct.unl.pt> Co-authored-by: Chavithra PARANA <chavithra@gmail.com> Co-authored-by: james <jmaslek11@gmail.com> Co-authored-by: jose-donato <zmcdonato@gmail.com>

print_help

82747072c511beb1b2672846ae2ee4aec53eb562

OpenBBTerminal

disc_controller.py

https://github.com/OpenBB-finance/OpenBBTerminal.git

Python

def print_help(self): help_text = console.print(text=help_text, menu="Stocks - Discovery")

django/core/serializers/xml_serializer.py

def handle_fk_field(self, obj, field): self._start_relational_field(field) related_att = getattr(obj, field.get_attname()) if related_att is not None: if self.use_natural_foreign_keys and hasattr( field.remote_field.model, "natural_key" ): related = getattr(obj, field.name) # If related object has a natural key, use it related = related.natural_key() # Iterable natural keys are rolled out as subelements for key_value in related:

Refs #33476 -- Reformatted code with Black.

handle_fk_field

9c19aff7c7561e3a82978a272ecdaad40dda5c00

django

xml_serializer.py

https://github.com/django/django.git

Python

def handle_fk_field(self, obj, field): self._start_relational_field(field) related_att = getattr(obj, field.get_attname()) if related_att is not None: if self.use_natural_foreign_keys and hasattr( field.remote_field.model, "natural_key" ): related = getattr(obj, field.name) # If related object has a natural key, use it related = related.natural_key() # Iterable natural keys are rolled out as subelements for key_value in related: self.xml.startElement("natural", {}) self.xml.characters(str(key_value)) self.xml.endElement("natural") else: self.xml.characters(str(related_att)) else: self.xml.addQuickElement("None") self.xml.endElement("field")

python/ray/tests/test_metrics_head.py

def test_metrics_folder(): with _ray_start(include_dashboard=True) as context: session_dir = context["session_dir"] assert os.path.exists( f"{session_dir}/metrics/grafana/provisioning/dashboards/default.yml" ) assert os.path.exists( f"{session_dir}/metrics/grafana/provisioning/dashboards" "/default_grafana_dashboard.json" ) assert os.path.exists( f"{session_dir}/metrics/grafana/provisioning/

Export default configurations for grafana and prometheus (#28286)

test_metrics_folder

42da4445e7a3cb358a1a02ae433a004e9fa836b5

ray

test_metrics_head.py

https://github.com/ray-project/ray.git

Python

def test_metrics_folder(): with _ray_start(include_dashboard=True) as context: session_dir = context["session_dir"] assert os.path.exists( f"{session_dir}/metrics/grafana/provisioning/dashboards/default.yml" ) assert os.path.exists( f"{session_dir}/metrics/grafana/provisioning/dashboards" "/default_grafana_dashboard.json" ) assert os.path.exists( f"{session_dir}/metrics/grafana/provisioning/datasources/default.yml" ) assert os.path.exists(f"{session_dir}/metrics/prometheus/prometheus.yml")

deepspeed/runtime/fp16/fused_optimizer.py

def state_dict(self): state_dict = {} state_dict['dynamic_loss_scale'] = self.dynamic_loss_scale state_dict['cur_scale'] = self.cur_scale state_dict['cur_iter'] = self.cur_iter if state_dict['dynamic_loss_scale']: state_dict['last_overflow_iter'] = self.last_overflow_iter state_dict['scale_factor'] = self.scale_factor state_dict['scale_window'] = self.scale_window state_dict[OPTIMIZER_STATE_DICT] = self.optimize

[ZeRO] Default disable elastic ckpt in stage 1+2 and reduce CPU memory overhead during ckpt load (#1525) Co-authored-by: Olatunji Ruwase <olruwase@microsoft.com>

state_dict

3293cf72a0abd5cf77a831996bd054bc908476a6

DeepSpeed

fused_optimizer.py

https://github.com/microsoft/DeepSpeed.git

Python

def state_dict(self): state_dict = {} state_dict['dynamic_loss_scale'] = self.dynamic_loss_scale state_dict['cur_scale'] = self.cur_scale state_dict['cur_iter'] = self.cur_iter if state_dict['dynamic_loss_scale']: state_dict['last_overflow_iter'] = self.last_overflow_iter state_dict['scale_factor'] = self.scale_factor state_dict['scale_window'] = self.scale_window state_dict[OPTIMIZER_STATE_DICT] = self.optimizer.state_dict() state_dict['fp32_groups_flat'] = self.fp32_groups_flat state_dict['clip_grad'] = self.clip_grad return state_dict # Refresh fp32 master params from fp16 copies

sklearn/naive_bayes.py

def _update_mean_variance(n_past, mu, var, X, sample_weight=None): if X.shape[0] == 0: return mu, var # Compute (potentially weighted) mean and variance of new datapoints if sample_weight is not None: n_new = float(sample_weight.sum()) if np.isclose(n_new, 0.0): return mu, var new_mu = np.average(X, axis=0, weights=sample_weight) new_var = np.average((X - new_mu) ** 2, axis=0, weights=sample_weig

TST Add common tests for single class fitting induced by sample weights (#24140) Co-authored-by: johayon <johayon.math@gmail.com> Co-authored-by: Guillaume Lemaitre <g.lemaitre58@gmail.com>

_update_mean_variance

2cce02414d4a7161f0d105450c196d94b1182220

scikit-learn

naive_bayes.py

https://github.com/scikit-learn/scikit-learn.git

Python

def _update_mean_variance(n_past, mu, var, X, sample_weight=None): if X.shape[0] == 0: return mu, var # Compute (potentially weighted) mean and variance of new datapoints if sample_weight is not None: n_new = float(sample_weight.sum()) if np.isclose(n_new, 0.0): return mu, var new_mu = np.average(X, axis=0, weights=sample_weight) new_var = np.average((X - new_mu) ** 2, axis=0, weights=sample_weight) else: n_new = X.shape[0] new_var = np.var(X, axis=0) new_mu = np.mean(X, axis=0) if n_past == 0: return new_mu, new_var n_total = float(n_past + n_new) # Combine mean of old and new data, taking into consideration # (weighted) number of observations total_mu = (n_new * new_mu + n_past * mu) / n_total # Combine variance of old and new data, taking into consideration # (weighted) number of observations. This is achieved by combining # the sum-of-squared-differences (ssd) old_ssd = n_past * var new_ssd = n_new * new_var total_ssd = old_ssd + new_ssd + (n_new * n_past / n_total) * (mu - new_mu) ** 2 total_var = total_ssd / n_total return total_mu, total_var

sympy/functions/combinatorial/numbers.py

def is_prime(n): sympy_deprecation_warning( ,

Deprecate redundant static methods

is_prime

b27e2b44626d138bd6ea235fbf114644baa5b144

sympy

numbers.py

https://github.com/sympy/sympy.git

Python

def is_prime(n): sympy_deprecation_warning( , deprecated_since_version="1.11", active_deprecations_target='deprecated-carmichael-static-methods', ) return isprime(n)

python3.10.4/Lib/base64.py

def standard_b64decode(s): return b64decode(s) _urlsafe_encode_tr

add python 3.10.4 for windows

standard_b64decode

8198943edd73a363c266633e1aa5b2a9e9c9f526

XX-Net

base64.py

https://github.com/XX-net/XX-Net.git

Python

def standard_b64decode(s): return b64decode(s) _urlsafe_encode_translation = bytes.maketrans(b'+/', b'-_') _urlsafe_decode_translation = bytes.maketrans(b'-_', b'+/')

python/ray/util/sgd/torch/examples/dcgan.py

def inception_score(self, imgs, batch_size=32, splits=1): N = len(imgs) dataloader = torch.utils.data.DataLoader(imgs, batch_size=batch_size) up = nn.Upsample( size=(28, 28), mo

[CI] Format Python code with Black (#21975) See #21316 and #21311 for the motivation behind these changes.

inception_score

7f1bacc7dc9caf6d0ec042e39499bbf1d9a7d065

ray

dcgan.py

https://github.com/ray-project/ray.git

Python

def inception_score(self, imgs, batch_size=32, splits=1): N = len(imgs) dataloader = torch.utils.data.DataLoader(imgs, batch_size=batch_size) up = nn.Upsample( size=(28, 28), mode="bilinear", align_corners=False, # This is to reduce user warnings from torch. ).type(torch.FloatTensor)

erpnext/patches/v13_0/update_shipment_status.py

def execute(): frappe.reload_doc("stock", "doctype", "shipment") # update submitted status frappe.db.sql( )

style: format code with black

execute

494bd9ef78313436f0424b918f200dab8fc7c20b

erpnext

update_shipment_status.py

https://github.com/frappe/erpnext.git

Python

def execute(): frappe.reload_doc("stock", "doctype", "shipment") # update submitted status frappe.db.sql( ) # update cancelled status frappe.db.sql( )

django/core/files/storage.py

def url(self, name): raise NotImplementedError("subclasses of Storage must provide a url() method

Refs #33476 -- Reformatted code with Black.

url

9c19aff7c7561e3a82978a272ecdaad40dda5c00

django

storage.py

https://github.com/django/django.git

Python

def url(self, name): raise NotImplementedError("subclasses of Storage must provide a url() method")

keras/saving/hdf5_format.py

def load_attributes_from_hdf5_group(group, name): if name in group.

Reformatting the codebase with black. PiperOrigin-RevId: 450093126

load_attributes_from_hdf5_group

84afc5193d38057e2e2badf9c889ea87d80d8fbf

keras

hdf5_format.py

https://github.com/keras-team/keras.git

Python

def load_attributes_from_hdf5_group(group, name): if name in group.attrs: data = [ n.decode("utf8") if hasattr(n, "decode") else n for n in group.attrs[name] ] else: data = [] chunk_id = 0 while "%s%d" % (name, chunk_id) in group.attrs: data.extend( [ n.decode("utf8") if hasattr(n, "decode") else n for n in group.attrs["%s%d" % (name, chunk_id)] ] ) chunk_id += 1 return data

src/prefect/orion/models/block_schemas.py

def _find_root_block_schema(block_schemas_with_references): return next( ( block_schema for ( block_schema, _, parent_block_schema_id, ) in block_schemas_with_references if parent_block_schema_

Nested Block Schemas (PrefectHQ/orion#1846) * Adds models and migration for block schema and block document references * Adds customization to the generation of a block schema's fields * Adds ability to reconstruct block schema fields on read * Adds ability to reconstruct block schema when read by checksum * Adds schema reconstruction when reading multiple block schemas * Adds ordering to query of recursive CTE * Refactors to make code path and purpose easier to follow

_find_root_block_schema

a05e44c89acf0b6073ac876479be24a5e51d7754

prefect

block_schemas.py

https://github.com/PrefectHQ/prefect.git

Python

def _find_root_block_schema(block_schemas_with_references): return next( ( block_schema for ( block_schema, _, parent_block_schema_id, ) in block_schemas_with_references if parent_block_schema_id is None ), None, )

ppocr/modeling/heads/local_graph.py

def feature_embedding(input_feats, out_feat_len): assert input_feats.ndim == 2 assert isinstance(out_feat_len, int) assert out_feat_len >= input_feats.shape[1] num_nodes = input_feats.shape[0] feat_dim = input_feats.shape[1] feat_repeat_times = out_feat_len // feat_dim residue_dim = out_feat_len % feat_dim if residue_dim > 0: embed_wave = np.array([ np.power(1000, 2.0 * (j // 2) / feat_repeat_times + 1) for j in range(feat_repeat_times + 1) ]).reshape((feat_repeat_times + 1, 1, 1)) repeat_feats = np.repeat( np.expand_dims( input_feats, axis=0), feat_repeat_times, axis=0) residue_feats = np.hstack([ input_feats[:, 0:residue_dim], np.zeros( (num_nodes, feat_dim - residue_dim)) ]) residue_feats = np.expand_dims(residue_feats, axis=0) repeat_feats = np.concatenate([repeat_feats, residue_feats], axis=0) embedded_feats = repeat_feats / embed_wave embedded_feats[:, 0::2] = np.sin(embedded_feats[:, 0::2]) embedded_feats[:, 1::2] = np.cos(embedded_feats[:, 1::2]) embedded_feats = np.transpose(embedded_feats, (1, 0, 2)).reshape( (num_nodes, -1))[:, 0:out_feat_len] else: embed_wave = np.array([ np.power(1000, 2.0 * (j // 2) / feat_repeat_times) for j in range(feat_repeat_times) ]).reshape((feat_repeat_times, 1, 1)) repeat_feats = np.repeat( np.expand_dims( input_feats, axis=0), feat_repeat_times, axis=0) embedded_feats = repeat_feats / embed_wave

add drrg

feature_embedding

1f9400dd7374ce9cc47981372e324ff412e53ba3

PaddleOCR

local_graph.py

https://github.com/PaddlePaddle/PaddleOCR.git

Python

def feature_embedding(input_feats, out_feat_len): assert input_feats.ndim == 2 assert isinstance(out_feat_len, int) assert out_feat_len >= input_feats.shape[1] num_nodes = input_feats.shape[0] feat_dim = input_feats.shape[1] feat_repeat_times = out_feat_len // feat_dim residue_dim = out_feat_len % feat_dim if residue_dim > 0: embed_wave = np.array([ np.power(1000, 2.0 * (j // 2) / feat_repeat_times + 1) for j in range(feat_repeat_times + 1) ]).reshape((feat_repeat_times + 1, 1, 1)) repeat_feats = np.repeat( np.expand_dims( input_feats, axis=0), feat_repeat_times, axis=0) residue_feats = np.hstack([ input_feats[:, 0:residue_dim], np.zeros( (num_nodes, feat_dim - residue_dim)) ]) residue_feats = np.expand_dims(residue_feats, axis=0) repeat_feats = np.concatenate([repeat_feats, residue_feats], axis=0) embedded_feats = repeat_feats / embed_wave embedded_feats[:, 0::2] = np.sin(embedded_feats[:, 0::2]) embedded_feats[:, 1::2] = np.cos(embedded_feats[:, 1::2]) embedded_feats = np.transpose(embedded_feats, (1, 0, 2)).reshape( (num_nodes, -1))[:, 0:out_feat_len] else: embed_wave = np.array([ np.power(1000, 2.0 * (j // 2) / feat_repeat_times) for j in range(feat_repeat_times) ]).reshape((feat_repeat_times, 1, 1)) repeat_feats = np.repeat( np.expand_dims( input_feats, axis=0), feat_repeat_times, axis=0) embedded_feats = repeat_feats / embed_wave embedded_feats[:, 0::2] = np.sin(embedded_feats[:, 0::2]) embedded_feats[:, 1::2] = np.cos(embedded_feats[:, 1::2]) embedded_feats = np.transpose(embedded_feats, (1, 0, 2)).reshape( (num_nodes, -1)).astype(np.float32) return embedded_feats

sklearn/linear_model/_base.py

def decision_function(self, X): check_is_fitted(self) xp, _ = get_namespace(X) X = s

ENH Adds Array API support to LinearDiscriminantAnalysis (#22554) Co-authored-by: Olivier Grisel <olivier.grisel@ensta.org> Co-authored-by: Julien Jerphanion <git@jjerphan.xyz>

decision_function

2710a9e7eefd2088ce35fd2fb6651d5f97e5ef8b

scikit-learn

_base.py

https://github.com/scikit-learn/scikit-learn.git

Python

def decision_function(self, X): check_is_fitted(self) xp, _ = get_namespace(X) X = self._validate_data(X, accept_sparse="csr", reset=False) scores = safe_sparse_dot(X, self.coef_.T, dense_output=True) + self.intercept_ return xp.reshape(scores, -1) if scores.shape[1] == 1 else scores

backend/postprocessing/rankings.py

def get_ranking(pairs): if len(pairs) == 1: return list(

ran pre-commit hook

get_ranking

38ca08446d560797522b7828720032799584d32a

Open-Assistant

rankings.py

https://github.com/LAION-AI/Open-Assistant.git

Python

def get_ranking(pairs): if len(pairs) == 1: return list(pairs[0]) w = get_winner(pairs) # now remove the winner from the list of pairs p_new = np.array([(a, b) for a, b in pairs if a != w]) return [w] + get_ranking(p_new)

.venv/lib/python3.8/site-packages/pip/_internal/utils/misc.py

def backup_dir(dir, ext=".bak"): # type: (str, str) -> str n = 1 extension = ext while os.path.exists(dir + extension): n += 1 extension = ext + str(n) return dir + extens

upd; format

backup_dir

f638f5d0e6c8ebed0e69a6584bc7f003ec646580

transferlearning

misc.py

https://github.com/jindongwang/transferlearning.git

Python

def backup_dir(dir, ext=".bak"): # type: (str, str) -> str n = 1 extension = ext while os.path.exists(dir + extension): n += 1 extension = ext + str(n) return dir + extension

rllib/utils/filter_manager.py

def synchronize(local_filters, remotes, update_remote=True): remote_filters = ray.get( [r.get_filters.remote(flush_

Clean up docstyle in python modules and add LINT rule (#25272)

synchronize

905258dbc19753c81039f993477e7ab027960729

ray

filter_manager.py

https://github.com/ray-project/ray.git

Python

def synchronize(local_filters, remotes, update_remote=True): remote_filters = ray.get( [r.get_filters.remote(flush_after=True) for r in remotes] ) for rf in remote_filters: for k in local_filters: local_filters[k].apply_changes(rf[k], with_buffer=False) if update_remote: copies = {k: v.as_serializable() for k, v in local_filters.items()} remote_copy = ray.put(copies) [r.sync_filters.remote(remote_copy) for r in remotes]

sklearn/tests/test_base.py

def test_estimator_empty_instance_dict(estimator): state = estimator.__getstate__() expected = {"_sklearn_version": sklearn.__version__} assert state == expected # this should not raise pickle.loads(pickle.dumps(BaseEstimator()))

FIX fix pickling for empty object with Python 3.11+ (#25188) Co-authored-by: Adrin Jalali <adrin.jalali@gmail.com> Co-authored-by: Guillaume Lemaitre <g.lemaitre58@gmail.com> Python 3.11 introduces `__getstate__` on the `object` level, which breaks our existing `__getstate__` code for objects w/o any attributes. This fixes the issue.

test_estimator_empty_instance_dict

9017c701833114a75903f580dd0772e1d8d7d125

scikit-learn

test_base.py

https://github.com/scikit-learn/scikit-learn.git

Python

def test_estimator_empty_instance_dict(estimator): state = estimator.__getstate__() expected = {"_sklearn_version": sklearn.__version__} assert state == expected # this should not raise pickle.loads(pickle.dumps(BaseEstimator()))

wagtail/admin/tests/test_templatetags.py

def test_with_variables(self): context = Context({"name": "j

Introduce new template fragment composition tags

test_with_variables

524cab82e33b43463b746c3df1a80657b3ae874a

wagtail

test_templatetags.py

https://github.com/wagtail/wagtail.git

Python

def test_with_variables(self): context = Context({"name": "jonathan wells"}) template = expected = self.assertHTMLEqual(expected, Template(template).render(context))

lib/ansible/executor/module_common.py

def _extract_interpreter(b_module_data): interpreter = None args = [] b_lines = b_module_data.split(b"\n", 1) if b_lines[0].startswith(b"#!"): b_shebang = b_lines[0].strip() # shlex.split on python-2.6 needs bytes. On python-3.x it needs text cli_split =

Allow specifying specific python via shebang (#76677) modules with python were always normalized to /usr/bin/python, while other interpreters could have specific versions. * now shebang is always constructed by get_shebang and args are preserved * only update shebang if interpreter changed * updated test expectation * added python shebang test

_extract_interpreter

9142be2f6cabbe6597c9254c5bb9186d17036d55

ansible

module_common.py

https://github.com/ansible/ansible.git

Python

def _extract_interpreter(b_module_data): interpreter = None args = [] b_lines = b_module_data.split(b"\n", 1) if b_lines[0].startswith(b"#!"): b_shebang = b_lines[0].strip() # shlex.split on python-2.6 needs bytes. On python-3.x it needs text cli_split = shlex.split(to_native(b_shebang[2:], errors='surrogate_or_strict')) # convert args to text cli_split = [to_text(a, errors='surrogate_or_strict') for a in cli_split] interpreter = cli_split[0] args = cli_split[1:] return interpreter, args

python/ray/tune/tests/test_tune_restore.py

def test_resource_exhausted_info(self):

[tune] Fix test_resource_exhausted_info test (#27426) #27213 broke this test Signed-off-by: Kai Fricke <kai@anyscale.com>

test_resource_exhausted_info

46ed3557ba6b4f4f72c15ef960aba5270ada2a9c

ray

test_tune_restore.py

https://github.com/ray-project/ray.git

Python

def test_resource_exhausted_info(self): # generate some random data to be captured implicitly in training func. from sklearn.datasets import fetch_olivetti_faces a_large_array = [] for i in range(50): a_large_array.append(fetch_olivetti_faces())

tests/conftest.py

def testing_session_settings(): with tempfile.TemporaryDirectory() as tmpdir: profile = prefect.settings.Profile( name="test-session", settings={ # Set PREFECT_HOME to a temporary directory to avoid clobbering # environments and settings PREFECT_HOME: tmpdir, PREFECT_PROFILES_PATH: "$PREFECT_HOME/profiles.toml", # Enable debug logging PREFECT_LOGGING_LEVEL: "DEBUG", # Disable shipping logs to the API; # can be enabled by the `enable_orion_handler` mark PREFECT_LOGGING_ORION_ENABLED: False, # Disable services for test runs PREFECT_ORION_ANALYTICS_ENABLED: False, PREFECT_ORION_SERVICES_LATE_RUNS_ENABLED: False, PREFECT_ORION_SERVICES_SCHEDULER_ENABLED: False, }, source=__file__, )

Squash issues with tests

testing_session_settings

4adc737611ffa284d9952779ba2f68174a7e73cc

prefect

conftest.py

https://github.com/PrefectHQ/prefect.git

Python

def testing_session_settings(): with tempfile.TemporaryDirectory() as tmpdir: profile = prefect.settings.Profile( name="test-session", settings={ # Set PREFECT_HOME to a temporary directory to avoid clobbering # environments and settings PREFECT_HOME: tmpdir, PREFECT_PROFILES_PATH: "$PREFECT_HOME/profiles.toml", # Enable debug logging PREFECT_LOGGING_LEVEL: "DEBUG", # Disable shipping logs to the API; # can be enabled by the `enable_orion_handler` mark PREFECT_LOGGING_ORION_ENABLED: False, # Disable services for test runs PREFECT_ORION_ANALYTICS_ENABLED: False, PREFECT_ORION_SERVICES_LATE_RUNS_ENABLED: False, PREFECT_ORION_SERVICES_SCHEDULER_ENABLED: False, }, source=__file__, ) with prefect.settings.use_profile( profile, override_environment_variables=True, include_current_context=False, ) as ctx: yield ctx

tests/strategy/strats/hyperoptable_strategy.py

def bot_start(self, **kwargs) -> None: self.buy_rsi =

Enhance hyperoptable strategy to test instance parameters

bot_start

5bf021be2e8f1479753e66573575fa7cde00a2b6

freqtrade

hyperoptable_strategy.py

https://github.com/freqtrade/freqtrade.git

Python

def bot_start(self, **kwargs) -> None: self.buy_rsi = IntParameter([0, 50], default=30, space='buy')

django/core/serializers/base.py

def getvalue(self): if callable(getattr(self.stream, "getvalue", None)): return self.stream.getvalue()

Refs #33476 -- Reformatted code with Black.

getvalue

9c19aff7c7561e3a82978a272ecdaad40dda5c00

django

base.py

https://github.com/django/django.git

Python

def getvalue(self): if callable(getattr(self.stream, "getvalue", None)): return self.stream.getvalue()

py/visdom/__init__.py

def boxplot(self, X, win=None, env=None, opts=None): X = np.squeeze(X) assert X.ndim == 1 or X.ndim == 2, "X should be one or two-dimensional" if X.ndim == 1: X = X[:, None] opts = {} if opts is None else opts _title2str(opts) _assert_opts(opts) if opts.get("legend") is not None: assert ( len(opts["legend"]) == X.shape[1] ), "number of legened labels must match number of columns" data = [] for k in range(X.shape[1]):

apply black py to all python files

boxplot

5b8b7f267cfaf76a2a39a727ef31a62b3909a093

visdom

__init__.py

https://github.com/fossasia/visdom.git

Python

def boxplot(self, X, win=None, env=None, opts=None): X = np.squeeze(X) assert X.ndim == 1 or X.ndim == 2, "X should be one or two-dimensional" if X.ndim == 1: X = X[:, None] opts = {} if opts is None else opts _title2str(opts) _assert_opts(opts) if opts.get("legend") is not None: assert ( len(opts["legend"]) == X.shape[1] ), "number of legened labels must match number of columns" data = [] for k in range(X.shape[1]): _data = { "y": X.take(k, 1).tolist(), "type": "box", } if opts.get("legend"): _data["name"] = opts["legend"][k] else: _data["name"] = "column " + str(k) data.append(_data) return self._send( { "data": data, "win": win, "eid": env, "layout": _opts2layout(opts), "opts": opts, } )

tests/requests/tests.py

def test_body_after_POST_multipart_related(self): # Ticket #9054 # There are cases in which the multipart data is related instead of # being a binary upload, in which case it should still be accessible # via body. payload_data = b"\r\n".join([ b'--boundary', b'Content-ID: id; name="name"', b'', b'value', b'--boundary--' ]) payload = FakePayload(payload_data) request = WSGIRequest({ 'REQUEST_METHOD': 'POST',

Refs #33476 -- Refactored problematic code before reformatting by Black. In these cases Black produces unexpected results, e.g. def make_random_password( self, length=10, allowed_chars='abcdefghjkmnpqrstuvwxyz' 'ABCDEFGHJKLMNPQRSTUVWXYZ' '23456789', ): or cursor.execute(""" SELECT ... """, [table name], )

test_body_after_POST_multipart_related

c5cd8783825b5f6384417dac5f3889b4210b7d08

django

tests.py

https://github.com/django/django.git

Python

def test_body_after_POST_multipart_related(self): # Ticket #9054 # There are cases in which the multipart data is related instead of # being a binary upload, in which case it should still be accessible # via body. payload_data = b"\r\n".join([ b'--boundary', b'Content-ID: id; name="name"', b'', b'value', b'--boundary--' ]) payload = FakePayload(payload_data) request = WSGIRequest({ 'REQUEST_METHOD': 'POST', 'CONTENT_TYPE': 'multipart/related; boundary=boundary', 'CONTENT_LENGTH': len(payload), 'wsgi.input': payload, }) self.assertEqual(request.POST, {}) self.assertEqual(request.body, payload_data)

airflow/providers/arangodb/hooks/arangodb.py

def query(self, query, **kwargs) -> Result: try: if self.db_conn: result = self.db_conn.aql.execute(query, **kwargs) return result else: raise AirflowException( f"Failed to execute AQLQuery, error connecting to database: {self.database}" ) except AQLQueryExecuteError as

Adding ArangoDB Provider (#22548) * Adding ArangoDB Provider

query

c758c76ac336c054fd17d4b878378aa893b7a979

airflow

arangodb.py

https://github.com/apache/airflow.git

Python

def query(self, query, **kwargs) -> Result: try: if self.db_conn: result = self.db_conn.aql.execute(query, **kwargs) return result else: raise AirflowException( f"Failed to execute AQLQuery, error connecting to database: {self.database}" ) except AQLQueryExecuteError as error: raise AirflowException(f"Failed to execute AQLQuery, error: {str(error)}")

sklearn/datasets/tests/test_arff_parser.py

def test_post_process_frame(feature_names, target_names): pd = pytest.importorskip("pandas") X_original = pd.DataFrame( { "col_int_as_integer": [1, 2, 3], "col_int_as_numeric": [1, 2, 3], "col_float_as_real": [1.0, 2.0, 3.0], "col_float_as_numeric": [1.0, 2.0, 3.0], "col_categorical": ["a", "b", "c"], "col_string": ["a", "b", "c"], } ) X, y = _post_process_frame(X_original, feature_names, target_names) assert isinstance(X, pd.DataFrame) if len(target_names) >= 2: assert isinstance(y, pd.DataFrame) elif len(target_names) == 1: assert isinstance(y, pd.Series) else:

ENH improve ARFF parser using pandas (#21938) Co-authored-by: Thomas J. Fan <thomasjpfan@gmail.com> Co-authored-by: Olivier Grisel <olivier.grisel@gmail.com> Co-authored-by: Adrin Jalali <adrin.jalali@gmail.com>

test_post_process_frame

a47d569e670fd4102af37c3165c9b1ddf6fd3005

scikit-learn

test_arff_parser.py

https://github.com/scikit-learn/scikit-learn.git

Python

def test_post_process_frame(feature_names, target_names): pd = pytest.importorskip("pandas") X_original = pd.DataFrame( { "col_int_as_integer": [1, 2, 3], "col_int_as_numeric": [1, 2, 3], "col_float_as_real": [1.0, 2.0, 3.0], "col_float_as_numeric": [1.0, 2.0, 3.0], "col_categorical": ["a", "b", "c"], "col_string": ["a", "b", "c"], } ) X, y = _post_process_frame(X_original, feature_names, target_names) assert isinstance(X, pd.DataFrame) if len(target_names) >= 2: assert isinstance(y, pd.DataFrame) elif len(target_names) == 1: assert isinstance(y, pd.Series) else: assert y is None

django/views/debug.py

def cleanse_setting(self, key, value): try: is_sensitive = self.hidden_settings.search(key) except TypeError: is_sensitive = False if is_sensitive: cleansed = self.cleansed_substitute elif isinstance(value, dict): cleansed = {k: self.cleanse_setting(k, v) for k, v in value.items()} elif isinstance(value, list): cleansed = [s

Refs #33476 -- Reformatted code with Black.

cleanse_setting

9c19aff7c7561e3a82978a272ecdaad40dda5c00

django

debug.py

https://github.com/django/django.git

Python

def cleanse_setting(self, key, value): try: is_sensitive = self.hidden_settings.search(key) except TypeError: is_sensitive = False if is_sensitive: cleansed = self.cleansed_substitute elif isinstance(value, dict): cleansed = {k: self.cleanse_setting(k, v) for k, v in value.items()} elif isinstance(value, list): cleansed = [self.cleanse_setting("", v) for v in value] elif isinstance(value, tuple): cleansed = tuple([self.cleanse_setting("", v) for v in value]) else: cleansed = value if callable(cleansed): cleansed = CallableSettingWrapper(cleansed) return cleansed

keras/utils/generic_utils.py

def func_dump(func): if os.name == "nt": raw_code = marshal.dumps(func.__code__).replace(b"\\", b"/") code = codecs.encode(raw_code, "base64").decode("ascii") else: raw_code = marshal.dumps(func.__code__) code = codecs.encode(raw_

Reformatting the codebase with black. PiperOrigin-RevId: 450093126

func_dump

84afc5193d38057e2e2badf9c889ea87d80d8fbf

keras

generic_utils.py

https://github.com/keras-team/keras.git

Python

def func_dump(func): if os.name == "nt": raw_code = marshal.dumps(func.__code__).replace(b"\\", b"/") code = codecs.encode(raw_code, "base64").decode("ascii") else: raw_code = marshal.dumps(func.__code__) code = codecs.encode(raw_code, "base64").decode("ascii") defaults = func.__defaults__ if func.__closure__: closure = tuple(c.cell_contents for c in func.__closure__) else: closure = None return code, defaults, closure

sympy/polys/polyclasses.py

def cauchy_upper_bound(f): if not f.lev:

Add new methods to `DMP` class, corresp. to new funcs.

cauchy_upper_bound

d032a7a870672667f778be8bf02a3eba4ae89381

sympy

polyclasses.py

https://github.com/sympy/sympy.git

Python

def cauchy_upper_bound(f): if not f.lev: return dup_cauchy_upper_bound(f.rep, f.dom) else: raise ValueError('univariate polynomial expected')

sympy/core/sympify.py

def kernS(s): hit = False quoted = '"' in s or "'" in s if '(' in s and not quoted: if s.count('(') != s.count(")"): raise SympifyError('unmatched left parenthesis') # strip all space from s s = ''.join(s.split()) olds = s # now use space to represent a symbol that # will # step 1. turn potential 2-arg Muls into 3-arg versions # 1a. *( -> * *( s = s.replace('*(', '* *(') # 1b. close up exponentials s = s.replace('** *', '**') # 2. handle the implied multiplication of a negated # parenthesized expression in two steps # 2a: -(...) --> -( *(...) target = '-( *(' s = s.replace('-(', target) # 2b: double the matching closing parenthesis # -( *(...) --> -( *(...)) i = nest = 0 assert target.endswith('(') # assumption below while True: j = s.find(target, i) if j == -1: break j += len(target) - 1 for j in range(j, len(s)): if s[j] == "(": nest += 1 elif s[j] == ")": nest -= 1 if nest == 0: break s = s[:j] + ")" + s[j:] i = j + 2 # the first char after 2nd ) if ' ' in s: # get a unique kern kern = '_' while kern in s: kern += choice(string.ascii_letters + string.digits) s = s.replace(' ', kern) hit = kern in s else: hit = False for i in range(2): try: expr = sympify(s) break except TypeError: # the kern might cause unknown errors... if hit: s = olds # maybe it didn't like the kern; use un-kerned s hit = False continue expr = sympify(s) # let original error raise if n

Remove abbreviations in documentation

kernS

65be461082dda54c8748922f9c29a19af1279fe1

sympy

sympify.py

https://github.com/sympy/sympy.git

Python

def kernS(s): hit = False quoted = '"' in s or "'" in s if '(' in s and not quoted: if s.count('(') != s.count(")"): raise SympifyError('unmatched left parenthesis') # strip all space from s s = ''.join(s.split()) olds = s # now use space to represent a symbol that # will # step 1. turn potential 2-arg Muls into 3-arg versions # 1a. *( -> * *( s = s.replace('*(', '* *(') # 1b. close up exponentials s = s.replace('** *', '**') # 2. handle the implied multiplication of a negated # parenthesized expression in two steps # 2a: -(...) --> -( *(...) target = '-( *(' s = s.replace('-(', target) # 2b: double the matching closing parenthesis # -( *(...) --> -( *(...)) i = nest = 0 assert target.endswith('(') # assumption below while True: j = s.find(target, i) if j == -1: break j += len(target) - 1 for j in range(j, len(s)): if s[j] == "(": nest += 1 elif s[j] == ")": nest -= 1 if nest == 0: break s = s[:j] + ")" + s[j:] i = j + 2 # the first char after 2nd ) if ' ' in s: # get a unique kern kern = '_' while kern in s: kern += choice(string.ascii_letters + string.digits) s = s.replace(' ', kern) hit = kern in s else: hit = False for i in range(2): try: expr = sympify(s) break except TypeError: # the kern might cause unknown errors... if hit: s = olds # maybe it didn't like the kern; use un-kerned s hit = False continue expr = sympify(s) # let original error raise if not hit: return expr from .symbol import Symbol rep = {Symbol(kern): 1}

src/documents/tests/test_classifier.py

def test_load_corrupt_file(self, patched_pickle_load): # First load is the schema version p

Updates the classifier to catch warnings from scikit-learn and rebuild the model file when this happens

test_load_corrupt_file

77fbbe95ffb965525136982846f50e3ad8244de9

paperless-ngx

test_classifier.py

https://github.com/paperless-ngx/paperless-ngx.git

Python

def test_load_corrupt_file(self, patched_pickle_load): # First load is the schema version patched_pickle_load.side_effect = [DocumentClassifier.FORMAT_VERSION, OSError()] with self.assertRaises(ClassifierModelCorruptError): self.classifier.load()

homeassistant/components/plugwise/select.py

def current_option(self) -> str: return self.device[self.entity_description.current_option_key]

Rename property in Plugwise EntityDescription (#78935)

current_option

5c7d40cccf473c3549900949fe410dbe9d2e1a19

core

select.py

https://github.com/home-assistant/core.git

Python

def current_option(self) -> str: return self.device[self.entity_description.current_option_key]

ppstructure/table/convert_label2html.py

def gen_html(img): html_code = img['html']['structure']['tokens'].copy() to_insert = [i for i, tag in enumerate(html_code) if tag in ('<td>', '>')] for i, cell in zip(to_insert[::-1], img['html']['cells'][::-1]): if cell['tokens']: text = ''.join(cell['tokens']) # skip empty text sp_char_list = ['<b>', '</b>', '\u2028', ' ', '<i>', '</i>'] text_remove_style = skip_char(text, sp_char_list) if len(text_remove_style) == 0: continue html_code.insert(i + 1, text) html_code = ''.join(html_code) html_code = '<html><body><table>{}</table

add copyright

gen_html

97f7f748085fbe516952d36808735902d305da40

PaddleOCR

convert_label2html.py

https://github.com/PaddlePaddle/PaddleOCR.git

Python

def gen_html(img): html_code = img['html']['structure']['tokens'].copy() to_insert = [i for i, tag in enumerate(html_code) if tag in ('<td>', '>')] for i, cell in zip(to_insert[::-1], img['html']['cells'][::-1]): if cell['tokens']: text = ''.join(cell['tokens']) # skip empty text sp_char_list = ['<b>', '</b>', '\u2028', ' ', '<i>', '</i>'] text_remove_style = skip_char(text, sp_char_list) if len(text_remove_style) == 0: continue html_code.insert(i + 1, text) html_code = ''.join(html_code) html_code = '<html><body><table>{}</table></body></html>'.format(html_code) return html_code

src/textual/events.py

def key_aliases(self) -> Iterable[str]: for alias in _get_key_aliases(self.key): yi

Move aliasing/normalisation logic into Key

key_aliases

bd3a723d86f9c550b0324153975580b70509cb22

textual

events.py

https://github.com/Textualize/textual.git

Python

def key_aliases(self) -> Iterable[str]: for alias in _get_key_aliases(self.key): yield _normalize_key(alias)

netbox/ipam/tests/test_api.py

def test_create_single_available_ip(self): vrf = VRF.objects.create(name='VRF 1') prefix = Prefix.objects.create(prefix=IPNetwork('192.0.2.0/30'), vrf=vrf, is_pool=True) u

Closes #10031: Enforce 'application/json' content type for REST API requests

test_create_single_available_ip

bfbf97aec9119539f7f42cf16f52d0ca8203ba60

netbox

test_api.py

https://github.com/netbox-community/netbox.git

Python

def test_create_single_available_ip(self): vrf = VRF.objects.create(name='VRF 1') prefix = Prefix.objects.create(prefix=IPNetwork('192.0.2.0/30'), vrf=vrf, is_pool=True) url = reverse('ipam-api:prefix-available-ips', kwargs={'pk': prefix.pk}) self.add_permissions('ipam.view_prefix', 'ipam.add_ipaddress') # Create all four available IPs with individual requests for i in range(1, 5): data = { 'description': 'Test IP {}'.format(i) } response = self.client.post(url, data, format='json', **self.header) self.assertHttpStatus(response, status.HTTP_201_CREATED) self.assertEqual(response.data['vrf']['id'], vrf.pk) self.assertEqual(response.data['description'], data['description']) # Try to create one more IP response = self.client.post(url, {}, format='json', **self.header) self.assertHttpStatus(response, status.HTTP_409_CONFLICT) self.assertIn('detail', response.data)

@pytest.fixture(name="climate_adc_t3000_missing_mode")

tests/components/zwave_js/conftest.py

def climate_adc_t3000_missing_setpoint_fixture(client, climate_adc_t3000_state): data = copy.deepcopy(climate_adc_t3000_state) data["name"] = f"{data['name']} missing setpoint" for value in data["values"][:]: if ( value["commandClassName"] == "Humidity Control Setpoint" and value["propertyKeyName"] == "De-humidifier" ): data["values"].remove(value) node = Node(client, data) client.driver.controller.nodes[node.node_id] = node return node @pytest.fixture(name="climate_adc_t3000_missing_mode")

Add Humidifier support to zwave_js (#65847)

climate_adc_t3000_missing_setpoint_fixture

87593fa3ec4edd1fb467ed0709ef57c3c41e0fc4

core

conftest.py

https://github.com/home-assistant/core.git

Python

def climate_adc_t3000_missing_setpoint_fixture(client, climate_adc_t3000_state): data = copy.deepcopy(climate_adc_t3000_state) data["name"] = f"{data['name']} missing setpoint" for value in data["values"][:]: if ( value["commandClassName"] == "Humidity Control Setpoint" and value["propertyKeyName"] == "De-humidifier" ): data["values"].remove(value) node = Node(client, data) client.driver.controller.nodes[node.node_id] = node return node @pytest.fixture(name="climate_adc_t3000_missing_mode")

r""" Returns a tuple of possible :py:meth:`~sympy.solvers.ode.dsolve` classifications for an ODE. The tuple is ordered so that first item is the classification that :py:meth:`~sympy.solvers.ode.dsolve` uses to solve the ODE by default. In general, classifications at the near the beginning of the list will produce better solutions faster than those near the end, thought there are always exceptions. To make :py:meth:`~sympy.solvers.ode.dsolve` use a different classification, use ``dsolve(ODE, func, hint=<classification>)``. See also the :py:meth:`~sympy.solvers.ode.dsolve` docstring for different meta-hints you can use. If ``dict`` is true, :py:meth:`~sympy.solvers.ode.classify_ode` will return a dictionary of ``hint:match`` expression terms. This is intended for internal use by :py:meth:`~sympy.solvers.ode.dsolve`. Note that because dictionaries are ordered arbitrarily, this will most likely not be in the same order as the tuple. You can get help on different hints by executing ``help(ode.ode_hintname)``, where ``hintname`` is the name of the hint without ``_Integral``. See :py:data:`~sympy.solvers.ode.allhints` or the :py:mod:`~sympy.solvers.ode` docstring for a list of all supported hints that can be returned from :py:meth:`~sympy.solvers.ode.classify_ode`. Notes ===== These are remarks on hint names. ``_Integral``r""" Returns a tuple ofpy:meth:classificationsan ODE. The tuple is ordered so that first item is the classification that :py:meth:`~sympy.solvers.ode.dsolve` uses to solve the ODE by default. In general, classifications at the near the beginning of the list will produce better solutions faster than those near the end, thought there are always exceptions. To make :py:meth:`~sympy.solvers.ode.dsolve` use a differentclassifications at the near the beginning of the list will produce better solutions faster than those near thethought there are always exceptions. To make :use ``hint=<classification>)``. See also the :py:meth:`~sympy.solvers.ode.dsolve` docstring for different=)``. See alsohints you can use. Ifyou can usedict:py:meth:`~sympy.solvers.ode.classify_ode` will return a dictionary of ``hint:match`` expression terms. This is intended for internal use by :py:meth:`~sympy.solvers.ode.dsolve`. Note that because dictionaries are orderedfor internal use by :py:meththis will most likely not be in the same order as the tuple. You can get help on different hints by executing ``help(ode.ode_hintname)``, where ``hintname`` is the name of the hint without ``_Integral``. See :py:data:`~sympy.solvers.ode.allhints` or the :py:mod:`~sympy.solvers.ode` docstring for a list of all supported hints that can be returned from :py:meth:the samethe tuple. You can get help on different hints by executing ``help(ode.ode_hintname)``, where ``hintname`` is the name of the hint without`_Integral=== These are remarks on hint names. ``If a classification has ``_Integral`` at the end, it will_Integralexpressionanclass:

sympy/solvers/ode/ode.py

def classify_ode(eq, func=None, dict=False, ics=None, *, prep=True, xi=None, eta=None, n=None, **kwargs): r

Allow initial conditions of the form f(0): f(0) in dsolve There was a check that the replacement value does not contain f, but this makes perfect sense. The check was changed to checking that the value doesn't contain x. Fixes #23702

classify_ode

32589850ff6a970bee8af3034980e37932db2eb9

sympy

ode.py

https://github.com/sympy/sympy.git

Python

def classify_ode(eq, func=None, dict=False, ics=None, *, prep=True, xi=None, eta=None, n=None, **kwargs): r

scipy/stats/_stats_py.py

def mode(a, axis=0, nan_policy='propagate'): a, axis = _chk_asarray(a, axis) if a.size == 0: return ModeResult(np.array([]), np.array([])) contains_nan, nan_policy = _contains_nan(a, nan_policy) if contains_nan and nan_policy == 'omit': a = ma.masked_invalid(a) return mstats_basic.mode(a, axis) if a.dtype == object and np.nan in set(a.ravel()): # Fall back to a slower method since np.unique does not work with NaN scores = set(np.ravel(a)) # get ALL unique values testshape = list(a.shape) testshape[axis] = 1 oldmostfreq = np.zeros(testshape, dtype=a.dtype) oldcounts = np.zeros(testshape, dtype=int) for score in scores: template = (a == score) counts = np.sum(template, axis, keepdims=True) mostfrequent = np.where(counts > oldcounts, score, oldmostfreq) oldcounts = np.maximum(counts, oldcounts)

MAINT: stats: mode: fix negative axis issue with np.moveaxis instead of custom code (#15421)

mode

7438fe5edfb565ff341fa6ab054461fcdd504aa2

scipy

_stats_py.py

https://github.com/scipy/scipy.git

Python

def mode(a, axis=0, nan_policy='propagate'): a, axis = _chk_asarray(a, axis) if a.size == 0: return ModeResult(np.array([]), np.array([])) contains_nan, nan_policy = _contains_nan(a, nan_policy) if contains_nan and nan_policy == 'omit': a = ma.masked_invalid(a) return mstats_basic.mode(a, axis) if a.dtype == object and np.nan in set(a.ravel()): # Fall back to a slower method since np.unique does not work with NaN scores = set(np.ravel(a)) # get ALL unique values testshape = list(a.shape) testshape[axis] = 1 oldmostfreq = np.zeros(testshape, dtype=a.dtype) oldcounts = np.zeros(testshape, dtype=int) for score in scores: template = (a == score) counts = np.sum(template, axis, keepdims=True) mostfrequent = np.where(counts > oldcounts, score, oldmostfreq) oldcounts = np.maximum(counts, oldcounts) oldmostfreq = mostfrequent return ModeResult(mostfrequent, oldcounts)

test/lib/ansible_test/_internal/host_profiles.py

def wait_for_instance(self) -> AnsibleCoreCI: core_ci = self.get_instance() cor

ansible-test - Use more native type hints. (#78435) * ansible-test - Use more native type hints. Simple search and replace to switch from comments to native type hints for return types of functions with no arguments. * ansible-test - Use more native type hints. Conversion of simple single-line function annotation type comments to native type hints. * ansible-test - Use more native type hints. Conversion of single-line function annotation type comments with default values to native type hints. * ansible-test - Use more native type hints. Manual conversion of type annotation comments for functions which have pylint directives.

wait_for_instance

3eb0485dd92c88cc92152d3656d94492db44b183

ansible

host_profiles.py

https://github.com/ansible/ansible.git

Python

def wait_for_instance(self) -> AnsibleCoreCI: core_ci = self.get_instance() core_ci.wait() return core_ci

sympy/polys/orthopolys.py

def spherical_bessel_fn(n, x=None, polys=False): if n < 0: dup = dup_spherical_bessel_fn_minus(-int(n), ZZ) else: dup = dup_spherical_bessel_fn(int(n), ZZ) poly = DMP(dup, ZZ) if x is not None: poly = Poly.new(poly, 1/x) else: poly = PurePoly.new(poly, 1/Dummy('x')) return poly if polys el

Link Appell sequences to corresponding continuous functions

spherical_bessel_fn

c6be089c27dd1891d4e273e7701926f7e5cf4d6f

sympy

orthopolys.py

https://github.com/sympy/sympy.git

Python

def spherical_bessel_fn(n, x=None, polys=False): if n < 0: dup = dup_spherical_bessel_fn_minus(-int(n), ZZ) else: dup = dup_spherical_bessel_fn(int(n), ZZ) poly = DMP(dup, ZZ) if x is not None: poly = Poly.new(poly, 1/x) else: poly = PurePoly.new(poly, 1/Dummy('x')) return poly if polys else poly.as_expr()

torchvision/models/optical_flow/raft.py

def raft_large(*, pretrained=False, progress=True, **kwargs): return _raft( arch="raft_large", pretrained=pretrained, progress=progress, # Feature encoder feature_encoder_layers=(64, 64, 96, 128, 256), feature_encoder_block=ResidualBlock, feature_encoder_norm_layer=InstanceNorm2d, # Context encoder context_encoder_layers=(64, 64, 96, 128, 256), context_encoder_block=ResidualBlock, conte

Change default weights of RAFT model builders (#5381) * Change default weights of RAFT model builders * update handle_legacy_interface input * Oops, wrong default

raft_large

97eddc5d6a83a9bf620070075ef1e1864c9a68ac

vision

raft.py

https://github.com/pytorch/vision.git

Python

def raft_large(*, pretrained=False, progress=True, **kwargs): return _raft( arch="raft_large", pretrained=pretrained, progress=progress, # Feature encoder feature_encoder_layers=(64, 64, 96, 128, 256), feature_encoder_block=ResidualBlock, feature_encoder_norm_layer=InstanceNorm2d, # Context encoder context_encoder_layers=(64, 64, 96, 128, 256), context_encoder_block=ResidualBlock, context_encoder_norm_layer=BatchNorm2d, # Correlation block corr_block_num_levels=4, corr_block_radius=4, # Motion encoder motion_encoder_corr_layers=(256, 192), motion_encoder_flow_layers=(128, 64), motion_encoder_out_channels=128, # Recurrent block recurrent_block_hidden_state_size=128, recurrent_block_kernel_size=((1, 5), (5, 1)), recurrent_block_padding=((0, 2), (2, 0)), # Flow head flow_head_hidden_size=256, # Mask predictor use_mask_predictor=True, **kwargs, )

jina/hubble/hubio.py

def _get_prettyprint_usage(self, console, executor_name, usage_kind=None): from rich.panel import Panel from rich.syntax import Syntax flow_plain = f flow_docker = f flow_sandbox = f panels = [ Panel( Syntax( p[0], 'python', theme='monokai', word_wrap=True, ), title=p[1], width=80, expand=False, ) for p in [ (flow_plain, 'Use via source'), (flow_docker, 'Use in Docker'), (flow_sandbox, 'Use in Sandbox'), ] ] if usage_kind == 'doc

feat: add sandbox after push (#4349)

_get_prettyprint_usage

c07f3c151d985b207af87ccc9115bc94c3164e55

jina

hubio.py

https://github.com/jina-ai/jina.git

Python

def _get_prettyprint_usage(self, console, executor_name, usage_kind=None): from rich.panel import Panel from rich.syntax import Syntax flow_plain = f flow_docker = f flow_sandbox = f panels = [ Panel( Syntax( p[0], 'python', theme='monokai', word_wrap=True, ), title=p[1], width=80, expand=False, ) for p in [ (flow_plain, 'Use via source'), (flow_docker, 'Use in Docker'), (flow_sandbox, 'Use in Sandbox'), ] ] if usage_kind == 'docker': console.print(panels[2]) elif usage_kind == 'source': console.print(panels[1]) else: console.print(*reversed(panels))

django/http/request.py

def encoding(self, val): self._encoding = val if hasattr(self, "GET"): del self.GET if hasattr(self, "_post"): del self._p

Refs #33476 -- Reformatted code with Black.

encoding

9c19aff7c7561e3a82978a272ecdaad40dda5c00

django

request.py

https://github.com/django/django.git

Python

def encoding(self, val): self._encoding = val if hasattr(self, "GET"): del self.GET if hasattr(self, "_post"): del self._post

manim/mobject/geometry.py

def scale(self, factor, scale_tips=False, **kwargs): r if self.get_length() == 0: return self if scale_tips: super().scale(factor, **kwargs) self._set_stroke_width_from_length() return self has_tip = self.has_tip() has_start_tip = self.has_start_tip() if has_tip or has_start_tip: old_tips = self.pop_tips() super().scale(factor, **kwargs) self._set_stroke_width_from_length() if has_tip: self.add_tip(tip=old_ti

Hide more private methods from the docs. (#2468) * hide privs from text_mobject.py * hide privs from tex_mobject.py * hide privs from code_mobject.py * hide privs from svg_mobject.py * remove SVGPath and utils from __init__.py * don't import string_to_numbers * hide privs from geometry.py * hide privs from matrix.py * hide privs from numbers.py * hide privs from three_dimensions.py * forgot underscore under set_stroke_width_from_length * there were more i missed * unhidea method that was used in docs * forgot other text2hash * remove svg_path from docs

scale

902e7eb4f0147b5882a613b67467e38a1d47f01e

manim

geometry.py

https://github.com/ManimCommunity/manim.git

Python

def scale(self, factor, scale_tips=False, **kwargs): r if self.get_length() == 0: return self if scale_tips: super().scale(factor, **kwargs) self._set_stroke_width_from_length() return self has_tip = self.has_tip() has_start_tip = self.has_start_tip() if has_tip or has_start_tip: old_tips = self.pop_tips() super().scale(factor, **kwargs) self._set_stroke_width_from_length() if has_tip: self.add_tip(tip=old_tips[0]) if has_start_tip: self.add_tip(tip=old_tips[1], at_start=True) return self

python3.10.4/Lib/bdb.py

def effective(file, line, frame): possibles = Breakpoint.bplist[file, line] for b in possibles: if not b.enabled: continue if not checkfuncname(b, frame): continue # Count every hit when bp is enabled b.hits += 1 if not b.cond: # If unconditional, and ignoring go on to n

add python 3.10.4 for windows

effective

8198943edd73a363c266633e1aa5b2a9e9c9f526

XX-Net

bdb.py

https://github.com/XX-net/XX-Net.git

Python

def effective(file, line, frame): possibles = Breakpoint.bplist[file, line] for b in possibles: if not b.enabled: continue if not checkfuncname(b, frame): continue # Count every hit when bp is enabled b.hits += 1 if not b.cond: # If unconditional, and ignoring go on to next, else break if b.ignore > 0: b.ignore -= 1 continue else: # breakpoint and marker that it's ok to delete if temporary return (b, True) else: # Conditional bp. # Ignore count applies only to those bpt hits where the # condition evaluates to true. try: val = eval(b.cond, frame.f_globals, frame.f_locals) if val: if b.ignore > 0: b.ignore -= 1 # continue else: return (b, True) # else: # continue except: # if eval fails, most conservative thing is to stop on # breakpoint regardless of ignore count. Don't delete # temporary, as another hint to user. return (b, False) return (None, None) # -------------------- testing --------------------

@_wraps(osp_stats.truncnorm.logpdf, update_doc=False)

jax/_src/scipy/stats/truncnorm.py

def _log_gauss_mass(a, b): a, b = jnp.array(a), jnp.array(b) a, b = jnp.broadcast_arrays(a, b) # Note: Docstring carried over from scipy # Calculations in right tail are inaccurate, so we'll exploit the # symmetry and work only in the left tail case_left = b <= 0 case_right = a > 0 ca

implement truncnorm in jax.scipy.stats fix some shape and type issues import into namespace imports into non-_src library working logpdf test cleanup working tests for cdf and sf after fixing select relax need for x to be in (a, b) ensure behavior with invalid input matches scipy remove enforcing valid parameters in tests added truncnorm to docs whoops alphabetical fix linter error fix circular import issue

_log_gauss_mass

5784d61048facfa9dac1f1d309bde2d60a32810c

jax

truncnorm.py

https://github.com/google/jax.git

Python

def _log_gauss_mass(a, b): a, b = jnp.array(a), jnp.array(b) a, b = jnp.broadcast_arrays(a, b) # Note: Docstring carried over from scipy # Calculations in right tail are inaccurate, so we'll exploit the # symmetry and work only in the left tail case_left = b <= 0 case_right = a > 0 case_central = ~(case_left | case_right) def mass_case_left(a, b): return _log_diff(log_ndtr(b), log_ndtr(a)) def mass_case_right(a, b): return mass_case_left(-b, -a) def mass_case_central(a, b): # Note: Docstring carried over from scipy # Previously, this was implemented as: # left_mass = mass_case_left(a, 0) # right_mass = mass_case_right(0, b) # return _log_sum(left_mass, right_mass) # Catastrophic cancellation occurs as np.exp(log_mass) approaches 1. # Correct for this with an alternative formulation. # We're not concerned with underflow here: if only one term # underflows, it was insignificant; if both terms underflow, # the result can't accurately be represented in logspace anyway # because sc.log1p(x) ~ x for small x. return jnp.log1p(-ndtr(a) - ndtr(-b)) out = jnp.select( [case_left, case_right, case_central], [mass_case_left(a, b), mass_case_right(a, b), mass_case_central(a, b)] ) return out @_wraps(osp_stats.truncnorm.logpdf, update_doc=False)

@RunIf(min_gpus=2)

tests/trainer/logging_/test_logger_connector.py

def test_fx_validator_integration(tmpdir): not_supported = { None: "`self.trainer` reference is not registered", "on_before_accelerator_backend_setup": "You can't", "setup": "You can't", "configure_sharded_model": "You can't", "on_configure_sharded_model": "You can't", "configure_optimizers": "

Add `LightningModule.lr_scheduler_step` (#10249) Co-authored-by: Carlos Mocholi <carlossmocholi@gmail.com>

test_fx_validator_integration

82c8875f33addb0becd7761c95e9674ccc98c7ee

lightning

test_logger_connector.py

https://github.com/Lightning-AI/lightning.git

Python

def test_fx_validator_integration(tmpdir): not_supported = { None: "`self.trainer` reference is not registered", "on_before_accelerator_backend_setup": "You can't", "setup": "You can't", "configure_sharded_model": "You can't", "on_configure_sharded_model": "You can't", "configure_optimizers": "You can't", "on_fit_start": "You can't", "on_pretrain_routine_start": "You can't", "on_pretrain_routine_end": "You can't", "on_train_dataloader": "You can't", "train_dataloader": "You can't", "on_val_dataloader": "You can't", "val_dataloader": "You can't", "on_validation_end": "You can't", "on_train_end": "You can't", "on_fit_end": "You can't", "teardown": "You can't", "on_sanity_check_start": "You can't", "on_sanity_check_end": "You can't", "prepare_data": "You can't", "configure_callbacks": "You can't", "on_validation_model_eval": "You can't", "on_validation_model_train": "You can't", "lr_scheduler_step": "You can't", "summarize": "not managed by the `Trainer", } model = HookedModel(not_supported) with pytest.warns(UserWarning, match=not_supported[None]): model.log("foo", 1) callback = HookedCallback(not_supported) trainer = Trainer( default_root_dir=tmpdir, max_epochs=2, limit_train_batches=1, limit_val_batches=1, limit_test_batches=1, limit_predict_batches=1, callbacks=callback, ) with pytest.deprecated_call(match="on_train_dataloader` is deprecated in v1.5"): trainer.fit(model) not_supported.update( { # `lightning_module` ref is now present from the `fit` call "on_before_accelerator_backend_setup": "You can't", "on_test_dataloader": "You can't", "test_dataloader": "You can't", "on_test_model_eval": "You can't", "on_test_model_train": "You can't", "on_test_end": "You can't", } ) with pytest.deprecated_call(match="on_test_dataloader` is deprecated in v1.5"): trainer.test(model, verbose=False) not_supported.update({k: "result collection is not registered yet" for k in not_supported}) not_supported.update( { "on_predict_dataloader": "result collection is not registered yet", "predict_dataloader": "result collection is not registered yet", "on_predict_model_eval": "result collection is not registered yet", "on_predict_start": "result collection is not registered yet", "on_predict_epoch_start": "result collection is not registered yet", "on_predict_batch_start": "result collection is not registered yet", "predict_step": "result collection is not registered yet", "on_predict_batch_end": "result collection is not registered yet", "on_predict_epoch_end": "result collection is not registered yet", "on_predict_end": "result collection is not registered yet", } ) with pytest.deprecated_call(match="on_predict_dataloader` is deprecated in v1.5"): trainer.predict(model) @RunIf(min_gpus=2)

src/textual/drivers/win32.py

def enable_application_mode() -> Callable[[], None]: terminal_in = sys.stdin terminal_out = sys.stdout current_console_mode_in = _get_console_mode(terminal_in) current_console_m

working windows driver

enable_application_mode

988838a872d2c7af6a1113546ace4f15b74a3254

textual

win32.py

https://github.com/Textualize/textual.git

Python

def enable_application_mode() -> Callable[[], None]: terminal_in = sys.stdin terminal_out = sys.stdout current_console_mode_in = _get_console_mode(terminal_in) current_console_mode_out = _get_console_mode(terminal_out)

lib/ansible/utils/_junit_xml.py

def get_attributes(self) -> dict[str, str]:

Simplify existing type hints.

get_attributes

871b2ca73adcba3a35551247cf839246cf121231

ansible

_junit_xml.py

https://github.com/ansible/ansible.git

Python

def get_attributes(self) -> dict[str, str]: return _attributes( message=self.message, type=self.type, )

freqtrade/freqtradebot.py

def check_handle_timedout(self) -> None: for trade in Trade.get_open_order_trades(): try: if not trade.open_order_id: continue order = self.exchange.fetch_order(trade.open_order_id, trade.pair) except (ExchangeError): logger.info('Cannot query order for %s due to %s', trade, traceback.format_exc()) continue fully_cancelled = self.update_trade_state(trade, trade.open_order_id, order) if (order['side'] == 'buy' and (order['status'] == 'open' or fully_cancelled) and ( fu

Extract timeout handling from freqtradebot class

check_handle_timedout

7bef9a9b3ec8593dac0701e7c5f8df6d77b5d4e0

freqtrade

freqtradebot.py

https://github.com/freqtrade/freqtrade.git

Python

def check_handle_timedout(self) -> None: for trade in Trade.get_open_order_trades(): try: if not trade.open_order_id: continue order = self.exchange.fetch_order(trade.open_order_id, trade.pair) except (ExchangeError): logger.info('Cannot query order for %s due to %s', trade, traceback.format_exc()) continue fully_cancelled = self.update_trade_state(trade, trade.open_order_id, order) if (order['side'] == 'buy' and (order['status'] == 'open' or fully_cancelled) and ( fully_cancelled or self.strategy.ft_check_timed_out( 'buy', trade, order, datetime.now(timezone.utc)) )): self.handle_cancel_enter(trade, order, constants.CANCEL_REASON['TIMEOUT']) elif (order['side'] == 'sell' and (order['status'] == 'open' or fully_cancelled) and ( fully_cancelled or self.strategy.ft_check_timed_out( 'sell', trade, order, datetime.now(timezone.utc))) ): self.handle_cancel_exit(trade, order, constants.CANCEL_REASON['TIMEOUT']) canceled_count = trade.get_exit_order_count() max_timeouts = self.config.get('unfilledtimeout', {}).get('exit_timeout_count', 0) if max_timeouts > 0 and canceled_count >= max_timeouts: logger.warning(f'Emergencyselling trade {trade}, as the sell order ' f'timed out {max_timeouts} times.') try: self.execute_trade_exit( trade, order.get('price'), sell_reason=SellCheckTuple(sell_type=SellType.EMERGENCY_SELL)) except DependencyException as exception: logger.warning(f'Unable to emergency sell trade {trade.pair}: {exception}')

tests/snuba/api/endpoints/test_organization_events.py

def test_user_misery_denominator(self): ProjectTransactionThreshold.objects.create( project=self.project, organization=self.project.organization, threshold=600, metric=TransactionMetric.LCP.value, ) lcps = [ 400, 400, 300, 3000, 3000, 3000, ] for idx, lcp in enumerate(lcps): data = self.load_data(

fix(tests): Discover backend test flakes (#41057) - `MetricsQueryBuilder` wasn't sorting environment tags - Consistent timestamps on test_organization_events - Updated `apply_feature_flag_on_cls` to only apply decorator on the run method

test_user_misery_denominator

618ae63cf2ba419e44e79ce578d88e8b062d7dd9

sentry

test_organization_events.py

https://github.com/getsentry/sentry.git

Python

def test_user_misery_denominator(self): ProjectTransactionThreshold.objects.create( project=self.project, organization=self.project.organization, threshold=600, metric=TransactionMetric.LCP.value, ) lcps = [ 400, 400, 300, 3000, 3000, 3000, ] for idx, lcp in enumerate(lcps): data = self.load_data( timestamp=before_now(minutes=(10 + idx)), ) data["event_id"] = f"{idx}" * 32 data["transaction"] = "/misery/new/" data["user"] = {"email": f"{idx}@example.com"} data["measurements"] = { "lcp": {"value": lcp}, } self.store_event(data, project_id=self.project.id) # Shouldn't count towards misery data = self.load_data(timestamp=self.ten_mins_ago, duration=timedelta(milliseconds=0)) data["transaction"] = "/misery/new/" data["user"] = {"email": "7@example.com"} data["measurements"] = {} self.store_event(data, project_id=self.project.id) query = { "field": [ "transaction", "user_misery()", ], "query": "event.type:transaction", "project": [self.project.id], "sort": "-user_misery", } response = self.do_request( query, ) assert response.status_code == 200, response.content assert len(response.data["data"]) == 1 data = response.data["data"] # (3 frustrated + 5.8875) / (6 + 117.75) assert abs(data[0]["user_misery()"] - 0.071818) < 0.0001

.venv/lib/python3.8/site-packages/pip/_internal/index/collector.py

def _determine_base_url(document, page_url): # type: (HTMLElement, str) -> str for base in document.findall(".//base"): href = base.get("href") if href is not None: return href return page_url

upd; format

_determine_base_url

f638f5d0e6c8ebed0e69a6584bc7f003ec646580

transferlearning

collector.py

https://github.com/jindongwang/transferlearning.git

Python

def _determine_base_url(document, page_url): # type: (HTMLElement, str) -> str for base in document.findall(".//base"): href = base.get("href") if href is not None: return href return page_url

reconstruction/ostec/external/stylegan2/metrics/precision_recall.py

def pairwise_distances(self, U, V): return self._distance_block.eval(feed_dict={self._features_batch1: U, self._features

initialize ostec

pairwise_distances

7375ee364e0df2a417f92593e09557f1b2a3575a

insightface

precision_recall.py

https://github.com/deepinsight/insightface.git

Python

def pairwise_distances(self, U, V): return self._distance_block.eval(feed_dict={self._features_batch1: U, self._features_batch2: V}) #----------------------------------------------------------------------------

mindsdb/migrations/versions/2022-10-14_43c52d23845a_projects.py

def upgrade(): op.create_table( 'project', sa.Column('id', sa.Integer(), nullable=False), sa.Column('created_at', sa.DateTime(), nullable=True), sa.Column('updated_at', sa.DateTime(), nullable=True), sa.Column('deleted_at', sa.DateTime(), nullable=True), sa.Column('name', sa.String(), nullable=False), sa.Column('company_id', sa.Integer(), nullable=True), sa.PrimaryKeyConstraint('id'), sa.UniqueConstraint('name', 'company_id', name='unique_integration_name_company_id') ) conn = op.get_bind() session = sa.orm.Session(bind=conn) project_record = db.Project(name='mindsdb') session.add(project_record) session.commit() with op.ba

Projects structure (#3532) Projects structure

upgrade

7c02e15aa403a4ca1fa34489dd2df9136d6c961c

mindsdb

2022-10-14_43c52d23845a_projects.py

https://github.com/mindsdb/mindsdb.git

Python

def upgrade(): op.create_table( 'project', sa.Column('id', sa.Integer(), nullable=False), sa.Column('created_at', sa.DateTime(), nullable=True), sa.Column('updated_at', sa.DateTime(), nullable=True), sa.Column('deleted_at', sa.DateTime(), nullable=True), sa.Column('name', sa.String(), nullable=False), sa.Column('company_id', sa.Integer(), nullable=True), sa.PrimaryKeyConstraint('id'), sa.UniqueConstraint('name', 'company_id', name='unique_integration_name_company_id') ) conn = op.get_bind() session = sa.orm.Session(bind=conn) project_record = db.Project(name='mindsdb') session.add(project_record) session.commit() with op.batch_alter_table('predictor', schema=None) as batch_op: batch_op.add_column(sa.Column('project_id', sa.Integer())) batch_op.create_foreign_key('fk_project_id', 'project', ['project_id'], ['id']) conn.execute(sa.sql.text(), project_id=project_record.id) with op.batch_alter_table('predictor', schema=None) as batch_op: batch_op.alter_column( 'project_id', existing_type=sa.INTEGER(), nullable=False ) with op.batch_alter_table('view', schema=None) as batch_op: batch_op.add_column(sa.Column('project_id', sa.Integer())) batch_op.create_foreign_key('fk_project_id', 'project', ['project_id'], ['id']) conn.execute(sa.sql.text(), project_id=project_record.id) with op.batch_alter_table('view', schema=None) as batch_op: batch_op.alter_column( 'project_id', existing_type=sa.INTEGER(), nullable=False ) views = conn.execute().fetchall() for row in views: conn.execute( text(), { 'name': f"{row['name']}_view", 'view_id': row['id'] } ) view_integration = session.query(db.Integration).filter_by(name='views').first() if view_integration is not None: session.delete(view_integration) session.commit()

spacy/pipeline/span_ruler.py

def clear(self) -> None: self._patterns: List[PatternType] = [] self.matcher: Matcher = Matcher(self.nlp.vocab, validate=self.validate) self.phrase_matcher: P

Add SpanRuler component (#9880) * Add SpanRuler component Add a `SpanRuler` component similar to `EntityRuler` that saves a list of matched spans to `Doc.spans[spans_key]`. The matches from the token and phrase matchers are deduplicated and sorted before assignment but are not otherwise filtered. * Update spacy/pipeline/span_ruler.py Co-authored-by: Sofie Van Landeghem <svlandeg@users.noreply.github.com> * Fix cast * Add self.key property * Use number of patterns as length * Remove patterns kwarg from init * Update spacy/tests/pipeline/test_span_ruler.py Co-authored-by: Sofie Van Landeghem <svlandeg@users.noreply.github.com> * Add options for spans filter and setting to ents * Add `spans_filter` option as a registered function' * Make `spans_key` optional and if `None`, set to `doc.ents` instead of `doc.spans[spans_key]`. * Update and generalize tests * Add test for setting doc.ents, fix key property type * Fix typing * Allow independent doc.spans and doc.ents * If `spans_key` is set, set `doc.spans` with `spans_filter`. * If `annotate_ents` is set, set `doc.ents` with `ents_fitler`. * Use `util.filter_spans` by default as `ents_filter`. * Use a custom warning if the filter does not work for `doc.ents`. * Enable use of SpanC.id in Span * Support id in SpanRuler as Span.id * Update types * `id` can only be provided as string (already by `PatternType` definition) * Update all uses of Span.id/ent_id in Doc * Rename Span id kwarg to span_id * Update types and docs * Add ents filter to mimic EntityRuler overwrite_ents * Refactor `ents_filter` to take `entities, spans` args for more filtering options * Give registered filters more descriptive names * Allow registered `filter_spans` filter (`spacy.first_longest_spans_filter.v1`) to take any number of `Iterable[Span]` objects as args so it can be used for spans filter or ents filter * Implement future entity ruler as span ruler Implement a compatible `entity_ruler` as `future_entity_ruler` using `SpanRuler` as the underlying component: * Add `sort_key` and `sort_reverse` to allow the sorting behavior to be customized. (Necessary for the same sorting/filtering as in `EntityRuler`.) * Implement `overwrite_overlapping_ents_filter` and `preserve_existing_ents_filter` to support `EntityRuler.overwrite_ents` settings. * Add `remove_by_id` to support `EntityRuler.remove` functionality. * Refactor `entity_ruler` tests to parametrize all tests to test both `entity_ruler` and `future_entity_ruler` * Implement `SpanRuler.token_patterns` and `SpanRuler.phrase_patterns` properties. Additional changes: * Move all config settings to top-level attributes to avoid duplicating settings in the config vs. `span_ruler/cfg`. (Also avoids a lot of casting.) * Format * Fix filter make method name * Refactor to use same error for removing by label or ID * Also provide existing spans to spans filter * Support ids property * Remove token_patterns and phrase_patterns * Update docstrings * Add span ruler docs * Fix types * Apply suggestions from code review Co-authored-by: Sofie Van Landeghem <svlandeg@users.noreply.github.com> * Move sorting into filters * Check for all tokens in seen tokens in entity ruler filters * Remove registered sort key * Set Token.ent_id in a backwards-compatible way in Doc.set_ents * Remove sort options from API docs * Update docstrings * Rename entity ruler filters * Fix and parameterize scoring * Add id to Span API docs * Fix typo in API docs * Include explicit labeled=True for scorer Co-authored-by: Sofie Van Landeghem <svlandeg@users.noreply.github.com>

clear

a322d6d5f2f85c2da6cded4fcd6143d41b5a9e96

spaCy

span_ruler.py

https://github.com/explosion/spaCy.git

Python

def clear(self) -> None: self._patterns: List[PatternType] = [] self.matcher: Matcher = Matcher(self.nlp.vocab, validate=self.validate) self.phrase_matcher: PhraseMatcher = PhraseMatcher( self.nlp.vocab, attr=self.phrase_matcher_attr, validate=self.validate, )

python3.10.4/Lib/doctest.py

def _from_module(self, module, object): if module is None: return True elif inspect.getmodule(object) is not None: return module is inspect.getmodule(object) elif inspect.isfunction(object): return module.__dict__ is object.__globals__ elif inspect.ismethoddescriptor(object): if hasattr(object, '__objclass__'): obj_mod = object.__objclass__.__module__ elif hasattr(object, '__module__'): obj_mod = object.__module__ else:

add python 3.10.4 for windows

_from_module

8198943edd73a363c266633e1aa5b2a9e9c9f526

XX-Net

doctest.py

https://github.com/XX-net/XX-Net.git

Python

def _from_module(self, module, object): if module is None: return True elif inspect.getmodule(object) is not None: return module is inspect.getmodule(object) elif inspect.isfunction(object): return module.__dict__ is object.__globals__ elif inspect.ismethoddescriptor(object): if hasattr(object, '__objclass__'): obj_mod = object.__objclass__.__module__ elif hasattr(object, '__module__'): obj_mod = object.__module__ else: return True # [XX] no easy way to tell otherwise return module.__name__ == obj_mod elif inspect.isclass(object): return module.__name__ == object.__module__ elif hasattr(object, '__module__'): return module.__name__ == object.__module__ elif isinstance(object, property): return True # [XX] no way not be sure. else: raise ValueError("object must be a class or function")

DemoPrograms/Demo_Script_Launcher_ANSI_Color_Output.py

def cut_ansi_string_into_parts(string_with_ansi_codes): color_codes_english = ['Black', 'Red', 'Green', 'Yellow', 'Blue', 'Magenta', 'Cyan', 'White', 'Reset'] color_codes = ["30m", "31m", "32m", "33m", "34m", "35m", "36m", "37m", "0m"] effect_codes_english = ['Italic', 'Underline', 'Slow Blink', 'Rapid Blink', 'Crossed Out'] effect_codes

Removed old code that used Popen and instead uses the PySimpleGUI Exec API calls for an all-in-one demo. Added expansion of the Multilline and a SizeGrip so that it's obvious to user the window is resizable.

cut_ansi_string_into_parts

a35687ac51dac5a2a0664ca20e7dd7cba6836c7b

PySimpleGUI

Demo_Script_Launcher_ANSI_Color_Output.py

https://github.com/PySimpleGUI/PySimpleGUI.git

Python

def cut_ansi_string_into_parts(string_with_ansi_codes): color_codes_english = ['Black', 'Red', 'Green', 'Yellow', 'Blue', 'Magenta', 'Cyan', 'White', 'Reset'] color_codes = ["30m", "31m", "32m", "33m", "34m", "35m", "36m", "37m", "0m"] effect_codes_english = ['Italic', 'Underline', 'Slow Blink', 'Rapid Blink', 'Crossed Out'] effect_codes = ["3m", "4m", "5m", "6m", "9m"] background_codes = ["40m", "41m", "42m", "43m", "44m", "45m", "46m", "47m"] background_codes_english = ["Black", "Red", "Green", "Yellow", "Blue", "Magenta", "Cyan", "White"] ansi_codes = color_codes + effect_codes tuple_list = [] string_list = string_with_ansi_codes.split("\u001b[") if (len(string_list)) == 1: string_list = string_with_ansi_codes.split("\033[") for teststring in string_list: if teststring == string_with_ansi_codes: tuple_list += [(teststring, None, None, None)] break if any(code in teststring for code in ansi_codes): static_string = None color_used = None effect_used = None background_used = None for color in range(0, len(color_codes)): if teststring.startswith(color_codes[color]): working_thread = teststring.split(color_codes[color]) ansi_strip = re.compile(r'\x1B[@-_][0-?]*[ -/]*[@-~]') static_string = ansi_strip.sub('', working_thread[1]) color_used = color_codes_english[color] for effect in range(0, len(effect_codes)): if teststring.startswith(effect_codes[effect]): working_thread = teststring.split(effect_codes[effect]) ansi_strip = re.compile(r'\x1B[@-_][0-?]*[ -/]*[@-~]') static_string = ansi_strip.sub('', working_thread[1]) effect_used = effect_codes_english[effect] for background in range(0, len(background_codes)): if teststring.startswith(background_codes[background]): working_thread = teststring.split(background_codes[background]) ansi_strip = re.compile(r'\x1B[@-_][0-?]*[ -/]*[@-~]') static_string = ansi_strip.sub('', working_thread[1]) background_used = background_codes_english[background] try: if not tuple_list[len(tuple_list) - 1][0]: if not tuple_list[len(tuple_list) - 1][1] == None: color_used = tuple_list[len(tuple_list) - 1][1] if not tuple_list[len(tuple_list) - 1][2] == None: background_used = tuple_list[len(tuple_list) - 1][2] if not tuple_list[len(tuple_list) - 1][3] == None: effect_used = tuple_list[len(tuple_list) - 1][3] tuple_list += [(static_string, color_used, background_used, effect_used)] else: tuple_list += [(static_string, color_used, background_used, effect_used)] except Exception: tuple_list += [(static_string, color_used, background_used, effect_used)] new_tuple_list = [] for x in range(0, len(tuple_list)): if tuple_list[x][0]: new_tuple_list += [[tuple_list[x][0], tuple_list[x][1], tuple_list[x][2], tuple_list[x][3]]] return new_tuple_list

research/neo_peq/legacy_frequency_response.py

def interpolate(self, f=None, f_step=DEFAULT_STEP, pol_order=1, f_min=DEFAULT_F_MIN, f_max=DEFAULT_F_MAX): # Remove None values i = 0 while i < len(self.raw): if self.raw[i] is None: self.raw = np.delete(self.raw, i) self.frequency = np.delete(self.frequency, i) else: i += 1 # Interpolation functions keys = 'raw error error_smoothed equalization equalized_raw equalized_smoothed target'.split() interpolators = dict() log_f = np.log10(self.frequency) for key in keys: if len(self.__dict__[key]): interpolators[key] = InterpolatedUnivariateSpline(log_f, self.__dict__[key], k=pol_order) if f is None: self.frequency = self.generate_frequencies(f_min=f_min, f_max=f_max, f_step=f_step) else: self.frequency = np.array(f) # Prevent log10 from exploding by replacing zero frequency with small value zero_freq_fix = False if self.frequency[0] == 0: self.frequency[0] = 0.001 zero_freq_fix = True # Run interpolators log_f = np.log10(self.frequency) for key in keys: if len(self.__dict__[key]) and key in interpolators: self.__dict__[key] = interpolators[key](log_f) if zero_freq_fix: # Restore zero frequency self.frequency[0] = 0 # Everything but the interpolated data is affected by interpolating, reset them

Added PEQ configs to CLI and function interfaces. Improved default value handling for PEQ parameters and added more predefined configs. Removed legacy PEQ optimization. Fixed readme write. Improved shelf filter initialization. Added plot method to PEQ. Notebook for comparing old and new optimizers. Bug fixes.

interpolate

9120cdffe618c6c2ff16fe6a311b6a1367efdbc8

AutoEq

legacy_frequency_response.py

https://github.com/jaakkopasanen/AutoEq.git

Python

def interpolate(self, f=None, f_step=DEFAULT_STEP, pol_order=1, f_min=DEFAULT_F_MIN, f_max=DEFAULT_F_MAX): # Remove None values i = 0 while i < len(self.raw): if self.raw[i] is None: self.raw = np.delete(self.raw, i) self.frequency = np.delete(self.frequency, i) else: i += 1 # Interpolation functions keys = 'raw error error_smoothed equalization equalized_raw equalized_smoothed target'.split() interpolators = dict() log_f = np.log10(self.frequency) for key in keys: if len(self.__dict__[key]): interpolators[key] = InterpolatedUnivariateSpline(log_f, self.__dict__[key], k=pol_order) if f is None: self.frequency = self.generate_frequencies(f_min=f_min, f_max=f_max, f_step=f_step) else: self.frequency = np.array(f) # Prevent log10 from exploding by replacing zero frequency with small value zero_freq_fix = False if self.frequency[0] == 0: self.frequency[0] = 0.001 zero_freq_fix = True # Run interpolators log_f = np.log10(self.frequency) for key in keys: if len(self.__dict__[key]) and key in interpolators: self.__dict__[key] = interpolators[key](log_f) if zero_freq_fix: # Restore zero frequency self.frequency[0] = 0 # Everything but the interpolated data is affected by interpolating, reset them self.reset(**{key: False for key in keys})

timm/optim/lars.py

def step(self, closure=None): loss = None if closure is not None: with torch.enable_grad(): loss = closure() device = self.param_groups[0]['params'][0].device one_tensor = torch.tensor(1.0, device=device) # because torch.where doesn't handle scalars correctly for group in self.param_groups: weight_decay = group['weight_decay'] momentum = group['momentum'] dampening = group['dampening'] nesterov = group['nesterov'] trust_coeff = group['trust_coeff'] eps = group['eps'] for p

fix lars

step

cdcd0a92ca8a3dc120336a5dde1b7d6ecd5e9186

pytorch-image-models

lars.py

https://github.com/huggingface/pytorch-image-models.git

Python

def step(self, closure=None): loss = None if closure is not None: with torch.enable_grad(): loss = closure() device = self.param_groups[0]['params'][0].device one_tensor = torch.tensor(1.0, device=device) # because torch.where doesn't handle scalars correctly for group in self.param_groups: weight_decay = group['weight_decay'] momentum = group['momentum'] dampening = group['dampening'] nesterov = group['nesterov'] trust_coeff = group['trust_coeff'] eps = group['eps'] for p in group['params']: if p.grad is None: continue grad = p.grad # apply LARS LR adaptation, LARC clipping, weight decay # ref: https://github.com/NVIDIA/apex/blob/master/apex/parallel/LARC.py if weight_decay != 0 or group['always_adapt']: w_norm = p.norm(2.0) g_norm = grad.norm(2.0) trust_ratio = trust_coeff * w_norm / (g_norm + w_norm * weight_decay + eps) # FIXME nested where required since logical and/or not working in PT XLA trust_ratio = torch.where( w_norm > 0, torch.where(g_norm > 0, trust_ratio, one_tensor), one_tensor, ) if group['trust_clip']: trust_ratio = torch.minimum(trust_ratio / group['lr'], one_tensor) grad.add_(p, alpha=weight_decay) grad.mul_(trust_ratio) # apply SGD update https://github.com/pytorch/pytorch/blob/1.7/torch/optim/sgd.py#L100 if momentum != 0: param_state = self.state[p] if 'momentum_buffer' not in param_state: buf = param_state['momentum_buffer'] = torch.clone(grad).detach() else: buf = param_state['momentum_buffer'] buf.mul_(momentum).add_(grad, alpha=1. - dampening) if nesterov: grad = grad.add(buf, alpha=momentum) else: grad = buf p.add_(grad, alpha=-group['lr']) return loss

homeassistant/components/hunterdouglas_powerview/cover.py

async def _async_force_resync(self, *_): self._forced_resync = None

Fix handling of powerview stale state (#70195)

_async_force_resync

2c2b678e80db615e50a7b72c3ec107730cc6f8dd

core

cover.py

https://github.com/home-assistant/core.git

Python

async def _async_force_resync(self, *_): self._forced_resync = None await self._async_force_refresh_state()

seaborn/palettes.py

def set_color_codes(palette="deep"): if palette == "reset": colors = [

Convert color palette docstrings to notebooks (#3034) * Convert color palette docstrings to notebooks and rerun all with py310 kernel * Add v0.12.1 release notes to index * Improve failure mode when ipywidgets is not involved * Update palettes docstrings * Remove all other doctest-style examples * Remove doctest-oriented testing infrastructure * Mention in release notes * Skip colormap patch test on matplotlib's where it's not relevant * Use more robust approach to mpl backcompat

set_color_codes

e644793f0ac2b1be178425f20f529121f37f29de

seaborn

palettes.py

https://github.com/mwaskom/seaborn.git

Python

def set_color_codes(palette="deep"): if palette == "reset": colors = [ (0., 0., 1.), (0., .5, 0.), (1., 0., 0.), (.75, 0., .75), (.75, .75, 0.), (0., .75, .75), (0., 0., 0.) ] elif not isinstance(palette, str): err = "set_color_codes requires a named seaborn palette" raise TypeError(err) elif palette in SEABORN_PALETTES: if not palette.endswith("6"): palette = palette + "6" colors = SEABORN_PALETTES[palette] + [(.1, .1, .1)] else: err = f"Cannot set colors with palette '{palette}'" raise ValueError(err) for code, color in zip("bgrmyck", colors): rgb = mpl.colors.colorConverter.to_rgb(color) mpl.colors.colorConverter.colors[code] = rgb mpl.colors.colorConverter.cache[code] = rgb

tests/models/test_dagrun.py

def test_mapped_literal_length_increase_at_runtime_adds_additional_tis(dag_maker, session):

Fix mapped task immutability after clear (#23667) We should be able to detect if the structure of mapped task has changed and verify the integrity. This PR ensures this Co-authored-by: Tzu-ping Chung <uranusjr@gmail.com>

test_mapped_literal_length_increase_at_runtime_adds_additional_tis

b692517ce3aafb276e9d23570e9734c30a5f3d1f

airflow

test_dagrun.py

https://github.com/apache/airflow.git

Python

def test_mapped_literal_length_increase_at_runtime_adds_additional_tis(dag_maker, session): from airflow.models import Variable Variable.set(key='arg1', value=[1, 2, 3])

src/documents/tests/test_management_convert_thumbnail.py

def create_png_thumbnail_file(self, thumb_dir): thumb_file = Path(thumb_dir) / Path(f"{self.doc.pk:07}.png") thumb_file.write_text("this is a dummy p

Fixes existing testing, adds test coverage of new command

create_png_thumbnail_file

08c3d6e84b17da2acfb10250438fe357398e5e0e

paperless-ngx

test_management_convert_thumbnail.py

https://github.com/paperless-ngx/paperless-ngx.git

Python

def create_png_thumbnail_file(self, thumb_dir): thumb_file = Path(thumb_dir) / Path(f"{self.doc.pk:07}.png") thumb_file.write_text("this is a dummy png file") return thumb_file

tests/test_api_validate.py

def test_parse_html(self): a

plugin.api.validate: implement ValidationError - Implement `ValidationError` - Inherit from `ValueError` to preserve backwards compatiblity - Allow collecting multiple errors (AnySchema) - Keep an error stack of parent `ValidationError`s or other exceptions - Format error stack when converting error to string - Raise `ValidationError` instead of `ValueError` - Add error contexts where it makes sense - Add schema names to error instances - Add and update tests

test_parse_html

3d44da082b3ba202b9d0557bfd8ce747a1d7960c

streamlink

test_api_validate.py

https://github.com/streamlink/streamlink.git

Python

def test_parse_html(self): assert validate(parse_html(), '<!DOCTYPE html><body>&quot;perfectly&quot;<a>valid<div>HTML').tag == "html" with self.assertRaises(ValueError) as cm: validate(parse_html(), None) assert_validationerror(cm.exception, )

sklearn/utils/validation.py

def _check_feature_names_in(estimator, input_features=None, *, generate_names=True): feature_names_in_ = getattr(estimator, "feature_names_in_", None) n_features_in_ = getattr(estimator, "n_features_in_", None) if input_features is not None: input_features = np.asarray(input_features, dtype=object) if feature_names_in_ is not None and not np.array_equal( feature_names_in_, input_features ): raise ValueError("input_features is not equal to feature_names_in_") if n_features_in_ is not None and len(input_features) != n_features_in_: raise ValueError( "input_features should have length equal to number of " f"features ({n_features_in_}), got {len(input_features)}" ) return input_features if feature_names_in_ is not None: return feature_n

ENH Adds feature_names_out to preprocessing module (#21079) Co-authored-by: Olivier Grisel <olivier.grisel@ensta.org> Co-authored-by: 赵丰 (Zhao Feng) <616545598@qq.com> Co-authored-by: Niket Jain <51831161+nikJ13@users.noreply.github.com> Co-authored-by: Loïc Estève <loic.esteve@ymail.com>

_check_feature_names_in

d7feac0ccfe1a7b8a55f2e16f249f77508a91fe1

scikit-learn

validation.py

https://github.com/scikit-learn/scikit-learn.git

Python

def _check_feature_names_in(estimator, input_features=None, *, generate_names=True): feature_names_in_ = getattr(estimator, "feature_names_in_", None) n_features_in_ = getattr(estimator, "n_features_in_", None) if input_features is not None: input_features = np.asarray(input_features, dtype=object) if feature_names_in_ is not None and not np.array_equal( feature_names_in_, input_features ): raise ValueError("input_features is not equal to feature_names_in_") if n_features_in_ is not None and len(input_features) != n_features_in_: raise ValueError( "input_features should have length equal to number of " f"features ({n_features_in_}), got {len(input_features)}" ) return input_features if feature_names_in_ is not None: return feature_names_in_ if not generate_names: return # Generates feature names if `n_features_in_` is defined if n_features_in_ is None: raise ValueError("Unable to generate feature names without n_features_in_") return np.asarray([f"x{i}" for i in range(n_features_in_)], dtype=object)

networkx/algorithms/shortest_paths/weighted.py

def all_pairs_bellman_ford_path(G, weight="weight"): path = single_source_bellm

DOC: Update documentation to include callables for weight argument (#5307) Update docs to include functions as valid input for weight argument.

all_pairs_bellman_ford_path

b5d41847b8db0c82372faf69cd3a339d11da7ef0

networkx

weighted.py

https://github.com/networkx/networkx.git

Python

def all_pairs_bellman_ford_path(G, weight="weight"): path = single_source_bellman_ford_path # TODO This can be trivially parallelized. for n in G: yield (n, path(G, n, weight=weight))

erpnext/manufacturing/doctype/bom_update_log/test_bom_update_log.py

def update_cost_in_all_boms_in_test(): log = enqueue_update_cost() # create BOM Update Log while log.status != "Completed": resume_bom_cost_update_jobs() # run cron job until complete log.reload() return log

chore: Less hacky tests, versioning (replace bom) and clearing log data (update cost) - Remove `auto_commit_on_many_writes` in `update_cost_in_level()` as commits happen every N BOMs - Auto commit every 50 BOMs - test: Remove hacky `frappe.flags.in_test` returns - test: Enqueue `now` if in tests (for update cost and replace bom) - Replace BOM: Copy bom object to `_doc_before_save` so that version.py finds a difference between the two - Replace BOM: Add reference to version - Update Cost: Unset `processed_boms` if Log is completed (useless after completion) - test: `update_cost_in_all_boms_in_test` works close to actual prod implementation (only call Cron job manually) - Test: use `enqueue_replace_bom` so that test works closest to production behaviour Co-authored-by: Ankush Menat <ankushmenat@gmail.com>

update_cost_in_all_boms_in_test

3fa0a46f39f7024c5d0b235a7725eaa9ad0f3869

erpnext

test_bom_update_log.py

https://github.com/frappe/erpnext.git

Python

def update_cost_in_all_boms_in_test(): log = enqueue_update_cost() # create BOM Update Log while log.status != "Completed": resume_bom_cost_update_jobs() # run cron job until complete log.reload() return log

src/textual/widgets/_data_table.py

def clear(self) -> None: self.row_count = 0 self._clear_caches()

ffixed table refresh on add row

clear

b524fa08eecadc83b0b694278db1c79d90feb9d8

textual

_data_table.py

https://github.com/Textualize/textual.git

Python

def clear(self) -> None: self.row_count = 0 self._clear_caches() self._y_offsets.clear() self.data.clear() self.rows.clear() self._line_no = 0 self._require_update_dimensions = True self.refresh()

nuitka/utils/FileOperations.py

def copyFile(source_path, dest_path): while 1: try: shutil.copyfile(source_path, dest_path) except PermissionError as e: if e.errno != errno.EACCES: raise general.warning("Problem copying file %s:" % e) try: reply

UI: In case of PermissionError, allow uses to retry * Esp. on Windows it happens a lot that running programs cannot be updated by Nuitka, this avoids the cryptic error somewhere ranomly.

copyFile

2c20b90946a8aa5ad4ee39ad365ff1b83f182770

Nuitka

FileOperations.py

https://github.com/Nuitka/Nuitka.git

Python

def copyFile(source_path, dest_path): while 1: try: shutil.copyfile(source_path, dest_path) except PermissionError as e: if e.errno != errno.EACCES: raise general.warning("Problem copying file %s:" % e) try: reply = raw_input("Retry? (YES/no) ") or "yes" except EOFError: reply = "no" if reply.upper() == "YES": continue raise break

sklearn/ensemble/tests/test_iforest.py

def test_iforest(global_random_seed): X_train = np.array([[0, 1], [1, 2]]) X_test = np.array([[2, 1], [1, 1]]) grid = ParameterGrid( {"n_estimators": [3], "max_samples": [0.5, 1.0, 3], "bootstrap": [True, False]} ) with ignore_warnings(): for params in grid: IsolationForest(random_state=global_random_seed, **params).fit( X_train ).predi

TST use global_random_seed in sklearn/ensemble/tests/test_iforest.py (#22901) Co-authored-by: jeremie du boisberranger <jeremiedbb@yahoo.fr> Co-authored-by: Guillaume Lemaitre <g.lemaitre58@gmail.com> Co-authored-by: Olivier Grisel <olivier.grisel@ensta.org>

test_iforest

6ca1f5e4d0d16bc9a7f28582079a15e14f012719

scikit-learn

test_iforest.py

https://github.com/scikit-learn/scikit-learn.git

Python

def test_iforest(global_random_seed): X_train = np.array([[0, 1], [1, 2]]) X_test = np.array([[2, 1], [1, 1]]) grid = ParameterGrid( {"n_estimators": [3], "max_samples": [0.5, 1.0, 3], "bootstrap": [True, False]} ) with ignore_warnings(): for params in grid: IsolationForest(random_state=global_random_seed, **params).fit( X_train ).predict(X_test)

python3.10.4/Lib/importlib/abc.py

def invalidate_caches(self): _register

add python 3.10.4 for windows

invalidate_caches

8198943edd73a363c266633e1aa5b2a9e9c9f526

XX-Net

abc.py

https://github.com/XX-net/XX-Net.git

Python

def invalidate_caches(self): _register(MetaPathFinder, machinery.BuiltinImporter, machinery.FrozenImporter, machinery.PathFinder, machinery.WindowsRegistryFinder)

awx/main/dispatch/reaper.py

def reap(instance=None, status='failed', excluded_uuids=[]): me = instance if me is None: try: me = Instance.objects.me() except RuntimeError as e: logger.warning(f'Local instance is not registered, not running reaper: {e}') return workflow_ctype_id = ContentType.objects.get_for_model(WorkflowJob).id jobs = UnifiedJob.objects.

Split reaper for running and waiting jobs Avoid running jobs that have already been reapted Co-authored-by: Elijah DeLee <kdelee@redhat.com> Remove unnecessary extra actions Fix waiting jobs in other cases of reaping

reap

278db2cddebec97ec48011ecae45129be1ac43a4

awx

reaper.py

https://github.com/ansible/awx.git

Python

def reap(instance=None, status='failed', excluded_uuids=[]): me = instance if me is None: try: me = Instance.objects.me() except RuntimeError as e: logger.warning(f'Local instance is not registered, not running reaper: {e}') return workflow_ctype_id = ContentType.objects.get_for_model(WorkflowJob).id jobs = UnifiedJob.objects.filter( Q(status='running') & (Q(execution_node=me.hostname) | Q(controller_node=me.hostname)) & ~Q(polymorphic_ctype_id=workflow_ctype_id) ).exclude(celery_task_id__in=excluded_uuids) for j in jobs: reap_job(j, status)

nltk/corpus/reader/wordnet.py

def closure(self, rel, depth=-1): from nltk.util import acyclic_breadth_first for synset in acyclic_breadth_first(self, rel, depth): if s

Fix some tests in Wordnet-related DocStrings

closure

692adaff901dd9daf29400fdf3385130aefbfb2a

nltk

wordnet.py

https://github.com/nltk/nltk.git

Python

def closure(self, rel, depth=-1): from nltk.util import acyclic_breadth_first for synset in acyclic_breadth_first(self, rel, depth): if synset != self: yield synset from nltk.util import acyclic_depth_first as acyclic_tree from nltk.util import unweighted_minimum_spanning_tree as mst # Also add this shortcut? # from nltk.util import unweighted_minimum_spanning_digraph as umsd

plugins/convert/writer/opencv.py

def _get_save_args(self) -> Tuple[int, ...]: filetype = self

Convert: Add option to output mask separately for draw-transparent

_get_save_args

049314429f71a21e6595e9d27e9e36f6a3479c42

faceswap

opencv.py

https://github.com/deepfakes/faceswap.git

Python

def _get_save_args(self) -> Tuple[int, ...]: filetype = self.config["format"] args: Tuple[int, ...] = tuple() if filetype == "jpg" and self.config["jpg_quality"] > 0: args = (cv2.IMWRITE_JPEG_QUALITY, # pylint: disable=no-member self.config["jpg_quality"]) if filetype == "png" and self.config["png_compress_level"] > -1: args = (cv2.IMWRITE_PNG_COMPRESSION, # pylint: disable=no-member self.config["png_compress_level"]) logger.debug(args) return args

lib/matplotlib/figure.py

def set_constrained_layout_pads(self, **kwargs): if isinstance(self.get_layout_engine(), ConstrainedLayoutEngine): self.

ENH: implement and use base layout_engine for more flexible layout.

set_constrained_layout_pads

ec4dfbc3c83866f487ff0bc9c87b0d43a1c02b22

matplotlib

figure.py

https://github.com/matplotlib/matplotlib.git

Python

def set_constrained_layout_pads(self, **kwargs): if isinstance(self.get_layout_engine(), ConstrainedLayoutEngine): self.get_layout_engine().set(**kwargs)

freqtrade/freqai/freqai_interface.py

def track_current_candle(self): if self.dd.current_candle > self.current_candle: self.get_corr_dataframes = True

start tracking the current candle in FreqAI, add robustness to corr_df caching and inference timer, add test for cache corr_df

track_current_candle

255eb71270991fe480cd642ee5ea2ce69964f8a9

freqtrade

freqai_interface.py

https://github.com/freqtrade/freqtrade.git

Python

def track_current_candle(self): if self.dd.current_candle > self.current_candle: self.get_corr_dataframes = True self.pair_it = 0 self.current_candle = self.dd.current_candle # Following methods which are overridden by user made prediction models. # See freqai/prediction_models/CatboostPredictionModel.py for an example.

.venv/lib/python3.8/site-packages/pip/_vendor/pkg_resources/__init__.py

def find(self, req): dist = self.by_key.get(req.key) if dist is not None and dist not in req: # XXX a

upd; format

find

f638f5d0e6c8ebed0e69a6584bc7f003ec646580

transferlearning

__init__.py

https://github.com/jindongwang/transferlearning.git

Python

def find(self, req): dist = self.by_key.get(req.key) if dist is not None and dist not in req: # XXX add more info raise VersionConflict(dist, req) return dist

nni/mutable/frozen.py

def current() -> dict | None: try: ContextStack.top(_FROZEN_CONTEXT_KEY) sample: Sample = {} for ctx in ContextStack

Mutable equal, frozen context, new labels (#5247)

current

a67180283b8d273b19f6a3497c6b898ab0c97b7d

nni

frozen.py

https://github.com/microsoft/nni.git

Python

def current() -> dict | None: try: ContextStack.top(_FROZEN_CONTEXT_KEY) sample: Sample = {} for ctx in ContextStack.stack(_FROZEN_CONTEXT_KEY): if not isinstance(ctx, dict): raise TypeError(f'Expect architecture to be a dict, found: {ctx}') sample.update(ctx) return sample except NoContextError: return None

packages/syft/tests/syft/core/tensor/tensor_serde_test.py

def test_rept_child() -> None: rows = 10_000 cols = 7 rept_row_count = 5 # these times and sizes are based on the above constants # and Madhavas MacBook Pro 2019 expected_rept_mem_size = 4.010650634765625 expected_rept_ser_size = 7.4926300048828125 macbook_pro_2019_ser_time = 0.18791760900000032 macbook_pro_2019_de_time = 0.1726598199999998 sept = make_sept(rows=rows, cols=cols) rept_rows = [sept.copy() for i in range(rept_row_count)] rept = REPT(rows=rept_rows) start = timeit.default_timer() ser = sy.serialize(rept, to_bytes=True) end = timeit.default_timer() time_ser = end - start start = timeit.default_timer() de = sy.deserialize(ser, from_byte

Started DPTensor resource optimization - Added initial REPT and SEPT benchmarking tests - Deleted unused old Tensor classes - Added pympler for memory size tests Co-authored-by: @IshanMi Co-authored-by: @rasswanth-s

test_rept_child

10ae1d589044a6ae4722ead7aedc63fcdc4923b5

PySyft

tensor_serde_test.py

https://github.com/OpenMined/PySyft.git

Python

def test_rept_child() -> None: rows = 10_000 cols = 7 rept_row_count = 5 # these times and sizes are based on the above constants # and Madhavas MacBook Pro 2019 expected_rept_mem_size = 4.010650634765625 expected_rept_ser_size = 7.4926300048828125 macbook_pro_2019_ser_time = 0.18791760900000032 macbook_pro_2019_de_time = 0.1726598199999998 sept = make_sept(rows=rows, cols=cols) rept_rows = [sept.copy() for i in range(rept_row_count)] rept = REPT(rows=rept_rows) start = timeit.default_timer() ser = sy.serialize(rept, to_bytes=True) end = timeit.default_timer() time_ser = end - start start = timeit.default_timer() de = sy.deserialize(ser, from_bytes=True) end = timeit.default_timer() time_de = end - start assert rept == de current_rept_mem_size = size(rept) mem_diff = (current_rept_mem_size / expected_rept_mem_size * 100) - 100 current_rept_bytes_size = size(ser) bytes_diff = (current_rept_bytes_size / expected_rept_ser_size * 100) - 100 ser_time_diff = (time_ser / macbook_pro_2019_ser_time * 100) - 100 de_time_diff = (time_de / macbook_pro_2019_de_time * 100) - 100 print("REPT Stats") print("==========") print("In-memory size of REPT", size(rept)) print("Serialized size of REPT", size(ser)) print(f"Serializing {rept_row_count}x{rows}x{cols} took {time_ser} secs") print(f"Deserializing {rept_row_count}x{rows}x{cols} took {time_de} secs") print("Current Results") print("===============") print(f"In-memory size delta: {mem_diff}%") print(f"Serialized size delta: {bytes_diff}%") print(f"Serializing time delta: {ser_time_diff}%") print(f"Deserializing time delta: {de_time_diff}%") # we want to assert that our calculated values are smaller than the old values with # some tolerance assert (current_rept_mem_size - expected_rept_mem_size) < 1e-3 assert (current_rept_bytes_size - expected_rept_ser_size) < 2e-2 # TODO: make time benchmarks stable (probably can't run in parallel) # assert (time_ser - macbook_pro_2019_ser_time) < 2e-1 # assert (time_de - macbook_pro_2019_de_time) < 2e-1

sympy/ntheory/ecm.py

def _ecm_one_factor(n, B1=10000, B2=100000, max_curve=200): n = as_int(n) if B1 % 2 != 0 or B2 % 2 != 0: raise ValueError("The Bounds should be an even integer") sieve.extend(B2) if isprime(n): return n from sympy.functions.elementary.miscellaneous import sqrt from sympy.polys.polytools import gcd curve = 0 D = int(sqrt(B2)) beta = [0]*(D + 1) S = [0]*(D + 1) k = 1 for p in sieve.primerange(1, B1 + 1): k *= pow(p, integer_log(B1, p)[0]) while(curve <= max_curve): curve += 1 #Suyama's Paramatrization sigma = rgen.randint(6, n - 1) u = (sigma*sigma - 5) % n v = (4*sigma) % n diff = v - u u_3 = pow(u, 3, n) try: C = (pow(diff, 3, n)*(3*u + v)*mod_inverse(4*u_3*v, n) - 2) % n except ValueError: #If the mod_inverse(4*u_3*v, n) doesn't exist return gcd(4*u_3*v, n) a24 = (C + 2)*mod_inverse(4, n) % n Q = Point(u_3, pow(v, 3, n), a24, n) Q = Q.mont_ladder(k) g = gcd(Q.z_cord, n) #Stage 1 factor if g != 1 and g != n: return g #Stage 1 failure. Q.z = 0, Try another curve

Refactored import ordering in functions

_ecm_one_factor

e0dc14eca132f37c5f49369eb4051eae37c9b119

sympy

ecm.py

https://github.com/sympy/sympy.git