PGCodeLLM/FEA-Bench-v1.0-Standard · Datasets at Hugging Face

instance_id stringlengths 13 45	pull_number int64 7 30.1k	repo stringclasses 83 values	version stringclasses 68 values	base_commit stringlengths 40 40	created_at stringdate 2013-05-16 18:15:55 2025-01-08 15:12:50	patch stringlengths 347 35.2k	test_patch stringlengths 432 113k	non_py_patch stringlengths 0 18.3k	new_components listlengths 0 40	FAIL_TO_PASS listlengths 1 2.53k	PASS_TO_PASS listlengths 0 1.7k	problem_statement stringlengths 607 52.7k	hints_text stringlengths 0 57.4k	environment_setup_commit stringclasses 167 values
conan-io__conan-15415	15,415	conan-io/conan	null	4f0533c8075ad86f116a6e2c71ab1df69373378a	2024-01-08T16:20:33Z	diff --git a/conans/model/settings.py b/conans/model/settings.py index 189bb71185d..d55e0f37452 100644 --- a/conans/model/settings.py +++ b/conans/model/settings.py @@ -106,6 +106,11 @@ def _get_child(self, item): raise undefined_field(self._name, item, None, self._value) if self._value is None: raise ConanException("'%s' value not defined" % self._name) + return self._get_definition() + + def _get_definition(self): + if self._value not in self._definition and "ANY" in self._definition: + return self._definition["ANY"] return self._definition[self._value] def __getattr__(self, item): @@ -142,7 +147,7 @@ def values_list(self): partial_name = ".".join(self._name.split(".")[1:]) result.append((partial_name, self._value)) if isinstance(self._definition, dict): - sub_config_dict = self._definition[self._value] + sub_config_dict = self._get_definition() result.extend(sub_config_dict.values_list) return result @@ -150,7 +155,7 @@ def validate(self): if self._value is None and None not in self._definition: raise ConanException("'%s' value not defined" % self._name) if isinstance(self._definition, dict): - self._definition[self._value].validate() + self._get_definition().validate() def possible_values(self): if isinstance(self._definition, list):	diff --git a/conans/test/unittests/model/settings_test.py b/conans/test/unittests/model/settings_test.py index b80904ff3f6..94d4a44673c 100644 --- a/conans/test/unittests/model/settings_test.py +++ b/conans/test/unittests/model/settings_test.py @@ -1,3 +1,4 @@ +import textwrap import unittest import pytest @@ -48,6 +49,32 @@ def test_none_any(self): self.assertTrue(settings.os == "Windows") self.assertEqual("os=Windows", settings.dumps()) + def test_nested_any(self): + yml = textwrap.dedent("""\ + os: + ANY: + version: [null, ANY] + Ubuntu: + version: ["18.04", "20.04"] + """) + settings = Settings.loads(yml) + settings.os = "Windows" + settings.validate() + self.assertTrue(settings.os == "Windows") + self.assertIn("os=Windows", settings.dumps()) + settings.os.version = 2 + self.assertTrue(settings.os == "Windows") + self.assertEqual("os=Windows\nos.version=2", settings.dumps()) + settings.os = "Ubuntu" + with self.assertRaisesRegex(ConanException, "'settings.os.version' value not defined"): + settings.validate() + with self.assertRaisesRegex(ConanException, + "Invalid setting '3' is not a valid 'settings.os.version'"): + settings.os.version = 3 + settings.os.version = "20.04" + self.assertEqual("os=Ubuntu\nos.version=20.04", settings.dumps()) + self.assertTrue(settings.os.version == "20.04") + def test_getattr_none(self): yml = "os: [None, Windows]" settings = Settings.loads(yml)		[ { "components": [ { "doc": "", "lines": [ 111, 114 ], "name": "SettingsItem._get_definition", "signature": "def _get_definition(self):", "type": "function" } ], "file": "conans/model/settings.py" } ]	[ "conans/test/unittests/model/settings_test.py::SettingsLoadsTest::test_nested_any" ]	[ "conans/test/unittests/model/settings_test.py::SettingsLoadsTest::test_any", "conans/test/unittests/model/settings_test.py::SettingsLoadsTest::test_get_safe", "conans/test/unittests/model/settings_test.py::SettingsLoadsTest::test_getattr_none", "conans/test/unittests/model/settings_test.py::SettingsLoadsTest:...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> explore nested ANY settings.yml Changelog: Feature: Allow nested "ANY" definitions in ``settings.yml``. Docs: https://github.com/conan-io/docs/pull/3546 Close https://github.com/conan-io/conan/issues/15414 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conans/model/settings.py] (definition of SettingsItem._get_definition:) def _get_definition(self): [end of new definitions in conans/model/settings.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		4a5b19a75db9225316c8cb022a2dfb9705a2af34
pyro-ppl__pyro-3311	3,311	pyro-ppl/pyro	null	5d920aabaaf80b7bb86e53f5a0dc11251bbdffa5	2024-01-04T17:04:23Z	diff --git a/docs/source/pyro.infer.mcmc.txt b/docs/source/pyro.infer.mcmc.txt index 0f51191474..0684a97b99 100644 --- a/docs/source/pyro.infer.mcmc.txt +++ b/docs/source/pyro.infer.mcmc.txt @@ -37,6 +37,14 @@ NUTS :undoc-members: :show-inheritance: +RandomWalkKernel +---------------- + +.. autoclass:: pyro.infer.mcmc.RandomWalkKernel + :members: + :undoc-members: + :show-inheritance: + BlockMassMatrix --------------- diff --git a/pyro/infer/__init__.py b/pyro/infer/__init__.py index 5485b7476e..c0f3a26c3f 100644 --- a/pyro/infer/__init__.py +++ b/pyro/infer/__init__.py @@ -11,6 +11,7 @@ from pyro.infer.mcmc.api import MCMC from pyro.infer.mcmc.hmc import HMC from pyro.infer.mcmc.nuts import NUTS +from pyro.infer.mcmc.rwkernel import RandomWalkKernel from pyro.infer.predictive import Predictive from pyro.infer.renyi_elbo import RenyiELBO from pyro.infer.rws import ReweightedWakeSleep @@ -45,6 +46,7 @@ "MCMC", "NUTS", "Predictive", + "RandomWalkKernel", "RBFSteinKernel", "RenyiELBO", "ReweightedWakeSleep", diff --git a/pyro/infer/mcmc/__init__.py b/pyro/infer/mcmc/__init__.py index 7be4bae99c..749af47b1a 100644 --- a/pyro/infer/mcmc/__init__.py +++ b/pyro/infer/mcmc/__init__.py @@ -5,6 +5,7 @@ from pyro.infer.mcmc.api import MCMC, StreamingMCMC from pyro.infer.mcmc.hmc import HMC from pyro.infer.mcmc.nuts import NUTS +from pyro.infer.mcmc.rwkernel import RandomWalkKernel __all__ = [ "ArrowheadMassMatrix", @@ -12,5 +13,6 @@ "HMC", "MCMC", "NUTS", + "RandomWalkKernel", "StreamingMCMC", ] diff --git a/pyro/infer/mcmc/rwkernel.py b/pyro/infer/mcmc/rwkernel.py new file mode 100644 index 0000000000..4c3da325df --- /dev/null +++ b/pyro/infer/mcmc/rwkernel.py @@ -0,0 +1,143 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +import math +from collections import OrderedDict + +import torch + +import pyro +import pyro.distributions as dist +from pyro.infer.mcmc.mcmc_kernel import MCMCKernel +from pyro.infer.mcmc.util import initialize_model + + +class RandomWalkKernel(MCMCKernel): + r""" + Simple gradient-free kernel that utilizes an isotropic gaussian random walk in the unconstrained + latent space of the model. The step size that controls the variance of the kernel is adapted during + warm-up with a simple adaptation scheme that targets a user-provided acceptance probability. + + :param model: Python callable containing Pyro primitives. + :param float init_step_size: A positive float that controls the initial step size. Defaults to 0.1. + :param float target_accept_prob: The target acceptance probability used during adaptation of + the step size. Defaults to 0.234. + + Example: + + >>> true_coefs = torch.tensor([1., 2., 3.]) + >>> data = torch.randn(2000, 3) + >>> dim = 3 + >>> labels = dist.Bernoulli(logits=(true_coefs * data).sum(-1)).sample() + >>> + >>> def model(data): + ... coefs_mean = torch.zeros(dim) + ... coefs = pyro.sample('beta', dist.Normal(coefs_mean, torch.ones(3))) + ... y = pyro.sample('y', dist.Bernoulli(logits=(coefs * data).sum(-1)), obs=labels) + ... return y + >>> + >>> hmc_kernel = RandomWalkKernel(model, init_step_size=0.2) + >>> mcmc = MCMC(hmc_kernel, num_samples=200, warmup_steps=100) + >>> mcmc.run(data) + >>> mcmc.get_samples()['beta'].mean(0) # doctest: +SKIP + tensor([ 0.9819, 1.9258, 2.9737]) + """ + + def __init__( + self, model, init_step_size: float = 0.1, target_accept_prob: float = 0.234 + ): + if not isinstance(init_step_size, float) or init_step_size <= 0.0: + raise ValueError("init_step_size must be a positive float.") + + if ( + not isinstance(target_accept_prob, float) + or target_accept_prob <= 0.0 + or target_accept_prob >= 1.0 + ): + raise ValueError( + "target_accept_prob must be a float in the interval (0, 1)." + ) + + self.model = model + self.init_step_size = init_step_size + self.target_accept_prob = target_accept_prob + + self._t = 0 + self._log_step_size = math.log(init_step_size) + self._accept_cnt = 0 + self._mean_accept_prob = 0.0 + super().__init__() + + def setup(self, warmup_steps, args, kwargs): + self._warmup_steps = warmup_steps + ( + self._initial_params, + self.potential_fn, + self.transforms, + self._prototype_trace, + ) = initialize_model( + self.model, + model_args=args, + model_kwargs=kwargs, + ) + self._energy_last = self.potential_fn(self._initial_params) + + def sample(self, params): + step_size = math.exp(self._log_step_size) + new_params = { + k: v + step_size torch.randn(v.shape, dtype=v.dtype, device=v.device) + for k, v in params.items() + } + energy_proposal = self.potential_fn(new_params) + delta_energy = energy_proposal - self._energy_last + + accept_prob = (-delta_energy).exp().clamp(max=1.0).item() + rand = pyro.sample( + "rand_t={}".format(self._t), + dist.Uniform(0.0, 1.0), + ) + accepted = False + if rand < accept_prob: + accepted = True + params = new_params + self._energy_last = energy_proposal + + if self._t <= self._warmup_steps: + adaptation_speed = max(0.001, 0.1 / math.sqrt(1 + self._t)) + self._log_step_size += adaptation_speed * ( + accept_prob - self.target_accept_prob + ) + + self._t += 1 + + if self._t > self._warmup_steps: + n = self._t - self._warmup_steps + if accepted: + self._accept_cnt += 1 + else: + n = self._t + + self._mean_accept_prob += (accept_prob - self._mean_accept_prob) / n + + return params.copy() + + @property + def initial_params(self): + return self._initial_params + + @initial_params.setter + def initial_params(self, params): + self._initial_params = params + + def logging(self): + return OrderedDict( + [ + ("step size", "{:.2e}".format(math.exp(self._log_step_size))), + ("acc. prob", "{:.3f}".format(self._mean_accept_prob)), + ] + ) + + def diagnostics(self): + return { + "acceptance rate": self._accept_cnt / (self._t - self._warmup_steps), + }	diff --git a/tests/infer/mcmc/test_rwkernel.py b/tests/infer/mcmc/test_rwkernel.py new file mode 100644 index 0000000000..08490703e6 --- /dev/null +++ b/tests/infer/mcmc/test_rwkernel.py @@ -0,0 +1,40 @@ +# Copyright (c) 2017-2019 Uber Technologies, Inc. +# SPDX-License-Identifier: Apache-2.0 + +import torch + +import pyro +import pyro.distributions as dist +from pyro.infer.mcmc.api import MCMC +from pyro.infer.mcmc.rwkernel import RandomWalkKernel +from tests.common import assert_equal + + +def test_beta_bernoulli(): + alpha = torch.tensor([1.1, 2.2]) + beta = torch.tensor([1.1, 2.2]) + + def model(data): + p_latent = pyro.sample("p_latent", dist.Beta(alpha, beta)) + with pyro.plate("data", data.shape[0], dim=-2): + pyro.sample("obs", dist.Bernoulli(p_latent), obs=data) + + num_data = 5 + true_probs = torch.tensor([0.9, 0.1]) + data = dist.Bernoulli(true_probs).sample(sample_shape=(torch.Size((num_data,)))) + + kernel = RandomWalkKernel(model) + mcmc = MCMC(kernel, num_samples=2000, warmup_steps=500) + mcmc.run(data) + samples = mcmc.get_samples() + + data_sum = data.sum(0) + alpha_post = alpha + data_sum + beta_post = beta + num_data - data_sum + expected_mean = alpha_post / (alpha_post + beta_post) + expected_var = ( + expected_mean.pow(2) * beta_post / (alpha_post * (1 + alpha_post + beta_post)) + ) + + assert_equal(samples["p_latent"].mean(0), expected_mean, prec=0.03) + assert_equal(samples["p_latent"].var(0), expected_var, prec=0.005)	diff --git a/docs/source/pyro.infer.mcmc.txt b/docs/source/pyro.infer.mcmc.txt index 0f51191474..0684a97b99 100644 --- a/docs/source/pyro.infer.mcmc.txt +++ b/docs/source/pyro.infer.mcmc.txt @@ -37,6 +37,14 @@ NUTS :undoc-members: :show-inheritance: +RandomWalkKernel +---------------- + +.. autoclass:: pyro.infer.mcmc.RandomWalkKernel + :members: + :undoc-members: + :show-inheritance: + BlockMassMatrix ---------------	[ { "components": [ { "doc": "Simple gradient-free kernel that utilizes an isotropic gaussian random walk in the unconstrained\nlatent space of the model. The step size that controls the variance of the kernel is adapted during\nwarm-up with a simple adaptation scheme that targets a user-provided ac...	[ "tests/infer/mcmc/test_rwkernel.py::test_beta_bernoulli" ]	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add simple RandomWalkKernel Add a simple gradient-free kernel to complements HMC/NUTS. - isotropic gaussian proposal - simple adaptation scheme to adapt step size ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pyro/infer/mcmc/rwkernel.py] (definition of RandomWalkKernel:) class RandomWalkKernel(MCMCKernel): """Simple gradient-free kernel that utilizes an isotropic gaussian random walk in the unconstrained latent space of the model. The step size that controls the variance of the kernel is adapted during warm-up with a simple adaptation scheme that targets a user-provided acceptance probability. :param model: Python callable containing Pyro primitives. :param float init_step_size: A positive float that controls the initial step size. Defaults to 0.1. :param float target_accept_prob: The target acceptance probability used during adaptation of the step size. Defaults to 0.234. Example: >>> true_coefs = torch.tensor([1., 2., 3.]) >>> data = torch.randn(2000, 3) >>> dim = 3 >>> labels = dist.Bernoulli(logits=(true_coefs * data).sum(-1)).sample() >>> >>> def model(data): ... coefs_mean = torch.zeros(dim) ... coefs = pyro.sample('beta', dist.Normal(coefs_mean, torch.ones(3))) ... y = pyro.sample('y', dist.Bernoulli(logits=(coefs * data).sum(-1)), obs=labels) ... return y >>> >>> hmc_kernel = RandomWalkKernel(model, init_step_size=0.2) >>> mcmc = MCMC(hmc_kernel, num_samples=200, warmup_steps=100) >>> mcmc.run(data) >>> mcmc.get_samples()['beta'].mean(0) # doctest: +SKIP tensor([ 0.9819, 1.9258, 2.9737])""" (definition of RandomWalkKernel.__init__:) def __init__( self, model, init_step_size: float = 0.1, target_accept_prob: float = 0.234 ): (definition of RandomWalkKernel.setup:) def setup(self, warmup_steps, args, *kwargs): (definition of RandomWalkKernel.sample:) def sample(self, params): (definition of RandomWalkKernel.initial_params:) def initial_params(self): (definition of RandomWalkKernel.initial_params:) def initial_params(self, params): (definition of RandomWalkKernel.logging:) def logging(self): (definition of RandomWalkKernel.diagnostics:) def diagnostics(self): [end of new definitions in pyro/infer/mcmc/rwkernel.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		64e71eee1c14dc926d5cbc5e762b6337bb4750a6
conan-io__conan-15382	15,382	conan-io/conan	null	e2a65483d2e294d604d4bae9ede883958c583f75	2024-01-03T16:56:11Z	diff --git a/conan/cli/commands/build.py b/conan/cli/commands/build.py index 2212e5f79ac..bf1543a8681 100644 --- a/conan/cli/commands/build.py +++ b/conan/cli/commands/build.py @@ -23,7 +23,8 @@ def build(conan_api, parser, args): parser.add_argument("-of", "--output-folder", help='The root output folder for generated and build files') parser.add_argument("-d", "--deployer", action="append", - help='Deploy using the provided deployer to the output folder') + help="Deploy using the provided deployer to the output folder. " + "Built-in deployers: 'full_deploy', 'direct_deploy', 'runtime_deploy'") parser.add_argument("--deployer-folder", help="Deployer output folder, base build folder by default if not set") parser.add_argument("--build-require", action='store_true', default=False, diff --git a/conan/cli/commands/graph.py b/conan/cli/commands/graph.py index c5fb5f168bd..85d7cb510ec 100644 --- a/conan/cli/commands/graph.py +++ b/conan/cli/commands/graph.py @@ -175,7 +175,10 @@ def graph_info(conan_api, parser, subparser, args): subparser.add_argument("--package-filter", action="append", help='Print information only for packages that match the patterns') subparser.add_argument("-d", "--deployer", action="append", - help='Deploy using the provided deployer to the output folder') + help="Deploy using the provided deployer to the output folder. " + "Built-in deployers: 'full_deploy', 'direct_deploy'. Deployers " + "will only deploy recipes, as 'conan graph info' do not retrieve " + "binaries") subparser.add_argument("-df", "--deployer-folder", help="Deployer output folder, base build folder by default if not set") subparser.add_argument("--build-require", action='store_true', default=False, diff --git a/conan/cli/commands/install.py b/conan/cli/commands/install.py index cad3168a543..703e022ea0f 100644 --- a/conan/cli/commands/install.py +++ b/conan/cli/commands/install.py @@ -30,7 +30,8 @@ def install(conan_api, parser, *args): parser.add_argument("-of", "--output-folder", help='The root output folder for generated and build files') parser.add_argument("-d", "--deployer", action="append", - help='Deploy using the provided deployer to the output folder') + help="Deploy using the provided deployer to the output folder. " + "Built-in deployers: 'full_deploy', 'direct_deploy', 'runtime_deploy'") parser.add_argument("--deployer-folder", help="Deployer output folder, base build folder by default if not set") parser.add_argument("--deployer-package", action="append", diff --git a/conan/internal/deploy.py b/conan/internal/deploy.py index 9631645ffdd..d5f04693d20 100644 --- a/conan/internal/deploy.py +++ b/conan/internal/deploy.py @@ -1,3 +1,4 @@ +import filecmp import os import shutil @@ -31,7 +32,8 @@ def _load(path): if os.path.isfile(cache_path): return _load(cache_path) builtin_deploy = {"full_deploy.py": full_deploy, - "direct_deploy.py": direct_deploy}.get(d) + "direct_deploy.py": direct_deploy, + "runtime_deploy.py": runtime_deploy}.get(d) if builtin_deploy is not None: return builtin_deploy raise ConanException(f"Cannot find deployer '{d}'") @@ -87,6 +89,75 @@ def full_deploy(graph, output_folder): _deploy_single(dep, conanfile, output_folder, folder_name) +def runtime_deploy(graph, output_folder): + """ + Deploy all the shared libraries and the executables of the dependencies in a flat directory. + """ + conanfile = graph.root.conanfile + output = ConanOutput(scope="runtime_deploy") + output.info(f"Deploying dependencies runtime to folder: {output_folder}") + output.warning("This deployer is experimental and subject to change. " + "Please give feedback at https://github.com/conan-io/conan/issues") + mkdir(output_folder) + symlinks = conanfile.conf.get("tools.deployer:symlinks", check_type=bool, default=True) + for _, dep in conanfile.dependencies.host.items(): + if dep.package_folder is None: + output.warning(f"{dep.ref} does not have any package folder, skipping binary") + continue + count = 0 + cpp_info = dep.cpp_info.aggregated_components() + for bindir in cpp_info.bindirs: + if not os.path.isdir(bindir): + output.warning(f"{dep.ref} {bindir} does not exist") + continue + count += _flatten_directory(dep, bindir, output_folder, symlinks) + + for libdir in cpp_info.libdirs: + if not os.path.isdir(libdir): + output.warning(f"{dep.ref} {libdir} does not exist") + continue + count += _flatten_directory(dep, libdir, output_folder, symlinks, [".dylib", ".so"]) + + output.info(f"Copied {count} files from {dep.ref}") + conanfile.output.success(f"Runtime deployed to folder: {output_folder}") + + +def _flatten_directory(dep, src_dir, output_dir, symlinks, extension_filter=None): + """ + Copy all the files from the source directory in a flat output directory. + An optional string, named extension_filter, can be set to copy only the files with + the listed extensions. + """ + file_count = 0 + + output = ConanOutput(scope="runtime_deploy") + for src_dirpath, _, src_filenames in os.walk(src_dir, followlinks=symlinks): + for src_filename in src_filenames: + if extension_filter and not any(src_filename.endswith(ext) for ext in extension_filter): + continue + + src_filepath = os.path.join(src_dirpath, src_filename) + dest_filepath = os.path.join(output_dir, src_filename) + if os.path.exists(dest_filepath): + if filecmp.cmp(src_filepath, dest_filepath): # Be efficient, do not copy + output.verbose(f"{dest_filepath} exists with same contents, skipping copy") + continue + else: + output.warning(f"{dest_filepath} exists and will be overwritten") + + try: + file_count += 1 + shutil.copy2(src_filepath, dest_filepath, follow_symlinks=symlinks) + output.verbose(f"Copied {src_filepath} into {output_dir}") + except Exception as e: + if "WinError 1314" in str(e): + ConanOutput().error("runtime_deploy: Windows symlinks require admin privileges " + "or 'Developer mode = ON'", error_type="exception") + raise ConanException(f"runtime_deploy: Copy of '{dep}' files failed: {e}.\nYou can " + f"use 'tools.deployer:symlinks' conf to disable symlinks") + return file_count + + def _deploy_single(dep, conanfile, output_folder, folder_name): new_folder = os.path.join(output_folder, folder_name) rmdir(new_folder)	diff --git a/test/functional/command/test_install_deploy.py b/test/functional/command/test_install_deploy.py index 24bb1bd63ba..1967e4b4836 100644 --- a/test/functional/command/test_install_deploy.py +++ b/test/functional/command/test_install_deploy.py @@ -435,3 +435,57 @@ def package_info(self): env = c.load("conanbuildenv-release-x86_64.sh") assert f'export MYPATH="{some_abs_path}/mypath"' in env + + +class TestRuntimeDeployer: + def test_runtime_deploy(self): + c = TestClient() + conanfile = textwrap.dedent(""" + from conan import ConanFile + from conan.tools.files import copy + class Pkg(ConanFile): + def package(self): + copy(self, ".so", src=self.build_folder, dst=self.package_folder) + copy(self, ".dll", src=self.build_folder, dst=self.package_folder) + """) + c.save({"pkga/conanfile.py": conanfile, + "pkga/lib/pkga.so": "", + "pkga/bin/pkga.dll": "", + "pkgb/conanfile.py": conanfile, + "pkgb/lib/pkgb.so": ""}) + c.run("export-pkg pkga --name=pkga --version=1.0") + c.run("export-pkg pkgb --name=pkgb --version=1.0") + c.run("install --requires=pkga/1.0 --requires=pkgb/1.0 --deployer=runtime_deploy " + "--deployer-folder=myruntime -vvv") + + expected = sorted(["pkga.so", "pkgb.so", "pkga.dll"]) + assert sorted(os.listdir(os.path.join(c.current_folder, "myruntime"))) == expected + + def test_runtime_deploy_components(self): + c = TestClient() + conanfile = textwrap.dedent(""" + import os + from conan import ConanFile + from conan.tools.files import copy + class Pkg(ConanFile): + def package(self): + copy(self, ".so", src=self.build_folder, + dst=os.path.join(self.package_folder, "a")) + copy(self, ".dll", src=self.build_folder, + dst=os.path.join(self.package_folder, "b")) + def package_info(self): + self.cpp_info.components["a"].libdirs = ["a"] + self.cpp_info.components["b"].bindirs = ["b"] + """) + c.save({"pkga/conanfile.py": conanfile, + "pkga/lib/pkga.so": "", + "pkga/bin/pkga.dll": "", + "pkgb/conanfile.py": conanfile, + "pkgb/lib/pkgb.so": ""}) + c.run("export-pkg pkga --name=pkga --version=1.0") + c.run("export-pkg pkgb --name=pkgb --version=1.0") + c.run("install --requires=pkga/1.0 --requires=pkgb/1.0 --deployer=runtime_deploy " + "--deployer-folder=myruntime -vvv") + + expected = sorted(["pkga.so", "pkgb.so", "pkga.dll"]) + assert sorted(os.listdir(os.path.join(c.current_folder, "myruntime"))) == expected		[ { "components": [ { "doc": "Deploy all the shared libraries and the executables of the dependencies in a flat directory.", "lines": [ 92, 122 ], "name": "runtime_deploy", "signature": "def runtime_deploy(graph, output_folder):", "type": "...	[ "test/functional/command/test_install_deploy.py::TestRuntimeDeployer::test_runtime_deploy", "test/functional/command/test_install_deploy.py::TestRuntimeDeployer::test_runtime_deploy_components" ]	[ "test/functional/command/test_install_deploy.py::test_copy_files_deploy", "test/functional/command/test_install_deploy.py::test_multi_deploy", "test/functional/command/test_install_deploy.py::test_deploy_local_import", "test/functional/command/test_install_deploy.py::test_builtin_full_deploy", "test/functio...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add built in runtime deployer Changelog: Feature: Add built in `runtime_deploy` deployer. Docs: https://github.com/conan-io/docs/pull/3789 Fix https://github.com/conan-io/conan/issues/15381 This PR is currently a draft, only tested manually on windows with: ``` conan install --requires=zlib/1.3 --requires=cmake/3.28.1 -of C:\Users\florian.degaulejac\tmp\zlib-cmake --deployer runtime_deploy.py -vtrace --deployer-folder C:\Users\florian.degaulejac\tmp\zlib-cmake\deploy -o "zlib/*:shared=True" ``` Remaining tasks that I won't have the time to complete: - [ ] write autotest instead of manual test - [ ] test other env (linux, apple...) - [ ] symbolic links - [ ] test with deep hierarchy and check it is flatten And a weird behavior I observed: dep.cpp_info.bindirs and dep.cpp_info.libdirs are populated with absolute paths instead of relative path like described in the documentation. Docs: https://github.com/conan-io/docs/pull/XXXX - [x] Refer to the issue that supports this Pull Request. - [x] If the issue has missing info, explain the purpose/use case/pain/need that covers this Pull Request. - [x] I've read the [Contributing guide](https://github.com/conan-io/conan/blob/develop/.github/CONTRIBUTING.md). - [ ] I've followed the PEP8 style guides for Python code. - [ ] I've opened another PR in the Conan docs repo to the ``develop`` branch, documenting this one. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conan/internal/deploy.py] (definition of runtime_deploy:) def runtime_deploy(graph, output_folder): """Deploy all the shared libraries and the executables of the dependencies in a flat directory.""" (definition of _flatten_directory:) def _flatten_directory(dep, src_dir, output_dir, symlinks, extension_filter=None): """Copy all the files from the source directory in a flat output directory. An optional string, named extension_filter, can be set to copy only the files with the listed extensions.""" [end of new definitions in conan/internal/deploy.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		4a5b19a75db9225316c8cb022a2dfb9705a2af34
deepset-ai__haystack-6676	6,676	deepset-ai/haystack	null	1336456b4f94e47ea1cf0d45835e5eef4349530d	2024-01-02T13:34:32Z	diff --git a/haystack/components/embedders/__init__.py b/haystack/components/embedders/__init__.py index d2005877a3..5a6730e5be 100644 --- a/haystack/components/embedders/__init__.py +++ b/haystack/components/embedders/__init__.py @@ -4,6 +4,8 @@ from haystack.components.embedders.sentence_transformers_document_embedder import SentenceTransformersDocumentEmbedder from haystack.components.embedders.openai_document_embedder import OpenAIDocumentEmbedder from haystack.components.embedders.openai_text_embedder import OpenAITextEmbedder +from haystack.components.embedders.azure_text_embedder import AzureOpenAITextEmbedder +from haystack.components.embedders.azure_document_embedder import AzureOpenAIDocumentEmbedder __all__ = [ "HuggingFaceTEITextEmbedder", @@ -12,4 +14,6 @@ "SentenceTransformersDocumentEmbedder", "OpenAITextEmbedder", "OpenAIDocumentEmbedder", + "AzureOpenAITextEmbedder", + "AzureOpenAIDocumentEmbedder", ] diff --git a/haystack/components/embedders/azure_document_embedder.py b/haystack/components/embedders/azure_document_embedder.py new file mode 100644 index 0000000000..9d98eab1ff --- /dev/null +++ b/haystack/components/embedders/azure_document_embedder.py @@ -0,0 +1,178 @@ +import os +from typing import List, Optional, Dict, Any, Tuple + +from openai.lib.azure import AzureADTokenProvider, AzureOpenAI +from tqdm import tqdm + +from haystack import component, Document, default_to_dict + + +@component +class AzureOpenAIDocumentEmbedder: + """ + A component for computing Document embeddings using OpenAI models. + The embedding of each Document is stored in the `embedding` field of the Document. + + Usage example: + ```python + from haystack import Document + from haystack.components.embedders import AzureOpenAIDocumentEmbedder + + doc = Document(content="I love pizza!") + + document_embedder = AzureOpenAIDocumentEmbedder() + + result = document_embedder.run([doc]) + print(result['documents'][0].embedding) + + # [0.017020374536514282, -0.023255806416273117, ...] + ``` + """ + + def __init__( + self, + azure_endpoint: Optional[str] = None, + api_version: Optional[str] = "2023-05-15", + azure_deployment: str = "text-embedding-ada-002", + api_key: Optional[str] = None, + azure_ad_token: Optional[str] = None, + azure_ad_token_provider: Optional[AzureADTokenProvider] = None, + organization: Optional[str] = None, + prefix: str = "", + suffix: str = "", + batch_size: int = 32, + progress_bar: bool = True, + meta_fields_to_embed: Optional[List[str]] = None, + embedding_separator: str = "\n", + ): + """ + Create an AzureOpenAITextEmbedder component. + + :param azure_endpoint: The endpoint of the deployed model, e.g. `https://example-resource.azure.openai.com/` + :param api_version: The version of the API to use. Defaults to 2023-05-15 + :param azure_deployment: The deployment of the model, usually the model name. + :param api_key: The API key to use for authentication. + :param azure_ad_token: Azure Active Directory token, see https://www.microsoft.com/en-us/security/business/identity-access/microsoft-entra-id + :param azure_ad_token_provider: A function that returns an Azure Active Directory token, will be invoked + on every request. + :param organization: The Organization ID, defaults to `None`. See + [production best practices](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization). + :param prefix: A string to add to the beginning of each text. + :param suffix: A string to add to the end of each text. + :param batch_size: Number of Documents to encode at once. + :param progress_bar: Whether to show a progress bar or not. Can be helpful to disable in production deployments + to keep the logs clean. + :param meta_fields_to_embed: List of meta fields that should be embedded along with the Document text. + :param embedding_separator: Separator used to concatenate the meta fields to the Document text. + """ + # if not provided as a parameter, azure_endpoint is read from the env var AZURE_OPENAI_ENDPOINT + azure_endpoint = azure_endpoint or os.environ.get("AZURE_OPENAI_ENDPOINT") + if not azure_endpoint: + raise ValueError("Please provide an Azure endpoint or set the environment variable AZURE_OPENAI_ENDPOINT.") + + self.api_version = api_version + self.azure_endpoint = azure_endpoint + self.azure_deployment = azure_deployment + self.organization = organization + self.prefix = prefix + self.suffix = suffix + self.batch_size = batch_size + self.progress_bar = progress_bar + self.meta_fields_to_embed = meta_fields_to_embed or [] + self.embedding_separator = embedding_separator + + self._client = AzureOpenAI( + api_version=api_version, + azure_endpoint=azure_endpoint, + azure_deployment=azure_deployment, + api_key=api_key, + azure_ad_token=azure_ad_token, + azure_ad_token_provider=azure_ad_token_provider, + organization=organization, + ) + + def _get_telemetry_data(self) -> Dict[str, Any]: + """ + Data that is sent to Posthog for usage analytics. + """ + return {"model": self.azure_deployment} + + def to_dict(self) -> Dict[str, Any]: + """ + This method overrides the default serializer in order to avoid leaking the `api_key` value passed + to the constructor. + """ + return default_to_dict( + self, + azure_endpoint=self.azure_endpoint, + azure_deployment=self.azure_deployment, + organization=self.organization, + api_version=self.api_version, + prefix=self.prefix, + suffix=self.suffix, + batch_size=self.batch_size, + progress_bar=self.progress_bar, + meta_fields_to_embed=self.meta_fields_to_embed, + embedding_separator=self.embedding_separator, + ) + + def _prepare_texts_to_embed(self, documents: List[Document]) -> List[str]: + """ + Prepare the texts to embed by concatenating the Document text with the metadata fields to embed. + """ + texts_to_embed = [] + for doc in documents: + meta_values_to_embed = [ + str(doc.meta[key]) for key in self.meta_fields_to_embed if key in doc.meta and doc.meta[key] is not None + ] + + text_to_embed = ( + self.prefix + self.embedding_separator.join(meta_values_to_embed + [doc.content or ""]) + self.suffix + ).replace("\n", " ") + + texts_to_embed.append(text_to_embed) + return texts_to_embed + + def _embed_batch(self, texts_to_embed: List[str], batch_size: int) -> Tuple[List[List[float]], Dict[str, Any]]: + """ + Embed a list of texts in batches. + """ + + all_embeddings: List[List[float]] = [] + meta: Dict[str, Any] = {"model": "", "usage": {"prompt_tokens": 0, "total_tokens": 0}} + for i in tqdm(range(0, len(texts_to_embed), batch_size), desc="Embedding Texts"): + batch = texts_to_embed[i : i + batch_size] + response = self._client.embeddings.create(model=self.azure_deployment, input=batch) + + # Append embeddings to the list + all_embeddings.extend(el.embedding for el in response.data) + + # Update the meta information only once if it's empty + if not meta["model"]: + meta["model"] = response.model + meta["usage"] = dict(response.usage) + else: + # Update the usage tokens + meta["usage"]["prompt_tokens"] += response.usage.prompt_tokens + meta["usage"]["total_tokens"] += response.usage.total_tokens + + return all_embeddings, meta + + @component.output_types(documents=List[Document], meta=Dict[str, Any]) + def run(self, documents: List[Document]): + """ + Embed a list of Documents. The embedding of each Document is stored in the `embedding` field of the Document. + + :param documents: A list of Documents to embed. + """ + if not (isinstance(documents, list) and all(isinstance(doc, Document) for doc in documents)): + raise TypeError("Input must be a list of Document instances. For strings, use AzureOpenAITextEmbedder.") + + texts_to_embed = self._prepare_texts_to_embed(documents=documents) + embeddings, meta = self._embed_batch(texts_to_embed=texts_to_embed, batch_size=self.batch_size) + + # Assign the corresponding embeddings to each document + for doc, emb in zip(documents, embeddings): + doc.embedding = emb + + return {"documents": documents, "meta": meta} diff --git a/haystack/components/embedders/azure_text_embedder.py b/haystack/components/embedders/azure_text_embedder.py new file mode 100644 index 0000000000..58ca3ba851 --- /dev/null +++ b/haystack/components/embedders/azure_text_embedder.py @@ -0,0 +1,123 @@ +import os +from typing import List, Optional, Dict, Any + +from openai.lib.azure import AzureADTokenProvider, AzureOpenAI + +from haystack import component, default_to_dict, Document + + +@component +class AzureOpenAITextEmbedder: + """ + A component for embedding strings using OpenAI models. + + Usage example: + ```python + from haystack.components.embedders import AzureOpenAITextEmbedder + + text_to_embed = "I love pizza!" + + text_embedder = AzureOpenAITextEmbedder() + + print(text_embedder.run(text_to_embed)) + + # {'embedding': [0.017020374536514282, -0.023255806416273117, ...], + # 'meta': {'model': 'text-embedding-ada-002-v2', + # 'usage': {'prompt_tokens': 4, 'total_tokens': 4}}} + ``` + """ + + def __init__( + self, + azure_endpoint: Optional[str] = None, + api_version: Optional[str] = "2023-05-15", + azure_deployment: str = "text-embedding-ada-002", + api_key: Optional[str] = None, + azure_ad_token: Optional[str] = None, + azure_ad_token_provider: Optional[AzureADTokenProvider] = None, + organization: Optional[str] = None, + prefix: str = "", + suffix: str = "", + ): + """ + Create an AzureOpenAITextEmbedder component. + + :param azure_endpoint: The endpoint of the deployed model, e.g. `https://example-resource.azure.openai.com/` + :param api_version: The version of the API to use. Defaults to 2023-05-15 + :param azure_deployment: The deployment of the model, usually the model name. + :param api_key: The API key to use for authentication. + :param azure_ad_token: Azure Active Directory token, see https://www.microsoft.com/en-us/security/business/identity-access/microsoft-entra-id + :param azure_ad_token_provider: A function that returns an Azure Active Directory token, will be invoked + on every request. + :param organization: The Organization ID, defaults to `None`. See + [production best practices](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization). + :param prefix: A string to add to the beginning of each text. + :param suffix: A string to add to the end of each text. + """ + # Why is this here? + # AzureOpenAI init is forcing us to use an init method that takes either base_url or azure_endpoint as not + # None init parameters. This way we accommodate the use case where env var AZURE_OPENAI_ENDPOINT is set instead + # of passing it as a parameter. + azure_endpoint = azure_endpoint or os.environ.get("AZURE_OPENAI_ENDPOINT") + if not azure_endpoint: + raise ValueError("Please provide an Azure endpoint or set the environment variable AZURE_OPENAI_ENDPOINT.") + + self.api_version = api_version + self.azure_endpoint = azure_endpoint + self.azure_deployment = azure_deployment + self.organization = organization + self.prefix = prefix + self.suffix = suffix + + self._client = AzureOpenAI( + api_version=api_version, + azure_endpoint=azure_endpoint, + azure_deployment=azure_deployment, + api_key=api_key, + azure_ad_token=azure_ad_token, + azure_ad_token_provider=azure_ad_token_provider, + organization=organization, + ) + + def _get_telemetry_data(self) -> Dict[str, Any]: + """ + Data that is sent to Posthog for usage analytics. + """ + return {"model": self.azure_deployment} + + def to_dict(self) -> Dict[str, Any]: + """ + Serialize this component to a dictionary. + :return: The serialized component as a dictionary. + """ + return default_to_dict( + self, + azure_endpoint=self.azure_endpoint, + azure_deployment=self.azure_deployment, + organization=self.organization, + api_version=self.api_version, + prefix=self.prefix, + suffix=self.suffix, + ) + + @component.output_types(embedding=List[float], meta=Dict[str, Any]) + def run(self, text: str): + """Embed a string using AzureOpenAITextEmbedder.""" + if not isinstance(text, str): + # Check if input is a list and all elements are instances of Document + if isinstance(text, list) and all(isinstance(elem, Document) for elem in text): + error_message = "Input must be a string. Use AzureOpenAIDocumentEmbedder for a list of Documents." + else: + error_message = "Input must be a string." + raise TypeError(error_message) + + # Preprocess the text by adding prefixes/suffixes + # finally, replace newlines as recommended by OpenAI docs + processed_text = f"{self.prefix}{text}{self.suffix}".replace("\n", " ") + + response = self._client.embeddings.create(model=self.azure_deployment, input=processed_text) + + return { + "embedding": response.data[0].embedding, + "meta": {"model": response.model, "usage": dict(response.usage)}, + } diff --git a/releasenotes/notes/add-azure-embedders-fd5f4fbcab0e1c48.yaml b/releasenotes/notes/add-azure-embedders-fd5f4fbcab0e1c48.yaml new file mode 100644 index 0000000000..d66d3207d2 --- /dev/null +++ b/releasenotes/notes/add-azure-embedders-fd5f4fbcab0e1c48.yaml @@ -0,0 +1,5 @@ +--- +features: + - \| + Adds AzureOpenAIDocumentEmbedder and AzureOpenAITextEmbedder as new embedders. These embedders are very similar to + their OpenAI counterparts, but they use the Azure API instead of the OpenAI API.	diff --git a/test/components/embedders/test_azure_document_embedder.py b/test/components/embedders/test_azure_document_embedder.py new file mode 100644 index 0000000000..b5625e71dd --- /dev/null +++ b/test/components/embedders/test_azure_document_embedder.py @@ -0,0 +1,76 @@ +import os + +import pytest + +from haystack import Document +from haystack.components.embedders import AzureOpenAIDocumentEmbedder + + +class TestAzureOpenAIDocumentEmbedder: + def test_init_default(self, monkeypatch): + monkeypatch.setenv("AZURE_OPENAI_API_KEY", "fake-api-key") + embedder = AzureOpenAIDocumentEmbedder(azure_endpoint="https://example-resource.azure.openai.com/") + assert embedder.azure_deployment == "text-embedding-ada-002" + assert embedder.organization is None + assert embedder.prefix == "" + assert embedder.suffix == "" + assert embedder.batch_size == 32 + assert embedder.progress_bar is True + assert embedder.meta_fields_to_embed == [] + assert embedder.embedding_separator == "\n" + + def test_to_dict(self): + component = AzureOpenAIDocumentEmbedder( + api_key="fake-api-key", azure_endpoint="https://example-resource.azure.openai.com/" + ) + data = component.to_dict() + assert data == { + "type": "haystack.components.embedders.azure_document_embedder.AzureOpenAIDocumentEmbedder", + "init_parameters": { + "api_version": "2023-05-15", + "azure_deployment": "text-embedding-ada-002", + "azure_endpoint": "https://example-resource.azure.openai.com/", + "organization": None, + "prefix": "", + "suffix": "", + "batch_size": 32, + "progress_bar": True, + "meta_fields_to_embed": [], + "embedding_separator": "\n", + }, + } + + @pytest.mark.integration + @pytest.mark.skipif( + not os.environ.get("AZURE_OPENAI_API_KEY", None) and not os.environ.get("AZURE_OPENAI_ENDPOINT", None), + reason=( + "Please export env variables called AZURE_OPENAI_API_KEY containing " + "the Azure OpenAI key, AZURE_OPENAI_ENDPOINT containing " + "the Azure OpenAI endpoint URL to run this test." + ), + ) + def test_run(self): + docs = [ + Document(content="I love cheese", meta={"topic": "Cuisine"}), + Document(content="A transformer is a deep learning architecture", meta={"topic": "ML"}), + ] + # the default model is text-embedding-ada-002 even if we don't specify it, but let's be explicit + embedder = AzureOpenAIDocumentEmbedder( + azure_deployment="text-embedding-ada-002", + meta_fields_to_embed=["topic"], + embedding_separator=" \| ", + organization="HaystackCI", + ) + + result = embedder.run(documents=docs) + documents_with_embeddings = result["documents"] + metadata = result["meta"] + + assert isinstance(documents_with_embeddings, list) + assert len(documents_with_embeddings) == len(docs) + for doc in documents_with_embeddings: + assert isinstance(doc, Document) + assert isinstance(doc.embedding, list) + assert len(doc.embedding) == 1536 + assert all(isinstance(x, float) for x in doc.embedding) + assert metadata == {"model": "ada", "usage": {"prompt_tokens": 15, "total_tokens": 15}} diff --git a/test/components/embedders/test_azure_text_embedder.py b/test/components/embedders/test_azure_text_embedder.py new file mode 100644 index 0000000000..8afcd5d3d6 --- /dev/null +++ b/test/components/embedders/test_azure_text_embedder.py @@ -0,0 +1,54 @@ +import os + +import pytest + +from haystack.components.embedders import AzureOpenAITextEmbedder + + +class TestAzureOpenAITextEmbedder: + def test_init_default(self, monkeypatch): + monkeypatch.setenv("AZURE_OPENAI_API_KEY", "fake-api-key") + embedder = AzureOpenAITextEmbedder(azure_endpoint="https://example-resource.azure.openai.com/") + + assert embedder._client.api_key == "fake-api-key" + assert embedder.azure_deployment == "text-embedding-ada-002" + assert embedder.organization is None + assert embedder.prefix == "" + assert embedder.suffix == "" + + def test_to_dict(self): + component = AzureOpenAITextEmbedder( + api_key="fake-api-key", azure_endpoint="https://example-resource.azure.openai.com/" + ) + data = component.to_dict() + assert data == { + "type": "haystack.components.embedders.azure_text_embedder.AzureOpenAITextEmbedder", + "init_parameters": { + "azure_deployment": "text-embedding-ada-002", + "organization": None, + "azure_endpoint": "https://example-resource.azure.openai.com/", + "api_version": "2023-05-15", + "prefix": "", + "suffix": "", + }, + } + + @pytest.mark.integration + @pytest.mark.skipif( + not os.environ.get("AZURE_OPENAI_API_KEY", None) and not os.environ.get("AZURE_OPENAI_ENDPOINT", None), + reason=( + "Please export env variables called AZURE_OPENAI_API_KEY containing " + "the Azure OpenAI key, AZURE_OPENAI_ENDPOINT containing " + "the Azure OpenAI endpoint URL to run this test." + ), + ) + def test_run(self): + # the default model is text-embedding-ada-002 even if we don't specify it, but let's be explicit + embedder = AzureOpenAITextEmbedder( + azure_deployment="text-embedding-ada-002", prefix="prefix ", suffix=" suffix", organization="HaystackCI" + ) + result = embedder.run(text="The food was delicious") + + assert len(result["embedding"]) == 1536 + assert all(isinstance(x, float) for x in result["embedding"]) + assert result["meta"] == {"model": "ada", "usage": {"prompt_tokens": 6, "total_tokens": 6}}	diff --git a/releasenotes/notes/add-azure-embedders-fd5f4fbcab0e1c48.yaml b/releasenotes/notes/add-azure-embedders-fd5f4fbcab0e1c48.yaml new file mode 100644 index 0000000000..d66d3207d2 --- /dev/null +++ b/releasenotes/notes/add-azure-embedders-fd5f4fbcab0e1c48.yaml @@ -0,0 +1,5 @@ +--- +features: + - \| + Adds AzureOpenAIDocumentEmbedder and AzureOpenAITextEmbedder as new embedders. These embedders are very similar to + their OpenAI counterparts, but they use the Azure API instead of the OpenAI API.	[ { "components": [ { "doc": "A component for computing Document embeddings using OpenAI models.\nThe embedding of each Document is stored in the `embedding` field of the Document.\n\nUsage example:\n```python\nfrom haystack import Document\nfrom haystack.components.embedders import AzureOpenAIDocum...	[ "test/components/embedders/test_azure_document_embedder.py::TestAzureOpenAIDocumentEmbedder::test_init_default", "test/components/embedders/test_azure_document_embedder.py::TestAzureOpenAIDocumentEmbedder::test_to_dict", "test/components/embedders/test_azure_text_embedder.py::TestAzureOpenAITextEmbedder::test_i...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat: Add Azure embedders support ### Why: Add new embedding components that leverage Azure's cognitive services for text and document embedding. These new components are intended to provide users with more embedding options and utilize Azure's models. ### What: The main changes introduced in the `azure_embedders` branch include: 1. Addition of Azure Embedders: The `AzureOpenAITextEmbedder` and `AzureOpenAIDocumentEmbedder` classes have been added. These are similar to their OpenAI counterparts but use Azure API for embedding texts and documents. 2. Modifications in `__init__.py`: The `__init__.py` file within the embedders directory has been modified to include the newly added Azure embedder classes. 3. Unit Tests: New unit tests have been added for both the `AzureOpenAITextEmbedder` and `AzureOpenAIDocumentEmbedder` to ensure they work as expected and handle various inputs correctly. 4. Release Notes: A release note has been added to document the inclusion of new Azure embedders. ### How can it be used: The new Azure embedders can be used in the Haystack framework for tasks that involve text and document embedding. Users can utilize these embedders to convert texts or documents into vectors using Azure's cognitive services. This can be particularly useful for tasks involving semantic search, text clustering, or any application that requires understanding the semantic content of texts. ### How did you test it: 1. Unit Tests: New tests were added to verify the functionality of the Azure embedders. These tests check if the embedders correctly initialize with default and custom parameters and if they return expected embeddings for given texts and documents. 2. Integration Testing: The embedders were tested in an integrated environment to ensure they interact correctly with the Azure API and the rest of the haystack components. This includes testing with actual text inputs and verifying the embeddings' quality and format. ### Notes for the reviewer: - Review the implementation of the Azure embedders to ensure they align with the project's standards and efficiently utilize Azure's cognitive services. - Consider the unit tests' coverage and whether any additional scenarios need to be tested. - As the embedders rely on external services (Azure), consider the latency, cost, and availability implications when using these components in production environments. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in haystack/components/embedders/azure_document_embedder.py] (definition of AzureOpenAIDocumentEmbedder:) class AzureOpenAIDocumentEmbedder: """A component for computing Document embeddings using OpenAI models. The embedding of each Document is stored in the `embedding` field of the Document. Usage example: ```python from haystack import Document from haystack.components.embedders import AzureOpenAIDocumentEmbedder doc = Document(content="I love pizza!") document_embedder = AzureOpenAIDocumentEmbedder() result = document_embedder.run([doc]) print(result['documents'][0].embedding) # [0.017020374536514282, -0.023255806416273117, ...] ```""" (definition of AzureOpenAIDocumentEmbedder.__init__:) def __init__( self, azure_endpoint: Optional[str] = None, api_version: Optional[str] = "2023-05-15", azure_deployment: str = "text-embedding-ada-002", api_key: Optional[str] = None, azure_ad_token: Optional[str] = None, azure_ad_token_provider: Optional[AzureADTokenProvider] = None, organization: Optional[str] = None, prefix: str = "", suffix: str = "", batch_size: int = 32, progress_bar: bool = True, meta_fields_to_embed: Optional[List[str]] = None, embedding_separator: str = "\n", ): """Create an AzureOpenAITextEmbedder component. :param azure_endpoint: The endpoint of the deployed model, e.g. `https://example-resource.azure.openai.com/` :param api_version: The version of the API to use. Defaults to 2023-05-15 :param azure_deployment: The deployment of the model, usually the model name. :param api_key: The API key to use for authentication. :param azure_ad_token: Azure Active Directory token, see https://www.microsoft.com/en-us/security/business/identity-access/microsoft-entra-id :param azure_ad_token_provider: A function that returns an Azure Active Directory token, will be invoked on every request. :param organization: The Organization ID, defaults to `None`. See [production best practices](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization). :param prefix: A string to add to the beginning of each text. :param suffix: A string to add to the end of each text. :param batch_size: Number of Documents to encode at once. :param progress_bar: Whether to show a progress bar or not. Can be helpful to disable in production deployments to keep the logs clean. :param meta_fields_to_embed: List of meta fields that should be embedded along with the Document text. :param embedding_separator: Separator used to concatenate the meta fields to the Document text.""" (definition of AzureOpenAIDocumentEmbedder._get_telemetry_data:) def _get_telemetry_data(self) -> Dict[str, Any]: """Data that is sent to Posthog for usage analytics.""" (definition of AzureOpenAIDocumentEmbedder.to_dict:) def to_dict(self) -> Dict[str, Any]: """This method overrides the default serializer in order to avoid leaking the `api_key` value passed to the constructor.""" (definition of AzureOpenAIDocumentEmbedder._prepare_texts_to_embed:) def _prepare_texts_to_embed(self, documents: List[Document]) -> List[str]: """Prepare the texts to embed by concatenating the Document text with the metadata fields to embed.""" (definition of AzureOpenAIDocumentEmbedder._embed_batch:) def _embed_batch(self, texts_to_embed: List[str], batch_size: int) -> Tuple[List[List[float]], Dict[str, Any]]: """Embed a list of texts in batches.""" (definition of AzureOpenAIDocumentEmbedder.run:) def run(self, documents: List[Document]): """Embed a list of Documents. The embedding of each Document is stored in the `embedding` field of the Document. :param documents: A list of Documents to embed.""" [end of new definitions in haystack/components/embedders/azure_document_embedder.py] [start of new definitions in haystack/components/embedders/azure_text_embedder.py] (definition of AzureOpenAITextEmbedder:) class AzureOpenAITextEmbedder: """A component for embedding strings using OpenAI models. Usage example: ```python from haystack.components.embedders import AzureOpenAITextEmbedder text_to_embed = "I love pizza!" text_embedder = AzureOpenAITextEmbedder() print(text_embedder.run(text_to_embed)) # {'embedding': [0.017020374536514282, -0.023255806416273117, ...], # 'meta': {'model': 'text-embedding-ada-002-v2', # 'usage': {'prompt_tokens': 4, 'total_tokens': 4}}} ```""" (definition of AzureOpenAITextEmbedder.__init__:) def __init__( self, azure_endpoint: Optional[str] = None, api_version: Optional[str] = "2023-05-15", azure_deployment: str = "text-embedding-ada-002", api_key: Optional[str] = None, azure_ad_token: Optional[str] = None, azure_ad_token_provider: Optional[AzureADTokenProvider] = None, organization: Optional[str] = None, prefix: str = "", suffix: str = "", ): """Create an AzureOpenAITextEmbedder component. :param azure_endpoint: The endpoint of the deployed model, e.g. `https://example-resource.azure.openai.com/` :param api_version: The version of the API to use. Defaults to 2023-05-15 :param azure_deployment: The deployment of the model, usually the model name. :param api_key: The API key to use for authentication. :param azure_ad_token: Azure Active Directory token, see https://www.microsoft.com/en-us/security/business/identity-access/microsoft-entra-id :param azure_ad_token_provider: A function that returns an Azure Active Directory token, will be invoked on every request. :param organization: The Organization ID, defaults to `None`. See [production best practices](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization). :param prefix: A string to add to the beginning of each text. :param suffix: A string to add to the end of each text.""" (definition of AzureOpenAITextEmbedder._get_telemetry_data:) def _get_telemetry_data(self) -> Dict[str, Any]: """Data that is sent to Posthog for usage analytics.""" (definition of AzureOpenAITextEmbedder.to_dict:) def to_dict(self) -> Dict[str, Any]: """Serialize this component to a dictionary. :return: The serialized component as a dictionary.""" (definition of AzureOpenAITextEmbedder.run:) def run(self, text: str): """Embed a string using AzureOpenAITextEmbedder.""" [end of new definitions in haystack/components/embedders/azure_text_embedder.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		f4d9c2bb917be0ffe132dffcc2ad4f1b0fcc5967
joke2k__faker-1968	1,968	joke2k/faker	null	b2df6408867310874d85bcad47348eb1fc802f0d	2023-12-28T18:51:45Z	diff --git a/faker/providers/bank/cs_CZ/__init__.py b/faker/providers/bank/cs_CZ/__init__.py new file mode 100644 index 0000000000..7ea79ab21e --- /dev/null +++ b/faker/providers/bank/cs_CZ/__init__.py @@ -0,0 +1,11 @@ +from .. import Provider as BankProvider + + +class Provider(BankProvider): + """Implement bank provider for ``cs_CZ`` locale. + + https://www.mbank.cz/informace-k-produktum/info/ucty/cislo-uctu-iban.html + """ + + bban_format = "####################" + country_code = "CZ"	diff --git a/tests/providers/test_bank.py b/tests/providers/test_bank.py index cf065af3ce..d373a4ced7 100644 --- a/tests/providers/test_bank.py +++ b/tests/providers/test_bank.py @@ -4,6 +4,7 @@ from faker.providers.bank import Provider as BankProvider from faker.providers.bank.az_AZ import Provider as AzAzBankProvider +from faker.providers.bank.cs_CZ import Provider as CsCZBankProvider from faker.providers.bank.de_CH import Provider as DeChBankProvider from faker.providers.bank.el_GR import Provider as ElGrBankProvider from faker.providers.bank.en_GB import Provider as EnGbBankProvider @@ -56,6 +57,21 @@ def test_bank(self, faker, num_samples): bank = faker.bank() assert bank in AzAzBankProvider.banks +class TestCsCz: + """Test cs_CZ bank provider""" + + def test_bban(self, faker, num_samples): + for _ in range(num_samples): + assert re.fullmatch(r"\d{20}", faker.bban()) + + def test_iban(self, faker, num_samples): + for _ in range(num_samples): + iban = faker.iban() + assert is_valid_iban(iban) + assert iban[:2] == CsCZBankProvider.country_code + assert re.fullmatch(r"\d{2}\d{20}", iban[2:]) + + class TestNoNo: """Test no_NO bank provider"""		[ { "components": [ { "doc": "Implement bank provider for ``cs_CZ`` locale.\n\nhttps://www.mbank.cz/informace-k-produktum/info/ucty/cislo-uctu-iban.html", "lines": [ 4, 11 ], "name": "Provider", "signature": "class Provider(BankProvider):", ...	[ "tests/providers/test_bank.py::TestAzAz::test_bban", "tests/providers/test_bank.py::TestAzAz::test_iban", "tests/providers/test_bank.py::TestAzAz::test_bank", "tests/providers/test_bank.py::TestCsCz::test_bban", "tests/providers/test_bank.py::TestCsCz::test_iban", "tests/providers/test_bank.py::TestNoNo::...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add bank provider for cs_CZ ### What does this change Add bank provider for cs_CZ ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in faker/providers/bank/cs_CZ/__init__.py] (definition of Provider:) class Provider(BankProvider): """Implement bank provider for ``cs_CZ`` locale. https://www.mbank.cz/informace-k-produktum/info/ucty/cislo-uctu-iban.html""" [end of new definitions in faker/providers/bank/cs_CZ/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		6edfdbf6ae90b0153309e3bf066aa3b2d16494a7
pypa__hatch-1178	1,178	pypa/hatch	null	a4ceb972aaba40d624b18363b95bafa339294ee8	2023-12-26T17:52:54Z	diff --git a/docs/history/hatch.md b/docs/history/hatch.md index 25a1f0a3a..5a8a9dd17 100644 --- a/docs/history/hatch.md +++ b/docs/history/hatch.md @@ -8,6 +8,21 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), ## Unreleased +*Added:* + +- Add the following methods to the `environment` interface for complete control over output during life cycle management: + - app_status_creation + - app_status_pre_installation + - app_status_post_installation + - app_status_project_installation + - app_status_dependency_state_check + - app_status_dependency_installation_check + - app_status_dependency_synchronization + +*Fixed:* + +- When projects derive dependencies from metadata hooks, there is now by default a status indicator for when the hooks are executed for better responsiveness + ## [1.9.1](https://github.com/pypa/hatch/releases/tag/hatch-v1.9.1) - 2023-12-25 ## {: #hatch-v1.9.1 } *Fixed:* diff --git a/docs/plugins/environment/reference.md b/docs/plugins/environment/reference.md index 374f02492..c310a2b89 100644 --- a/docs/plugins/environment/reference.md +++ b/docs/plugins/environment/reference.md @@ -42,6 +42,26 @@ All environment types should [offer support](#hatch.env.plugin.interface.Environ options: members: - PLUGIN_NAME + - find + - create + - remove + - exists + - install_project + - install_project_dev_mode + - dependencies_in_sync + - sync_dependencies + - dependency_hash + - build_environment + - build_environment_exists + - activate + - deactivate + - app_status_creation + - app_status_pre_installation + - app_status_post_installation + - app_status_project_installation + - app_status_dependency_state_check + - app_status_dependency_installation_check + - app_status_dependency_synchronization - app - root - name @@ -58,19 +78,6 @@ All environment types should [offer support](#hatch.env.plugin.interface.Environ - skip_install - dev_mode - description - - activate - - deactivate - - find - - create - - remove - - exists - - install_project - - install_project_dev_mode - - dependencies_in_sync - - sync_dependencies - - dependency_hash - - build_environment - - build_environment_exists - run_builder - construct_build_command - command_context diff --git a/src/hatch/cli/application.py b/src/hatch/cli/application.py index 198df6f0c..ec22f2566 100644 --- a/src/hatch/cli/application.py +++ b/src/hatch/cli/application.py @@ -85,33 +85,34 @@ def prepare_environment(self, environment: EnvironmentInterface): if not environment.exists(): self.env_metadata.reset(environment) - with self.status(f'Creating environment: {environment.name}'): + with environment.app_status_creation(): environment.create() if not environment.skip_install: if environment.pre_install_commands: - with self.status('Running pre-installation commands'): + with environment.app_status_pre_installation(): self.run_shell_commands(environment, environment.pre_install_commands, source='pre-install') - if environment.dev_mode: - with self.status('Installing project in development mode'): + with environment.app_status_project_installation(): + if environment.dev_mode: environment.install_project_dev_mode() - else: - with self.status('Installing project'): + else: environment.install_project() if environment.post_install_commands: - with self.status('Running post-installation commands'): + with environment.app_status_post_installation(): self.run_shell_commands(environment, environment.post_install_commands, source='post-install') - new_dep_hash = environment.dependency_hash() + with environment.app_status_dependency_state_check(): + new_dep_hash = environment.dependency_hash() + current_dep_hash = self.env_metadata.dependency_hash(environment) if new_dep_hash != current_dep_hash: - with self.status('Checking dependencies'): + with environment.app_status_dependency_installation_check(): dependencies_in_sync = environment.dependencies_in_sync() if not dependencies_in_sync: - with self.status('Syncing dependencies'): + with environment.app_status_dependency_synchronization(): environment.sync_dependencies() new_dep_hash = environment.dependency_hash() diff --git a/src/hatch/env/plugin/interface.py b/src/hatch/env/plugin/interface.py index 849dbbc94..1be90afed 100644 --- a/src/hatch/env/plugin/interface.py +++ b/src/hatch/env/plugin/interface.py @@ -659,6 +659,71 @@ def dependency_hash(self): return hash_dependencies(self.dependencies_complex) + @contextmanager + def app_status_creation(self): + """ + See the [life cycle of environments](reference.md#life-cycle). + """ + with self.app.status(f'Creating environment: {self.name}'): + yield + + @contextmanager + def app_status_pre_installation(self): + """ + See the [life cycle of environments](reference.md#life-cycle). + """ + with self.app.status('Running pre-installation commands'): + yield + + @contextmanager + def app_status_post_installation(self): + """ + See the [life cycle of environments](reference.md#life-cycle). + """ + with self.app.status('Running post-installation commands'): + yield + + @contextmanager + def app_status_project_installation(self): + """ + See the [life cycle of environments](reference.md#life-cycle). + """ + if self.dev_mode: + with self.app.status('Installing project in development mode'): + yield + else: + with self.app.status('Installing project'): + yield + + @contextmanager + def app_status_dependency_state_check(self): + """ + See the [life cycle of environments](reference.md#life-cycle). + """ + if not self.skip_install and ( + 'dependencies' in self.metadata.dynamic or 'optional-dependencies' in self.metadata.dynamic + ): + with self.app.status('Polling dependency state'): + yield + else: + yield + + @contextmanager + def app_status_dependency_installation_check(self): + """ + See the [life cycle of environments](reference.md#life-cycle). + """ + with self.app.status('Checking dependencies'): + yield + + @contextmanager + def app_status_dependency_synchronization(self): + """ + See the [life cycle of environments](reference.md#life-cycle). + """ + with self.app.status('Syncing dependencies'): + yield + @contextmanager def build_environment( self,	diff --git a/tests/cli/env/test_create.py b/tests/cli/env/test_create.py index 358cdbfa5..fed313a3f 100644 --- a/tests/cli/env/test_create.py +++ b/tests/cli/env/test_create.py @@ -1359,6 +1359,7 @@ def update(self, metadata): Creating environment: test Installing project in development mode Running post-installation commands + Polling dependency state Checking dependencies Syncing dependencies """	diff --git a/docs/history/hatch.md b/docs/history/hatch.md index 25a1f0a3a..5a8a9dd17 100644 --- a/docs/history/hatch.md +++ b/docs/history/hatch.md @@ -8,6 +8,21 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), ## Unreleased +*Added:* + +- Add the following methods to the `environment` interface for complete control over output during life cycle management: + - app_status_creation + - app_status_pre_installation + - app_status_post_installation + - app_status_project_installation + - app_status_dependency_state_check + - app_status_dependency_installation_check + - app_status_dependency_synchronization + +*Fixed:* + +- When projects derive dependencies from metadata hooks, there is now by default a status indicator for when the hooks are executed for better responsiveness + ## [1.9.1](https://github.com/pypa/hatch/releases/tag/hatch-v1.9.1) - 2023-12-25 ## {: #hatch-v1.9.1 } *Fixed:* diff --git a/docs/plugins/environment/reference.md b/docs/plugins/environment/reference.md index 374f02492..c310a2b89 100644 --- a/docs/plugins/environment/reference.md +++ b/docs/plugins/environment/reference.md @@ -42,6 +42,26 @@ All environment types should [offer support](#hatch.env.plugin.interface.Environ options: members: - PLUGIN_NAME + - find + - create + - remove + - exists + - install_project + - install_project_dev_mode + - dependencies_in_sync + - sync_dependencies + - dependency_hash + - build_environment + - build_environment_exists + - activate + - deactivate + - app_status_creation + - app_status_pre_installation + - app_status_post_installation + - app_status_project_installation + - app_status_dependency_state_check + - app_status_dependency_installation_check + - app_status_dependency_synchronization - app - root - name @@ -58,19 +78,6 @@ All environment types should [offer support](#hatch.env.plugin.interface.Environ - skip_install - dev_mode - description - - activate - - deactivate - - find - - create - - remove - - exists - - install_project - - install_project_dev_mode - - dependencies_in_sync - - sync_dependencies - - dependency_hash - - build_environment - - build_environment_exists - run_builder - construct_build_command - command_context	[ { "components": [ { "doc": "See the [life cycle of environments](reference.md#life-cycle).", "lines": [ 663, 668 ], "name": "EnvironmentInterface.app_status_creation", "signature": "def app_status_creation(self):", "type": "function" ...	[ "tests/cli/env/test_create.py::test_sync_dynamic_dependencies" ]	[ "tests/cli/env/test_create.py::test_undefined", "tests/cli/env/test_create.py::test_unknown_type", "tests/cli/env/test_create.py::test_new", "tests/cli/env/test_create.py::test_selected_absolute_directory", "tests/cli/env/test_create.py::test_option_absolute_directory", "tests/cli/env/test_create.py::test...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add life cycle messaging methods to the `environment` interface @juftin Curious your thoughts on this ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/hatch/env/plugin/interface.py] (definition of EnvironmentInterface.app_status_creation:) def app_status_creation(self): """See the [life cycle of environments](reference.md#life-cycle).""" (definition of EnvironmentInterface.app_status_pre_installation:) def app_status_pre_installation(self): """See the [life cycle of environments](reference.md#life-cycle).""" (definition of EnvironmentInterface.app_status_post_installation:) def app_status_post_installation(self): """See the [life cycle of environments](reference.md#life-cycle).""" (definition of EnvironmentInterface.app_status_project_installation:) def app_status_project_installation(self): """See the [life cycle of environments](reference.md#life-cycle).""" (definition of EnvironmentInterface.app_status_dependency_state_check:) def app_status_dependency_state_check(self): """See the [life cycle of environments](reference.md#life-cycle).""" (definition of EnvironmentInterface.app_status_dependency_installation_check:) def app_status_dependency_installation_check(self): """See the [life cycle of environments](reference.md#life-cycle).""" (definition of EnvironmentInterface.app_status_dependency_synchronization:) def app_status_dependency_synchronization(self): """See the [life cycle of environments](reference.md#life-cycle).""" [end of new definitions in src/hatch/env/plugin/interface.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c06c820d722667306f39bda956c58cf4c48d0728
deepset-ai__haystack-6648	6,648	deepset-ai/haystack	null	9c08f3d9c7f0888d29deec98373d536b8f61e4b8	2023-12-26T15:48:58Z	diff --git a/haystack/components/generators/__init__.py b/haystack/components/generators/__init__.py index a9251b9336..73818abfbb 100644 --- a/haystack/components/generators/__init__.py +++ b/haystack/components/generators/__init__.py @@ -1,5 +1,12 @@ from haystack.components.generators.hugging_face_local import HuggingFaceLocalGenerator from haystack.components.generators.hugging_face_tgi import HuggingFaceTGIGenerator from haystack.components.generators.openai import OpenAIGenerator, GPTGenerator +from haystack.components.generators.azure import AzureOpenAIGenerator -__all__ = ["HuggingFaceLocalGenerator", "HuggingFaceTGIGenerator", "OpenAIGenerator", "GPTGenerator"] +__all__ = [ + "HuggingFaceLocalGenerator", + "HuggingFaceTGIGenerator", + "OpenAIGenerator", + "GPTGenerator", + "AzureOpenAIGenerator", +] diff --git a/haystack/components/generators/azure.py b/haystack/components/generators/azure.py new file mode 100644 index 0000000000..fd38b5b140 --- /dev/null +++ b/haystack/components/generators/azure.py @@ -0,0 +1,158 @@ +import logging +import os +from typing import Optional, Callable, Dict, Any + +# pylint: disable=import-error +from openai.lib.azure import AzureADTokenProvider, AzureOpenAI + +from haystack import default_to_dict, default_from_dict +from haystack.components.generators import OpenAIGenerator +from haystack.components.generators.utils import serialize_callback_handler, deserialize_callback_handler +from haystack.dataclasses import StreamingChunk + +logger = logging.getLogger(__name__) + + +class AzureOpenAIGenerator(OpenAIGenerator): + """ + Enables text generation using OpenAI's large language models (LLMs) on Azure. It supports gpt-4 and gpt-3.5-turbo + family of models. + + Users can pass any text generation parameters valid for the `openai.ChatCompletion.create` method + directly to this component via the `generation_kwargs` parameter in __init__ or the `generation_kwargs` + parameter in `run` method. + + For more details on OpenAI models deployed on Azure, refer to the Microsoft + [documentation](https://learn.microsoft.com/en-us/azure/ai-services/openai/). + + + ```python + from haystack.components.generators import AzureOpenAIGenerator + client = AzureOpenAIGenerator(azure_endpoint="<Your Azure endpoint e.g. `https://your-company.azure.openai.com/>", + api_key="<you api key>", + azure_deployment="<this a model name, e.g. gpt-35-turbo>") + response = client.run("What's Natural Language Processing? Be brief.") + print(response) + + >> {'replies': ['Natural Language Processing (NLP) is a branch of artificial intelligence that focuses on + >> the interaction between computers and human language. It involves enabling computers to understand, interpret, + >> and respond to natural human language in a way that is both meaningful and useful.'], 'meta': [{'model': + >> 'gpt-3.5-turbo-0613', 'index': 0, 'finish_reason': 'stop', 'usage': {'prompt_tokens': 16, + >> 'completion_tokens': 49, 'total_tokens': 65}}]} + ``` + + Key Features and Compatibility: + - Primary Compatibility: Designed to work seamlessly with gpt-4, gpt-3.5-turbo family of models. + - Streaming Support: Supports streaming responses from the OpenAI API. + - Customizability: Supports all parameters supported by the OpenAI API. + + Input and Output Format: + - String Format: This component uses the strings for both input and output. + """ + + # pylint: disable=super-init-not-called + def __init__( + self, + azure_endpoint: Optional[str] = None, + api_version: Optional[str] = "2023-05-15", + azure_deployment: Optional[str] = "gpt-35-turbo", + api_key: Optional[str] = None, + azure_ad_token: Optional[str] = None, + azure_ad_token_provider: Optional[AzureADTokenProvider] = None, + organization: Optional[str] = None, + streaming_callback: Optional[Callable[[StreamingChunk], None]] = None, + system_prompt: Optional[str] = None, + generation_kwargs: Optional[Dict[str, Any]] = None, + ): + """ + :param azure_endpoint: The endpoint of the deployed model, e.g. `https://example-resource.azure.openai.com/` + :param api_version: The version of the API to use. Defaults to 2023-05-15 + :param azure_deployment: The deployment of the model, usually the model name. + :param api_key: The API key to use for authentication. + :param azure_ad_token: Azure Active Directory token, see https://www.microsoft.com/en-us/security/business/identity-access/microsoft-entra-id + :param azure_ad_token_provider: A function that returns an Azure Active Directory token, will be invoked + on every request. + :param organization: The Organization ID, defaults to `None`. See + [production best practices](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization). + :param streaming_callback: A callback function that is called when a new token is received from the stream. + The callback function accepts StreamingChunk as an argument. + :param system_prompt: The prompt to use for the system. If not provided, the system prompt will be + :param generation_kwargs: Other parameters to use for the model. These parameters are all sent directly to + the OpenAI endpoint. See OpenAI [documentation](https://platform.openai.com/docs/api-reference/chat) for + more details. + Some of the supported parameters: + - `max_tokens`: The maximum number of tokens the output text can have. + - `temperature`: What sampling temperature to use. Higher values mean the model will take more risks. + Try 0.9 for more creative applications and 0 (argmax sampling) for ones with a well-defined answer. + - `top_p`: An alternative to sampling with temperature, called nucleus sampling, where the model + considers the results of the tokens with top_p probability mass. So 0.1 means only the tokens + comprising the top 10% probability mass are considered. + - `n`: How many completions to generate for each prompt. For example, if the LLM gets 3 prompts and n is 2, + it will generate two completions for each of the three prompts, ending up with 6 completions in total. + - `stop`: One or more sequences after which the LLM should stop generating tokens. + - `presence_penalty`: What penalty to apply if a token is already present at all. Bigger values mean + the model will be less likely to repeat the same token in the text. + - `frequency_penalty`: What penalty to apply if a token has already been generated in the text. + Bigger values mean the model will be less likely to repeat the same token in the text. + - `logit_bias`: Add a logit bias to specific tokens. The keys of the dictionary are tokens, and the + values are the bias to add to that token. + """ + # We intentionally do not call super().__init__ here because we only need to instantiate the client to interact + # with the API. + + # Why is this here? + # AzureOpenAI init is forcing us to use an init method that takes either base_url or azure_endpoint as not + # None init parameters. This way we accommodate the use case where env var AZURE_OPENAI_ENDPOINT is set instead + # of passing it as a parameter. + azure_endpoint = azure_endpoint or os.environ.get("AZURE_OPENAI_ENDPOINT") + if not azure_endpoint: + raise ValueError("Please provide an Azure endpoint or set the environment variable AZURE_OPENAI_ENDPOINT.") + + self.generation_kwargs = generation_kwargs or {} + self.system_prompt = system_prompt + self.streaming_callback = streaming_callback + self.api_version = api_version + self.azure_endpoint = azure_endpoint + self.azure_deployment = azure_deployment + self.organization = organization + self.model_name: str = azure_deployment or "gpt-35-turbo" + + self.client = AzureOpenAI( + api_version=api_version, + azure_endpoint=azure_endpoint, + azure_deployment=azure_deployment, + api_key=api_key, + azure_ad_token=azure_ad_token, + azure_ad_token_provider=azure_ad_token_provider, + organization=organization, + ) + + def to_dict(self) -> Dict[str, Any]: + """ + Serialize this component to a dictionary. + :return: The serialized component as a dictionary. + """ + callback_name = serialize_callback_handler(self.streaming_callback) if self.streaming_callback else None + return default_to_dict( + self, + azure_endpoint=self.azure_endpoint, + azure_deployment=self.azure_deployment, + organization=self.organization, + api_version=self.api_version, + streaming_callback=callback_name, + generation_kwargs=self.generation_kwargs, + system_prompt=self.system_prompt, + ) + + @classmethod + def from_dict(cls, data: Dict[str, Any]) -> "AzureOpenAIGenerator": + """ + Deserialize this component from a dictionary. + :param data: The dictionary representation of this component. + :return: The deserialized component instance. + """ + init_params = data.get("init_parameters", {}) + serialized_callback_handler = init_params.get("streaming_callback") + if serialized_callback_handler: + data["init_parameters"]["streaming_callback"] = deserialize_callback_handler(serialized_callback_handler) + return default_from_dict(cls, data) diff --git a/haystack/components/generators/chat/__init__.py b/haystack/components/generators/chat/__init__.py index 3227e50bfa..028389a568 100644 --- a/haystack/components/generators/chat/__init__.py +++ b/haystack/components/generators/chat/__init__.py @@ -1,4 +1,5 @@ from haystack.components.generators.chat.hugging_face_tgi import HuggingFaceTGIChatGenerator from haystack.components.generators.chat.openai import OpenAIChatGenerator, GPTChatGenerator +from haystack.components.generators.chat.azure import AzureOpenAIChatGenerator -__all__ = ["HuggingFaceTGIChatGenerator", "OpenAIChatGenerator", "GPTChatGenerator"] +__all__ = ["HuggingFaceTGIChatGenerator", "OpenAIChatGenerator", "GPTChatGenerator", "AzureOpenAIChatGenerator"] diff --git a/haystack/components/generators/chat/azure.py b/haystack/components/generators/chat/azure.py new file mode 100644 index 0000000000..7b1f4513f6 --- /dev/null +++ b/haystack/components/generators/chat/azure.py @@ -0,0 +1,161 @@ +import logging +import os +from typing import Optional, Callable, Dict, Any + +# pylint: disable=import-error +from openai.lib.azure import AzureADTokenProvider, AzureOpenAI + +from haystack import default_to_dict, default_from_dict +from haystack.components.generators.chat import OpenAIChatGenerator +from haystack.components.generators.utils import serialize_callback_handler, deserialize_callback_handler +from haystack.dataclasses import StreamingChunk + +logger = logging.getLogger(__name__) + + +class AzureOpenAIChatGenerator(OpenAIChatGenerator): + """ + Enables text generation using OpenAI's large language models (LLMs) on Azure. It supports gpt-4 and gpt-3.5-turbo + family of models accessed through the chat completions API endpoint. + + Users can pass any text generation parameters valid for the `openai.ChatCompletion.create` method + directly to this component via the `generation_kwargs` parameter in __init__ or the `generation_kwargs` + parameter in `run` method. + + For more details on OpenAI models deployed on Azure, refer to the Microsoft + [documentation](https://learn.microsoft.com/en-us/azure/ai-services/openai/). + + ```python + from haystack.components.generators.chat import AzureOpenAIGenerator + from haystack.dataclasses import ChatMessage + + messages = [ChatMessage.from_user("What's Natural Language Processing?")] + + client = AzureOpenAIGenerator(azure_endpoint="<Your Azure endpoint e.g. `https://your-company.azure.openai.com/>", + api_key="<you api key>", + azure_deployment="<this a model name, e.g. gpt-35-turbo>") + response = client.run(messages) + print(response) + + >>{'replies': [ChatMessage(content='Natural Language Processing (NLP) is a branch of artificial intelligence + >>that focuses on enabling computers to understand, interpret, and generate human language in a way that is + >>meaningful and useful.', role=<ChatRole.ASSISTANT: 'assistant'>, name=None, + >>meta={'model': 'gpt-3.5-turbo-0613', 'index': 0, 'finish_reason': 'stop', + >>'usage': {'prompt_tokens': 15, 'completion_tokens': 36, 'total_tokens': 51}})]} + + ``` + + Key Features and Compatibility: + - Primary Compatibility: Designed to work seamlessly with the OpenAI API Chat Completion endpoint + and gpt-4 and gpt-3.5-turbo family of models. + - Streaming Support: Supports streaming responses from the OpenAI API Chat Completion endpoint. + - Customizability: Supports all parameters supported by the OpenAI API Chat Completion endpoint. + + Input and Output Format: + - ChatMessage Format: This component uses the ChatMessage format for structuring both input and output, + ensuring coherent and contextually relevant responses in chat-based text generation scenarios. Details on the + ChatMessage format can be found at: https://github.com/openai/openai-python/blob/main/chatml.md. + """ + + # pylint: disable=super-init-not-called + def __init__( + self, + azure_endpoint: Optional[str] = None, + api_version: Optional[str] = "2023-05-15", + azure_deployment: Optional[str] = "gpt-35-turbo", + api_key: Optional[str] = None, + azure_ad_token: Optional[str] = None, + azure_ad_token_provider: Optional[AzureADTokenProvider] = None, + organization: Optional[str] = None, + streaming_callback: Optional[Callable[[StreamingChunk], None]] = None, + generation_kwargs: Optional[Dict[str, Any]] = None, + ): + """ + :param azure_endpoint: The endpoint of the deployed model, e.g. `https://example-resource.azure.openai.com/` + :param api_version: The version of the API to use. Defaults to 2023-05-15 + :param azure_deployment: The deployment of the model, usually the model name. + :param api_key: The API key to use for authentication. + :param azure_ad_token: Azure Active Directory token, see https://www.microsoft.com/en-us/security/business/identity-access/microsoft-entra-id + :param azure_ad_token_provider: A function that returns an Azure Active Directory token, will be invoked + on every request. + :param organization: The Organization ID, defaults to `None`. See + [production best practices](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization). + :param streaming_callback: A callback function that is called when a new token is received from the stream. + The callback function accepts StreamingChunk as an argument. + :param generation_kwargs: Other parameters to use for the model. These parameters are all sent directly to + the OpenAI endpoint. See OpenAI [documentation](https://platform.openai.com/docs/api-reference/chat) for + more details. + Some of the supported parameters: + - `max_tokens`: The maximum number of tokens the output text can have. + - `temperature`: What sampling temperature to use. Higher values mean the model will take more risks. + Try 0.9 for more creative applications and 0 (argmax sampling) for ones with a well-defined answer. + - `top_p`: An alternative to sampling with temperature, called nucleus sampling, where the model + considers the results of the tokens with top_p probability mass. So 0.1 means only the tokens + comprising the top 10% probability mass are considered. + - `n`: How many completions to generate for each prompt. For example, if the LLM gets 3 prompts and n is 2, + it will generate two completions for each of the three prompts, ending up with 6 completions in total. + - `stop`: One or more sequences after which the LLM should stop generating tokens. + - `presence_penalty`: What penalty to apply if a token is already present at all. Bigger values mean + the model will be less likely to repeat the same token in the text. + - `frequency_penalty`: What penalty to apply if a token has already been generated in the text. + Bigger values mean the model will be less likely to repeat the same token in the text. + - `logit_bias`: Add a logit bias to specific tokens. The keys of the dictionary are tokens, and the + values are the bias to add to that token. + """ + # We intentionally do not call super().__init__ here because we only need to instantiate the client to interact + # with the API. + + # Why is this here? + # AzureOpenAI init is forcing us to use an init method that takes either base_url or azure_endpoint as not + # None init parameters. This way we accommodate the use case where env var AZURE_OPENAI_ENDPOINT is set instead + # of passing it as a parameter. + azure_endpoint = azure_endpoint or os.environ.get("AZURE_OPENAI_ENDPOINT") + if not azure_endpoint: + raise ValueError("Please provide an Azure endpoint or set the environment variable AZURE_OPENAI_ENDPOINT.") + + self.generation_kwargs = generation_kwargs or {} + self.streaming_callback = streaming_callback + self.api_version = api_version + self.azure_endpoint = azure_endpoint + self.azure_deployment = azure_deployment + self.organization = organization + self.model_name = azure_deployment or "gpt-35-turbo" + + self.client = AzureOpenAI( + api_version=api_version, + azure_endpoint=azure_endpoint, + azure_deployment=azure_deployment, + api_key=api_key, + azure_ad_token=azure_ad_token, + azure_ad_token_provider=azure_ad_token_provider, + organization=organization, + ) + + def to_dict(self) -> Dict[str, Any]: + """ + Serialize this component to a dictionary. + :return: The serialized component as a dictionary. + """ + callback_name = serialize_callback_handler(self.streaming_callback) if self.streaming_callback else None + return default_to_dict( + self, + azure_endpoint=self.azure_endpoint, + azure_deployment=self.azure_deployment, + organization=self.organization, + api_version=self.api_version, + streaming_callback=callback_name, + generation_kwargs=self.generation_kwargs, + ) + + @classmethod + def from_dict(cls, data: Dict[str, Any]) -> "AzureOpenAIChatGenerator": + """ + Deserialize this component from a dictionary. + :param data: The dictionary representation of this component. + :return: The deserialized component instance. + """ + init_params = data.get("init_parameters", {}) + serialized_callback_handler = init_params.get("streaming_callback") + if serialized_callback_handler: + data["init_parameters"]["streaming_callback"] = deserialize_callback_handler(serialized_callback_handler) + return default_from_dict(cls, data) diff --git a/releasenotes/notes/add-azure-generators-a30c786204b22e48.yaml b/releasenotes/notes/add-azure-generators-a30c786204b22e48.yaml new file mode 100644 index 0000000000..2a3422cfeb --- /dev/null +++ b/releasenotes/notes/add-azure-generators-a30c786204b22e48.yaml @@ -0,0 +1,4 @@ +--- +features: + - \| + Adds support for Azure OpenAI models with AzureOpenAIGenerator and AzureOpenAIChatGenerator components.	diff --git a/test/components/generators/chat/test_azure.py b/test/components/generators/chat/test_azure.py new file mode 100644 index 0000000000..2a9f900f7d --- /dev/null +++ b/test/components/generators/chat/test_azure.py @@ -0,0 +1,89 @@ +import os + +import pytest +from openai import OpenAIError + +from haystack.components.generators.chat import AzureOpenAIChatGenerator +from haystack.components.generators.utils import default_streaming_callback +from haystack.dataclasses import ChatMessage + + +class TestOpenAIChatGenerator: + def test_init_default(self): + component = AzureOpenAIChatGenerator(azure_endpoint="some-non-existing-endpoint", api_key="test-api-key") + assert component.client.api_key == "test-api-key" + assert component.azure_deployment == "gpt-35-turbo" + assert component.streaming_callback is None + assert not component.generation_kwargs + + def test_init_fail_wo_api_key(self, monkeypatch): + monkeypatch.delenv("AZURE_OPENAI_API_KEY", raising=False) + with pytest.raises(OpenAIError): + AzureOpenAIChatGenerator(azure_endpoint="some-non-existing-endpoint") + + def test_init_with_parameters(self): + component = AzureOpenAIChatGenerator( + azure_endpoint="some-non-existing-endpoint", + api_key="test-api-key", + streaming_callback=default_streaming_callback, + generation_kwargs={"max_tokens": 10, "some_test_param": "test-params"}, + ) + assert component.client.api_key == "test-api-key" + assert component.azure_deployment == "gpt-35-turbo" + assert component.streaming_callback is default_streaming_callback + assert component.generation_kwargs == {"max_tokens": 10, "some_test_param": "test-params"} + + def test_to_dict_default(self): + component = AzureOpenAIChatGenerator(api_key="test-api-key", azure_endpoint="some-non-existing-endpoint") + data = component.to_dict() + assert data == { + "type": "haystack.components.generators.chat.azure.AzureOpenAIChatGenerator", + "init_parameters": { + "api_version": "2023-05-15", + "azure_endpoint": "some-non-existing-endpoint", + "azure_deployment": "gpt-35-turbo", + "organization": None, + "streaming_callback": None, + "generation_kwargs": {}, + }, + } + + def test_to_dict_with_parameters(self): + component = AzureOpenAIChatGenerator( + api_key="test-api-key", + azure_endpoint="some-non-existing-endpoint", + generation_kwargs={"max_tokens": 10, "some_test_param": "test-params"}, + ) + data = component.to_dict() + assert data == { + "type": "haystack.components.generators.chat.azure.AzureOpenAIChatGenerator", + "init_parameters": { + "api_version": "2023-05-15", + "azure_endpoint": "some-non-existing-endpoint", + "azure_deployment": "gpt-35-turbo", + "organization": None, + "streaming_callback": None, + "generation_kwargs": {"max_tokens": 10, "some_test_param": "test-params"}, + }, + } + + @pytest.mark.integration + @pytest.mark.skipif( + not os.environ.get("AZURE_OPENAI_API_KEY", None) and not os.environ.get("AZURE_OPENAI_ENDPOINT", None), + reason=( + "Please export env variables called AZURE_OPENAI_API_KEY containing " + "the Azure OpenAI key, AZURE_OPENAI_ENDPOINT containing " + "the Azure OpenAI endpoint URL to run this test." + ), + ) + def test_live_run(self): + chat_messages = [ChatMessage.from_user("What's the capital of France")] + component = AzureOpenAIChatGenerator(organization="HaystackCI") + results = component.run(chat_messages) + assert len(results["replies"]) == 1 + message: ChatMessage = results["replies"][0] + assert "Paris" in message.content + assert "gpt-35-turbo" in message.meta["model"] + assert message.meta["finish_reason"] == "stop" + + # additional tests intentionally omitted as they are covered by test_openai.py diff --git a/test/components/generators/test_azure.py b/test/components/generators/test_azure.py new file mode 100644 index 0000000000..816afb9a51 --- /dev/null +++ b/test/components/generators/test_azure.py @@ -0,0 +1,99 @@ +import os + +import pytest +from openai import OpenAIError + +from haystack.components.generators import AzureOpenAIGenerator +from haystack.components.generators.utils import default_streaming_callback + + +class TestAzureOpenAIGenerator: + def test_init_default(self): + component = AzureOpenAIGenerator(api_key="test-api-key", azure_endpoint="some-non-existing-endpoint") + assert component.client.api_key == "test-api-key" + assert component.azure_deployment == "gpt-35-turbo" + assert component.streaming_callback is None + assert not component.generation_kwargs + + def test_init_fail_wo_api_key(self, monkeypatch): + monkeypatch.delenv("AZURE_OPENAI_API_KEY", raising=False) + with pytest.raises(OpenAIError): + AzureOpenAIGenerator(azure_endpoint="some-non-existing-endpoint") + + def test_init_with_parameters(self): + component = AzureOpenAIGenerator( + api_key="test-api-key", + azure_endpoint="some-non-existing-endpoint", + azure_deployment="gpt-35-turbo", + streaming_callback=default_streaming_callback, + generation_kwargs={"max_tokens": 10, "some_test_param": "test-params"}, + ) + assert component.client.api_key == "test-api-key" + assert component.azure_deployment == "gpt-35-turbo" + assert component.streaming_callback is default_streaming_callback + assert component.generation_kwargs == {"max_tokens": 10, "some_test_param": "test-params"} + + def test_to_dict_default(self): + component = AzureOpenAIGenerator(api_key="test-api-key", azure_endpoint="some-non-existing-endpoint") + data = component.to_dict() + assert data == { + "type": "haystack.components.generators.azure.AzureOpenAIGenerator", + "init_parameters": { + "azure_deployment": "gpt-35-turbo", + "api_version": "2023-05-15", + "streaming_callback": None, + "azure_endpoint": "some-non-existing-endpoint", + "organization": None, + "system_prompt": None, + "generation_kwargs": {}, + }, + } + + def test_to_dict_with_parameters(self): + component = AzureOpenAIGenerator( + api_key="test-api-key", + azure_endpoint="some-non-existing-endpoint", + generation_kwargs={"max_tokens": 10, "some_test_param": "test-params"}, + ) + + data = component.to_dict() + assert data == { + "type": "haystack.components.generators.azure.AzureOpenAIGenerator", + "init_parameters": { + "azure_deployment": "gpt-35-turbo", + "api_version": "2023-05-15", + "streaming_callback": None, + "azure_endpoint": "some-non-existing-endpoint", + "organization": None, + "system_prompt": None, + "generation_kwargs": {"max_tokens": 10, "some_test_param": "test-params"}, + }, + } + + @pytest.mark.integration + @pytest.mark.skipif( + not os.environ.get("AZURE_OPENAI_API_KEY", None) and not os.environ.get("AZURE_OPENAI_ENDPOINT", None), + reason=( + "Please export env variables called AZURE_OPENAI_API_KEY containing " + "the Azure OpenAI key, AZURE_OPENAI_ENDPOINT containing " + "the Azure OpenAI endpoint URL to run this test." + ), + ) + def test_live_run(self): + component = AzureOpenAIGenerator(organization="HaystackCI") + results = component.run("What's the capital of France?") + assert len(results["replies"]) == 1 + assert len(results["meta"]) == 1 + response: str = results["replies"][0] + assert "Paris" in response + + metadata = results["meta"][0] + assert "gpt-35-turbo" in metadata["model"] + assert metadata["finish_reason"] == "stop" + + assert "usage" in metadata + assert "prompt_tokens" in metadata["usage"] and metadata["usage"]["prompt_tokens"] > 0 + assert "completion_tokens" in metadata["usage"] and metadata["usage"]["completion_tokens"] > 0 + assert "total_tokens" in metadata["usage"] and metadata["usage"]["total_tokens"] > 0 + + # additional tests intentionally omitted as they are covered by test_openai.py	diff --git a/releasenotes/notes/add-azure-generators-a30c786204b22e48.yaml b/releasenotes/notes/add-azure-generators-a30c786204b22e48.yaml new file mode 100644 index 0000000000..2a3422cfeb --- /dev/null +++ b/releasenotes/notes/add-azure-generators-a30c786204b22e48.yaml @@ -0,0 +1,4 @@ +--- +features: + - \| + Adds support for Azure OpenAI models with AzureOpenAIGenerator and AzureOpenAIChatGenerator components.	[ { "components": [ { "doc": "Enables text generation using OpenAI's large language models (LLMs) on Azure. It supports gpt-4 and gpt-3.5-turbo\nfamily of models.\n\nUsers can pass any text generation parameters valid for the `openai.ChatCompletion.create` method\ndirectly to this component via the ...	[ "test/components/generators/chat/test_azure.py::TestOpenAIChatGenerator::test_init_default", "test/components/generators/chat/test_azure.py::TestOpenAIChatGenerator::test_init_fail_wo_api_key", "test/components/generators/chat/test_azure.py::TestOpenAIChatGenerator::test_init_with_parameters", "test/component...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat: Add AzureOpenAIGenerator and AzureOpenAIChatGenerator ### Why: Add support for OpenAI LLMs like GPT-3.5 and GPT-4, which are available through Azure's services. ### What: Two main components have been added: 1. AzureGenerator: This class extends the capabilities of the `OpenAIGenerator` to use Azure's deployment of OpenAI's models. It involves numerous parameters and methods that facilitate text generation with customizable settings tailored to Azure's API structure and authentication mechanisms. 2. AzureChatGenerator: Similar to `AzureGenerator`, this class is tailored for chat-based applications, providing functionalities to utilize Azure's deployment of OpenAI models in chatbots or other conversational AI applications. Additionally, both components are registered in their respective `__init__.py` files. ### How can it be used: Developers and researchers can use these components to integrate Azure's powerful language models into their applications for a variety of tasks, including but not limited to: - Generating text based on prompts - Building conversational agents - Automating content creation These generators provide easy access to advanced NLP capabilities and can be customized with different parameters to suit specific needs, such as adjusting the model's creativity or response length. ### How did you test it: Manually. Unit tests were not added as we use the already tested OpenAIGenerator and OpenAIChatGenerator ### Notes for the reviewer: - Omission of super init call: Azure generators intentionally omit super init call to parent components. This is intentional, see if that is the best approach possible. - Understanding Azure: As these changes involve integration with Azure, understanding the Azure environment, its authentication mechanisms, and how it hosts OpenAI models is crucial. - Reviewing Dependencies: Changes include imports specific to Azure's SDK (`openai.lib.azure`) and other related utilities, which should be reviewed for compatibility and stability. - Considerations for Deployment: Ensure that the addition of these new components aligns with the overall architecture and does not introduce any issues or conflicts with existing functionalities. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in haystack/components/generators/azure.py] (definition of AzureOpenAIGenerator:) class AzureOpenAIGenerator(OpenAIGenerator): """Enables text generation using OpenAI's large language models (LLMs) on Azure. It supports gpt-4 and gpt-3.5-turbo family of models. Users can pass any text generation parameters valid for the `openai.ChatCompletion.create` method directly to this component via the `generation_kwargs` parameter in __init__ or the `generation_kwargs` parameter in `run` method. For more details on OpenAI models deployed on Azure, refer to the Microsoft [documentation](https://learn.microsoft.com/en-us/azure/ai-services/openai/). ```python from haystack.components.generators import AzureOpenAIGenerator client = AzureOpenAIGenerator(azure_endpoint="<Your Azure endpoint e.g. `https://your-company.azure.openai.com/>", api_key="<you api key>", azure_deployment="<this a model name, e.g. gpt-35-turbo>") response = client.run("What's Natural Language Processing? Be brief.") print(response) >> {'replies': ['Natural Language Processing (NLP) is a branch of artificial intelligence that focuses on >> the interaction between computers and human language. It involves enabling computers to understand, interpret, >> and respond to natural human language in a way that is both meaningful and useful.'], 'meta': [{'model': >> 'gpt-3.5-turbo-0613', 'index': 0, 'finish_reason': 'stop', 'usage': {'prompt_tokens': 16, >> 'completion_tokens': 49, 'total_tokens': 65}}]} ``` Key Features and Compatibility: - Primary Compatibility: Designed to work seamlessly with gpt-4, gpt-3.5-turbo family of models. - Streaming Support: Supports streaming responses from the OpenAI API. - Customizability: Supports all parameters supported by the OpenAI API. Input and Output Format: - String Format: This component uses the strings for both input and output.""" (definition of AzureOpenAIGenerator.__init__:) def __init__( self, azure_endpoint: Optional[str] = None, api_version: Optional[str] = "2023-05-15", azure_deployment: Optional[str] = "gpt-35-turbo", api_key: Optional[str] = None, azure_ad_token: Optional[str] = None, azure_ad_token_provider: Optional[AzureADTokenProvider] = None, organization: Optional[str] = None, streaming_callback: Optional[Callable[[StreamingChunk], None]] = None, system_prompt: Optional[str] = None, generation_kwargs: Optional[Dict[str, Any]] = None, ): """:param azure_endpoint: The endpoint of the deployed model, e.g. `https://example-resource.azure.openai.com/` :param api_version: The version of the API to use. Defaults to 2023-05-15 :param azure_deployment: The deployment of the model, usually the model name. :param api_key: The API key to use for authentication. :param azure_ad_token: Azure Active Directory token, see https://www.microsoft.com/en-us/security/business/identity-access/microsoft-entra-id :param azure_ad_token_provider: A function that returns an Azure Active Directory token, will be invoked on every request. :param organization: The Organization ID, defaults to `None`. See [production best practices](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization). :param streaming_callback: A callback function that is called when a new token is received from the stream. The callback function accepts StreamingChunk as an argument. :param system_prompt: The prompt to use for the system. If not provided, the system prompt will be :param generation_kwargs: Other parameters to use for the model. These parameters are all sent directly to the OpenAI endpoint. See OpenAI [documentation](https://platform.openai.com/docs/api-reference/chat) for more details. Some of the supported parameters: - `max_tokens`: The maximum number of tokens the output text can have. - `temperature`: What sampling temperature to use. Higher values mean the model will take more risks. Try 0.9 for more creative applications and 0 (argmax sampling) for ones with a well-defined answer. - `top_p`: An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass. So 0.1 means only the tokens comprising the top 10% probability mass are considered. - `n`: How many completions to generate for each prompt. For example, if the LLM gets 3 prompts and n is 2, it will generate two completions for each of the three prompts, ending up with 6 completions in total. - `stop`: One or more sequences after which the LLM should stop generating tokens. - `presence_penalty`: What penalty to apply if a token is already present at all. Bigger values mean the model will be less likely to repeat the same token in the text. - `frequency_penalty`: What penalty to apply if a token has already been generated in the text. Bigger values mean the model will be less likely to repeat the same token in the text. - `logit_bias`: Add a logit bias to specific tokens. The keys of the dictionary are tokens, and the values are the bias to add to that token.""" (definition of AzureOpenAIGenerator.to_dict:) def to_dict(self) -> Dict[str, Any]: """Serialize this component to a dictionary. :return: The serialized component as a dictionary.""" (definition of AzureOpenAIGenerator.from_dict:) def from_dict(cls, data: Dict[str, Any]) -> "AzureOpenAIGenerator": """Deserialize this component from a dictionary. :param data: The dictionary representation of this component. :return: The deserialized component instance.""" [end of new definitions in haystack/components/generators/azure.py] [start of new definitions in haystack/components/generators/chat/azure.py] (definition of AzureOpenAIChatGenerator:) class AzureOpenAIChatGenerator(OpenAIChatGenerator): """Enables text generation using OpenAI's large language models (LLMs) on Azure. It supports gpt-4 and gpt-3.5-turbo family of models accessed through the chat completions API endpoint. Users can pass any text generation parameters valid for the `openai.ChatCompletion.create` method directly to this component via the `generation_kwargs` parameter in __init__ or the `generation_kwargs` parameter in `run` method. For more details on OpenAI models deployed on Azure, refer to the Microsoft [documentation](https://learn.microsoft.com/en-us/azure/ai-services/openai/). ```python from haystack.components.generators.chat import AzureOpenAIGenerator from haystack.dataclasses import ChatMessage messages = [ChatMessage.from_user("What's Natural Language Processing?")] client = AzureOpenAIGenerator(azure_endpoint="<Your Azure endpoint e.g. `https://your-company.azure.openai.com/>", api_key="<you api key>", azure_deployment="<this a model name, e.g. gpt-35-turbo>") response = client.run(messages) print(response) >>{'replies': [ChatMessage(content='Natural Language Processing (NLP) is a branch of artificial intelligence >>that focuses on enabling computers to understand, interpret, and generate human language in a way that is >>meaningful and useful.', role=<ChatRole.ASSISTANT: 'assistant'>, name=None, >>meta={'model': 'gpt-3.5-turbo-0613', 'index': 0, 'finish_reason': 'stop', >>'usage': {'prompt_tokens': 15, 'completion_tokens': 36, 'total_tokens': 51}})]} ``` Key Features and Compatibility: - Primary Compatibility: Designed to work seamlessly with the OpenAI API Chat Completion endpoint and gpt-4 and gpt-3.5-turbo family of models. - Streaming Support: Supports streaming responses from the OpenAI API Chat Completion endpoint. - Customizability: Supports all parameters supported by the OpenAI API Chat Completion endpoint. Input and Output Format: - ChatMessage Format: This component uses the ChatMessage format for structuring both input and output, ensuring coherent and contextually relevant responses in chat-based text generation scenarios. Details on the ChatMessage format can be found at: https://github.com/openai/openai-python/blob/main/chatml.md.""" (definition of AzureOpenAIChatGenerator.__init__:) def __init__( self, azure_endpoint: Optional[str] = None, api_version: Optional[str] = "2023-05-15", azure_deployment: Optional[str] = "gpt-35-turbo", api_key: Optional[str] = None, azure_ad_token: Optional[str] = None, azure_ad_token_provider: Optional[AzureADTokenProvider] = None, organization: Optional[str] = None, streaming_callback: Optional[Callable[[StreamingChunk], None]] = None, generation_kwargs: Optional[Dict[str, Any]] = None, ): """:param azure_endpoint: The endpoint of the deployed model, e.g. `https://example-resource.azure.openai.com/` :param api_version: The version of the API to use. Defaults to 2023-05-15 :param azure_deployment: The deployment of the model, usually the model name. :param api_key: The API key to use for authentication. :param azure_ad_token: Azure Active Directory token, see https://www.microsoft.com/en-us/security/business/identity-access/microsoft-entra-id :param azure_ad_token_provider: A function that returns an Azure Active Directory token, will be invoked on every request. :param organization: The Organization ID, defaults to `None`. See [production best practices](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization). :param streaming_callback: A callback function that is called when a new token is received from the stream. The callback function accepts StreamingChunk as an argument. :param generation_kwargs: Other parameters to use for the model. These parameters are all sent directly to the OpenAI endpoint. See OpenAI [documentation](https://platform.openai.com/docs/api-reference/chat) for more details. Some of the supported parameters: - `max_tokens`: The maximum number of tokens the output text can have. - `temperature`: What sampling temperature to use. Higher values mean the model will take more risks. Try 0.9 for more creative applications and 0 (argmax sampling) for ones with a well-defined answer. - `top_p`: An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass. So 0.1 means only the tokens comprising the top 10% probability mass are considered. - `n`: How many completions to generate for each prompt. For example, if the LLM gets 3 prompts and n is 2, it will generate two completions for each of the three prompts, ending up with 6 completions in total. - `stop`: One or more sequences after which the LLM should stop generating tokens. - `presence_penalty`: What penalty to apply if a token is already present at all. Bigger values mean the model will be less likely to repeat the same token in the text. - `frequency_penalty`: What penalty to apply if a token has already been generated in the text. Bigger values mean the model will be less likely to repeat the same token in the text. - `logit_bias`: Add a logit bias to specific tokens. The keys of the dictionary are tokens, and the values are the bias to add to that token.""" (definition of AzureOpenAIChatGenerator.to_dict:) def to_dict(self) -> Dict[str, Any]: """Serialize this component to a dictionary. :return: The serialized component as a dictionary.""" (definition of AzureOpenAIChatGenerator.from_dict:) def from_dict(cls, data: Dict[str, Any]) -> "AzureOpenAIChatGenerator": """Deserialize this component from a dictionary. :param data: The dictionary representation of this component. :return: The deserialized component instance.""" [end of new definitions in haystack/components/generators/chat/azure.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		f4d9c2bb917be0ffe132dffcc2ad4f1b0fcc5967
pvlib__pvlib-python-1940	1,940	pvlib/pvlib-python	0.9	6bb149fa8c933ea32a060198864a12887dc5c538	2023-12-22T21:20:00Z	diff --git a/docs/sphinx/source/reference/pv_modeling/system_models.rst b/docs/sphinx/source/reference/pv_modeling/system_models.rst index c2c55d2580..55e01f437e 100644 --- a/docs/sphinx/source/reference/pv_modeling/system_models.rst +++ b/docs/sphinx/source/reference/pv_modeling/system_models.rst @@ -47,3 +47,11 @@ ADR model pvarray.pvefficiency_adr pvarray.fit_pvefficiency_adr + +PVGIS model +^^^^^^^^^^^ + +.. autosummary:: + :toctree: ../generated/ + + pvarray.huld diff --git a/docs/sphinx/source/whatsnew/v0.10.4.rst b/docs/sphinx/source/whatsnew/v0.10.4.rst index df73d68e98..adb9c3e251 100644 --- a/docs/sphinx/source/whatsnew/v0.10.4.rst +++ b/docs/sphinx/source/whatsnew/v0.10.4.rst @@ -7,6 +7,7 @@ v0.10.4 (Anticipated March, 2024) Enhancements ~~~~~~~~~~~~ +* Added the Huld PV model used by PVGIS (:pull:`1940`) Bug fixes @@ -28,4 +29,5 @@ Requirements Contributors ~~~~~~~~~~~~ +* Cliff Hansen (:ghuser:`cwhanse`) * :ghuser:`matsuobasho` diff --git a/pvlib/pvarray.py b/pvlib/pvarray.py index e8968886e1..a8bbd36eb3 100644 --- a/pvlib/pvarray.py +++ b/pvlib/pvarray.py @@ -223,3 +223,128 @@ def adr_wrapper(xdata, params): return dict(zip(P_NAMES, popt)) else: return popt + + +def _infer_k_huld(cell_type, pdc0): + # from PVGIS documentation, "PVGIS data sources & calculation methods", + # Section 5.2.3, accessed 12/22/2023 + # The parameters in PVGIS' documentation are for a version of Huld's + # equation that has factored Pdc0 out of the polynomial: + # P = G/1000 Pdc0 * (1 + k1 log(Geff) + ...) so these parameters are + # multiplied by pdc0 + huld_params = {'csi': (-0.017237, -0.040465, -0.004702, 0.000149, + 0.000170, 0.000005), + 'cis': (-0.005554, -0.038724, -0.003723, -0.000905, + -0.001256, 0.000001), + 'cdte': (-0.046689, -0.072844, -0.002262, 0.000276, + 0.000159, -0.000006)} + k = tuple([xpdc0 for x in huld_params[cell_type.lower()]]) + return k + + +def huld(effective_irradiance, temp_mod, pdc0, k=None, cell_type=None): + r""" + Power (DC) using the Huld model. + + The Huld model [1]_ is used by PVGIS and is given by + + + .. math:: + + P_{dc} &= G' ( P_{dc0} + k_1 \log(G') + k_2 \log^2 (G') + k_3 T' + + k_4 T' \log(G') + k_5 T' \log^2 (G') + k_6 T'^2) + + G' &= \frac{G_{poa eff}}{1000} + + T' &= T_{mod} - 25^{\circ}C + + + Parameters + ---------- + effective_irradiance : numeric + The irradiance that is converted to photocurrent. [:math:`W/m^2`] + temp_mod: numeric + Module back-surface temperature. [C] + pdc0: numeric + Power of the modules at reference conditions 1000 :math:`W/m^2` + and :math:`25^{\circ}C`. [W] + k : tuple, optional + Empirical coefficients used in the power model. Length 6. If ``k`` is + not provided, ``cell_type`` must be specified. + cell_type : str, optional + If provided, must be one of ``'cSi'``, ``'CIS'``, or ``'CdTe'``. + Used to look up default values for ``k`` if ``k`` is not specified. + + Returns + ------- + pdc: numeric + DC power. [W] + + Raises + ------ + ValueError + If neither ``k`` nor ``cell_type`` are specified. + + Notes + ----- + The equation for :math:`P_{dc}` is from [1]_. The expression used in PVGIS + documentation differs by factoring :math:`P_{dc0}` out of the + polynomial: + + .. math:: + + P_{dc} = G' P_{dc0} (1 + k'_1 \log(G') + k'_2 \log^2 (G') + k'_3 T' + + k'_4 T' \log(G') + k'_5 T' \log^2 (G') + k'_6 T'^2) + + + PVGIS documentation shows a table of default parameters :math:`k'` for + different cell types. The parameters :math:`k'` differ from the parameters + :math:`k` for :py:func:`huld` by the factor ``pdc0``, that is, + + .. math:: + + k = P_{dc0} k' + + With default values for :math:`k`, at very low irradiance, i.e., + :math:`G' < 20 W/m^2`, :math:`P_{dc}` may be negative + due to the terms involving :math:`\log(G')`. + + :py:func:`huld` is a component of the PV performance model implemented in + PVGIS. Among other components, the full PVGIS model includes: + - the Faiman model for module temperature + :py:func:`pvlib.temperature.faiman` + - the Martin and Ruiz model for the incidence angle modifier (IAM) + :py:func:`pvlib.iam.martin_ruiz` + - a custom model for a spectral adjustment factor + The PVGIS API (see :py:func:`pvlib.iotools.get_pvgis_hourly`) returns + broadband plane-of-array irradiance (``poa_global``) and DC power (``P``). + ``poa_global`` is irradiance before applying the IAM and spectral + adjustments. In contrast the ``effective_irradiance`` for :py:func:`huld` + should have the IAM and spectral adjustments. Users comparing output of + :py:func:`huld` to PVGIS' ``P`` values should expect differences unless + ``effective_irradiance`` is computed in the same way as done by PVGIS. + + References + ---------- + .. [1] T. Huld, G. Friesen, A. Skoczek, R. Kenny, T. Sample, M. Field, + E. Dunlop. A power-rating model for crystalline silicon PV modules. + Solar Energy Materials and Solar Cells 95, (2011), pp. 3359-3369. + :doi:`10.1016/j.solmat.2011.07.026`. + """ + if k is None: + if cell_type is not None: + k = _infer_k_huld(cell_type, pdc0) + else: + raise ValueError('Either k or cell_type must be specified') + + gprime = effective_irradiance / 1000 + tprime = temp_mod - 25 + # accomodate gprime<=0 + with np.errstate(divide='ignore'): + logGprime = np.log(gprime, out=np.zeros_like(gprime), + where=np.array(gprime > 0)) + # Eq. 1 in [1] + pdc = gprime (pdc0 + k[0] * logGprime + k[1] * logGprime*2 + + k[2] tprime + k[3] * tprime * logGprime + + k[4] * tprime * logGprime*2 + k[5] tprime**2) + return pdc	diff --git a/pvlib/tests/test_pvarray.py b/pvlib/tests/test_pvarray.py index 6dcacdefe1..693ef78b2a 100644 --- a/pvlib/tests/test_pvarray.py +++ b/pvlib/tests/test_pvarray.py @@ -1,5 +1,8 @@ import numpy as np +import pandas as pd from numpy.testing import assert_allclose +from .conftest import assert_series_equal +import pytest from pvlib import pvarray @@ -44,3 +47,25 @@ def test_pvefficiency_adr_round_trip(): params = pvarray.fit_pvefficiency_adr(g, t, eta, dict_output=False) result = pvarray.pvefficiency_adr(g, t, params) assert_allclose(result, eta, atol=1e-6) + + +def test_huld(): + pdc0 = 100 + res = pvarray.huld(1000, 25, pdc0, cell_type='cSi') + assert np.isclose(res, pdc0) + exp_sum = np.exp(1) (np.sum(pvarray._infer_k_huld('cSi', pdc0)) + pdc0) + res = pvarray.huld(1000np.exp(1), 26, pdc0, cell_type='cSi') + assert np.isclose(res, exp_sum) + res = pvarray.huld(100, 30, pdc0, k=(1, 1, 1, 1, 1, 1)) + exp_100 = 0.1 (pdc0 + np.log(0.1) + np.log(0.1)*2 + 5 + 5np.log(0.1) + + 5np.log(0.1)*2 + 25) + assert np.isclose(res, exp_100) + # Series input, and irradiance = 0 + eff_irr = pd.Series([1000, 100, 0]) + tm = pd.Series([25, 30, 30]) + expected = pd.Series([pdc0, exp_100, 0]) + res = pvarray.huld(eff_irr, tm, pdc0, k=(1, 1, 1, 1, 1, 1)) + assert_series_equal(res, expected) + with pytest.raises(ValueError, + match='Either k or cell_type must be specified'): + res = pvarray.huld(1000, 25, 100) diff --git a/pvlib/tests/test_pvsystem.py b/pvlib/tests/test_pvsystem.py index 6557d77e10..ebc59a838a 100644 --- a/pvlib/tests/test_pvsystem.py +++ b/pvlib/tests/test_pvsystem.py @@ -12,7 +12,6 @@ import unittest.mock as mock from pvlib import inverter, pvsystem -from pvlib import atmosphere from pvlib import iam as _iam from pvlib import irradiance from pvlib import spectrum	diff --git a/docs/sphinx/source/reference/pv_modeling/system_models.rst b/docs/sphinx/source/reference/pv_modeling/system_models.rst index c2c55d2580..55e01f437e 100644 --- a/docs/sphinx/source/reference/pv_modeling/system_models.rst +++ b/docs/sphinx/source/reference/pv_modeling/system_models.rst @@ -47,3 +47,11 @@ ADR model pvarray.pvefficiency_adr pvarray.fit_pvefficiency_adr + +PVGIS model +^^^^^^^^^^^ + +.. autosummary:: + :toctree: ../generated/ + + pvarray.huld diff --git a/docs/sphinx/source/whatsnew/v0.10.4.rst b/docs/sphinx/source/whatsnew/v0.10.4.rst index df73d68e98..adb9c3e251 100644 --- a/docs/sphinx/source/whatsnew/v0.10.4.rst +++ b/docs/sphinx/source/whatsnew/v0.10.4.rst @@ -7,6 +7,7 @@ v0.10.4 (Anticipated March, 2024) Enhancements ~~~~~~~~~~~~ +* Added the Huld PV model used by PVGIS (:pull:`1940`) Bug fixes @@ -28,4 +29,5 @@ Requirements Contributors ~~~~~~~~~~~~ +* Cliff Hansen (:ghuser:`cwhanse`) * :ghuser:`matsuobasho`	[ { "components": [ { "doc": "", "lines": [ 228, 242 ], "name": "_infer_k_huld", "signature": "def _infer_k_huld(cell_type, pdc0):", "type": "function" }, { "doc": "Power (DC) using the Huld model.\n\nThe Huld model [1]_...	[ "pvlib/tests/test_pvarray.py::test_huld" ]	[ "pvlib/tests/test_pvarray.py::test_pvefficiency_adr", "pvlib/tests/test_pvarray.py::test_fit_pvefficiency_adr", "pvlib/tests/test_pvarray.py::test_pvefficiency_adr_round_trip", "pvlib/tests/test_pvsystem.py::test_PVSystem_get_iam[ashrae-model_params0]", "pvlib/tests/test_pvsystem.py::test_PVSystem_get_iam[p...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add Huld PV model ~~- [ ] Closes #xxxx~~ - [x] I am familiar with the [contributing guidelines](https://pvlib-python.readthedocs.io/en/latest/contributing.html) - [x] Tests added - [x] Updates entries in [`docs/sphinx/source/reference`](https://github.com/pvlib/pvlib-python/blob/main/docs/sphinx/source/reference) for API changes. - [x] Adds description and name entries in the appropriate "what's new" file in [`docs/sphinx/source/whatsnew`](https://github.com/pvlib/pvlib-python/tree/main/docs/sphinx/source/whatsnew) for all changes. Includes link to the GitHub Issue with `` :issue:`num` `` or this Pull Request with `` :pull:`num` ``. Includes contributor name and/or GitHub username (link with `` :ghuser:`user` ``). - [x] New code is fully documented. Includes [numpydoc](https://numpydoc.readthedocs.io/en/latest/format.html) compliant docstrings, examples, and comments where necessary. - [x] Pull request is nearly complete and ready for detailed review. - [x] Maintainer: Appropriate GitHub Labels (including `remote-data`) and Milestone are assigned to the Pull Request and linked Issue. Adds Huld's model for DC power. This model is used in PVGIS. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pvlib/pvarray.py] (definition of _infer_k_huld:) def _infer_k_huld(cell_type, pdc0): (definition of huld:) def huld(effective_irradiance, temp_mod, pdc0, k=None, cell_type=None): """Power (DC) using the Huld model. The Huld model [1]_ is used by PVGIS and is given by .. math:: P_{dc} &= G' ( P_{dc0} + k_1 \log(G') + k_2 \log^2 (G') + k_3 T' + k_4 T' \log(G') + k_5 T' \log^2 (G') + k_6 T'^2) G' &= \frac{G_{poa eff}}{1000} T' &= T_{mod} - 25^{\circ}C Parameters ---------- effective_irradiance : numeric The irradiance that is converted to photocurrent. [:math:`W/m^2`] temp_mod: numeric Module back-surface temperature. [C] pdc0: numeric Power of the modules at reference conditions 1000 :math:`W/m^2` and :math:`25^{\circ}C`. [W] k : tuple, optional Empirical coefficients used in the power model. Length 6. If ``k`` is not provided, ``cell_type`` must be specified. cell_type : str, optional If provided, must be one of ``'cSi'``, ``'CIS'``, or ``'CdTe'``. Used to look up default values for ``k`` if ``k`` is not specified. Returns ------- pdc: numeric DC power. [W] Raises ------ ValueError If neither ``k`` nor ``cell_type`` are specified. Notes ----- The equation for :math:`P_{dc}` is from [1]_. The expression used in PVGIS documentation differs by factoring :math:`P_{dc0}` out of the polynomial: .. math:: P_{dc} = G' P_{dc0} (1 + k'_1 \log(G') + k'_2 \log^2 (G') + k'_3 T' + k'_4 T' \log(G') + k'_5 T' \log^2 (G') + k'_6 T'^2) PVGIS documentation shows a table of default parameters :math:`k'` for different cell types. The parameters :math:`k'` differ from the parameters :math:`k` for :py:func:`huld` by the factor ``pdc0``, that is, .. math:: k = P_{dc0} k' With default values for :math:`k`, at very low irradiance, i.e., :math:`G' < 20 W/m^2`, :math:`P_{dc}` may be negative due to the terms involving :math:`\log(G')`. :py:func:`huld` is a component of the PV performance model implemented in PVGIS. Among other components, the full PVGIS model includes: - the Faiman model for module temperature :py:func:`pvlib.temperature.faiman` - the Martin and Ruiz model for the incidence angle modifier (IAM) :py:func:`pvlib.iam.martin_ruiz` - a custom model for a spectral adjustment factor The PVGIS API (see :py:func:`pvlib.iotools.get_pvgis_hourly`) returns broadband plane-of-array irradiance (``poa_global``) and DC power (``P``). ``poa_global`` is irradiance before applying the IAM and spectral adjustments. In contrast the ``effective_irradiance`` for :py:func:`huld` should have the IAM and spectral adjustments. Users comparing output of :py:func:`huld` to PVGIS' ``P`` values should expect differences unless ``effective_irradiance`` is computed in the same way as done by PVGIS. References ---------- .. [1] T. Huld, G. Friesen, A. Skoczek, R. Kenny, T. Sample, M. Field, E. Dunlop. A power-rating model for crystalline silicon PV modules. Solar Energy Materials and Solar Cells 95, (2011), pp. 3359-3369. :doi:`10.1016/j.solmat.2011.07.026`.""" [end of new definitions in pvlib/pvarray.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		d53f97e984bfdd268aa92f8bf482ced0edda0110
deepset-ai__haystack-6592	6,592	deepset-ai/haystack	null	f877704839dc585cf47305d97fd5011be367b907	2023-12-19T13:28:08Z	diff --git a/haystack/components/others/__init__.py b/haystack/components/others/__init__.py new file mode 100644 index 0000000000..cac8782cd1 --- /dev/null +++ b/haystack/components/others/__init__.py @@ -0,0 +1,3 @@ +from haystack.components.others.multiplexer import Multiplexer + +__all__ = ["Multiplexer"] diff --git a/haystack/components/others/multiplexer.py b/haystack/components/others/multiplexer.py new file mode 100644 index 0000000000..8c69172185 --- /dev/null +++ b/haystack/components/others/multiplexer.py @@ -0,0 +1,69 @@ +import sys +import logging +from typing import Any, Dict + +from haystack.core.component.types import Variadic +from haystack import component, default_to_dict, default_from_dict +from haystack.components.routers.conditional_router import serialize_type, deserialize_type + +if sys.version_info < (3, 10): + from typing_extensions import TypeAlias +else: + from typing import TypeAlias + + +logger = logging.getLogger(__name__) + + +@component +class Multiplexer: + """ + This component is used to distribute a single value to many components that may need it. + It can take such value from different sources (the user's input, or another component), so + it's only input is of Variadic type. + + The type of the expected input (and therefore of the output as well) must be given at init time. + + Example usage: + + ```python + >>> mp = Multiplexer(str) + >>> mp.run(value=["hello"]) + {"value" : "hello"} + + >>> mp = Multiplexer(int) + >>> mp.run(value=[3]) + {"value": 3} + ``` + + This component won't handle several inputs at the same time: it always only expects one. + If more than one input is received when run is invoked, it will raise a ValueError. + + ```python + >>> mp = Multiplexer(int) + >>> mp.run([2, 4]) + ValueError: Multiplexer expects only one input, but 2 were received. + + >>> mp = Multiplexer(int) + >>> mp.run([2, None]) + ValueError: Multiplexer expects only one input, but 2 were received. + ``` + """ + + def __init__(self, type_: TypeAlias): + self.type_ = type_ + component.set_input_types(self, value=Variadic[type_]) + component.set_output_types(self, value=type_) + + def to_dict(self): + return default_to_dict(self, type_=serialize_type(self.type_)) + + @classmethod + def from_dict(cls, data: Dict[str, Any]) -> "Multiplexer": + data["init_parameters"]["type_"] = deserialize_type(data["init_parameters"]["type_"]) + return default_from_dict(cls, data) + + def run(self, **kwargs): + if (inputs_count := len(kwargs["value"])) != 1: + raise ValueError(f"Multiplexer expects only one input, but {inputs_count} were received.") + return {"value": kwargs["value"][0]} diff --git a/releasenotes/notes/multiplexer-a7b1259bd20c144c.yaml b/releasenotes/notes/multiplexer-a7b1259bd20c144c.yaml new file mode 100644 index 0000000000..2ef1fbaa42 --- /dev/null +++ b/releasenotes/notes/multiplexer-a7b1259bd20c144c.yaml @@ -0,0 +1,3 @@ +features: + - \| + Add `Multiplexer`. For an example of its usage, see https://github.com/deepset-ai/haystack/pull/6420.	diff --git a/test/components/others/test_multiplexer.py b/test/components/others/test_multiplexer.py new file mode 100644 index 0000000000..3488b61c28 --- /dev/null +++ b/test/components/others/test_multiplexer.py @@ -0,0 +1,32 @@ +import pytest + +from haystack.components.others import Multiplexer + + +class TestMultiplexer: + def test_one_value(self): + multiplexer = Multiplexer(int) + output = multiplexer.run(value=[2]) + assert output == {"value": 2} + + def test_one_value_of_wrong_type(self): + # Multiplexer does not type check the input + multiplexer = Multiplexer(int) + output = multiplexer.run(value=["hello"]) + assert output == {"value": "hello"} + + def test_one_value_of_none_type(self): + # Multiplexer does not type check the input + multiplexer = Multiplexer(int) + output = multiplexer.run(value=[None]) + assert output == {"value": None} + + def test_more_values_of_expected_type(self): + multiplexer = Multiplexer(int) + with pytest.raises(ValueError, match="Multiplexer expects only one input, but 3 were received."): + multiplexer.run(value=[2, 3, 4]) + + def test_no_values(self): + multiplexer = Multiplexer(int) + with pytest.raises(ValueError, match="Multiplexer expects only one input, but 0 were received."): + multiplexer.run(value=[])	diff --git a/releasenotes/notes/multiplexer-a7b1259bd20c144c.yaml b/releasenotes/notes/multiplexer-a7b1259bd20c144c.yaml new file mode 100644 index 0000000000..2ef1fbaa42 --- /dev/null +++ b/releasenotes/notes/multiplexer-a7b1259bd20c144c.yaml @@ -0,0 +1,3 @@ +features: + - \| + Add `Multiplexer`. For an example of its usage, see https://github.com/deepset-ai/haystack/pull/6420.	[ { "components": [ { "doc": "This component is used to distribute a single value to many components that may need it.\nIt can take such value from different sources (the user's input, or another component), so\nit's only input is of Variadic type.\n\nThe type of the expected input (and therefore of...	[ "test/components/others/test_multiplexer.py::TestMultiplexer::test_one_value", "test/components/others/test_multiplexer.py::TestMultiplexer::test_one_value_of_wrong_type", "test/components/others/test_multiplexer.py::TestMultiplexer::test_one_value_of_none_type", "test/components/others/test_multiplexer.py::T...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat: `Multiplexer` ### Related Issues - See https://github.com/deepset-ai/haystack/pull/6420 ### Proposed Changes: Introduces a `Multiplexer` component that takes an arbitrary number of input connections, but expects only one value from them. This value is then redirected to the output, unchanged. Components like `Multiplexer` come very handy in looping pipelines such as https://github.com/deepset-ai/haystack/pull/6420, where the input is guaranteed to only come from one input connection, but several need to be made to the same component. They can also help simplify the input of a pipeline, as they can distribute a single input value to several components on behalf of the user. ### How did you test it? Local tests, CI ### Notes for the reviewer n/a ### Checklist - I have read the [contributors guidelines](https://github.com/deepset-ai/haystack/blob/main/CONTRIBUTING.md) and the [code of conduct](https://github.com/deepset-ai/haystack/blob/main/code_of_conduct.txt) - I have updated the related issue with new insights and changes - I added unit tests and updated the docstrings - I've used one of the [conventional commit types](https://www.conventionalcommits.org/en/v1.0.0/) for my PR title: `fix:`, `feat:`, `build:`, `chore:`, `ci:`, `docs:`, `style:`, `refactor:`, `perf:`, `test:`. - I documented my code - I ran [pre-commit hooks](https://github.com/deepset-ai/haystack/blob/main/CONTRIBUTING.md#installation) and fixed any issue ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in haystack/components/others/multiplexer.py] (definition of Multiplexer:) class Multiplexer: """This component is used to distribute a single value to many components that may need it. It can take such value from different sources (the user's input, or another component), so it's only input is of Variadic type. The type of the expected input (and therefore of the output as well) must be given at init time. Example usage: ```python >>> mp = Multiplexer(str) >>> mp.run(value=["hello"]) {"value" : "hello"} >>> mp = Multiplexer(int) >>> mp.run(value=[3]) {"value": 3} ``` This component won't handle several inputs at the same time: it always only expects one. If more than one input is received when run is invoked, it will raise a ValueError. ```python >>> mp = Multiplexer(int) >>> mp.run([2, 4]) ValueError: Multiplexer expects only one input, but 2 were received. >>> mp = Multiplexer(int) >>> mp.run([2, None]) ValueError: Multiplexer expects only one input, but 2 were received. ```""" (definition of Multiplexer.__init__:) def __init__(self, type_: TypeAlias): (definition of Multiplexer.to_dict:) def to_dict(self): (definition of Multiplexer.from_dict:) def from_dict(cls, data: Dict[str, Any]) -> "Multiplexer": (definition of Multiplexer.run:) def run(self, **kwargs): [end of new definitions in haystack/components/others/multiplexer.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		f4d9c2bb917be0ffe132dffcc2ad4f1b0fcc5967
deepset-ai__haystack-6582	6,582	deepset-ai/haystack	null	0ac1bdc6a0a741a18bde9d44321142c4efa91ad6	2023-12-18T10:07:47Z	diff --git a/haystack/components/converters/html.py b/haystack/components/converters/html.py index 71475aea5d..859f62fed9 100644 --- a/haystack/components/converters/html.py +++ b/haystack/components/converters/html.py @@ -1,6 +1,6 @@ import logging from pathlib import Path -from typing import Any, Dict, List, Optional, Union +from typing import Any, Dict, List, Optional, Union, Literal from boilerpy3 import extractors from haystack import Document, component @@ -28,6 +28,27 @@ class HTMLToDocument: """ + def __init__( + self, + extractor_type: Literal[ + "DefaultExtractor", + "ArticleExtractor", + "ArticleSentencesExtractor", + "LargestContentExtractor", + "CanolaExtractor", + "KeepEverythingExtractor", + "NumWordsRulesExtractor", + ] = "DefaultExtractor", + ): + """ + Create an HTMLToDocument component. + + :param extractor_type: The type of boilerpy3 extractor to use. Defaults to `DefaultExtractor`. + For more information on the different types of extractors, + see [boilerpy3 documentation](https://github.com/jmriebold/BoilerPy3?tab=readme-ov-file#extractors). + """ + self.extractor_type = extractor_type + @component.output_types(documents=List[Document]) def run(self, sources: List[Union[str, Path, ByteStream]], meta: Optional[List[Dict[str, Any]]] = None): """ @@ -46,7 +67,8 @@ def run(self, sources: List[Union[str, Path, ByteStream]], meta: Optional[List[D elif len(sources) != len(meta): raise ValueError("The length of the metadata list must match the number of sources.") - extractor = extractors.ArticleExtractor(raise_on_failure=False) + extractor_class = getattr(extractors, self.extractor_type) + extractor = extractor_class(raise_on_failure=False) for source, metadata in zip(sources, meta): try: diff --git a/releasenotes/notes/htmlconverter-allow-extractor-customizability-730ae129db17327a.yaml b/releasenotes/notes/htmlconverter-allow-extractor-customizability-730ae129db17327a.yaml new file mode 100644 index 0000000000..a77b947505 --- /dev/null +++ b/releasenotes/notes/htmlconverter-allow-extractor-customizability-730ae129db17327a.yaml @@ -0,0 +1,7 @@ +--- +enhancements: + - \| + The `HTMLToDocument` converter now allows choosing the boilerpy3 extractor + to extract the content from the HTML document. + The default extractor has been changed to `DefaultExtractor`, which is better + for generic use cases than the previous default (`ArticleExtractor`).	diff --git a/test/components/converters/test_html_to_document.py b/test/components/converters/test_html_to_document.py index 437ab9e616..1cdb478127 100644 --- a/test/components/converters/test_html_to_document.py +++ b/test/components/converters/test_html_to_document.py @@ -18,6 +18,20 @@ def test_run(self, test_files_path): assert len(docs) == 1 assert "Haystack" in docs[0].content + def test_run_different_extractors(self, test_files_path): + """ + Test if the component runs correctly with different boilrepy3 extractors. + """ + sources = [test_files_path / "html" / "what_is_haystack.html"] + + converter_article = HTMLToDocument(extractor_type="ArticleExtractor") + converter_keep_everything = HTMLToDocument(extractor_type="KeepEverythingExtractor") + + doc_article = converter_article.run(sources=sources)["documents"][0] + doc_keep_everything = converter_keep_everything.run(sources=sources)["documents"][0] + + assert len(doc_keep_everything.content) > len(doc_article.content) + def test_run_doc_metadata(self, test_files_path): """ Test if the component runs correctly when metadata is supplied by the user.	diff --git a/releasenotes/notes/htmlconverter-allow-extractor-customizability-730ae129db17327a.yaml b/releasenotes/notes/htmlconverter-allow-extractor-customizability-730ae129db17327a.yaml new file mode 100644 index 0000000000..a77b947505 --- /dev/null +++ b/releasenotes/notes/htmlconverter-allow-extractor-customizability-730ae129db17327a.yaml @@ -0,0 +1,7 @@ +--- +enhancements: + - \| + The `HTMLToDocument` converter now allows choosing the boilerpy3 extractor + to extract the content from the HTML document. + The default extractor has been changed to `DefaultExtractor`, which is better + for generic use cases than the previous default (`ArticleExtractor`).	[ { "components": [ { "doc": "Create an HTMLToDocument component.\n\n:param extractor_type: The type of boilerpy3 extractor to use. Defaults to `DefaultExtractor`.\n For more information on the different types of extractors,\n see [boilerpy3 documentation](https://github.com/jmriebold/BoilerPy3?ta...	[ "test/components/converters/test_html_to_document.py::TestHTMLToDocument::test_run_different_extractors" ]	[ "[", "test/components/converters/test_html_to_document.py::TestHTMLToDocument::test_run", "test/components/converters/test_html_to_document.py::TestHTMLToDocument::test_run_doc_metadata", "test/components/converters/test_html_to_document.py::TestHTMLToDocument::test_incorrect_meta", "test/components/convert...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat!: `HTMLToDocument` - allow choosing the boilerpy3 extractor ### Related Issues - fixes #6579 ### Proposed Changes: - allow choosing the boilerpy3 extractor to extract the content from the HTML document - change the default extractor to `DefaultExtractor`, which is better for generic use cases than the previous default (`ArticleExtractor`). ### How did you test it? CI, new test. ### Checklist - I have read the [contributors guidelines](https://github.com/deepset-ai/haystack/blob/main/CONTRIBUTING.md) and the [code of conduct](https://github.com/deepset-ai/haystack/blob/main/code_of_conduct.txt) - I have updated the related issue with new insights and changes - I added unit tests and updated the docstrings - I've used one of the [conventional commit types](https://www.conventionalcommits.org/en/v1.0.0/) for my PR title: `fix:`, `feat:`, `build:`, `chore:`, `ci:`, `docs:`, `style:`, `refactor:`, `perf:`, `test:`. - I documented my code - I ran [pre-commit hooks](https://github.com/deepset-ai/haystack/blob/main/CONTRIBUTING.md#installation) and fixed any issue ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in haystack/components/converters/html.py] (definition of HTMLToDocument.__init__:) def __init__( self, extractor_type: Literal[ "DefaultExtractor", "ArticleExtractor", "ArticleSentencesExtractor", "LargestContentExtractor", "CanolaExtractor", "KeepEverythingExtractor", "NumWordsRulesExtractor", ] = "DefaultExtractor", ): """Create an HTMLToDocument component. :param extractor_type: The type of boilerpy3 extractor to use. Defaults to `DefaultExtractor`. For more information on the different types of extractors, see [boilerpy3 documentation](https://github.com/jmriebold/BoilerPy3?tab=readme-ov-file#extractors).""" [end of new definitions in haystack/components/converters/html.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> `HTMLToDocument` sometimes skips some relevant text Describe the bug `HTMLToDocument` uses `ArticleExtractor` from [boilerpy3](https://github.com/jmriebold/BoilerPy3). This extractor is tuned towards news articles and sometimes skips some relevant text. To Reproduce ```python from haystack.components.fetchers import LinkContentFetcher from haystack.components.converters import HTMLToDocument lc = LinkContentFetcher() hd = HTMLToDocument() out=lc.run(urls=["https://www.rainforest-alliance.org/species/capybara/"]) print('largest rodents' in str(out['streams'][0])) # True doc=hd.run(sources=out['streams'])['documents'][0] print('largest rodents' in doc.content) # False ``` Expected behavior - I would like to configure the best [boilerpy3 extractor](https://github.com/jmriebold/BoilerPy3?tab=readme-ov-file#extractors) for my use case - The default extractor should probably be more generic (e.g., `DefaultExtractor`) System: - Haystack version (commit or version number): 2.0.0b3 ---------- -------------------- </issues>	f4d9c2bb917be0ffe132dffcc2ad4f1b0fcc5967
conan-io__conan-15284	15,284	conan-io/conan	null	98d8f6aaa074b2bf6b827a359daf415f447a86a3	2023-12-16T10:42:15Z	diff --git a/conan/api/subapi/lockfile.py b/conan/api/subapi/lockfile.py index e9fc4daf337..7e4bf7de760 100644 --- a/conan/api/subapi/lockfile.py +++ b/conan/api/subapi/lockfile.py @@ -88,6 +88,12 @@ def add_lockfile(lockfile=None, requires=None, build_requires=None, python_requi python_requires=python_requires) return lockfile + @staticmethod + def remove_lockfile(lockfile, requires=None, build_requires=None, python_requires=None): + lockfile.remove(requires=requires, build_requires=build_requires, + python_requires=python_requires) + return lockfile + @staticmethod def save_lockfile(lockfile, lockfile_out, path=None): if lockfile_out is not None: diff --git a/conan/cli/commands/lock.py b/conan/cli/commands/lock.py index 9831337c29c..31630863a43 100644 --- a/conan/cli/commands/lock.py +++ b/conan/cli/commands/lock.py @@ -6,7 +6,6 @@ from conan.cli import make_abs_path from conan.cli.args import common_graph_args, validate_common_graph_args from conan.cli.printers.graph import print_graph_packages, print_graph_basic -from conans.client.cache.cache import ClientCache from conans.model.graph_lock import Lockfile, LOCKFILE from conans.model.recipe_ref import RecipeReference @@ -124,3 +123,27 @@ def _parse_requires(reqs): python_requires=python_requires, build_requires=build_requires) conan_api.lockfile.save_lockfile(lockfile, args.lockfile_out) + + +@conan_subcommand() +def lock_remove(conan_api, parser, subparser, args): + """ + Remove requires, build-requires or python-requires from an existing or new lockfile. + References can be supplied with and without revisions like "--requires=pkg/version", + """ + subparser.add_argument('--requires', action="append", help='Remove references to lockfile.') + subparser.add_argument('--build-requires', action="append", + help='Remove build-requires from lockfile') + subparser.add_argument('--python-requires', action="append", + help='Remove python-requires from lockfile') + subparser.add_argument("--lockfile-out", action=OnceArgument, default=LOCKFILE, + help="Filename of the created lockfile") + subparser.add_argument("--lockfile", action=OnceArgument, help="Filename of the input lockfile") + args = parser.parse_args(args) + + lockfile = conan_api.lockfile.get_lockfile(lockfile=args.lockfile, partial=True) + lockfile = conan_api.lockfile.remove_lockfile(lockfile, + requires=args.requires, + python_requires=args.python_requires, + build_requires=args.build_requires) + conan_api.lockfile.save_lockfile(lockfile, args.lockfile_out) diff --git a/conans/model/graph_lock.py b/conans/model/graph_lock.py index 789bb081824..3786beb07d5 100644 --- a/conans/model/graph_lock.py +++ b/conans/model/graph_lock.py @@ -1,3 +1,4 @@ +import fnmatch import json import os from collections import OrderedDict @@ -6,6 +7,7 @@ from conans.client.graph.graph import RECIPE_VIRTUAL, RECIPE_CONSUMER, CONTEXT_BUILD, Overrides from conans.errors import ConanException from conans.model.recipe_ref import RecipeReference +from conans.model.version_range import VersionRange from conans.util.files import load, save LOCKFILE = "conan.lock" @@ -64,6 +66,23 @@ def add(self, ref, package_ids=None): raise ConanException(f"Cannot add {ref} to lockfile, already exists") self._requires[ref] = package_ids + def remove(self, pattern): + ref = RecipeReference.loads(pattern) + version = str(ref.version) + remove = [] + if version.startswith("[") and version.endswith("]"): + version_range = VersionRange(version[1:-1]) + for k, v in self._requires.items(): + if fnmatch.fnmatch(k.name, ref.name) and version_range.contains(k.version, None): + new_pattern = f"{k.name}/*@{ref.user or ''}" + new_pattern += f"/{ref.channel}" if ref.channel else "" + if k.matches(new_pattern, False): + remove.append(k) + else: + remove = [k for k in self._requires if k.matches(pattern, False)] + self._requires = OrderedDict((k, v) for k, v in self._requires.items() if k not in remove) + return remove + def sort(self): self._requires = OrderedDict(reversed(sorted(self._requires.items()))) @@ -171,6 +190,19 @@ def add(self, requires=None, build_requires=None, python_requires=None): self._python_requires.add(r) self._python_requires.sort() + def remove(self, requires=None, build_requires=None, python_requires=None): + def _remove(reqs, self_reqs, name): + if reqs: + removed = [] + for r in reqs: + removed.extend(self_reqs.remove(r)) + for d in removed: + ConanOutput().info(f"Removed locked {name}: {d.repr_notime()}") + + _remove(requires, self._requires, "require") + _remove(build_requires, self._build_requires, "build_require") + _remove(python_requires, self._python_requires, "python_require") + @staticmethod def deserialize(data): """ constructs a GraphLock from a json like dict	diff --git a/conans/test/integration/lockfile/test_user_overrides.py b/conans/test/integration/lockfile/test_user_overrides.py index f37a91c4259..53648a5c6c2 100644 --- a/conans/test/integration/lockfile/test_user_overrides.py +++ b/conans/test/integration/lockfile/test_user_overrides.py @@ -1,4 +1,7 @@ import json +import textwrap + +import pytest from conans.test.assets.genconanfile import GenConanfile from conans.test.utils.tools import TestClient @@ -211,3 +214,106 @@ def test_lock_add_error(): c = TestClient() c.run(f"lock add --requires=math/1.0:pid1", assert_error=True) assert "ERROR: Invalid recipe reference 'math/1.0:pid1' is a package reference" in c.out + + +class TestLockRemove: + @pytest.mark.parametrize("args, removed", [ + ("--requires=math/", ["math"]), + ("--requires=math/2.0", []), + ("--build-requires=cmake/1.0", ["cmake"]), + # Not valid ("--build-requires=", ["cmake", "ninja"]), + ("--build-requires=/", ["cmake", "ninja"]), # But this is valid + ("--python-requires=mytool/", ["mytool"]), + ("--python-requires=tool/", ["mytool", "othertool"]), + # With version ranges + ('--requires="math/[>=1.0 <2]"', ["math"]), + ('--requires="math/[>1.0]"', []), + ('--requires="/[>=1.0 <2]"', ["math", "engine"]) + ]) + def test_lock_remove(self, args, removed): + c = TestClient() + lock = textwrap.dedent("""\ + { + "version": "0.5", + "requires": [ + "math/1.0#85d927a4a067a531b1a9c7619522c015%1702683583.3411012", + "math/1.0#12345%1702683584.3411012", + "engine/1.0#fd2b006646a54397c16a1478ac4111ac%1702683583.3544693" + ], + "build_requires": [ + "cmake/1.0#85d927a4a067a531b1a9c7619522c015%1702683583.3411012", + "ninja/1.0#fd2b006646a54397c16a1478ac4111ac%1702683583.3544693" + ], + "python_requires": [ + "mytool/1.0#85d927a4a067a531b1a9c7619522c015%1702683583.3411012", + "othertool/1.0#fd2b006646a54397c16a1478ac4111ac%1702683583.3544693" + ] + } + """) + c.save({"conan.lock": lock}) + c.run(f"lock remove {args}") + lock = c.load("conan.lock") + for remove in removed: + assert remove not in lock + for pkg in {"math", "engine", "cmake", "ninja", "mytool", "othertool"}.difference(removed): + assert pkg in lock + + @pytest.mark.parametrize("args, removed", [ + ("--requires=math/1.0#12345", ["math/1.0#123456789abcdef"]), + ("--requires=math/1.0#", ["math/1.0#123456789abcdef", + "math/1.0#85d927a4a067a531b1a9c7619522c015"]), + ]) + def test_lock_remove_revisions(self, args, removed): + c = TestClient() + lock = textwrap.dedent("""\ + { + "version": "0.5", + "requires": [ + "math/1.0#123456789abcdef%1702683584.3411012", + "math/1.0#85d927a4a067a531b1a9c7619522c015%1702683583.3411012", + "engine/1.0#fd2b006646a54397c16a1478ac4111ac%1702683583.3544693" + ] + } + """) + c.save({"conan.lock": lock}) + c.run(f"lock remove {args}") + lock = c.load("conan.lock") + for remove in removed: + assert remove not in lock + for pkg in {"math/1.0#123456789abcdef", + "math/1.0#85d927a4a067a531b1a9c7619522c015", + "engine/1.0#fd2b006646a54397c16a1478ac4111ac"}.difference(removed): + assert pkg in lock + + @pytest.mark.parametrize("args, removed", [ + ("--requires=/@team", ["pkg/1.0@team"]), + ("--requires=/@team", ["pkg/1.0@team", "math/2.0@team/stable"]), + ("--requires=/@user", ["math/1.0@user", "other/1.0@user"]), + ("--requires=/@", ["engine/1.0"]), # Remove those without user + # with version ranges + ("--requires=math/[]@user", ["math/1.0@user"]), + ("--requires=math/[]@team", ["math/2.0@team/stable"]), + ]) + def test_lock_remove_user_channel(self, args, removed): + c = TestClient() + lock = textwrap.dedent("""\ + { + "version": "0.5", + "requires": [ + "math/1.0@user#123456789abcdef%1702683584.3411012", + "math/2.0@team/stable#123456789abcdef%1702683584.3411012", + "other/1.0@user#85d927a4a067a531b1a9c7619522c015%1702683583.3411012", + "pkg/1.0@team#85d927a4a067a531b1a9c7619522c015%1702683583.3411012", + "engine/1.0#fd2b006646a54397c16a1478ac4111ac%1702683583.3544693" + ] + } + """) + c.save({"conan.lock": lock}) + c.run(f"lock remove {args}") + lock = c.load("conan.lock") + for remove in removed: + assert remove not in lock + rest = {"math/1.0@user", "math/2.0@team/stable", + "other/1.0@user", "pkg/1.0@team", "engine/1.0"}.difference(removed) + for pkg in rest: + assert pkg in lock		[ { "components": [ { "doc": "", "lines": [ 92, 95 ], "name": "LockfileAPI.remove_lockfile", "signature": "def remove_lockfile(lockfile, requires=None, build_requires=None, python_requires=None):", "type": "function" } ], "fil...	[ "conans/test/integration/lockfile/test_user_overrides.py::TestLockRemove::test_lock_remove[--requires=math/*-removed0]", "conans/test/integration/lockfile/test_user_overrides.py::TestLockRemove::test_lock_remove[--requires=math/2.0-removed1]", "conans/test/integration/lockfile/test_user_overrides.py::TestLockRe...	[ "conans/test/integration/lockfile/test_user_overrides.py::test_user_overrides", "conans/test/integration/lockfile/test_user_overrides.py::test_user_build_overrides", "conans/test/integration/lockfile/test_user_overrides.py::test_user_python_overrides", "conans/test/integration/lockfile/test_user_overrides.py:...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> new lock remove command Changelog: Feature: New ``conan lock remove`` command to remove requires from lockfiles. Docs: https://github.com/conan-io/docs/pull/3496 I am proposing this PR to close: Close https://github.com/conan-io/conan/issues/14523 Close https://github.com/conan-io/conan/issues/14524 The idea is that updates are equivalent to something like: ```bash $ conan remove --requires=zlib/* && conan add --requires=zlib/1.2.11 ``` But it will allow us to first iterate and learn about the logic of removal of versions from lockfiles, because ``conan remove`` makes sense in isolation, even without ``lock update`` or ``lock add``, like for example using it before resolving it to latest with ``--lockfile-partial``. When we have clear what is the UX and UI for the removal, we can do a single command ``conan update`` or ``conan add`` with extra arguments ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conan/api/subapi/lockfile.py] (definition of LockfileAPI.remove_lockfile:) def remove_lockfile(lockfile, requires=None, build_requires=None, python_requires=None): [end of new definitions in conan/api/subapi/lockfile.py] [start of new definitions in conan/cli/commands/lock.py] (definition of lock_remove:) def lock_remove(conan_api, parser, subparser, *args): """Remove requires, build-requires or python-requires from an existing or new lockfile. References can be supplied with and without revisions like "--requires=pkg/version",""" [end of new definitions in conan/cli/commands/lock.py] [start of new definitions in conans/model/graph_lock.py] (definition of _LockRequires.remove:) def remove(self, pattern): (definition of Lockfile.remove:) def remove(self, requires=None, build_requires=None, python_requires=None): (definition of Lockfile.remove._remove:) def _remove(reqs, self_reqs, name): [end of new definitions in conans/model/graph_lock.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		4a5b19a75db9225316c8cb022a2dfb9705a2af34
astropy__astropy-15737	15,737	astropy/astropy	v5.3	f87e75d967fcf0ede5a1fe9f1326e4b84e333f94	2023-12-14T19:52:14Z	diff --git a/astropy/coordinates/baseframe.py b/astropy/coordinates/baseframe.py index 88a525feb8ff..7be15424b799 100644 --- a/astropy/coordinates/baseframe.py +++ b/astropy/coordinates/baseframe.py @@ -26,11 +26,12 @@ from astropy.utils.exceptions import AstropyWarning from . import representation as r -from .angles import Angle +from .angles import Angle, position_angle from .attributes import Attribute from .transformations import TransformGraph if TYPE_CHECKING: + from astropy.coordinates import Latitude, Longitude, SkyCoord from astropy.units import Unit @@ -1765,6 +1766,50 @@ def __eq__(self, value): def __ne__(self, value): return np.logical_not(self == value) + def _prepare_unit_sphere_coords( + self, other: BaseCoordinateFrame \| SkyCoord + ) -> tuple[Longitude, Latitude, Longitude, Latitude]: + self_sph = self.represent_as(r.UnitSphericalRepresentation) + other_sph = ( + getattr(other, "frame", other) + .transform_to(self) + .represent_as(r.UnitSphericalRepresentation) + ) + return self_sph.lon, self_sph.lat, other_sph.lon, other_sph.lat + + def position_angle(self, other: BaseCoordinateFrame \| SkyCoord) -> Angle: + """Compute the on-sky position angle to another coordinate. + + Parameters + ---------- + other : `~astropy.coordinates.BaseCoordinateFrame` or `~astropy.coordinates.SkyCoord` + The other coordinate to compute the position angle to. It is + treated as the "head" of the vector of the position angle. + + Returns + ------- + `~astropy.coordinates.Angle` + The (positive) position angle of the vector pointing from ``self`` + to ``other``, measured East from North. If either ``self`` or + ``other`` contain arrays, this will be an array following the + appropriate `numpy` broadcasting rules. + + Examples + -------- + >>> from astropy import units as u + >>> from astropy.coordinates import ICRS, SkyCoord + >>> c1 = SkyCoord(0u.deg, 0u.deg) + >>> c2 = ICRS(1u.deg, 0u.deg) + >>> c1.position_angle(c2).degree + 90.0 + >>> c2.position_angle(c1).degree + 270.0 + >>> c3 = SkyCoord(1u.deg, 1u.deg) + >>> c1.position_angle(c3).degree # doctest: +FLOAT_CMP + 44.995636455344844 + """ + return position_angle(self._prepare_unit_sphere_coords(other)) + def separation(self, other): """ Computes on-sky separation between this coordinate and another. @@ -1800,18 +1845,9 @@ def separation(self, other): """ from .angles import Angle, angular_separation - self_unit_sph = self.represent_as(r.UnitSphericalRepresentation) - other_unit_sph = ( - getattr(other, "frame", other) - .transform_to(self) - .represent_as(r.UnitSphericalRepresentation) - ) - - # Get the separation as a Quantity, convert to Angle in degrees - sep = angular_separation( - self_unit_sph.lon, self_unit_sph.lat, other_unit_sph.lon, other_unit_sph.lat + return Angle( + angular_separation(self._prepare_unit_sphere_coords(other)), unit=u.degree ) - return Angle(sep, unit=u.degree) def separation_3d(self, other): """ diff --git a/astropy/coordinates/sky_coordinate.py b/astropy/coordinates/sky_coordinate.py index 027d65e0d6f3..e446c4d272da 100644 --- a/astropy/coordinates/sky_coordinate.py +++ b/astropy/coordinates/sky_coordinate.py @@ -295,6 +295,7 @@ class name that allow for creating a \|SkyCoord\| object and transforming info = SkyCoordInfo() # Methods implemented by the underlying frame + position_angle: Callable[[BaseCoordinateFrame \| SkyCoord], Angle] separation: Callable[[BaseCoordinateFrame \| SkyCoord], Angle] separation_3d: Callable[[BaseCoordinateFrame \| SkyCoord], Distance] @@ -1182,7 +1183,7 @@ def spherical_offsets_to(self, tocoord): -------- :meth:`~astropy.coordinates.BaseCoordinateFrame.separation` : for the total angular offset (not broken out into components). - position_angle : + :meth:`~astropy.coordinates.BaseCoordinateFrame.position_angle` : for the direction of the offset. """ @@ -1255,8 +1256,7 @@ def directional_offset_by(self, position_angle, separation): ------- newpoints : `~astropy.coordinates.SkyCoord` The coordinates for the location that corresponds to offsetting by - the given `position_angle` and - :meth:`~astropy.coordinates.BaseCoordinateFrame.separation`. + the given ``position_angle`` and ``separation``. Notes ----- @@ -1273,8 +1273,10 @@ def directional_offset_by(self, position_angle, separation): See Also -------- - position_angle : inverse operation for the ``position_angle`` component - :meth:`~astropy.coordinates.BaseCoordinateFrame.separation` : inverse operation for the ``separation`` component + :meth:`~astropy.coordinates.BaseCoordinateFrame.position_angle` : + inverse operation for the ``position_angle`` component + :meth:`~astropy.coordinates.BaseCoordinateFrame.separation` : + inverse operation for the ``separation`` component """ from .angles import offset_by @@ -1541,53 +1543,6 @@ def search_around_3d(self, searcharoundcoords, distlimit): searcharoundcoords, self, distlimit, storekdtree="_kdtree_3d" ) - def position_angle(self, other): - """ - Computes the on-sky position angle (East of North) between this - SkyCoord and another. - - Parameters - ---------- - other : \|SkyCoord\| - The other coordinate to compute the position angle to. It is - treated as the "head" of the vector of the position angle. - - Returns - ------- - pa : `~astropy.coordinates.Angle` - The (positive) position angle of the vector pointing from ``self`` - to ``other``. If either ``self`` or ``other`` contain arrays, this - will be an array following the appropriate `numpy` broadcasting - rules. - - Examples - -------- - >>> c1 = SkyCoord(0u.deg, 0u.deg) - >>> c2 = SkyCoord(1u.deg, 0u.deg) - >>> c1.position_angle(c2).degree - 90.0 - >>> c3 = SkyCoord(1u.deg, 1u.deg) - >>> c1.position_angle(c3).degree # doctest: +FLOAT_CMP - 44.995636455344844 - """ - from .angles import position_angle - - if not self.is_equivalent_frame(other): - try: - other = other.transform_to(self, merge_attributes=False) - except TypeError: - raise TypeError( - "Can only get position_angle to another " - "SkyCoord or a coordinate frame with data" - ) - - slat = self.represent_as(UnitSphericalRepresentation).lat - slon = self.represent_as(UnitSphericalRepresentation).lon - olat = other.represent_as(UnitSphericalRepresentation).lat - olon = other.represent_as(UnitSphericalRepresentation).lon - - return position_angle(slon, slat, olon, olat) - def skyoffset_frame(self, rotation=None): """ Returns the sky offset frame with this SkyCoord at the origin. diff --git a/docs/changes/coordinates/15737.feature.rst b/docs/changes/coordinates/15737.feature.rst new file mode 100644 index 000000000000..fd33dd6a78b8 --- /dev/null +++ b/docs/changes/coordinates/15737.feature.rst @@ -0,0 +1,2 @@ +``BaseCoordinateFrame`` now has a ``position_angle()`` method, which is the +same as the ``position_angle`` method of ``SkyCoord`` instances. diff --git a/docs/coordinates/matchsep.rst b/docs/coordinates/matchsep.rst index fdf2f1b140d9..209f373c7ef5 100644 --- a/docs/coordinates/matchsep.rst +++ b/docs/coordinates/matchsep.rst @@ -68,8 +68,8 @@ rather than the single scalar angular offset of a separation. offsets encountered in astronomy. The first piece of such functionality is the -:meth:`~astropy.coordinates.SkyCoord.position_angle` method. This method -computes the position angle between one +:meth:`~astropy.coordinates.BaseCoordinateFrame.position_angle` method. +This method computes the position angle between one \|SkyCoord\| instance and another (passed as the argument) following the astronomy convention (positive angles East of North):: @@ -79,8 +79,9 @@ astronomy convention (positive angles East of North):: <Angle 44.97818294 deg> The combination of :meth:`~astropy.coordinates.BaseCoordinateFrame.separation` -and :meth:`~astropy.coordinates.SkyCoord.position_angle` thus give a set of -directional offsets. To do the inverse operation — determining the new +and :meth:`~astropy.coordinates.BaseCoordinateFrame.position_angle` thus give a +set of directional offsets. +To do the inverse operation — determining the new "destination" coordinate given a separation and position angle — the :meth:`~astropy.coordinates.SkyCoord.directional_offset_by` method is provided:: diff --git a/docs/coordinates/skycoord.rst b/docs/coordinates/skycoord.rst index f73a1727e8ec..ff1914d32eaf 100644 --- a/docs/coordinates/skycoord.rst +++ b/docs/coordinates/skycoord.rst @@ -1256,7 +1256,7 @@ the available docstrings below: - `~astropy.coordinates.SkyCoord.match_to_catalog_sky`, - `~astropy.coordinates.SkyCoord.match_to_catalog_3d`, -- `~astropy.coordinates.SkyCoord.position_angle`, +- `~astropy.coordinates.BaseCoordinateFrame.position_angle`, - `~astropy.coordinates.BaseCoordinateFrame.separation`, - `~astropy.coordinates.BaseCoordinateFrame.separation_3d` - `~astropy.coordinates.SkyCoord.apply_space_motion`	diff --git a/astropy/coordinates/tests/test_frame_skycoord_common_methods.py b/astropy/coordinates/tests/test_frame_skycoord_common_methods.py new file mode 100644 index 000000000000..29fc2b5853be --- /dev/null +++ b/astropy/coordinates/tests/test_frame_skycoord_common_methods.py @@ -0,0 +1,39 @@ +# Licensed under a 3-clause BSD style license - see LICENSE.rst + +""" +Tests for methods that are implemented in `BaseCoordinateFrame`, +but are also exposed by `SkyCoord` instances. +""" + +import pytest + +from astropy import units as u +from astropy.coordinates import FK5, ICRS, SkyCoord +from astropy.tests.helper import assert_quantity_allclose + + +@pytest.mark.parametrize("self_class", [SkyCoord, ICRS]) +@pytest.mark.parametrize("other_class", [SkyCoord, ICRS]) +def test_position_angle_array(self_class, other_class): + c1 = self_class(0 * u.deg, [0, 1, 2] * u.deg) + c2 = other_class([-1, -2, -3] * u.deg, [0.1, 1.1, 2.1] * u.deg) + assert_quantity_allclose( + c1.position_angle(c2), [275.710887, 272.880921, 271.963607] * u.deg + ) + + +@pytest.mark.parametrize("self_class", [SkyCoord, ICRS]) +@pytest.mark.parametrize( + "other_coord,value", + [ + (SkyCoord(1 * u.deg, 0 * u.deg), 90 * u.deg), + (SkyCoord(1 * u.deg, 0.1 * u.deg), 84.289113 * u.deg), + (SkyCoord(1 * u.deg, 1 * u.deg), 44.995636455344844 * u.deg), + (ICRS(0 * u.deg, 1 * u.deg), 0 * u.deg), + (FK5(1 * u.deg, 0 * u.deg), 90.000139 * u.deg), + ], +) +def test_position_angle_scalar(self_class, other_coord, value): + assert_quantity_allclose( + self_class(0 * u.deg, 0 * u.deg).position_angle(other_coord), value + ) diff --git a/astropy/coordinates/tests/test_sky_coord.py b/astropy/coordinates/tests/test_sky_coord.py index 8e433d63618e..db5eb11b74e7 100644 --- a/astropy/coordinates/tests/test_sky_coord.py +++ b/astropy/coordinates/tests/test_sky_coord.py @@ -853,33 +853,6 @@ def test_none_transform(): npt.assert_array_equal(sc_arr5.ra, sc_arr2.transform_to("fk5").ra) -def test_position_angle(): - c1 = SkyCoord(0 * u.deg, 0 * u.deg) - - c2 = SkyCoord(1 * u.deg, 0 * u.deg) - assert_allclose(c1.position_angle(c2) - 90.0 * u.deg, 0 * u.deg) - - c3 = SkyCoord(1 * u.deg, 0.1 * u.deg) - assert c1.position_angle(c3) < 90 * u.deg - - c4 = SkyCoord(0 * u.deg, 1 * u.deg) - assert_allclose(c1.position_angle(c4), 0 * u.deg) - - carr1 = SkyCoord(0 * u.deg, [0, 1, 2] * u.deg) - carr2 = SkyCoord([-1, -2, -3] * u.deg, [0.1, 1.1, 2.1] * u.deg) - - res = carr1.position_angle(carr2) - assert res.shape == (3,) - assert np.all(res < 360 * u.degree) - assert np.all(res > 270 * u.degree) - - cicrs = SkyCoord(0 * u.deg, 0 * u.deg, frame="icrs") - cfk5 = SkyCoord(1 * u.deg, 0 * u.deg, frame="fk5") - # because of the frame transform, it's just a bit more than 90 degrees - assert cicrs.position_angle(cfk5) > 90.0 * u.deg - assert cicrs.position_angle(cfk5) < 91.0 * u.deg - - def test_position_angle_directly(): """Regression check for #3800: position_angle should accept floats.""" from astropy.coordinates import position_angle	diff --git a/docs/changes/coordinates/15737.feature.rst b/docs/changes/coordinates/15737.feature.rst new file mode 100644 index 000000000000..fd33dd6a78b8 --- /dev/null +++ b/docs/changes/coordinates/15737.feature.rst @@ -0,0 +1,2 @@ +``BaseCoordinateFrame`` now has a ``position_angle()`` method, which is the +same as the ``position_angle`` method of ``SkyCoord`` instances. diff --git a/docs/coordinates/matchsep.rst b/docs/coordinates/matchsep.rst index fdf2f1b140d9..209f373c7ef5 100644 --- a/docs/coordinates/matchsep.rst +++ b/docs/coordinates/matchsep.rst @@ -68,8 +68,8 @@ rather than the single scalar angular offset of a separation. offsets encountered in astronomy. The first piece of such functionality is the -:meth:`~astropy.coordinates.SkyCoord.position_angle` method. This method -computes the position angle between one +:meth:`~astropy.coordinates.BaseCoordinateFrame.position_angle` method. +This method computes the position angle between one \|SkyCoord\| instance and another (passed as the argument) following the astronomy convention (positive angles East of North):: @@ -79,8 +79,9 @@ astronomy convention (positive angles East of North):: <Angle 44.97818294 deg> The combination of :meth:`~astropy.coordinates.BaseCoordinateFrame.separation` -and :meth:`~astropy.coordinates.SkyCoord.position_angle` thus give a set of -directional offsets. To do the inverse operation — determining the new +and :meth:`~astropy.coordinates.BaseCoordinateFrame.position_angle` thus give a +set of directional offsets. +To do the inverse operation — determining the new "destination" coordinate given a separation and position angle — the :meth:`~astropy.coordinates.SkyCoord.directional_offset_by` method is provided:: diff --git a/docs/coordinates/skycoord.rst b/docs/coordinates/skycoord.rst index f73a1727e8ec..ff1914d32eaf 100644 --- a/docs/coordinates/skycoord.rst +++ b/docs/coordinates/skycoord.rst @@ -1256,7 +1256,7 @@ the available docstrings below: - `~astropy.coordinates.SkyCoord.match_to_catalog_sky`, - `~astropy.coordinates.SkyCoord.match_to_catalog_3d`, -- `~astropy.coordinates.SkyCoord.position_angle`, +- `~astropy.coordinates.BaseCoordinateFrame.position_angle`, - `~astropy.coordinates.BaseCoordinateFrame.separation`, - `~astropy.coordinates.BaseCoordinateFrame.separation_3d` - `~astropy.coordinates.SkyCoord.apply_space_motion`	[ { "components": [ { "doc": "", "lines": [ 1769, 1778 ], "name": "BaseCoordinateFrame._prepare_unit_sphere_coords", "signature": "def _prepare_unit_sphere_coords( self, other: BaseCoordinateFrame \| SkyCoord ) -> tuple[Longitude, Latitude, Longitud...	[ "astropy/coordinates/tests/test_frame_skycoord_common_methods.py::test_position_angle_array[SkyCoord-ICRS]", "astropy/coordinates/tests/test_frame_skycoord_common_methods.py::test_position_angle_array[ICRS-ICRS]", "astropy/coordinates/tests/test_frame_skycoord_common_methods.py::test_position_angle_scalar[other...	[ "astropy/coordinates/tests/test_frame_skycoord_common_methods.py::test_position_angle_array[SkyCoord-SkyCoord]", "astropy/coordinates/tests/test_frame_skycoord_common_methods.py::test_position_angle_array[ICRS-SkyCoord]", "astropy/coordinates/tests/test_frame_skycoord_common_methods.py::test_position_angle_scal...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Move `position_angle()` from `SkyCoord` to `BaseCoordinateFrame` ### Description The first commit implements a new private method in `BaseCoordinateFrame` that simplifies the implementation of `separation()` and `position_angle()` methods. The second commit moves `position_angle()` from `SkyCoord` to `BaseCoordinateFrame`. The method remains accessible for `SkyCoord` instances because they have access to methods defined both in `SkyCoord` and in their underlying frame. I felt it appropriate to create a new file for testing methods that are implemented in `BaseCoordinateFrame`, but are exposed also by `SkyCoord` instances. That file should also include tests for `separation()` and `separation_3d()`, but moving those tests over would be beyond the scope of this pull request, which is large enough as it is. <!-- Optional opt-out --> - [x] By checking this box, the PR author has requested that maintainers do NOT use the "Squash and Merge" button. Maintainers should respect this when possible; however, the final decision is at the discretion of the maintainer that merges the PR. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in astropy/coordinates/baseframe.py] (definition of BaseCoordinateFrame._prepare_unit_sphere_coords:) def _prepare_unit_sphere_coords( self, other: BaseCoordinateFrame \| SkyCoord ) -> tuple[Longitude, Latitude, Longitude, Latitude]: (definition of BaseCoordinateFrame.position_angle:) def position_angle(self, other: BaseCoordinateFrame \| SkyCoord) -> Angle: """Compute the on-sky position angle to another coordinate. Parameters ---------- other : `~astropy.coordinates.BaseCoordinateFrame` or `~astropy.coordinates.SkyCoord` The other coordinate to compute the position angle to. It is treated as the "head" of the vector of the position angle. Returns ------- `~astropy.coordinates.Angle` The (positive) position angle of the vector pointing from ``self`` to ``other``, measured East from North. If either ``self`` or ``other`` contain arrays, this will be an array following the appropriate `numpy` broadcasting rules. Examples -------- >>> from astropy import units as u >>> from astropy.coordinates import ICRS, SkyCoord >>> c1 = SkyCoord(0u.deg, 0u.deg) >>> c2 = ICRS(1u.deg, 0u.deg) >>> c1.position_angle(c2).degree 90.0 >>> c2.position_angle(c1).degree 270.0 >>> c3 = SkyCoord(1u.deg, 1u.deg) >>> c1.position_angle(c3).degree # doctest: +FLOAT_CMP 44.995636455344844""" [end of new definitions in astropy/coordinates/baseframe.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		2d281019494aaebf522f6626c0dae37510c16688
googleapis__python-aiplatform-3105	3,105	googleapis/python-aiplatform	null	f54048ac67a4d4e3b8fc607f6321b3b4d48588d7	2023-12-13T23:04:29Z	diff --git a/google/cloud/aiplatform/jobs.py b/google/cloud/aiplatform/jobs.py index 653d31f73a..188b671b5c 100644 --- a/google/cloud/aiplatform/jobs.py +++ b/google/cloud/aiplatform/jobs.py @@ -252,6 +252,14 @@ def _block_until_complete(self): else: _LOGGER.log_action_completed_against_resource("run", "completed", self) + def wait_for_completion(self) -> None: + """Waits for job to complete. + + Raises: + RuntimeError: If job failed or cancelled. + """ + self._block_until_complete() + @classmethod def list( cls, @@ -609,6 +617,530 @@ def create( (jobs.BatchPredictionJob): Instantiated representation of the created batch prediction job. """ + return cls._submit_impl( + job_display_name=job_display_name, + model_name=model_name, + instances_format=instances_format, + predictions_format=predictions_format, + gcs_source=gcs_source, + bigquery_source=bigquery_source, + gcs_destination_prefix=gcs_destination_prefix, + bigquery_destination_prefix=bigquery_destination_prefix, + model_parameters=model_parameters, + machine_type=machine_type, + accelerator_type=accelerator_type, + accelerator_count=accelerator_count, + starting_replica_count=starting_replica_count, + max_replica_count=max_replica_count, + generate_explanation=generate_explanation, + explanation_metadata=explanation_metadata, + explanation_parameters=explanation_parameters, + labels=labels, + project=project, + location=location, + credentials=credentials, + encryption_spec_key_name=encryption_spec_key_name, + sync=sync, + create_request_timeout=create_request_timeout, + batch_size=batch_size, + model_monitoring_objective_config=model_monitoring_objective_config, + model_monitoring_alert_config=model_monitoring_alert_config, + analysis_instance_schema_uri=analysis_instance_schema_uri, + service_account=service_account, + # Main distinction of `create` vs `submit`: + wait_for_completion=True, + ) + + @classmethod + def submit( + cls, + , + job_display_name: Optional[str] = None, + model_name: Union[str, "aiplatform.Model"], + instances_format: str = "jsonl", + predictions_format: str = "jsonl", + gcs_source: Optional[Union[str, Sequence[str]]] = None, + bigquery_source: Optional[str] = None, + gcs_destination_prefix: Optional[str] = None, + bigquery_destination_prefix: Optional[str] = None, + model_parameters: Optional[Dict] = None, + machine_type: Optional[str] = None, + accelerator_type: Optional[str] = None, + accelerator_count: Optional[int] = None, + starting_replica_count: Optional[int] = None, + max_replica_count: Optional[int] = None, + generate_explanation: Optional[bool] = False, + explanation_metadata: Optional["aiplatform.explain.ExplanationMetadata"] = None, + explanation_parameters: Optional[ + "aiplatform.explain.ExplanationParameters" + ] = None, + labels: Optional[Dict[str, str]] = None, + project: Optional[str] = None, + location: Optional[str] = None, + credentials: Optional[auth_credentials.Credentials] = None, + encryption_spec_key_name: Optional[str] = None, + create_request_timeout: Optional[float] = None, + batch_size: Optional[int] = None, + model_monitoring_objective_config: Optional[ + "aiplatform.model_monitoring.ObjectiveConfig" + ] = None, + model_monitoring_alert_config: Optional[ + "aiplatform.model_monitoring.AlertConfig" + ] = None, + analysis_instance_schema_uri: Optional[str] = None, + service_account: Optional[str] = None, + ) -> "BatchPredictionJob": + """Sumbit a batch prediction job (not waiting for completion). + + Args: + job_display_name (str): + Required. The user-defined name of the BatchPredictionJob. + The name can be up to 128 characters long and can be consist + of any UTF-8 characters. + model_name (Union[str, aiplatform.Model]): + Required. A fully-qualified model resource name or model ID. + Example: "projects/123/locations/us-central1/models/456" or + "456" when project and location are initialized or passed. + May optionally contain a version ID or alias in + {model_name}@{version} form. + + Or an instance of aiplatform.Model. + instances_format (str): + Required. The format in which instances are provided. Must be one + of the formats listed in `Model.supported_input_storage_formats`. + Default is "jsonl" when using `gcs_source`. If a `bigquery_source` + is provided, this is overridden to "bigquery". + predictions_format (str): + Required. The format in which Vertex AI outputs the + predictions, must be one of the formats specified in + `Model.supported_output_storage_formats`. + Default is "jsonl" when using `gcs_destination_prefix`. If a + `bigquery_destination_prefix` is provided, this is overridden to + "bigquery". + gcs_source (Optional[Sequence[str]]): + Google Cloud Storage URI(-s) to your instances to run + batch prediction on. They must match `instances_format`. + + bigquery_source (Optional[str]): + BigQuery URI to a table, up to 2000 characters long. For example: + `bq://projectId.bqDatasetId.bqTableId` + gcs_destination_prefix (Optional[str]): + The Google Cloud Storage location of the directory where the + output is to be written to. In the given directory a new + directory is created. Its name is + ``prediction-<model-display-name>-<job-create-time>``, where + timestamp is in YYYY-MM-DDThh:mm:ss.sssZ ISO-8601 format. + Inside of it files ``predictions_0001.<extension>``, + ``predictions_0002.<extension>``, ..., + ``predictions_N.<extension>`` are created where + ``<extension>`` depends on chosen ``predictions_format``, + and N may equal 0001 and depends on the total number of + successfully predicted instances. If the Model has both + ``instance`` and ``prediction`` schemata defined then each such + file contains predictions as per the ``predictions_format``. + If prediction for any instance failed (partially or + completely), then an additional ``errors_0001.<extension>``, + ``errors_0002.<extension>``,..., ``errors_N.<extension>`` + files are created (N depends on total number of failed + predictions). These files contain the failed instances, as + per their schema, followed by an additional ``error`` field + which as value has ```google.rpc.Status`` <Status>`__ + containing only ``code`` and ``message`` fields. + bigquery_destination_prefix (Optional[str]): + The BigQuery project or dataset location where the output is + to be written to. If project is provided, a new dataset is + created with name + ``prediction_<model-display-name>_<job-create-time>`` where + is made BigQuery-dataset-name compatible (for example, most + special characters become underscores), and timestamp is in + YYYY_MM_DDThh_mm_ss_sssZ "based on ISO-8601" format. In the + dataset two tables will be created, ``predictions``, and + ``errors``. If the Model has both + [instance][google.cloud.aiplatform.v1.PredictSchemata.instance_schema_uri] + and + [prediction][google.cloud.aiplatform.v1.PredictSchemata.parameters_schema_uri] + schemata defined then the tables have columns as follows: + The ``predictions`` table contains instances for which the + prediction succeeded, it has columns as per a concatenation + of the Model's instance and prediction schemata. The + ``errors`` table contains rows for which the prediction has + failed, it has instance columns, as per the instance schema, + followed by a single "errors" column, which as values has + [google.rpc.Status][google.rpc.Status] represented as a + STRUCT, and containing only ``code`` and ``message``. + model_parameters (Optional[Dict]): + The parameters that govern the predictions. The schema of + the parameters may be specified via the Model's `parameters_schema_uri`. + machine_type (Optional[str]): + The type of machine for running batch prediction on + dedicated resources. Not specifying machine type will result in + batch prediction job being run with automatic resources. + accelerator_type (Optional[str]): + The type of accelerator(s) that may be attached + to the machine as per `accelerator_count`. Only used if + `machine_type` is set. + accelerator_count (Optional[int]): + The number of accelerators to attach to the + `machine_type`. Only used if `machine_type` is set. + starting_replica_count (Optional[int]): + The number of machine replicas used at the start of the batch + operation. If not set, Vertex AI decides starting number, not + greater than `max_replica_count`. Only used if `machine_type` is + set. + max_replica_count (Optional[int]): + The maximum number of machine replicas the batch operation may + be scaled to. Only used if `machine_type` is set. + Default is 10. + generate_explanation (bool): + Optional. Generate explanation along with the batch prediction + results. This will cause the batch prediction output to include + explanations based on the `prediction_format`: + - `bigquery`: output includes a column named `explanation`. The value + is a struct that conforms to the [aiplatform.gapic.Explanation] object. + - `jsonl`: The JSON objects on each line include an additional entry + keyed `explanation`. The value of the entry is a JSON object that + conforms to the [aiplatform.gapic.Explanation] object. + - `csv`: Generating explanations for CSV format is not supported. + explanation_metadata (aiplatform.explain.ExplanationMetadata): + Optional. Explanation metadata configuration for this BatchPredictionJob. + Can be specified only if `generate_explanation` is set to `True`. + + This value overrides the value of `Model.explanation_metadata`. + All fields of `explanation_metadata` are optional in the request. If + a field of the `explanation_metadata` object is not populated, the + corresponding field of the `Model.explanation_metadata` object is inherited. + For more details, see `Ref docs <http://tinyurl.com/1igh60kt>` + explanation_parameters (aiplatform.explain.ExplanationParameters): + Optional. Parameters to configure explaining for Model's predictions. + Can be specified only if `generate_explanation` is set to `True`. + + This value overrides the value of `Model.explanation_parameters`. + All fields of `explanation_parameters` are optional in the request. If + a field of the `explanation_parameters` object is not populated, the + corresponding field of the `Model.explanation_parameters` object is inherited. + For more details, see `Ref docs <http://tinyurl.com/1an4zake>` + labels (Dict[str, str]): + Optional. The labels with user-defined metadata to organize your + BatchPredictionJobs. Label keys and values can be no longer than + 64 characters (Unicode codepoints), can only contain lowercase + letters, numeric characters, underscores and dashes. + International characters are allowed. See https://goo.gl/xmQnxf + for more information and examples of labels. + credentials (Optional[auth_credentials.Credentials]): + Custom credentials to use to create this batch prediction + job. Overrides credentials set in aiplatform.init. + encryption_spec_key_name (Optional[str]): + Optional. The Cloud KMS resource identifier of the customer + managed encryption key used to protect the job. Has the + form: + ``projects/my-project/locations/my-region/keyRings/my-kr/cryptoKeys/my-key``. + The key needs to be in the same region as where the compute + resource is created. + + If this is set, then all + resources created by the BatchPredictionJob will + be encrypted with the provided encryption key. + + Overrides encryption_spec_key_name set in aiplatform.init. + create_request_timeout (float): + Optional. The timeout for the create request in seconds. + batch_size (int): + Optional. The number of the records (e.g. instances) of the operation given in each batch + to a machine replica. Machine type, and size of a single record should be considered + when setting this parameter, higher value speeds up the batch operation's execution, + but too high value will result in a whole batch not fitting in a machine's memory, + and the whole operation will fail. + The default value is 64. + model_monitoring_objective_config (aiplatform.model_monitoring.ObjectiveConfig): + Optional. The objective config for model monitoring. Passing this parameter enables + monitoring on the model associated with this batch prediction job. + model_monitoring_alert_config (aiplatform.model_monitoring.EmailAlertConfig): + Optional. Configures how model monitoring alerts are sent to the user. Right now + only email alert is supported. + analysis_instance_schema_uri (str): + Optional. Only applicable if model_monitoring_objective_config is also passed. + This parameter specifies the YAML schema file uri describing the format of a single + instance that you want Tensorflow Data Validation (TFDV) to + analyze. If this field is empty, all the feature data types are + inferred from predict_instance_schema_uri, meaning that TFDV + will use the data in the exact format as prediction request/response. + If there are any data type differences between predict instance + and TFDV instance, this field can be used to override the schema. + For models trained with Vertex AI, this field must be set as all the + fields in predict instance formatted as string. + service_account (str): + Optional. Specifies the service account for workload run-as account. + Users submitting jobs must have act-as permission on this run-as account. + Returns: + (jobs.BatchPredictionJob): + Instantiated representation of the created batch prediction job. + """ + return cls._submit_impl( + job_display_name=job_display_name, + model_name=model_name, + instances_format=instances_format, + predictions_format=predictions_format, + gcs_source=gcs_source, + bigquery_source=bigquery_source, + gcs_destination_prefix=gcs_destination_prefix, + bigquery_destination_prefix=bigquery_destination_prefix, + model_parameters=model_parameters, + machine_type=machine_type, + accelerator_type=accelerator_type, + accelerator_count=accelerator_count, + starting_replica_count=starting_replica_count, + max_replica_count=max_replica_count, + generate_explanation=generate_explanation, + explanation_metadata=explanation_metadata, + explanation_parameters=explanation_parameters, + labels=labels, + project=project, + location=location, + credentials=credentials, + encryption_spec_key_name=encryption_spec_key_name, + create_request_timeout=create_request_timeout, + batch_size=batch_size, + model_monitoring_objective_config=model_monitoring_objective_config, + model_monitoring_alert_config=model_monitoring_alert_config, + analysis_instance_schema_uri=analysis_instance_schema_uri, + service_account=service_account, + # Main distinction of `create` vs `submit`: + wait_for_completion=False, + sync=True, + ) + + @classmethod + def _submit_impl( + cls, + , + job_display_name: Optional[str] = None, + model_name: Union[str, "aiplatform.Model"], + instances_format: str = "jsonl", + predictions_format: str = "jsonl", + gcs_source: Optional[Union[str, Sequence[str]]] = None, + bigquery_source: Optional[str] = None, + gcs_destination_prefix: Optional[str] = None, + bigquery_destination_prefix: Optional[str] = None, + model_parameters: Optional[Dict] = None, + machine_type: Optional[str] = None, + accelerator_type: Optional[str] = None, + accelerator_count: Optional[int] = None, + starting_replica_count: Optional[int] = None, + max_replica_count: Optional[int] = None, + generate_explanation: Optional[bool] = False, + explanation_metadata: Optional["aiplatform.explain.ExplanationMetadata"] = None, + explanation_parameters: Optional[ + "aiplatform.explain.ExplanationParameters" + ] = None, + labels: Optional[Dict[str, str]] = None, + project: Optional[str] = None, + location: Optional[str] = None, + credentials: Optional[auth_credentials.Credentials] = None, + encryption_spec_key_name: Optional[str] = None, + sync: bool = True, + create_request_timeout: Optional[float] = None, + batch_size: Optional[int] = None, + model_monitoring_objective_config: Optional[ + "aiplatform.model_monitoring.ObjectiveConfig" + ] = None, + model_monitoring_alert_config: Optional[ + "aiplatform.model_monitoring.AlertConfig" + ] = None, + analysis_instance_schema_uri: Optional[str] = None, + service_account: Optional[str] = None, + wait_for_completion: bool = False, + ) -> "BatchPredictionJob": + """Create a batch prediction job. + + Args: + job_display_name (str): + Required. The user-defined name of the BatchPredictionJob. + The name can be up to 128 characters long and can be consist + of any UTF-8 characters. + model_name (Union[str, aiplatform.Model]): + Required. A fully-qualified model resource name or model ID. + Example: "projects/123/locations/us-central1/models/456" or + "456" when project and location are initialized or passed. + May optionally contain a version ID or alias in + {model_name}@{version} form. + + Or an instance of aiplatform.Model. + instances_format (str): + Required. The format in which instances are provided. Must be one + of the formats listed in `Model.supported_input_storage_formats`. + Default is "jsonl" when using `gcs_source`. If a `bigquery_source` + is provided, this is overridden to "bigquery". + predictions_format (str): + Required. The format in which Vertex AI outputs the + predictions, must be one of the formats specified in + `Model.supported_output_storage_formats`. + Default is "jsonl" when using `gcs_destination_prefix`. If a + `bigquery_destination_prefix` is provided, this is overridden to + "bigquery". + gcs_source (Optional[Sequence[str]]): + Google Cloud Storage URI(-s) to your instances to run + batch prediction on. They must match `instances_format`. + + bigquery_source (Optional[str]): + BigQuery URI to a table, up to 2000 characters long. For example: + `bq://projectId.bqDatasetId.bqTableId` + gcs_destination_prefix (Optional[str]): + The Google Cloud Storage location of the directory where the + output is to be written to. In the given directory a new + directory is created. Its name is + ``prediction-<model-display-name>-<job-create-time>``, where + timestamp is in YYYY-MM-DDThh:mm:ss.sssZ ISO-8601 format. + Inside of it files ``predictions_0001.<extension>``, + ``predictions_0002.<extension>``, ..., + ``predictions_N.<extension>`` are created where + ``<extension>`` depends on chosen ``predictions_format``, + and N may equal 0001 and depends on the total number of + successfully predicted instances. If the Model has both + ``instance`` and ``prediction`` schemata defined then each such + file contains predictions as per the ``predictions_format``. + If prediction for any instance failed (partially or + completely), then an additional ``errors_0001.<extension>``, + ``errors_0002.<extension>``,..., ``errors_N.<extension>`` + files are created (N depends on total number of failed + predictions). These files contain the failed instances, as + per their schema, followed by an additional ``error`` field + which as value has ```google.rpc.Status`` <Status>`__ + containing only ``code`` and ``message`` fields. + bigquery_destination_prefix (Optional[str]): + The BigQuery project or dataset location where the output is + to be written to. If project is provided, a new dataset is + created with name + ``prediction_<model-display-name>_<job-create-time>`` where + is made BigQuery-dataset-name compatible (for example, most + special characters become underscores), and timestamp is in + YYYY_MM_DDThh_mm_ss_sssZ "based on ISO-8601" format. In the + dataset two tables will be created, ``predictions``, and + ``errors``. If the Model has both + [instance][google.cloud.aiplatform.v1.PredictSchemata.instance_schema_uri] + and + [prediction][google.cloud.aiplatform.v1.PredictSchemata.parameters_schema_uri] + schemata defined then the tables have columns as follows: + The ``predictions`` table contains instances for which the + prediction succeeded, it has columns as per a concatenation + of the Model's instance and prediction schemata. The + ``errors`` table contains rows for which the prediction has + failed, it has instance columns, as per the instance schema, + followed by a single "errors" column, which as values has + [google.rpc.Status][google.rpc.Status] represented as a + STRUCT, and containing only ``code`` and ``message``. + model_parameters (Optional[Dict]): + The parameters that govern the predictions. The schema of + the parameters may be specified via the Model's `parameters_schema_uri`. + machine_type (Optional[str]): + The type of machine for running batch prediction on + dedicated resources. Not specifying machine type will result in + batch prediction job being run with automatic resources. + accelerator_type (Optional[str]): + The type of accelerator(s) that may be attached + to the machine as per `accelerator_count`. Only used if + `machine_type` is set. + accelerator_count (Optional[int]): + The number of accelerators to attach to the + `machine_type`. Only used if `machine_type` is set. + starting_replica_count (Optional[int]): + The number of machine replicas used at the start of the batch + operation. If not set, Vertex AI decides starting number, not + greater than `max_replica_count`. Only used if `machine_type` is + set. + max_replica_count (Optional[int]): + The maximum number of machine replicas the batch operation may + be scaled to. Only used if `machine_type` is set. + Default is 10. + generate_explanation (bool): + Optional. Generate explanation along with the batch prediction + results. This will cause the batch prediction output to include + explanations based on the `prediction_format`: + - `bigquery`: output includes a column named `explanation`. The value + is a struct that conforms to the [aiplatform.gapic.Explanation] object. + - `jsonl`: The JSON objects on each line include an additional entry + keyed `explanation`. The value of the entry is a JSON object that + conforms to the [aiplatform.gapic.Explanation] object. + - `csv`: Generating explanations for CSV format is not supported. + explanation_metadata (aiplatform.explain.ExplanationMetadata): + Optional. Explanation metadata configuration for this BatchPredictionJob. + Can be specified only if `generate_explanation` is set to `True`. + + This value overrides the value of `Model.explanation_metadata`. + All fields of `explanation_metadata` are optional in the request. If + a field of the `explanation_metadata` object is not populated, the + corresponding field of the `Model.explanation_metadata` object is inherited. + For more details, see `Ref docs <http://tinyurl.com/1igh60kt>` + explanation_parameters (aiplatform.explain.ExplanationParameters): + Optional. Parameters to configure explaining for Model's predictions. + Can be specified only if `generate_explanation` is set to `True`. + + This value overrides the value of `Model.explanation_parameters`. + All fields of `explanation_parameters` are optional in the request. If + a field of the `explanation_parameters` object is not populated, the + corresponding field of the `Model.explanation_parameters` object is inherited. + For more details, see `Ref docs <http://tinyurl.com/1an4zake>` + labels (Dict[str, str]): + Optional. The labels with user-defined metadata to organize your + BatchPredictionJobs. Label keys and values can be no longer than + 64 characters (Unicode codepoints), can only contain lowercase + letters, numeric characters, underscores and dashes. + International characters are allowed. See https://goo.gl/xmQnxf + for more information and examples of labels. + credentials (Optional[auth_credentials.Credentials]): + Custom credentials to use to create this batch prediction + job. Overrides credentials set in aiplatform.init. + encryption_spec_key_name (Optional[str]): + Optional. The Cloud KMS resource identifier of the customer + managed encryption key used to protect the job. Has the + form: + ``projects/my-project/locations/my-region/keyRings/my-kr/cryptoKeys/my-key``. + The key needs to be in the same region as where the compute + resource is created. + + If this is set, then all + resources created by the BatchPredictionJob will + be encrypted with the provided encryption key. + + Overrides encryption_spec_key_name set in aiplatform.init. + sync (bool): + Whether to execute this method synchronously. If False, this method + will be executed in concurrent Future and any downstream object will + be immediately returned and synced when the Future has completed. + create_request_timeout (float): + Optional. The timeout for the create request in seconds. + batch_size (int): + Optional. The number of the records (e.g. instances) of the operation given in each batch + to a machine replica. Machine type, and size of a single record should be considered + when setting this parameter, higher value speeds up the batch operation's execution, + but too high value will result in a whole batch not fitting in a machine's memory, + and the whole operation will fail. + The default value is 64. + model_monitoring_objective_config (aiplatform.model_monitoring.ObjectiveConfig): + Optional. The objective config for model monitoring. Passing this parameter enables + monitoring on the model associated with this batch prediction job. + model_monitoring_alert_config (aiplatform.model_monitoring.EmailAlertConfig): + Optional. Configures how model monitoring alerts are sent to the user. Right now + only email alert is supported. + analysis_instance_schema_uri (str): + Optional. Only applicable if model_monitoring_objective_config is also passed. + This parameter specifies the YAML schema file uri describing the format of a single + instance that you want Tensorflow Data Validation (TFDV) to + analyze. If this field is empty, all the feature data types are + inferred from predict_instance_schema_uri, meaning that TFDV + will use the data in the exact format as prediction request/response. + If there are any data type differences between predict instance + and TFDV instance, this field can be used to override the schema. + For models trained with Vertex AI, this field must be set as all the + fields in predict instance formatted as string. + service_account (str): + Optional. Specifies the service account for workload run-as account. + Users submitting jobs must have act-as permission on this run-as account. + wait_for_completion (bool): + Whether to wait for the job completion. + Returns: + (jobs.BatchPredictionJob): + Instantiated representation of the created batch prediction job. + """ # TODO(b/242108750): remove temporary logic once model monitoring for batch prediction is GA if model_monitoring_objective_config: from google.cloud.aiplatform.compat.types import ( @@ -802,18 +1334,19 @@ def create( gapic_batch_prediction_job.model_monitoring_config = gapic_mm_config # TODO(b/242108750): remove temporary logic once model monitoring for batch prediction is GA - return cls._create( + return cls._submit_and_optionally_wait_with_sync_support( empty_batch_prediction_job=empty_batch_prediction_job, model_or_model_name=model_name, gca_batch_prediction_job=gapic_batch_prediction_job, generate_explanation=generate_explanation, sync=sync, create_request_timeout=create_request_timeout, + wait_for_completion=wait_for_completion, ) @classmethod @base.optional_sync(return_input_arg="empty_batch_prediction_job") - def _create( + def _submit_and_optionally_wait_with_sync_support( cls, empty_batch_prediction_job: "BatchPredictionJob", model_or_model_name: Union[str, "aiplatform.Model"], @@ -821,6 +1354,7 @@ def _create( generate_explanation: bool, sync: bool = True, create_request_timeout: Optional[float] = None, + wait_for_completion: bool = True, ) -> "BatchPredictionJob": """Create a batch prediction job. @@ -839,6 +1373,8 @@ def _create( results. create_request_timeout (float): Optional. The timeout for the create request in seconds. + wait_for_completion (bool): + Whether to wait for the job completion. Returns: (jobs.BatchPredictionJob): Instantiated representation of the created batch prediction job. @@ -882,8 +1418,8 @@ def _create( _LOGGER.info( "View Batch Prediction Job:\n%s" % batch_prediction_job._dashboard_uri() ) - - batch_prediction_job._block_until_complete() + if wait_for_completion: + batch_prediction_job._block_until_complete() return batch_prediction_job	diff --git a/tests/unit/aiplatform/test_jobs.py b/tests/unit/aiplatform/test_jobs.py index 7f1cd8288e..79f99ea7e0 100644 --- a/tests/unit/aiplatform/test_jobs.py +++ b/tests/unit/aiplatform/test_jobs.py @@ -877,6 +877,34 @@ def test_batch_predict_job_done_create(self, create_batch_prediction_job_mock): assert batch_prediction_job.done() is True + @mock.patch.object(jobs, "_JOB_WAIT_TIME", 1) + @mock.patch.object(jobs, "_LOG_WAIT_TIME", 1) + @pytest.mark.usefixtures("get_batch_prediction_job_mock") + def test_batch_predict_job_submit(self, create_batch_prediction_job_mock): + aiplatform.init(project=_TEST_PROJECT, location=_TEST_LOCATION) + + # Make SDK batch_predict method call + batch_prediction_job = jobs.BatchPredictionJob._submit_impl( + model_name=_TEST_MODEL_NAME, + job_display_name=_TEST_BATCH_PREDICTION_JOB_DISPLAY_NAME, + gcs_source=_TEST_BATCH_PREDICTION_GCS_SOURCE, + gcs_destination_prefix=_TEST_BATCH_PREDICTION_GCS_DEST_PREFIX, + service_account=_TEST_SERVICE_ACCOUNT, + ) + + batch_prediction_job.wait_for_resource_creation() + assert batch_prediction_job.done() is False + assert ( + batch_prediction_job.state + != jobs.gca_job_state.JobState.JOB_STATE_SUCCEEDED + ) + + batch_prediction_job.wait_for_completion() + assert ( + batch_prediction_job.state + == jobs.gca_job_state.JobState.JOB_STATE_SUCCEEDED + ) + @mock.patch.object(jobs, "_JOB_WAIT_TIME", 1) @mock.patch.object(jobs, "_LOG_WAIT_TIME", 1) @pytest.mark.parametrize("sync", [True, False])		[ { "components": [ { "doc": "Waits for job to complete.\n\nRaises:\n RuntimeError: If job failed or cancelled.", "lines": [ 255, 261 ], "name": "_Job.wait_for_completion", "signature": "def wait_for_completion(self) -> None:", "type": "...	[ "tests/unit/aiplatform/test_jobs.py::TestBatchPredictionJob::test_batch_predict_job_submit" ]	[ "tests/unit/aiplatform/test_jobs.py::TestJob::test_init_job_class", "tests/unit/aiplatform/test_jobs.py::TestJob::test_cancel_mock_job", "tests/unit/aiplatform/test_jobs.py::TestBatchPredictionJob::test_init_batch_prediction_job", "tests/unit/aiplatform/test_jobs.py::TestBatchPredictionJob::test_batch_predict...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat: Added the `BatchPredictionJob.submit` method - a non-blocking version of `BatchPredictionJob.create` feat: Added the `BatchPredictionJob.submit` method - a non-blocking version of `BatchPredictionJob.create` ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in google/cloud/aiplatform/jobs.py] (definition of _Job.wait_for_completion:) def wait_for_completion(self) -> None: """Waits for job to complete. Raises: RuntimeError: If job failed or cancelled.""" (definition of BatchPredictionJob.submit:) def submit( cls, , job_display_name: Optional[str] = None, model_name: Union[str, "aiplatform.Model"], instances_format: str = "jsonl", predictions_format: str = "jsonl", gcs_source: Optional[Union[str, Sequence[str]]] = None, bigquery_source: Optional[str] = None, gcs_destination_prefix: Optional[str] = None, bigquery_destination_prefix: Optional[str] = None, model_parameters: Optional[Dict] = None, machine_type: Optional[str] = None, accelerator_type: Optional[str] = None, accelerator_count: Optional[int] = None, starting_replica_count: Optional[int] = None, max_replica_count: Optional[int] = None, generate_explanation: Optional[bool] = False, explanation_metadata: Optional["aiplatform.explain.ExplanationMetadata"] = None, explanation_parameters: Optional[ "aiplatform.explain.ExplanationParameters" ] = None, labels: Optional[Dict[str, str]] = None, project: Optional[str] = None, location: Optional[str] = None, credentials: Optional[auth_credentials.Credentials] = None, encryption_spec_key_name: Optional[str] = None, create_request_timeout: Optional[float] = None, batch_size: Optional[int] = None, model_monitoring_objective_config: Optional[ "aiplatform.model_monitoring.ObjectiveConfig" ] = None, model_monitoring_alert_config: Optional[ "aiplatform.model_monitoring.AlertConfig" ] = None, analysis_instance_schema_uri: Optional[str] = None, service_account: Optional[str] = None, ) -> "BatchPredictionJob": """Sumbit a batch prediction job (not waiting for completion). Args: job_display_name (str): Required. The user-defined name of the BatchPredictionJob. The name can be up to 128 characters long and can be consist of any UTF-8 characters. model_name (Union[str, aiplatform.Model]): Required. A fully-qualified model resource name or model ID. Example: "projects/123/locations/us-central1/models/456" or "456" when project and location are initialized or passed. May optionally contain a version ID or alias in {model_name}@{version} form. Or an instance of aiplatform.Model. instances_format (str): Required. The format in which instances are provided. Must be one of the formats listed in `Model.supported_input_storage_formats`. Default is "jsonl" when using `gcs_source`. If a `bigquery_source` is provided, this is overridden to "bigquery". predictions_format (str): Required. The format in which Vertex AI outputs the predictions, must be one of the formats specified in `Model.supported_output_storage_formats`. Default is "jsonl" when using `gcs_destination_prefix`. If a `bigquery_destination_prefix` is provided, this is overridden to "bigquery". gcs_source (Optional[Sequence[str]]): Google Cloud Storage URI(-s) to your instances to run batch prediction on. They must match `instances_format`. bigquery_source (Optional[str]): BigQuery URI to a table, up to 2000 characters long. For example: `bq://projectId.bqDatasetId.bqTableId` gcs_destination_prefix (Optional[str]): The Google Cloud Storage location of the directory where the output is to be written to. In the given directory a new directory is created. Its name is ``prediction-<model-display-name>-<job-create-time>``, where timestamp is in YYYY-MM-DDThh:mm:ss.sssZ ISO-8601 format. Inside of it files ``predictions_0001.<extension>``, ``predictions_0002.<extension>``, ..., ``predictions_N.<extension>`` are created where ``<extension>`` depends on chosen ``predictions_format``, and N may equal 0001 and depends on the total number of successfully predicted instances. If the Model has both ``instance`` and ``prediction`` schemata defined then each such file contains predictions as per the ``predictions_format``. If prediction for any instance failed (partially or completely), then an additional ``errors_0001.<extension>``, ``errors_0002.<extension>``,..., ``errors_N.<extension>`` files are created (N depends on total number of failed predictions). These files contain the failed instances, as per their schema, followed by an additional ``error`` field which as value has ```google.rpc.Status`` <Status>`__ containing only ``code`` and ``message`` fields. bigquery_destination_prefix (Optional[str]): The BigQuery project or dataset location where the output is to be written to. If project is provided, a new dataset is created with name ``prediction_<model-display-name>_<job-create-time>`` where is made BigQuery-dataset-name compatible (for example, most special characters become underscores), and timestamp is in YYYY_MM_DDThh_mm_ss_sssZ "based on ISO-8601" format. In the dataset two tables will be created, ``predictions``, and ``errors``. If the Model has both [instance][google.cloud.aiplatform.v1.PredictSchemata.instance_schema_uri] and [prediction][google.cloud.aiplatform.v1.PredictSchemata.parameters_schema_uri] schemata defined then the tables have columns as follows: The ``predictions`` table contains instances for which the prediction succeeded, it has columns as per a concatenation of the Model's instance and prediction schemata. The ``errors`` table contains rows for which the prediction has failed, it has instance columns, as per the instance schema, followed by a single "errors" column, which as values has [google.rpc.Status][google.rpc.Status] represented as a STRUCT, and containing only ``code`` and ``message``. model_parameters (Optional[Dict]): The parameters that govern the predictions. The schema of the parameters may be specified via the Model's `parameters_schema_uri`. machine_type (Optional[str]): The type of machine for running batch prediction on dedicated resources. Not specifying machine type will result in batch prediction job being run with automatic resources. accelerator_type (Optional[str]): The type of accelerator(s) that may be attached to the machine as per `accelerator_count`. Only used if `machine_type` is set. accelerator_count (Optional[int]): The number of accelerators to attach to the `machine_type`. Only used if `machine_type` is set. starting_replica_count (Optional[int]): The number of machine replicas used at the start of the batch operation. If not set, Vertex AI decides starting number, not greater than `max_replica_count`. Only used if `machine_type` is set. max_replica_count (Optional[int]): The maximum number of machine replicas the batch operation may be scaled to. Only used if `machine_type` is set. Default is 10. generate_explanation (bool): Optional. Generate explanation along with the batch prediction results. This will cause the batch prediction output to include explanations based on the `prediction_format`: - `bigquery`: output includes a column named `explanation`. The value is a struct that conforms to the [aiplatform.gapic.Explanation] object. - `jsonl`: The JSON objects on each line include an additional entry keyed `explanation`. The value of the entry is a JSON object that conforms to the [aiplatform.gapic.Explanation] object. - `csv`: Generating explanations for CSV format is not supported. explanation_metadata (aiplatform.explain.ExplanationMetadata): Optional. Explanation metadata configuration for this BatchPredictionJob. Can be specified only if `generate_explanation` is set to `True`. This value overrides the value of `Model.explanation_metadata`. All fields of `explanation_metadata` are optional in the request. If a field of the `explanation_metadata` object is not populated, the corresponding field of the `Model.explanation_metadata` object is inherited. For more details, see `Ref docs <http://tinyurl.com/1igh60kt>` explanation_parameters (aiplatform.explain.ExplanationParameters): Optional. Parameters to configure explaining for Model's predictions. Can be specified only if `generate_explanation` is set to `True`. This value overrides the value of `Model.explanation_parameters`. All fields of `explanation_parameters` are optional in the request. If a field of the `explanation_parameters` object is not populated, the corresponding field of the `Model.explanation_parameters` object is inherited. For more details, see `Ref docs <http://tinyurl.com/1an4zake>` labels (Dict[str, str]): Optional. The labels with user-defined metadata to organize your BatchPredictionJobs. Label keys and values can be no longer than 64 characters (Unicode codepoints), can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. See https://goo.gl/xmQnxf for more information and examples of labels. credentials (Optional[auth_credentials.Credentials]): Custom credentials to use to create this batch prediction job. Overrides credentials set in aiplatform.init. encryption_spec_key_name (Optional[str]): Optional. The Cloud KMS resource identifier of the customer managed encryption key used to protect the job. Has the form: ``projects/my-project/locations/my-region/keyRings/my-kr/cryptoKeys/my-key``. The key needs to be in the same region as where the compute resource is created. If this is set, then all resources created by the BatchPredictionJob will be encrypted with the provided encryption key. Overrides encryption_spec_key_name set in aiplatform.init. create_request_timeout (float): Optional. The timeout for the create request in seconds. batch_size (int): Optional. The number of the records (e.g. instances) of the operation given in each batch to a machine replica. Machine type, and size of a single record should be considered when setting this parameter, higher value speeds up the batch operation's execution, but too high value will result in a whole batch not fitting in a machine's memory, and the whole operation will fail. The default value is 64. model_monitoring_objective_config (aiplatform.model_monitoring.ObjectiveConfig): Optional. The objective config for model monitoring. Passing this parameter enables monitoring on the model associated with this batch prediction job. model_monitoring_alert_config (aiplatform.model_monitoring.EmailAlertConfig): Optional. Configures how model monitoring alerts are sent to the user. Right now only email alert is supported. analysis_instance_schema_uri (str): Optional. Only applicable if model_monitoring_objective_config is also passed. This parameter specifies the YAML schema file uri describing the format of a single instance that you want Tensorflow Data Validation (TFDV) to analyze. If this field is empty, all the feature data types are inferred from predict_instance_schema_uri, meaning that TFDV will use the data in the exact format as prediction request/response. If there are any data type differences between predict instance and TFDV instance, this field can be used to override the schema. For models trained with Vertex AI, this field must be set as all the fields in predict instance formatted as string. service_account (str): Optional. Specifies the service account for workload run-as account. Users submitting jobs must have act-as permission on this run-as account. Returns: (jobs.BatchPredictionJob): Instantiated representation of the created batch prediction job.""" (definition of BatchPredictionJob._submit_impl:) def _submit_impl( cls, , job_display_name: Optional[str] = None, model_name: Union[str, "aiplatform.Model"], instances_format: str = "jsonl", predictions_format: str = "jsonl", gcs_source: Optional[Union[str, Sequence[str]]] = None, bigquery_source: Optional[str] = None, gcs_destination_prefix: Optional[str] = None, bigquery_destination_prefix: Optional[str] = None, model_parameters: Optional[Dict] = None, machine_type: Optional[str] = None, accelerator_type: Optional[str] = None, accelerator_count: Optional[int] = None, starting_replica_count: Optional[int] = None, max_replica_count: Optional[int] = None, generate_explanation: Optional[bool] = False, explanation_metadata: Optional["aiplatform.explain.ExplanationMetadata"] = None, explanation_parameters: Optional[ "aiplatform.explain.ExplanationParameters" ] = None, labels: Optional[Dict[str, str]] = None, project: Optional[str] = None, location: Optional[str] = None, credentials: Optional[auth_credentials.Credentials] = None, encryption_spec_key_name: Optional[str] = None, sync: bool = True, create_request_timeout: Optional[float] = None, batch_size: Optional[int] = None, model_monitoring_objective_config: Optional[ "aiplatform.model_monitoring.ObjectiveConfig" ] = None, model_monitoring_alert_config: Optional[ "aiplatform.model_monitoring.AlertConfig" ] = None, analysis_instance_schema_uri: Optional[str] = None, service_account: Optional[str] = None, wait_for_completion: bool = False, ) -> "BatchPredictionJob": """Create a batch prediction job. Args: job_display_name (str): Required. The user-defined name of the BatchPredictionJob. The name can be up to 128 characters long and can be consist of any UTF-8 characters. model_name (Union[str, aiplatform.Model]): Required. A fully-qualified model resource name or model ID. Example: "projects/123/locations/us-central1/models/456" or "456" when project and location are initialized or passed. May optionally contain a version ID or alias in {model_name}@{version} form. Or an instance of aiplatform.Model. instances_format (str): Required. The format in which instances are provided. Must be one of the formats listed in `Model.supported_input_storage_formats`. Default is "jsonl" when using `gcs_source`. If a `bigquery_source` is provided, this is overridden to "bigquery". predictions_format (str): Required. The format in which Vertex AI outputs the predictions, must be one of the formats specified in `Model.supported_output_storage_formats`. Default is "jsonl" when using `gcs_destination_prefix`. If a `bigquery_destination_prefix` is provided, this is overridden to "bigquery". gcs_source (Optional[Sequence[str]]): Google Cloud Storage URI(-s) to your instances to run batch prediction on. They must match `instances_format`. bigquery_source (Optional[str]): BigQuery URI to a table, up to 2000 characters long. For example: `bq://projectId.bqDatasetId.bqTableId` gcs_destination_prefix (Optional[str]): The Google Cloud Storage location of the directory where the output is to be written to. In the given directory a new directory is created. Its name is ``prediction-<model-display-name>-<job-create-time>``, where timestamp is in YYYY-MM-DDThh:mm:ss.sssZ ISO-8601 format. Inside of it files ``predictions_0001.<extension>``, ``predictions_0002.<extension>``, ..., ``predictions_N.<extension>`` are created where ``<extension>`` depends on chosen ``predictions_format``, and N may equal 0001 and depends on the total number of successfully predicted instances. If the Model has both ``instance`` and ``prediction`` schemata defined then each such file contains predictions as per the ``predictions_format``. If prediction for any instance failed (partially or completely), then an additional ``errors_0001.<extension>``, ``errors_0002.<extension>``,..., ``errors_N.<extension>`` files are created (N depends on total number of failed predictions). These files contain the failed instances, as per their schema, followed by an additional ``error`` field which as value has ```google.rpc.Status`` <Status>`__ containing only ``code`` and ``message`` fields. bigquery_destination_prefix (Optional[str]): The BigQuery project or dataset location where the output is to be written to. If project is provided, a new dataset is created with name ``prediction_<model-display-name>_<job-create-time>`` where is made BigQuery-dataset-name compatible (for example, most special characters become underscores), and timestamp is in YYYY_MM_DDThh_mm_ss_sssZ "based on ISO-8601" format. In the dataset two tables will be created, ``predictions``, and ``errors``. If the Model has both [instance][google.cloud.aiplatform.v1.PredictSchemata.instance_schema_uri] and [prediction][google.cloud.aiplatform.v1.PredictSchemata.parameters_schema_uri] schemata defined then the tables have columns as follows: The ``predictions`` table contains instances for which the prediction succeeded, it has columns as per a concatenation of the Model's instance and prediction schemata. The ``errors`` table contains rows for which the prediction has failed, it has instance columns, as per the instance schema, followed by a single "errors" column, which as values has [google.rpc.Status][google.rpc.Status] represented as a STRUCT, and containing only ``code`` and ``message``. model_parameters (Optional[Dict]): The parameters that govern the predictions. The schema of the parameters may be specified via the Model's `parameters_schema_uri`. machine_type (Optional[str]): The type of machine for running batch prediction on dedicated resources. Not specifying machine type will result in batch prediction job being run with automatic resources. accelerator_type (Optional[str]): The type of accelerator(s) that may be attached to the machine as per `accelerator_count`. Only used if `machine_type` is set. accelerator_count (Optional[int]): The number of accelerators to attach to the `machine_type`. Only used if `machine_type` is set. starting_replica_count (Optional[int]): The number of machine replicas used at the start of the batch operation. If not set, Vertex AI decides starting number, not greater than `max_replica_count`. Only used if `machine_type` is set. max_replica_count (Optional[int]): The maximum number of machine replicas the batch operation may be scaled to. Only used if `machine_type` is set. Default is 10. generate_explanation (bool): Optional. Generate explanation along with the batch prediction results. This will cause the batch prediction output to include explanations based on the `prediction_format`: - `bigquery`: output includes a column named `explanation`. The value is a struct that conforms to the [aiplatform.gapic.Explanation] object. - `jsonl`: The JSON objects on each line include an additional entry keyed `explanation`. The value of the entry is a JSON object that conforms to the [aiplatform.gapic.Explanation] object. - `csv`: Generating explanations for CSV format is not supported. explanation_metadata (aiplatform.explain.ExplanationMetadata): Optional. Explanation metadata configuration for this BatchPredictionJob. Can be specified only if `generate_explanation` is set to `True`. This value overrides the value of `Model.explanation_metadata`. All fields of `explanation_metadata` are optional in the request. If a field of the `explanation_metadata` object is not populated, the corresponding field of the `Model.explanation_metadata` object is inherited. For more details, see `Ref docs <http://tinyurl.com/1igh60kt>` explanation_parameters (aiplatform.explain.ExplanationParameters): Optional. Parameters to configure explaining for Model's predictions. Can be specified only if `generate_explanation` is set to `True`. This value overrides the value of `Model.explanation_parameters`. All fields of `explanation_parameters` are optional in the request. If a field of the `explanation_parameters` object is not populated, the corresponding field of the `Model.explanation_parameters` object is inherited. For more details, see `Ref docs <http://tinyurl.com/1an4zake>` labels (Dict[str, str]): Optional. The labels with user-defined metadata to organize your BatchPredictionJobs. Label keys and values can be no longer than 64 characters (Unicode codepoints), can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. See https://goo.gl/xmQnxf for more information and examples of labels. credentials (Optional[auth_credentials.Credentials]): Custom credentials to use to create this batch prediction job. Overrides credentials set in aiplatform.init. encryption_spec_key_name (Optional[str]): Optional. The Cloud KMS resource identifier of the customer managed encryption key used to protect the job. Has the form: ``projects/my-project/locations/my-region/keyRings/my-kr/cryptoKeys/my-key``. The key needs to be in the same region as where the compute resource is created. If this is set, then all resources created by the BatchPredictionJob will be encrypted with the provided encryption key. Overrides encryption_spec_key_name set in aiplatform.init. sync (bool): Whether to execute this method synchronously. If False, this method will be executed in concurrent Future and any downstream object will be immediately returned and synced when the Future has completed. create_request_timeout (float): Optional. The timeout for the create request in seconds. batch_size (int): Optional. The number of the records (e.g. instances) of the operation given in each batch to a machine replica. Machine type, and size of a single record should be considered when setting this parameter, higher value speeds up the batch operation's execution, but too high value will result in a whole batch not fitting in a machine's memory, and the whole operation will fail. The default value is 64. model_monitoring_objective_config (aiplatform.model_monitoring.ObjectiveConfig): Optional. The objective config for model monitoring. Passing this parameter enables monitoring on the model associated with this batch prediction job. model_monitoring_alert_config (aiplatform.model_monitoring.EmailAlertConfig): Optional. Configures how model monitoring alerts are sent to the user. Right now only email alert is supported. analysis_instance_schema_uri (str): Optional. Only applicable if model_monitoring_objective_config is also passed. This parameter specifies the YAML schema file uri describing the format of a single instance that you want Tensorflow Data Validation (TFDV) to analyze. If this field is empty, all the feature data types are inferred from predict_instance_schema_uri, meaning that TFDV will use the data in the exact format as prediction request/response. If there are any data type differences between predict instance and TFDV instance, this field can be used to override the schema. For models trained with Vertex AI, this field must be set as all the fields in predict instance formatted as string. service_account (str): Optional. Specifies the service account for workload run-as account. Users submitting jobs must have act-as permission on this run-as account. wait_for_completion (bool): Whether to wait for the job completion. Returns: (jobs.BatchPredictionJob): Instantiated representation of the created batch prediction job.""" (definition of BatchPredictionJob._submit_and_optionally_wait_with_sync_support:) def _submit_and_optionally_wait_with_sync_support( cls, empty_batch_prediction_job: "BatchPredictionJob", model_or_model_name: Union[str, "aiplatform.Model"], gca_batch_prediction_job: gca_bp_job_compat.BatchPredictionJob, generate_explanation: bool, sync: bool = True, create_request_timeout: Optional[float] = None, wait_for_completion: bool = True, ) -> "BatchPredictionJob": """Create a batch prediction job. Args: empty_batch_prediction_job (BatchPredictionJob): Required. BatchPredictionJob without _gca_resource populated. model_or_model_name (Union[str, aiplatform.Model]): Required. Required. A fully-qualified model resource name or an instance of aiplatform.Model. If a resource name, it may optionally contain a version ID or alias in {model_name}@{version} form. gca_batch_prediction_job (gca_bp_job.BatchPredictionJob): Required. a batch prediction job proto for creating a batch prediction job on Vertex AI. generate_explanation (bool): Required. Generate explanation along with the batch prediction results. create_request_timeout (float): Optional. The timeout for the create request in seconds. wait_for_completion (bool): Whether to wait for the job completion. Returns: (jobs.BatchPredictionJob): Instantiated representation of the created batch prediction job. Raises: ValueError: If no or multiple source or destinations are provided. Also, if provided instances_format or predictions_format are not supported by Vertex AI.""" [end of new definitions in google/cloud/aiplatform/jobs.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		67358fa6a830eb842f6b52d09061af4a41b54af6
conan-io__conan-15270	15,270	conan-io/conan	null	98d68db7f3a7d6eec4dc463a24839af542fb70cc	2023-12-13T22:43:40Z	diff --git a/conan/cli/commands/graph.py b/conan/cli/commands/graph.py index d9c773a00f5..d8babfefa96 100644 --- a/conan/cli/commands/graph.py +++ b/conan/cli/commands/graph.py @@ -56,6 +56,8 @@ def graph_build_order(conan_api, parser, subparser, args): Compute the build order of a dependency graph. """ common_graph_args(subparser) + subparser.add_argument("--order", choices=['recipe', 'configuration'], default="recipe", + help='Select which order method') args = parser.parse_args(args) # parameter validation @@ -93,7 +95,7 @@ def graph_build_order(conan_api, parser, subparser, args): out = ConanOutput() out.title("Computing the build order") - install_graph = InstallGraph(deps_graph) + install_graph = InstallGraph(deps_graph, order=args.order) install_order_serialized = install_graph.install_build_order() lockfile = conan_api.lockfile.update_lockfile(lockfile, deps_graph, args.lockfile_packages, @@ -110,11 +112,12 @@ def graph_build_order_merge(conan_api, parser, subparser, args): """ subparser.add_argument("--file", nargs="?", action="append", help="Files to be merged") args = parser.parse_args(*args) + if not args.file or len(args.file) < 2: + raise ConanException("At least 2 files are needed to be merged") - result = InstallGraph() - for f in args.file: - f = make_abs_path(f) - install_graph = InstallGraph.load(f) + result = InstallGraph.load(make_abs_path(args.file[0])) + for f in args.file[1:]: + install_graph = InstallGraph.load(make_abs_path(f)) result.merge(install_graph) install_order_serialized = result.install_build_order() diff --git a/conans/client/graph/install_graph.py b/conans/client/graph/install_graph.py index ab39d8dc283..e34c525bf03 100644 --- a/conans/client/graph/install_graph.py +++ b/conans/client/graph/install_graph.py @@ -193,13 +193,123 @@ def deserialize(data, filename): return result +class _InstallConfiguration: + """ Represents a single, unique PackageReference to be downloaded, built, etc. + Same PREF should only be built or downloaded once, but it is possible to have multiple + nodes in the DepsGraph that share the same PREF. + PREF could have PREV if to be downloaded (must be the same for all), but won't if to be built + """ + def __init__(self): + self.ref = None + self.package_id = None + self.prev = None + self.nodes = [] # GraphNode + self.binary = None # The action BINARY_DOWNLOAD, etc must be the same for all nodes + self.context = None # Same PREF could be in both contexts, but only 1 context is enough to + # be able to reproduce, typically host preferrably + self.options = [] # to be able to fire a build, the options will be necessary + self.filenames = [] # The build_order.json filenames e.g. "windows_build_order" + self.depends = [] # List of full prefs + self.overrides = Overrides() + + @property + def pref(self): + return PkgReference(self.ref, self.package_id, self.prev) + + @property + def conanfile(self): + return self.nodes[0].conanfile + + @staticmethod + def create(node): + result = _InstallConfiguration() + result.ref = node.ref + result.package_id = node.pref.package_id + result.prev = node.pref.revision + result.binary = node.binary + result.context = node.context + # self_options are the minimum to reproduce state + result.options = node.conanfile.self_options.dumps().splitlines() + result.overrides = node.overrides() + + result.nodes.append(node) + for dep in node.dependencies: + if dep.dst.binary != BINARY_SKIP: + if dep.dst.pref not in result.depends: + result.depends.append(dep.dst.pref) + return result + + def add(self, node): + assert self.package_id == node.package_id, f"{self.pref}!={node.pref}" + assert self.binary == node.binary, f"Binary for {node}: {self.binary}!={node.binary}" + assert self.prev == node.prev + # The context might vary, but if same package_id, all fine + # assert self.context == node.context + self.nodes.append(node) + + for dep in node.dependencies: + if dep.dst.binary != BINARY_SKIP: + if dep.dst.pref not in self.depends: + self.depends.append(dep.dst.pref) + + def _build_args(self): + if self.binary != BINARY_BUILD: + return None + cmd = f"--require={self.ref}" if self.context == "host" else f"--tool-require={self.ref}" + cmd += f" --build={self.ref}" + if self.options: + cmd += " " + " ".join(f"-o {o}" for o in self.options) + if self.overrides: + cmd += f' --lockfile-overrides="{self.overrides}"' + return cmd + + def serialize(self): + return {"ref": self.ref.repr_notime(), + "pref": self.pref.repr_notime(), + "package_id": self.pref.package_id, + "prev": self.pref.revision, + "context": self.context, + "binary": self.binary, + "options": self.options, + "filenames": self.filenames, + "depends": [d.repr_notime() for d in self.depends], + "overrides": self.overrides.serialize(), + "build_args": self._build_args() + } + + @staticmethod + def deserialize(data, filename): + result = _InstallConfiguration() + result.ref = RecipeReference.loads(data["ref"]) + result.package_id = data["package_id"] + result.prev = data["prev"] + result.binary = data["binary"] + result.context = data["context"] + result.options = data["options"] + result.filenames = data["filenames"] or [filename] + result.depends = [PkgReference.loads(p) for p in data["depends"]] + result.overrides = Overrides.deserialize(data["overrides"]) + return result + + def merge(self, other): + assert self.ref == other.ref + for d in other.depends: + if d not in self.depends: + self.depends.append(d) + + for d in other.filenames: + if d not in self.filenames: + self.filenames.append(d) + + class InstallGraph: """ A graph containing the package references in order to be built/downloaded """ - def __init__(self, deps_graph=None): + def __init__(self, deps_graph, order="recipe"): self._nodes = {} # ref with rev: _InstallGraphNode - + self._order = order + self._node_cls = _InstallRecipeReference if order == "recipe" else _InstallConfiguration self._is_test_package = False if deps_graph is not None: self._initialize_deps_graph(deps_graph) @@ -217,6 +327,8 @@ def merge(self, other): """ @type other: InstallGraph """ + if self._order != other._order: + raise ConanException(f"Cannot merge build-orders of `{self._order}!={other._order}") for ref, install_node in other._nodes.items(): existing = self._nodes.get(ref) if existing is None: @@ -226,11 +338,17 @@ def merge(self, other): @staticmethod def deserialize(data, filename): - result = InstallGraph() + # Automatic deduction of the order based on the data + try: + order = "recipe" if "packages" in data[0][0] else "configuration" + except IndexError: + order = "recipe" + result = InstallGraph(None, order=order) for level in data: for item in level: - elem = _InstallRecipeReference.deserialize(item, filename) - result._nodes[elem.ref] = elem + elem = result._node_cls.deserialize(item, filename) + key = elem.ref if order == "recipe" else elem.pref + result._nodes[key] = elem return result def _initialize_deps_graph(self, deps_graph): @@ -238,9 +356,10 @@ def _initialize_deps_graph(self, deps_graph): if node.recipe in (RECIPE_CONSUMER, RECIPE_VIRTUAL) or node.binary == BINARY_SKIP: continue - existing = self._nodes.get(node.ref) + key = node.ref if self._order == "recipe" else node.pref + existing = self._nodes.get(key) if existing is None: - self._nodes[node.ref] = _InstallRecipeReference.create(node) + self._nodes[key] = self._node_cls.create(node) else: existing.add(node)	diff --git a/conans/test/integration/command_v2/test_info_build_order.py b/conans/test/integration/command_v2/test_info_build_order.py index 6e9354b057e..3f484445761 100644 --- a/conans/test/integration/command_v2/test_info_build_order.py +++ b/conans/test/integration/command_v2/test_info_build_order.py @@ -62,6 +62,55 @@ def test_info_build_order(): assert bo_json == result +def test_info_build_order_configuration(): + c = TestClient() + c.save({"dep/conanfile.py": GenConanfile(), + "pkg/conanfile.py": GenConanfile().with_requires("dep/0.1"), + "consumer/conanfile.txt": "[requires]\npkg/0.1"}) + c.run("export dep --name=dep --version=0.1") + c.run("export pkg --name=pkg --version=0.1") + c.run("graph build-order consumer --build=missing --order=configuration --format=json") + bo_json = json.loads(c.stdout) + + result = [ + [ + { + "ref": "dep/0.1#4d670581ccb765839f2239cc8dff8fbd", + "pref": "dep/0.1#4d670581ccb765839f2239cc8dff8fbd:da39a3ee5e6b4b0d3255bfef95601890afd80709", + "depends": [], + "package_id": "da39a3ee5e6b4b0d3255bfef95601890afd80709", + 'prev': None, + 'filenames': [], + "context": "host", + "binary": "Build", + 'build_args': '--require=dep/0.1 --build=dep/0.1', + "options": [], + "overrides": {} + } + ], + [ + { + "ref": "pkg/0.1#1ac8dd17c0f9f420935abd3b6a8fa032", + "pref": "pkg/0.1#1ac8dd17c0f9f420935abd3b6a8fa032:59205ba5b14b8f4ebc216a6c51a89553021e82c1", + "depends": [ + "dep/0.1#4d670581ccb765839f2239cc8dff8fbd:da39a3ee5e6b4b0d3255bfef95601890afd80709" + ], + "package_id": "59205ba5b14b8f4ebc216a6c51a89553021e82c1", + 'prev': None, + 'filenames': [], + "context": "host", + "binary": "Build", + 'build_args': '--require=pkg/0.1 --build=pkg/0.1', + "options": [], + "overrides": {} + + } + ] + ] + + assert bo_json == result + + def test_info_build_order_build_require(): c = TestClient() c.save({"dep/conanfile.py": GenConanfile(), @@ -252,6 +301,83 @@ def test_info_build_order_merge_multi_product(): assert bo_json == result +def test_info_build_order_merge_multi_product_configurations(): + c = TestClient() + c.save({"dep/conanfile.py": GenConanfile(), + "pkg/conanfile.py": GenConanfile().with_requires("dep/0.1"), + "consumer1/conanfile.txt": "[requires]\npkg/0.1", + "consumer2/conanfile.txt": "[requires]\npkg/0.2"}) + c.run("export dep --name=dep --version=0.1") + c.run("export pkg --name=pkg --version=0.1") + c.run("export pkg --name=pkg --version=0.2") + c.run("graph build-order consumer1 --build=missing --order=configuration --format=json", + redirect_stdout="bo1.json") + c.run("graph build-order consumer2 --build=missing --order=configuration --format=json", + redirect_stdout="bo2.json") + c.run("graph build-order-merge --file=bo1.json --file=bo2.json --format=json", + redirect_stdout="bo3.json") + + bo_json = json.loads(c.load("bo3.json")) + result = [ + [ + { + "ref": "dep/0.1#4d670581ccb765839f2239cc8dff8fbd", + "pref": "dep/0.1#4d670581ccb765839f2239cc8dff8fbd:da39a3ee5e6b4b0d3255bfef95601890afd80709", + "package_id": "da39a3ee5e6b4b0d3255bfef95601890afd80709", + "prev": None, + "context": "host", + "binary": "Build", + "options": [], + "filenames": [ + "bo1", + "bo2" + ], + "depends": [], + "overrides": {}, + "build_args": "--require=dep/0.1 --build=dep/0.1" + } + ], + [ + { + "ref": "pkg/0.1#1ac8dd17c0f9f420935abd3b6a8fa032", + "pref": "pkg/0.1#1ac8dd17c0f9f420935abd3b6a8fa032:59205ba5b14b8f4ebc216a6c51a89553021e82c1", + "package_id": "59205ba5b14b8f4ebc216a6c51a89553021e82c1", + "prev": None, + "context": "host", + "binary": "Build", + "options": [], + "filenames": [ + "bo1" + ], + "depends": [ + "dep/0.1#4d670581ccb765839f2239cc8dff8fbd:da39a3ee5e6b4b0d3255bfef95601890afd80709" + ], + "overrides": {}, + "build_args": "--require=pkg/0.1 --build=pkg/0.1" + }, + { + "ref": "pkg/0.2#1ac8dd17c0f9f420935abd3b6a8fa032", + "pref": "pkg/0.2#1ac8dd17c0f9f420935abd3b6a8fa032:59205ba5b14b8f4ebc216a6c51a89553021e82c1", + "package_id": "59205ba5b14b8f4ebc216a6c51a89553021e82c1", + "prev": None, + "context": "host", + "binary": "Build", + "options": [], + "filenames": [ + "bo2" + ], + "depends": [ + "dep/0.1#4d670581ccb765839f2239cc8dff8fbd:da39a3ee5e6b4b0d3255bfef95601890afd80709" + ], + "overrides": {}, + "build_args": "--require=pkg/0.2 --build=pkg/0.2" + } + ] + ] + + assert bo_json == result + + def test_info_build_order_merge_conditionals(): c = TestClient() conanfile = textwrap.dedent("""		[ { "components": [ { "doc": "Represents a single, unique PackageReference to be downloaded, built, etc.\nSame PREF should only be built or downloaded once, but it is possible to have multiple\nnodes in the DepsGraph that share the same PREF.\nPREF could have PREV if to be downloaded (must be the sa...	[ "conans/test/integration/command_v2/test_info_build_order.py::test_info_build_order_configuration", "conans/test/integration/command_v2/test_info_build_order.py::test_info_build_order_merge_multi_product_configurations" ]	[ "conans/test/integration/command_v2/test_info_build_order.py::test_info_build_order", "conans/test/integration/command_v2/test_info_build_order.py::test_info_build_order_build_require", "conans/test/integration/command_v2/test_info_build_order.py::test_info_build_order_options", "conans/test/integration/comma...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> graph build-order --order=configuration Changelog: Feature: New ``conan graph build-order --order=configuration`` to output a different order, sorted by package binaries/configurations, not grouped by recipe revisions. Docs: https://github.com/conan-io/docs/pull/3552 Close https://github.com/conan-io/conan/issues/15254 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conans/client/graph/install_graph.py] (definition of _InstallConfiguration:) class _InstallConfiguration: """Represents a single, unique PackageReference to be downloaded, built, etc. Same PREF should only be built or downloaded once, but it is possible to have multiple nodes in the DepsGraph that share the same PREF. PREF could have PREV if to be downloaded (must be the same for all), but won't if to be built""" (definition of _InstallConfiguration.__init__:) def __init__(self): (definition of _InstallConfiguration.pref:) def pref(self): (definition of _InstallConfiguration.conanfile:) def conanfile(self): (definition of _InstallConfiguration.create:) def create(node): (definition of _InstallConfiguration.add:) def add(self, node): (definition of _InstallConfiguration._build_args:) def _build_args(self): (definition of _InstallConfiguration.serialize:) def serialize(self): (definition of _InstallConfiguration.deserialize:) def deserialize(data, filename): (definition of _InstallConfiguration.merge:) def merge(self, other): [end of new definitions in conans/client/graph/install_graph.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		4a5b19a75db9225316c8cb022a2dfb9705a2af34
Project-MONAI__MONAI-7308	7,308	Project-MONAI/MONAI	null	c64993431198774ef896f525bad0fd6cc932e788	2023-12-11T06:23:04Z	diff --git a/docs/source/losses.rst b/docs/source/losses.rst index 61dd959807..ba794af3eb 100644 --- a/docs/source/losses.rst +++ b/docs/source/losses.rst @@ -139,6 +139,11 @@ Reconstruction Losses .. autoclass:: JukeboxLoss :members: +`SURELoss` +~~~~~~~~~~ +.. autoclass:: SURELoss + :members: + Loss Wrappers ------------- diff --git a/docs/source/networks.rst b/docs/source/networks.rst index 8eada7933f..b59c8af5fc 100644 --- a/docs/source/networks.rst +++ b/docs/source/networks.rst @@ -408,6 +408,11 @@ Layers .. autoclass:: LLTM :members: +`ConjugateGradient` +~~~~~~~~~~~~~~~~~~~ +.. autoclass:: ConjugateGradient + :members: + `Utilities` ~~~~~~~~~~~ .. automodule:: monai.networks.layers.convutils diff --git a/monai/losses/__init__.py b/monai/losses/__init__.py index 4ebedb2084..e937b53fa4 100644 --- a/monai/losses/__init__.py +++ b/monai/losses/__init__.py @@ -41,5 +41,6 @@ from .spatial_mask import MaskedLoss from .spectral_loss import JukeboxLoss from .ssim_loss import SSIMLoss +from .sure_loss import SURELoss from .tversky import TverskyLoss from .unified_focal_loss import AsymmetricUnifiedFocalLoss diff --git a/monai/losses/sure_loss.py b/monai/losses/sure_loss.py new file mode 100644 index 0000000000..ebf25613a6 --- /dev/null +++ b/monai/losses/sure_loss.py @@ -0,0 +1,200 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import annotations + +from typing import Callable, Optional + +import torch +import torch.nn as nn +from torch.nn.modules.loss import _Loss + + +def complex_diff_abs_loss(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: + """ + First compute the difference in the complex domain, + then get the absolute value and take the mse + + Args: + x, y - B, 2, H, W real valued tensors representing complex numbers + or B,1,H,W complex valued tensors + Returns: + l2_loss - scalar + """ + if not x.is_complex(): + x = torch.view_as_complex(x.permute(0, 2, 3, 1).contiguous()) + if not y.is_complex(): + y = torch.view_as_complex(y.permute(0, 2, 3, 1).contiguous()) + + diff = torch.abs(x - y) + return nn.functional.mse_loss(diff, torch.zeros_like(diff), reduction="mean") + + +def sure_loss_function( + operator: Callable, + x: torch.Tensor, + y_pseudo_gt: torch.Tensor, + y_ref: Optional[torch.Tensor] = None, + eps: Optional[float] = -1.0, + perturb_noise: Optional[torch.Tensor] = None, + complex_input: Optional[bool] = False, +) -> torch.Tensor: + """ + Args: + operator (function): The operator function that takes in an input + tensor x and returns an output tensor y. We will use this to compute + the divergence. More specifically, we will perturb the input x by a + small amount and compute the divergence between the perturbed output + and the reference output + + x (torch.Tensor): The input tensor of shape (B, C, H, W) to the + operator. For complex input, the shape is (B, 2, H, W) aka C=2 real. + For real input, the shape is (B, 1, H, W) real. + + y_pseudo_gt (torch.Tensor): The pseudo ground truth tensor of shape + (B, C, H, W) used to compute the L2 loss. For complex input, the shape is + (B, 2, H, W) aka C=2 real. For real input, the shape is (B, 1, H, W) + real. + + y_ref (torch.Tensor, optional): The reference output tensor of shape + (B, C, H, W) used to compute the divergence. Defaults to None. For + complex input, the shape is (B, 2, H, W) aka C=2 real. For real input, + the shape is (B, 1, H, W) real. + + eps (float, optional): The perturbation scalar. Set to -1 to set it + automatically estimated based on y_pseudo_gtk + + perturb_noise (torch.Tensor, optional): The noise vector of shape (B, C, H, W). + Defaults to None. For complex input, the shape is (B, 2, H, W) aka C=2 real. + For real input, the shape is (B, 1, H, W) real. + + complex_input(bool, optional): Whether the input is complex or not. + Defaults to False. + + Returns: + sure_loss (torch.Tensor): The SURE loss scalar. + """ + # perturb input + if perturb_noise is None: + perturb_noise = torch.randn_like(x) + if eps == -1.0: + eps = float(torch.abs(y_pseudo_gt.max())) / 1000 + # get y_ref if not provided + if y_ref is None: + y_ref = operator(x) + + # get perturbed output + x_perturbed = x + eps * perturb_noise + y_perturbed = operator(x_perturbed) + # divergence + divergence = torch.sum(1.0 / eps * torch.matmul(perturb_noise.permute(0, 1, 3, 2), y_perturbed - y_ref)) # type: ignore + # l2 loss between y_ref, y_pseudo_gt + if complex_input: + l2_loss = complex_diff_abs_loss(y_ref, y_pseudo_gt) + else: + # real input + l2_loss = nn.functional.mse_loss(y_ref, y_pseudo_gt, reduction="mean") + + # sure loss + sure_loss = l2_loss * divergence / (x.shape[0] * x.shape[2] * x.shape[3]) + return sure_loss + + +class SURELoss(_Loss): + """ + Calculate the Stein's Unbiased Risk Estimator (SURE) loss for a given operator. + + This is a differentiable loss function that can be used to train/guide an + operator (e.g. neural network), where the pseudo ground truth is available + but the reference ground truth is not. For example, in the MRI + reconstruction, the pseudo ground truth is the zero-filled reconstruction + and the reference ground truth is the fully sampled reconstruction. Often, + the reference ground truth is not available due to the lack of fully sampled + data. + + The original SURE loss is proposed in [1]. The SURE loss used for guiding + the diffusion model based MRI reconstruction is proposed in [2]. + + Reference + + [1] Stein, C.M.: Estimation of the mean of a multivariate normal distribution. Annals of Statistics + + [2] B. Ozturkler et al. SMRD: SURE-based Robust MRI Reconstruction with Diffusion Models. + (https://arxiv.org/pdf/2310.01799.pdf) + """ + + def __init__(self, perturb_noise: Optional[torch.Tensor] = None, eps: Optional[float] = None) -> None: + """ + Args: + perturb_noise (torch.Tensor, optional): The noise vector of shape + (B, C, H, W). Defaults to None. For complex input, the shape is (B, 2, H, W) aka C=2 real. + For real input, the shape is (B, 1, H, W) real. + + eps (float, optional): The perturbation scalar. Defaults to None. + """ + super().__init__() + self.perturb_noise = perturb_noise + self.eps = eps + + def forward( + self, + operator: Callable, + x: torch.Tensor, + y_pseudo_gt: torch.Tensor, + y_ref: Optional[torch.Tensor] = None, + complex_input: Optional[bool] = False, + ) -> torch.Tensor: + """ + Args: + operator (function): The operator function that takes in an input + tensor x and returns an output tensor y. We will use this to compute + the divergence. More specifically, we will perturb the input x by a + small amount and compute the divergence between the perturbed output + and the reference output + + x (torch.Tensor): The input tensor of shape (B, C, H, W) to the + operator. C=1 or 2: For complex input, the shape is (B, 2, H, W) aka + C=2 real. For real input, the shape is (B, 1, H, W) real. + + y_pseudo_gt (torch.Tensor): The pseudo ground truth tensor of shape + (B, C, H, W) used to compute the L2 loss. C=1 or 2: For complex + input, the shape is (B, 2, H, W) aka C=2 real. For real input, the + shape is (B, 1, H, W) real. + + y_ref (torch.Tensor, optional): The reference output tensor of the + same shape as y_pseudo_gt + + Returns: + sure_loss (torch.Tensor): The SURE loss scalar. + """ + + # check inputs shapes + if x.dim() != 4: + raise ValueError(f"Input tensor x should be 4D, got {x.dim()}.") + if y_pseudo_gt.dim() != 4: + raise ValueError(f"Input tensor y_pseudo_gt should be 4D, but got {y_pseudo_gt.dim()}.") + if y_ref is not None and y_ref.dim() != 4: + raise ValueError(f"Input tensor y_ref should be 4D, but got {y_ref.dim()}.") + if x.shape != y_pseudo_gt.shape: + raise ValueError( + f"Input tensor x and y_pseudo_gt should have the same shape, but got x shape {x.shape}, " + f"y_pseudo_gt shape {y_pseudo_gt.shape}." + ) + if y_ref is not None and y_pseudo_gt.shape != y_ref.shape: + raise ValueError( + f"Input tensor y_pseudo_gt and y_ref should have the same shape, but got y_pseudo_gt shape {y_pseudo_gt.shape}, " + f"y_ref shape {y_ref.shape}." + ) + + # compute loss + loss = sure_loss_function(operator, x, y_pseudo_gt, y_ref, self.eps, self.perturb_noise, complex_input) + + return loss diff --git a/monai/networks/layers/__init__.py b/monai/networks/layers/__init__.py index d61ed57f7f..3a6e4aa554 100644 --- a/monai/networks/layers/__init__.py +++ b/monai/networks/layers/__init__.py @@ -11,6 +11,7 @@ from __future__ import annotations +from .conjugate_gradient import ConjugateGradient from .convutils import calculate_out_shape, gaussian_1d, polyval, same_padding, stride_minus_kernel_padding from .drop_path import DropPath from .factories import Act, Conv, Dropout, LayerFactory, Norm, Pad, Pool, split_args diff --git a/monai/networks/layers/conjugate_gradient.py b/monai/networks/layers/conjugate_gradient.py new file mode 100644 index 0000000000..93a45930d7 --- /dev/null +++ b/monai/networks/layers/conjugate_gradient.py @@ -0,0 +1,112 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import annotations + +from typing import Callable + +import torch +from torch import nn + + +def _zdot(x1: torch.Tensor, x2: torch.Tensor) -> torch.Tensor: + """ + Complex dot product between tensors x1 and x2: sum(x1.x2) + """ + if torch.is_complex(x1): + assert torch.is_complex(x2), "x1 and x2 must both be complex" + return torch.sum(x1.conj() x2) + else: + return torch.sum(x1 * x2) + + +def _zdot_single(x: torch.Tensor) -> torch.Tensor: + """ + Complex dot product between tensor x and itself + """ + res = _zdot(x, x) + if torch.is_complex(res): + return res.real + else: + return res + + +class ConjugateGradient(nn.Module): + """ + Congugate Gradient (CG) solver for linear systems Ax = y. + + For linear_op that is positive definite and self-adjoint, CG is + guaranteed to converge CG is often used to solve linear systems of the form + Ax = y, where A is too large to store explicitly, but can be computed via a + linear operator. + + As a result, here we won't set A explicitly as a matrix, but rather as a + linear operator. For example, A could be a FFT/IFFT operation + """ + + def __init__(self, linear_op: Callable, num_iter: int): + """ + Args: + linear_op: Linear operator + num_iter: Number of iterations to run CG + """ + super().__init__() + + self.linear_op = linear_op + self.num_iter = num_iter + + def update( + self, x: torch.Tensor, p: torch.Tensor, r: torch.Tensor, rsold: torch.Tensor + ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: + """ + perform one iteration of the CG method. It takes the current solution x, + the current search direction p, the current residual r, and the old + residual norm rsold as inputs. Then it computes the new solution, search + direction, residual, and residual norm, and returns them. + """ + + dy = self.linear_op(p) + p_dot_dy = _zdot(p, dy) + alpha = rsold / p_dot_dy + x = x + alpha * p + r = r - alpha * dy + rsnew = _zdot_single(r) + beta = rsnew / rsold + rsold = rsnew + p = beta * p + r + return x, p, r, rsold + + def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: + """ + run conjugate gradient for num_iter iterations to solve Ax = y + + Args: + x: tensor (real or complex); Initial guess for linear system Ax = y. + The size of x should be applicable to the linear operator. For + example, if the linear operator is FFT, then x is HCHW; if the + linear operator is a matrix multiplication, then x is a vector + + y: tensor (real or complex); Measurement. Same size as x + + Returns: + x: Solution to Ax = y + """ + # Compute residual + r = y - self.linear_op(x) + rsold = _zdot_single(r) + p = r + + # Update + for _i in range(self.num_iter): + x, p, r, rsold = self.update(x, p, r, rsold) + if rsold < 1e-10: + break + return x	diff --git a/tests/test_conjugate_gradient.py b/tests/test_conjugate_gradient.py new file mode 100644 index 0000000000..239dbe3ecd --- /dev/null +++ b/tests/test_conjugate_gradient.py @@ -0,0 +1,55 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import annotations + +import unittest + +import torch + +from monai.networks.layers import ConjugateGradient + + +class TestConjugateGradient(unittest.TestCase): + def test_real_valued_inverse(self): + """Test ConjugateGradient with real-valued input: when the input is real + value, the output should be the inverse of the matrix.""" + a_dim = 3 + a_mat = torch.tensor([[1, 2, 3], [2, 1, 2], [3, 2, 1]], dtype=torch.float) + + def a_op(x): + return a_mat @ x + + cg_solver = ConjugateGradient(a_op, num_iter=100) + # define the measurement + y = torch.tensor([1, 2, 3], dtype=torch.float) + # solve for x + x = cg_solver(torch.zeros(a_dim), y) + x_ref = torch.linalg.solve(a_mat, y) + # assert torch.allclose(x, x_ref, atol=1e-6), 'CG solver failed to converge to reference solution' + self.assertTrue(torch.allclose(x, x_ref, atol=1e-6)) + + def test_complex_valued_inverse(self): + a_dim = 3 + a_mat = torch.tensor([[1, 2, 3], [2, 1, 2], [3, 2, 1]], dtype=torch.complex64) + + def a_op(x): + return a_mat @ x + + cg_solver = ConjugateGradient(a_op, num_iter=100) + y = torch.tensor([1, 2, 3], dtype=torch.complex64) + x = cg_solver(torch.zeros(a_dim, dtype=torch.complex64), y) + x_ref = torch.linalg.solve(a_mat, y) + self.assertTrue(torch.allclose(x, x_ref, atol=1e-6)) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_sure_loss.py b/tests/test_sure_loss.py new file mode 100644 index 0000000000..945da657bf --- /dev/null +++ b/tests/test_sure_loss.py @@ -0,0 +1,71 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import annotations + +import unittest + +import torch + +from monai.losses import SURELoss + + +class TestSURELoss(unittest.TestCase): + def test_real_value(self): + """Test SURELoss with real-valued input: when the input is real value, the loss should be 0.0.""" + sure_loss_real = SURELoss(perturb_noise=torch.zeros(2, 1, 128, 128), eps=0.1) + + def operator(x): + return x + + y_pseudo_gt = torch.randn(2, 1, 128, 128) + x = torch.randn(2, 1, 128, 128) + loss = sure_loss_real(operator, x, y_pseudo_gt, complex_input=False) + self.assertAlmostEqual(loss.item(), 0.0) + + def test_complex_value(self): + """Test SURELoss with complex-valued input: when the input is complex value, the loss should be 0.0.""" + + def operator(x): + return x + + sure_loss_complex = SURELoss(perturb_noise=torch.zeros(2, 2, 128, 128), eps=0.1) + y_pseudo_gt = torch.randn(2, 2, 128, 128) + x = torch.randn(2, 2, 128, 128) + loss = sure_loss_complex(operator, x, y_pseudo_gt, complex_input=True) + self.assertAlmostEqual(loss.item(), 0.0) + + def test_complex_general_input(self): + """Test SURELoss with complex-valued input: when the input is general complex value, the loss should be 0.0.""" + + def operator(x): + return x + + perturb_noise_real = torch.randn(2, 1, 128, 128) + perturb_noise_complex = torch.zeros(2, 2, 128, 128) + perturb_noise_complex[:, 0, :, :] = perturb_noise_real.squeeze() + y_pseudo_gt_real = torch.randn(2, 1, 128, 128) + y_pseudo_gt_complex = torch.zeros(2, 2, 128, 128) + y_pseudo_gt_complex[:, 0, :, :] = y_pseudo_gt_real.squeeze() + x_real = torch.randn(2, 1, 128, 128) + x_complex = torch.zeros(2, 2, 128, 128) + x_complex[:, 0, :, :] = x_real.squeeze() + + sure_loss_real = SURELoss(perturb_noise=perturb_noise_real, eps=0.1) + sure_loss_complex = SURELoss(perturb_noise=perturb_noise_complex, eps=0.1) + + loss_real = sure_loss_real(operator, x_real, y_pseudo_gt_real, complex_input=False) + loss_complex = sure_loss_complex(operator, x_complex, y_pseudo_gt_complex, complex_input=True) + self.assertAlmostEqual(loss_real.item(), loss_complex.abs().item(), places=6) + + +if __name__ == "__main__": + unittest.main()	diff --git a/docs/source/losses.rst b/docs/source/losses.rst index 61dd959807..ba794af3eb 100644 --- a/docs/source/losses.rst +++ b/docs/source/losses.rst @@ -139,6 +139,11 @@ Reconstruction Losses .. autoclass:: JukeboxLoss :members: +`SURELoss` +~~~~~~~~~~ +.. autoclass:: SURELoss + :members: + Loss Wrappers ------------- diff --git a/docs/source/networks.rst b/docs/source/networks.rst index 8eada7933f..b59c8af5fc 100644 --- a/docs/source/networks.rst +++ b/docs/source/networks.rst @@ -408,6 +408,11 @@ Layers .. autoclass:: LLTM :members: +`ConjugateGradient` +~~~~~~~~~~~~~~~~~~~ +.. autoclass:: ConjugateGradient + :members: + `Utilities` ~~~~~~~~~~~ .. automodule:: monai.networks.layers.convutils	[ { "components": [ { "doc": "First compute the difference in the complex domain,\nthen get the absolute value and take the mse\n\nArgs:\n x, y - B, 2, H, W real valued tensors representing complex numbers\n or B,1,H,W complex valued tensors\nReturns:\n l2_loss - scalar", "...	[ "tests/test_conjugate_gradient.py::TestConjugateGradient::test_complex_valued_inverse", "tests/test_conjugate_gradient.py::TestConjugateGradient::test_real_valued_inverse", "tests/test_sure_loss.py::TestSURELoss::test_complex_general_input", "tests/test_sure_loss.py::TestSURELoss::test_complex_value", "test...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Stein's Unbiased Risk Estimator (SURE) loss and Conjugate Gradient ### Description Based on the discussion topic [here](https://github.com/Project-MONAI/MONAI/discussions/7161#discussion-5773293), we implemented the Conjugate-Gradient algorithm for linear operator inversion, and Stein's Unbiased Risk Estimator (SURE) [1] loss for ground-truth-date free diffusion process guidance that is proposed in [2] and illustrated in the algorithm below: <img width="650" alt="Screenshot 2023-12-10 at 10 19 25 PM" src="https://github.com/Project-MONAI/MONAI/assets/8581162/97069466-cbaf-44e0-b7a7-ae9deb8fd7f2"> The Conjugate-Gradient (CG) algorithm is used to solve for the inversion of the linear operator in Line-4 in the algorithm above, where the linear operator is too large to store explicitly as a matrix (such as FFT/IFFT of an image) and invert directly. Instead, we can solve for the linear inversion iteratively as in CG. The SURE loss is applied for Line-6 above. This is a differentiable loss function that can be used to train/giude an operator (e.g. neural network), where the pseudo ground truth is available but the reference ground truth is not. For example, in the MRI reconstruction, the pseudo ground truth is the zero-filled reconstruction and the reference ground truth is the fully sampled reconstruction. The reference ground truth is not available due to the lack of fully sampled. Reference [1] Stein, C.M.: Estimation of the mean of a multivariate normal distribution. Annals of Statistics 1981 [[paper link](https://projecteuclid.org/journals/annals-of-statistics/volume-9/issue-6/Estimation-of-the-Mean-of-a-Multivariate-Normal-Distribution/10.1214/aos/1176345632.full)] [2] B. Ozturkler et al. SMRD: SURE-based Robust MRI Reconstruction with Diffusion Models. MICCAI 2023 [[paper link](https://arxiv.org/pdf/2310.01799.pdf)] ### Types of changes <!--- Put an `x` in all the boxes that apply, and remove the not applicable items --> - [x] Non-breaking change (fix or new feature that would not break existing functionality). - [ ] Breaking change (fix or new feature that would cause existing functionality to change). - [x] New tests added to cover the changes. - [x] Integration tests passed locally by running `./runtests.sh -f -u --net --coverage`. - [x] Quick tests passed locally by running `./runtests.sh --quick --unittests --disttests`. - [x] In-line docstrings updated. - [x] Documentation updated, tested `make html` command in the `docs/` folder. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in monai/losses/sure_loss.py] (definition of complex_diff_abs_loss:) def complex_diff_abs_loss(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: """First compute the difference in the complex domain, then get the absolute value and take the mse Args: x, y - B, 2, H, W real valued tensors representing complex numbers or B,1,H,W complex valued tensors Returns: l2_loss - scalar""" (definition of sure_loss_function:) def sure_loss_function( operator: Callable, x: torch.Tensor, y_pseudo_gt: torch.Tensor, y_ref: Optional[torch.Tensor] = None, eps: Optional[float] = -1.0, perturb_noise: Optional[torch.Tensor] = None, complex_input: Optional[bool] = False, ) -> torch.Tensor: """Args: operator (function): The operator function that takes in an input tensor x and returns an output tensor y. We will use this to compute the divergence. More specifically, we will perturb the input x by a small amount and compute the divergence between the perturbed output and the reference output x (torch.Tensor): The input tensor of shape (B, C, H, W) to the operator. For complex input, the shape is (B, 2, H, W) aka C=2 real. For real input, the shape is (B, 1, H, W) real. y_pseudo_gt (torch.Tensor): The pseudo ground truth tensor of shape (B, C, H, W) used to compute the L2 loss. For complex input, the shape is (B, 2, H, W) aka C=2 real. For real input, the shape is (B, 1, H, W) real. y_ref (torch.Tensor, optional): The reference output tensor of shape (B, C, H, W) used to compute the divergence. Defaults to None. For complex input, the shape is (B, 2, H, W) aka C=2 real. For real input, the shape is (B, 1, H, W) real. eps (float, optional): The perturbation scalar. Set to -1 to set it automatically estimated based on y_pseudo_gtk perturb_noise (torch.Tensor, optional): The noise vector of shape (B, C, H, W). Defaults to None. For complex input, the shape is (B, 2, H, W) aka C=2 real. For real input, the shape is (B, 1, H, W) real. complex_input(bool, optional): Whether the input is complex or not. Defaults to False. Returns: sure_loss (torch.Tensor): The SURE loss scalar.""" (definition of SURELoss:) class SURELoss(_Loss): """Calculate the Stein's Unbiased Risk Estimator (SURE) loss for a given operator. This is a differentiable loss function that can be used to train/guide an operator (e.g. neural network), where the pseudo ground truth is available but the reference ground truth is not. For example, in the MRI reconstruction, the pseudo ground truth is the zero-filled reconstruction and the reference ground truth is the fully sampled reconstruction. Often, the reference ground truth is not available due to the lack of fully sampled data. The original SURE loss is proposed in [1]. The SURE loss used for guiding the diffusion model based MRI reconstruction is proposed in [2]. Reference [1] Stein, C.M.: Estimation of the mean of a multivariate normal distribution. Annals of Statistics [2] B. Ozturkler et al. SMRD: SURE-based Robust MRI Reconstruction with Diffusion Models. (https://arxiv.org/pdf/2310.01799.pdf)""" (definition of SURELoss.__init__:) def __init__(self, perturb_noise: Optional[torch.Tensor] = None, eps: Optional[float] = None) -> None: """Args: perturb_noise (torch.Tensor, optional): The noise vector of shape (B, C, H, W). Defaults to None. For complex input, the shape is (B, 2, H, W) aka C=2 real. For real input, the shape is (B, 1, H, W) real. eps (float, optional): The perturbation scalar. Defaults to None.""" (definition of SURELoss.forward:) def forward( self, operator: Callable, x: torch.Tensor, y_pseudo_gt: torch.Tensor, y_ref: Optional[torch.Tensor] = None, complex_input: Optional[bool] = False, ) -> torch.Tensor: """Args: operator (function): The operator function that takes in an input tensor x and returns an output tensor y. We will use this to compute the divergence. More specifically, we will perturb the input x by a small amount and compute the divergence between the perturbed output and the reference output x (torch.Tensor): The input tensor of shape (B, C, H, W) to the operator. C=1 or 2: For complex input, the shape is (B, 2, H, W) aka C=2 real. For real input, the shape is (B, 1, H, W) real. y_pseudo_gt (torch.Tensor): The pseudo ground truth tensor of shape (B, C, H, W) used to compute the L2 loss. C=1 or 2: For complex input, the shape is (B, 2, H, W) aka C=2 real. For real input, the shape is (B, 1, H, W) real. y_ref (torch.Tensor, optional): The reference output tensor of the same shape as y_pseudo_gt Returns: sure_loss (torch.Tensor): The SURE loss scalar.""" [end of new definitions in monai/losses/sure_loss.py] [start of new definitions in monai/networks/layers/conjugate_gradient.py] (definition of _zdot:) def _zdot(x1: torch.Tensor, x2: torch.Tensor) -> torch.Tensor: """Complex dot product between tensors x1 and x2: sum(x1.*x2)""" (definition of _zdot_single:) def _zdot_single(x: torch.Tensor) -> torch.Tensor: """Complex dot product between tensor x and itself""" (definition of ConjugateGradient:) class ConjugateGradient(nn.Module): """Congugate Gradient (CG) solver for linear systems Ax = y. For linear_op that is positive definite and self-adjoint, CG is guaranteed to converge CG is often used to solve linear systems of the form Ax = y, where A is too large to store explicitly, but can be computed via a linear operator. As a result, here we won't set A explicitly as a matrix, but rather as a linear operator. For example, A could be a FFT/IFFT operation""" (definition of ConjugateGradient.__init__:) def __init__(self, linear_op: Callable, num_iter: int): """Args: linear_op: Linear operator num_iter: Number of iterations to run CG""" (definition of ConjugateGradient.update:) def update( self, x: torch.Tensor, p: torch.Tensor, r: torch.Tensor, rsold: torch.Tensor ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: """perform one iteration of the CG method. It takes the current solution x, the current search direction p, the current residual r, and the old residual norm rsold as inputs. Then it computes the new solution, search direction, residual, and residual norm, and returns them.""" (definition of ConjugateGradient.forward:) def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: """run conjugate gradient for num_iter iterations to solve Ax = y Args: x: tensor (real or complex); Initial guess for linear system Ax = y. The size of x should be applicable to the linear operator. For example, if the linear operator is FFT, then x is HCHW; if the linear operator is a matrix multiplication, then x is a vector y: tensor (real or complex); Measurement. Same size as x Returns: x: Solution to Ax = y""" [end of new definitions in monai/networks/layers/conjugate_gradient.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		e73257caa79309dcce1e93abf1632f4bfd75b11f
astronomer__astronomer-cosmos-758	758	astronomer/astronomer-cosmos	null	9fcee8e785ea3bcb0d19e8d36f3f5b94bedafc98	2023-12-11T01:54:27Z	diff --git a/cosmos/profiles/athena/access_key.py b/cosmos/profiles/athena/access_key.py index a8f71c2b7..02de2be24 100644 --- a/cosmos/profiles/athena/access_key.py +++ b/cosmos/profiles/athena/access_key.py @@ -3,20 +3,33 @@ from typing import Any +from cosmos.exceptions import CosmosValueError + from ..base import BaseProfileMapping class AthenaAccessKeyProfileMapping(BaseProfileMapping): """ - Maps Airflow AWS connections to a dbt Athena profile using an access key id and secret access key. + Uses the Airflow AWS Connection provided to get_credentials() to generate the profile for dbt. - https://docs.getdbt.com/docs/core/connect-data-platform/athena-setup https://airflow.apache.org/docs/apache-airflow-providers-amazon/stable/connections/aws.html + + + This behaves similarly to other provider operators such as the AWS Athena Operator. + Where you pass the aws_conn_id and the operator will generate the credentials for you. + + https://registry.astronomer.io/providers/amazon/versions/latest/modules/athenaoperator + + Information about the dbt Athena profile that is generated can be found here: + + https://github.com/dbt-athena/dbt-athena?tab=readme-ov-file#configuring-your-profile + https://docs.getdbt.com/docs/core/connect-data-platform/athena-setup """ airflow_connection_type: str = "aws" dbt_profile_type: str = "athena" is_community: bool = True + temporary_credentials = None required_fields = [ "aws_access_key_id", @@ -26,11 +39,7 @@ class AthenaAccessKeyProfileMapping(BaseProfileMapping): "s3_staging_dir", "schema", ] - secret_fields = ["aws_secret_access_key", "aws_session_token"] airflow_param_mapping = { - "aws_access_key_id": "login", - "aws_secret_access_key": "password", - "aws_session_token": "extra.aws_session_token", "aws_profile_name": "extra.aws_profile_name", "database": "extra.database", "debug_query_state": "extra.debug_query_state", @@ -49,11 +58,43 @@ class AthenaAccessKeyProfileMapping(BaseProfileMapping): @property def profile(self) -> dict[str, Any \| None]: "Gets profile. The password is stored in an environment variable." + + self.temporary_credentials = self._get_temporary_credentials() # type: ignore + profile = { self.mapped_params, self.profile_args, - # aws_secret_access_key and aws_session_token should always get set as env var + "aws_access_key_id": self.temporary_credentials.access_key, "aws_secret_access_key": self.get_env_var_format("aws_secret_access_key"), "aws_session_token": self.get_env_var_format("aws_session_token"), } + return self.filter_null(profile) + + @property + def env_vars(self) -> dict[str, str]: + "Overwrites the env_vars for athena, Returns a dictionary of environment variables that should be set based on the self.temporary_credentials." + + if self.temporary_credentials is None: + raise CosmosValueError(f"Could not find the athena credentials.") + + env_vars = {} + + env_secret_key_name = self.get_env_var_name("aws_secret_access_key") + env_session_token_name = self.get_env_var_name("aws_session_token") + + env_vars[env_secret_key_name] = str(self.temporary_credentials.secret_key) + env_vars[env_session_token_name] = str(self.temporary_credentials.token) + + return env_vars + + def _get_temporary_credentials(self): # type: ignore + """ + Helper function to retrieve temporary short lived credentials + Returns an object including access_key, secret_key and token + """ + from airflow.providers.amazon.aws.hooks.base_aws import AwsGenericHook + + hook = AwsGenericHook(self.conn_id) # type: ignore + credentials = hook.get_credentials() + return credentials diff --git a/pyproject.toml b/pyproject.toml index c08de4ade..9d367c075 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -57,6 +57,7 @@ dbt-all = [ ] dbt-athena = [ "dbt-athena-community", + "apache-airflow-providers-amazon>=8.0.0", ] dbt-bigquery = [ "dbt-bigquery", @@ -110,7 +111,6 @@ tests = [ "mypy", "sqlalchemy-stubs", # Change when sqlalchemy is upgraded https://docs.sqlalchemy.org/en/14/orm/extensions/mypy.html ] - docker = [ "apache-airflow-providers-docker>=3.5.0", ] @@ -121,7 +121,6 @@ pydantic = [ "pydantic>=1.10.0,<2.0.0", ] - [project.entry-points.cosmos] provider_info = "cosmos:get_provider_info"	diff --git a/tests/profiles/athena/test_athena_access_key.py b/tests/profiles/athena/test_athena_access_key.py index 22c8efa2c..c224a9d4b 100644 --- a/tests/profiles/athena/test_athena_access_key.py +++ b/tests/profiles/athena/test_athena_access_key.py @@ -1,20 +1,49 @@ "Tests for the Athena profile." import json -from unittest.mock import patch - +from collections import namedtuple +import sys +from unittest.mock import MagicMock, patch import pytest from airflow.models.connection import Connection from cosmos.profiles import get_automatic_profile_mapping from cosmos.profiles.athena.access_key import AthenaAccessKeyProfileMapping +Credentials = namedtuple("Credentials", ["access_key", "secret_key", "token"]) + +mock_assumed_credentials = Credentials( + secret_key="my_aws_assumed_secret_key", + access_key="my_aws_assumed_access_key", + token="my_aws_assumed_token", +) + +mock_missing_credentials = Credentials(access_key=None, secret_key=None, token=None) + + +@pytest.fixture(autouse=True) +def mock_aws_module(): + mock_aws_hook = MagicMock() + + class MockAwsGenericHook: + def __init__(self, conn_id: str) -> None: + pass + + def get_credentials(self) -> Credentials: + return mock_assumed_credentials + + mock_aws_hook.AwsGenericHook = MockAwsGenericHook + + with patch.dict(sys.modules, {"airflow.providers.amazon.aws.hooks.base_aws": mock_aws_hook}): + yield mock_aws_hook + @pytest.fixture() def mock_athena_conn(): # type: ignore """ Sets the connection as an environment variable. """ + conn = Connection( conn_id="my_athena_connection", conn_type="aws", @@ -24,7 +53,7 @@ def mock_athena_conn(): # type: ignore { "aws_session_token": "token123", "database": "my_database", - "region_name": "my_region", + "region_name": "us-east-1", "s3_staging_dir": "s3://my_bucket/dbt/", "schema": "my_schema", } @@ -48,6 +77,7 @@ def test_athena_connection_claiming() -> None: # - region_name # - s3_staging_dir # - schema + potential_values = { "conn_type": "aws", "login": "my_aws_access_key_id", @@ -55,7 +85,7 @@ def test_athena_connection_claiming() -> None: "extra": json.dumps( { "database": "my_database", - "region_name": "my_region", + "region_name": "us-east-1", "s3_staging_dir": "s3://my_bucket/dbt/", "schema": "my_schema", } @@ -68,12 +98,14 @@ def test_athena_connection_claiming() -> None: del values[key] conn = Connection(values) # type: ignore - print("testing with", values) - - with patch("airflow.hooks.base.BaseHook.get_connection", return_value=conn): - # should raise an InvalidMappingException - profile_mapping = AthenaAccessKeyProfileMapping(conn, {}) - assert not profile_mapping.can_claim_connection() + with patch( + "cosmos.profiles.athena.access_key.AthenaAccessKeyProfileMapping._get_temporary_credentials", + return_value=mock_missing_credentials, + ): + with patch("airflow.hooks.base.BaseHook.get_connection", return_value=conn): + # should raise an InvalidMappingException + profile_mapping = AthenaAccessKeyProfileMapping(conn, {}) + assert not profile_mapping.can_claim_connection() # if we have them all, it should claim conn = Connection(potential_values) # type: ignore @@ -88,6 +120,7 @@ def test_athena_profile_mapping_selected( """ Tests that the correct profile mapping is selected for Athena. """ + profile_mapping = get_automatic_profile_mapping( mock_athena_conn.conn_id, ) @@ -100,13 +133,14 @@ def test_athena_profile_args( """ Tests that the profile values get set correctly for Athena. """ + profile_mapping = get_automatic_profile_mapping( mock_athena_conn.conn_id, ) assert profile_mapping.profile == { "type": "athena", - "aws_access_key_id": mock_athena_conn.login, + "aws_access_key_id": mock_assumed_credentials.access_key, "aws_secret_access_key": "{{ env_var('COSMOS_CONN_AWS_AWS_SECRET_ACCESS_KEY') }}", "aws_session_token": "{{ env_var('COSMOS_CONN_AWS_AWS_SESSION_TOKEN') }}", "database": mock_athena_conn.extra_dejson.get("database"), @@ -122,9 +156,14 @@ def test_athena_profile_args_overrides( """ Tests that you can override the profile values for Athena. """ + profile_mapping = get_automatic_profile_mapping( mock_athena_conn.conn_id, - profile_args={"schema": "my_custom_schema", "database": "my_custom_db", "aws_session_token": "override_token"}, + profile_args={ + "schema": "my_custom_schema", + "database": "my_custom_db", + "aws_session_token": "override_token", + }, ) assert profile_mapping.profile_args == { @@ -135,7 +174,7 @@ def test_athena_profile_args_overrides( assert profile_mapping.profile == { "type": "athena", - "aws_access_key_id": mock_athena_conn.login, + "aws_access_key_id": mock_assumed_credentials.access_key, "aws_secret_access_key": "{{ env_var('COSMOS_CONN_AWS_AWS_SECRET_ACCESS_KEY') }}", "aws_session_token": "{{ env_var('COSMOS_CONN_AWS_AWS_SESSION_TOKEN') }}", "database": "my_custom_db", @@ -151,10 +190,12 @@ def test_athena_profile_env_vars( """ Tests that the environment variables get set correctly for Athena. """ + profile_mapping = get_automatic_profile_mapping( mock_athena_conn.conn_id, ) + assert profile_mapping.env_vars == { - "COSMOS_CONN_AWS_AWS_SECRET_ACCESS_KEY": mock_athena_conn.password, - "COSMOS_CONN_AWS_AWS_SESSION_TOKEN": mock_athena_conn.extra_dejson.get("aws_session_token"), + "COSMOS_CONN_AWS_AWS_SECRET_ACCESS_KEY": mock_assumed_credentials.secret_key, + "COSMOS_CONN_AWS_AWS_SESSION_TOKEN": mock_assumed_credentials.token, }	diff --git a/pyproject.toml b/pyproject.toml index c08de4ade..9d367c075 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -57,6 +57,7 @@ dbt-all = [ ] dbt-athena = [ "dbt-athena-community", + "apache-airflow-providers-amazon>=8.0.0", ] dbt-bigquery = [ "dbt-bigquery", @@ -110,7 +111,6 @@ tests = [ "mypy", "sqlalchemy-stubs", # Change when sqlalchemy is upgraded https://docs.sqlalchemy.org/en/14/orm/extensions/mypy.html ] - docker = [ "apache-airflow-providers-docker>=3.5.0", ] @@ -121,7 +121,6 @@ pydantic = [ "pydantic>=1.10.0,<2.0.0", ] - [project.entry-points.cosmos] provider_info = "cosmos:get_provider_info"	[ { "components": [ { "doc": "Overwrites the env_vars for athena, Returns a dictionary of environment variables that should be set based on the self.temporary_credentials.", "lines": [ 75, 89 ], "name": "AthenaAccessKeyProfileMapping.env_vars", "si...	[ "tests/profiles/athena/test_athena_access_key.py::test_athena_connection_claiming", "tests/profiles/athena/test_athena_access_key.py::test_athena_profile_args", "tests/profiles/athena/test_athena_access_key.py::test_athena_profile_args_overrides", "tests/profiles/athena/test_athena_access_key.py::test_athena_...	[ "tests/profiles/athena/test_athena_access_key.py::test_athena_profile_mapping_selected" ]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Athena - Get temporary credentials from the conn_id ## Description <!-- Add a brief but complete description of the change. --> Passes the `conn_id` to the `AwsGenericHook` and uses `get_credentials()`, which handles the creation of a session, credentials, freezing of credentials & also masking. [See get_credentials() docs here](https://airflow.apache.org/docs/apache-airflow-providers-amazon/stable/_api/airflow/providers/amazon/aws/hooks/base_aws/index.html#airflow.providers.amazon.aws.hooks.base_aws.AwsGenericHook.get_credentials) ## Related Issue(s) #691 <!-- If this PR closes an issue, you can use a keyword to auto-close. --> <!-- i.e. "closes #0000" --> ## Breaking Change? <!-- If this introduces a breaking change, specify that here. --> ## Checklist - [ ] I have made corresponding changes to the documentation (if required) - [X] I have added tests that prove my fix is effective or that my feature works ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in cosmos/profiles/athena/access_key.py] (definition of AthenaAccessKeyProfileMapping.env_vars:) def env_vars(self) -> dict[str, str]: """Overwrites the env_vars for athena, Returns a dictionary of environment variables that should be set based on the self.temporary_credentials.""" (definition of AthenaAccessKeyProfileMapping._get_temporary_credentials:) def _get_temporary_credentials(self): """Helper function to retrieve temporary short lived credentials Returns an object including access_key, secret_key and token""" [end of new definitions in cosmos/profiles/athena/access_key.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c5edba07d2265d5185eaba149a639e8a0740e498
conan-io__conan-15221	15,221	conan-io/conan	null	acbaf44874c0c821a6f6702f46f99d2ee7553deb	2023-12-05T21:26:03Z	diff --git a/conans/model/dependencies.py b/conans/model/dependencies.py index e001141cc8b..c1eebef5302 100644 --- a/conans/model/dependencies.py +++ b/conans/model/dependencies.py @@ -73,6 +73,17 @@ def items(self): def values(self): return self._data.values() + def __contains__(self, item): + try: + self.get(item) + return True + except KeyError: + return False + except ConanException: + # ConanException is raised when there are more than one matching the filters + # so it's definitely in the dict + return True + class ConanFileDependencies(UserRequirementsDict):	diff --git a/conans/test/integration/graph/test_dependencies_visit.py b/conans/test/integration/graph/test_dependencies_visit.py index 75c9fda1402..3bb77dc92d4 100644 --- a/conans/test/integration/graph/test_dependencies_visit.py +++ b/conans/test/integration/graph/test_dependencies_visit.py @@ -29,6 +29,18 @@ def generate(self): self.output.info("DefPRefBuild: {}!!!".format(dep.pref.repr_notime())) for r, d in self.dependencies.build.items(): self.output.info("DIRECTBUILD {}: {}".format(r.direct, d)) + + if "openssl" in self.dependencies: + self.output.info("OpenSSL found in deps") + + if "cmake" in self.dependencies: + self.output.info("cmake found in default deps") + + if "cmake" in self.dependencies.build: + self.output.info("cmake found in deps.build") + + if "badlib" in self.dependencies: + self.output.info("badlib found in deps") """) client.save({"conanfile.py": conanfile}) @@ -48,6 +60,12 @@ def generate(self): assert "conanfile.py: DIRECTBUILD True: cmake/0.1" in client.out assert "conanfile.py: DIRECTBUILD False: openssl/0.2" in client.out + assert "OpenSSL found in deps" in client.out + assert "badlib found in deps" not in client.out + + assert "cmake found in default deps" not in client.out + assert "cmake found in deps.build" in client.out + def test_dependencies_visit_settings_options(): client = TestClient() @@ -89,6 +107,9 @@ def generate(self): '- cmake/0.2, Traits: build=True, headers=False, libs=False, run=False, visible=False' ), ('self.dependencies["missing"]', True, "'missing' not found in the dependency set"), + ('self.output.info("Missing in deps: " + str("missing" in self.dependencies))', False, "Missing in deps: False"), + ('self.output.info("Zlib in deps: " + str("zlib" in self.dependencies))', False, "Zlib in deps: True"), + ('self.output.info("Zlib in deps.build: " + str("zlib" in self.dependencies.build))', False, "Zlib in deps.build: True"), ]		[ { "components": [ { "doc": "", "lines": [ 76, 85 ], "name": "UserRequirementsDict.__contains__", "signature": "def __contains__(self, item):", "type": "function" } ], "file": "conans/model/dependencies.py" } ]	[ "conans/test/integration/graph/test_dependencies_visit.py::test_dependencies_visit", "conans/test/integration/graph/test_dependencies_visit.py::test_cmake_zlib[self.output.info(\"Missing", "conans/test/integration/graph/test_dependencies_visit.py::test_cmake_zlib[self.output.info(\"Zlib" ]	[ "conans/test/integration/graph/test_dependencies_visit.py::test_dependencies_visit_settings_options", "conans/test/integration/graph/test_dependencies_visit.py::test_cmake_zlib[print(\"=>{}\".format(self.dependencies[\"zlib\"].ref))-False-=>zlib/0.2]", "conans/test/integration/graph/test_dependencies_visit.py::...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add `in` operator support for ConanFile's `self.dependencies` Changelog: Feature: Add `in` operator support for ConanFile's `self.dependencies`. Docs: https://github.com/conan-io/docs/pull/3481 Closes https://github.com/conan-io/conan/issues/12832 Found this in the wild as a leftover while going over my created issues :) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conans/model/dependencies.py] (definition of UserRequirementsDict.__contains__:) def __contains__(self, item): [end of new definitions in conans/model/dependencies.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		4a5b19a75db9225316c8cb022a2dfb9705a2af34
googleapis__python-aiplatform-3060	3,060	googleapis/python-aiplatform	null	d0c2ffa8d8d070f9ef247c3c742a67b12d1bc16d	2023-12-05T17:21:57Z	diff --git a/samples/model-builder/vector_search/vector_search_find_neighbors_sample.py b/samples/model-builder/vector_search/vector_search_find_neighbors_sample.py new file mode 100644 index 0000000000..8afef4a82d --- /dev/null +++ b/samples/model-builder/vector_search/vector_search_find_neighbors_sample.py @@ -0,0 +1,59 @@ +# Copyright 2023 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import List + +from google.cloud import aiplatform + + +# [START aiplatform_sdk_vector_search_find_neighbors_sample] +def vector_search_find_neighbors( + project: str, + location: str, + index_endpoint_name: str, + deployed_index_id: str, + queries: List[List[float]], + num_neighbors: int, +) -> None: + """Query the vector search index. + + Args: + project (str): Required. Project ID + location (str): Required. The region name + index_endpoint_name (str): Required. Index endpoint to run the query + against. + deployed_index_id (str): Required. The ID of the DeployedIndex to run + the queries against. + queries (List[List[float]]): Required. A list of queries. Each query is + a list of floats, representing a single embedding. + num_neighbors (int): Required. The number of neighbors to return. + """ + # Initialize the Vertex AI client + aiplatform.init(project=project, location=location) + + # Create the index endpoint instance from an existing endpoint. + my_index_endpoint = aiplatform.MatchingEngineIndexEndpoint( + index_endpoint_name=index_endpoint_name + ) + + # Query the index endpoint for the nearest neighbors. + resp = my_index_endpoint.find_neighbors( + deployed_index_id=deployed_index_id, + queries=queries, + num_neighbors=num_neighbors, + ) + print(resp) + + +# [END aiplatform_sdk_vector_search_find_neighbors_sample] diff --git a/samples/model-builder/vector_search/vector_search_stream_update_sample.py b/samples/model-builder/vector_search/vector_search_stream_update_sample.py new file mode 100644 index 0000000000..03ab377878 --- /dev/null +++ b/samples/model-builder/vector_search/vector_search_stream_update_sample.py @@ -0,0 +1,47 @@ +# Copyright 2023 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Sequence + +from google.cloud import aiplatform + + +# [START aiplatform_sdk_vector_search_stream_update_sample] +def stream_update_vector_search_index( + project: str, location: str, index_name: str, datapoints: Sequence[dict] +) -> None: + """Stream update an existing vector search index + + Args: + project (str): Required. The Project ID + location (str): Required. The region name, e.g. "us-central1" + index_name (str): Required. The index to update. A fully-qualified index + resource name or a index ID. Example: + "projects/123/locations/us-central1/ indexes/my_index_id" or + "my_index_id". + datapoints: Sequence[dict]: Required. The datapoints to be updated. The dict + element should be of the IndexDatapoint type. + """ + # Initialize the Vertex AI client + aiplatform.init(project=project, location=location) + + # Create the index instance from an existing index with stream_update + # enabled + my_index = aiplatform.MatchingEngineIndex(index_name=index_name) + + # Upsert the datapoints to the index + my_index.upsert_datapoints(datapoints=datapoints) + + +# [END aiplatform_sdk_vector_search_stream_update_sample]	diff --git a/samples/model-builder/conftest.py b/samples/model-builder/conftest.py index a9679e74e3..750e682e20 100644 --- a/samples/model-builder/conftest.py +++ b/samples/model-builder/conftest.py @@ -1204,3 +1204,52 @@ def mock_autolog(): with patch.object(aiplatform, "autolog") as mock_autolog_method: mock_autolog_method.return_value = None yield mock_autolog_method + + +""" +---------------------------------------------------------------------------- +Vector Search Fixtures +---------------------------------------------------------------------------- +""" + + +@pytest.fixture +def mock_index(): + mock = MagicMock(aiplatform.MatchingEngineIndex) + yield mock + + +@pytest.fixture +def mock_index_endpoint(): + mock = MagicMock(aiplatform.MatchingEngineIndexEndpoint) + yield mock + + +@pytest.fixture +def mock_index_init(mock_index): + with patch.object(aiplatform, "MatchingEngineIndex") as mock: + mock.return_value = mock_index + yield mock + + +@pytest.fixture +def mock_index_upsert_datapoints(mock_index): + with patch.object(mock_index, "upsert_datapoints") as mock_upsert: + mock_upsert.return_value = None + yield mock_upsert + + +@pytest.fixture +def mock_index_endpoint_init(mock_index_endpoint): + with patch.object(aiplatform, "MatchingEngineIndexEndpoint") as mock: + mock.return_value = mock_index_endpoint + yield mock + + +@pytest.fixture +def mock_index_endpoint_find_neighbors(mock_index_endpoint): + with patch.object( + mock_index_endpoint, "find_neighbors" + ) as mock_find_neighbors: + mock_find_neighbors.return_value = None + yield mock_find_neighbors diff --git a/samples/model-builder/test_constants.py b/samples/model-builder/test_constants.py index 4c0b349e3d..924d888746 100644 --- a/samples/model-builder/test_constants.py +++ b/samples/model-builder/test_constants.py @@ -338,3 +338,12 @@ ) TENSORBOARD_EXPERIMENT_NAME = "my-tensorboard-experiment" TENSORBOARD_PLUGIN_PROFILE_NAME = "profile" + +# Vector Search +VECTOR_SEARCH_INDEX = "123" +VECTOR_SERACH_INDEX_DATAPOINTS = [ + {"datapoint_id": "datapoint_id_1", "feature_vector": [0.1]} +] +VECTOR_SEARCH_INDEX_ENDPOINT = "456" +VECTOR_SEARCH_DEPLOYED_INDEX_ID = "789" +VECTOR_SERACH_INDEX_QUERIES = [[0.1]] diff --git a/samples/model-builder/vector_search/vector_search_find_neighbors_sample_test.py b/samples/model-builder/vector_search/vector_search_find_neighbors_sample_test.py new file mode 100644 index 0000000000..d4ba3143cb --- /dev/null +++ b/samples/model-builder/vector_search/vector_search_find_neighbors_sample_test.py @@ -0,0 +1,45 @@ +# Copyright 2023 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import test_constants as constants +from vector_search import vector_search_find_neighbors_sample + + +def test_vector_search_find_neighbors_sample( + mock_sdk_init, mock_index_endpoint_init, mock_index_endpoint_find_neighbors +): + vector_search_find_neighbors_sample.vector_search_find_neighbors( + project=constants.PROJECT, + location=constants.LOCATION, + index_endpoint_name=constants.VECTOR_SEARCH_INDEX_ENDPOINT, + deployed_index_id=constants.VECTOR_SEARCH_DEPLOYED_INDEX_ID, + queries=constants.VECTOR_SERACH_INDEX_QUERIES, + num_neighbors=10 + ) + + # Check client initialization + mock_sdk_init.assert_called_with( + project=constants.PROJECT, location=constants.LOCATION + ) + + # Check index endpoint initialization with right index endpoint name + mock_index_endpoint_init.assert_called_with( + index_endpoint_name=constants.VECTOR_SEARCH_INDEX_ENDPOINT) + + # Check index_endpoint.find_neighbors is called with right params. + mock_index_endpoint_find_neighbors.assert_called_with( + deployed_index_id=constants.VECTOR_SEARCH_DEPLOYED_INDEX_ID, + queries=constants.VECTOR_SERACH_INDEX_QUERIES, + num_neighbors=10 + ) diff --git a/samples/model-builder/vector_search/vector_search_stream_update_sample_test.py b/samples/model-builder/vector_search/vector_search_stream_update_sample_test.py new file mode 100644 index 0000000000..884a851fcc --- /dev/null +++ b/samples/model-builder/vector_search/vector_search_stream_update_sample_test.py @@ -0,0 +1,40 @@ +# Copyright 2023 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# limitations under the License. + +import test_constants as constants +from vector_search import vector_search_stream_update_sample + + +def test_vector_search_stream_update_sample( + mock_sdk_init, mock_index_init, mock_index_upsert_datapoints +): + vector_search_stream_update_sample.stream_update_vector_search_index( + project=constants.PROJECT, + location=constants.LOCATION, + index_name=constants.VECTOR_SEARCH_INDEX, + datapoints=constants.VECTOR_SERACH_INDEX_DATAPOINTS, + ) + + # Check client initialization + mock_sdk_init.assert_called_with( + project=constants.PROJECT, location=constants.LOCATION + ) + + # Check index initialization with right index name + mock_index_init.assert_called_with(index_name=constants.VECTOR_SEARCH_INDEX) + + # Check index.upsert_datapoints is called with right params. + mock_index_upsert_datapoints.assert_called_with( + datapoints=constants.VECTOR_SERACH_INDEX_DATAPOINTS + )		[ { "components": [ { "doc": "Query the vector search index.\n\nArgs:\n project (str): Required. Project ID\n location (str): Required. The region name\n index_endpoint_name (str): Required. Index endpoint to run the query\n against.\n deployed_index_id (str): Required. The ID of the ...	[ "samples/model-builder/vector_search/vector_search_find_neighbors_sample_test.py::test_vector_search_find_neighbors_sample", "samples/model-builder/vector_search/vector_search_stream_update_sample_test.py::test_vector_search_stream_update_sample" ]	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> chore: adding code samples for vector search streaming update and find neighbors chore: adding code samples for vector search streaming update and find neighbors ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in samples/model-builder/vector_search/vector_search_find_neighbors_sample.py] (definition of vector_search_find_neighbors:) def vector_search_find_neighbors( project: str, location: str, index_endpoint_name: str, deployed_index_id: str, queries: List[List[float]], num_neighbors: int, ) -> None: """Query the vector search index. Args: project (str): Required. Project ID location (str): Required. The region name index_endpoint_name (str): Required. Index endpoint to run the query against. deployed_index_id (str): Required. The ID of the DeployedIndex to run the queries against. queries (List[List[float]]): Required. A list of queries. Each query is a list of floats, representing a single embedding. num_neighbors (int): Required. The number of neighbors to return.""" [end of new definitions in samples/model-builder/vector_search/vector_search_find_neighbors_sample.py] [start of new definitions in samples/model-builder/vector_search/vector_search_stream_update_sample.py] (definition of stream_update_vector_search_index:) def stream_update_vector_search_index( project: str, location: str, index_name: str, datapoints: Sequence[dict] ) -> None: """Stream update an existing vector search index Args: project (str): Required. The Project ID location (str): Required. The region name, e.g. "us-central1" index_name (str): Required. The index to update. A fully-qualified index resource name or a index ID. Example: "projects/123/locations/us-central1/ indexes/my_index_id" or "my_index_id". datapoints: Sequence[dict]: Required. The datapoints to be updated. The dict element should be of the IndexDatapoint type.""" [end of new definitions in samples/model-builder/vector_search/vector_search_stream_update_sample.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		67358fa6a830eb842f6b52d09061af4a41b54af6
google-deepmind__optax-651	651	google-deepmind/optax	null	b67577e2810b473d38fa851dee3da695a9bf2135	2023-12-01T20:06:12Z	diff --git a/docs/api.rst b/docs/api.rst index 9efa959c3..510dc74d6 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -776,6 +776,10 @@ scale_gradient SAMState cocob COCOBState + dadapt_adamw + DAdaptAdamWState + prodigy + ProdigyState Complex-Valued Optimization diff --git a/optax/contrib/__init__.py b/optax/contrib/__init__.py index a9d4b9892..39fd9c35e 100644 --- a/optax/contrib/__init__.py +++ b/optax/contrib/__init__.py @@ -27,3 +27,5 @@ from optax.contrib.sam import NormalizeState from optax.contrib.sam import sam from optax.contrib.sam import SAMState +from optax.contrib.dadapt_adamw import dadapt_adamw +from optax.contrib.prodigy import prodigy diff --git a/optax/contrib/dadapt_adamw.py b/optax/contrib/dadapt_adamw.py new file mode 100644 index 000000000..df0cc5aa8 --- /dev/null +++ b/optax/contrib/dadapt_adamw.py @@ -0,0 +1,123 @@ + +# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""D-Adatation (AdamW variant). + +A contributed implementation of the method from "Learning-Rate-Free Learning +by D-Adaptation" (https://arxiv.org/abs/2301.07733) by Aaron Defazio and +Konstantin Mishchenko (ICML 2023 Outstanding Paper award). +""" +import jax.numpy as jnp +from jax.tree_util import tree_map + +from typing import NamedTuple, Optional, Tuple +from optax import tree_utils +from optax._src import base +from optax._src import utils + +class DAdaptAdamWState(NamedTuple): + exp_avg: base.Updates + exp_avg_sq: base.Updates + grad_sum: base.Updates # exponential moving average of the sum of gradients + estim_lr: float # Distance to solution estimate + numerator_weighted: float + count: float + +def dadapt_adamw(learning_rate: base.ScalarOrSchedule = 1.0, + betas=(0.9, 0.999), + eps=1e-8, + estim_lr0=1e-6, + weight_decay=0) -> base.GradientTransformation: + """Learning rate free AdamW by D-Adaptation + + Adapts the baseline learning rate of AdamW automatically by estimating the + initial distance to solution in the infinity norm. + This method works best when combined with a learning rate schedule that + treats 1.0 as the base (usually max) value. + + References: + [Defazio & Mishchenko, 2023](https://arxiv.org/abs/2301.07733) + + Args: + learning_rate: Learning rate scheduling parameter. The recommended schedule + is a linear_schedule with init_value=1.0 and end_value=0, combined with a + 0-20% learning rate warmup. + betas: Betas for the underlying AdamW Optimizer. + eps: eps for the underlying AdamW Optimizer. + estim_lr0: Initial (under-)estimate of the learning rate. + weight_decay: AdamW style weight-decay. To use Regular Adam decay, chain + with add_decayed_weights. + + Returns: + A `GradientTransformation` object. + """ + def init_fn(params: base.Params) -> DAdaptAdamWState: + exp_avg = tree_map(lambda p: jnp.zeros(p.shape), params) + exp_avg_sq = tree_map(lambda p: jnp.zeros(p.shape), params) + grad_sum = tree_map(lambda p: jnp.zeros(p.shape), params) + estim_lr = estim_lr0 + numerator_weighted = 0 + count = 0 + return DAdaptAdamWState(exp_avg, exp_avg_sq, + grad_sum, estim_lr, numerator_weighted, count) + + def update_fn( + updates: base.Updates, + state: DAdaptAdamWState, + params: Optional[base.Params] = None, + ) -> Tuple[base.Updates, DAdaptAdamWState]: + if params is None: + raise ValueError(base.NO_PARAMS_MSG) + + count = state.count + beta1, beta2 = betas + sb2 = beta2(0.5) + sched = learning_rate(count) if callable(learning_rate) else learning_rate + + grad_sum = state.grad_sum + numerator_weighted = state.numerator_weighted + + bc = ((1-beta2(count+1))0.5)/(1-beta1(count+1)) + dlr = state.estim_lr * sched * bc + + s_weighted = tree_map(lambda sk, eas: sk/(jnp.sqrt(eas)+eps), + grad_sum, state.exp_avg_sq) + numerator_acum = tree_utils.tree_vdot(updates, s_weighted) + + exp_avg = tree_map(lambda ea, g: beta1ea + (1-beta1)dlrg, + state.exp_avg, updates) + exp_avg_sq = tree_map(lambda eas, g: beta2eas + (1-beta2)gg, + state.exp_avg_sq, updates) + + grad_sum = tree_map(lambda sk, g: sb2sk + (1-sb2)dlrg, grad_sum, updates) + + grad_sum_l1 = tree_utils.tree_sum(tree_map(jnp.abs, grad_sum)) + + numerator_weighted = sb2numerator_weighted + (1-sb2)dlrnumerator_acum + + d_estimate = numerator_weighted/((1-sb2)grad_sum_l1) + estim_lr = jnp.maximum(state.estim_lr, d_estimate) + + p_update = tree_map(lambda ea, eas, p: + -weight_decaydlrp + - ea/(jnp.sqrt(eas)+eps), + exp_avg, exp_avg_sq, params) + + new_state = DAdaptAdamWState(exp_avg, exp_avg_sq, grad_sum, + estim_lr, numerator_weighted, + utils.safe_int32_increment(count)) + return p_update, new_state + + return base.GradientTransformation(init_fn, update_fn) diff --git a/optax/contrib/prodigy.py b/optax/contrib/prodigy.py new file mode 100644 index 000000000..14addd895 --- /dev/null +++ b/optax/contrib/prodigy.py @@ -0,0 +1,137 @@ + +# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Prodigy Optimizer. + +A contributed implementation of the method from "Prodigy: An Expeditiously +Adaptive Parameter-Free Learner" (https://arxiv.org/abs/2306.06101) by +Konstantin Mishchenko and Aaron Defazio. A new variant of D-Adapt Adam that +adapts the learning rate faster. +""" +import jax.numpy as jnp +from jax.tree_util import tree_map + +from typing import NamedTuple, Optional, Tuple +from optax import tree_utils +from optax._src import base +from optax._src import utils + +class ProdigyState(NamedTuple): + exp_avg: base.Updates + exp_avg_sq: base.Updates + grad_sum: base.Updates # exponential moving average of the sum of gradients + params0: base.Updates # Initial point + estim_lr: float # Distance to solution estimate + numerator_weighted: float + count: float + +def prodigy(learning_rate: base.ScalarOrSchedule = 0.1, + betas=(0.9, 0.999), + beta3=None, + eps=1e-8, + estim_lr0=1e-6, + estim_lr_coef=1.0, + weight_decay=0) -> base.GradientTransformation: + """Learning rate free AdamW with Prodigy + + Implementation of the Prodigy method from "Prodigy: An Expeditiously + Adaptive Parameter-Free Learner", a version of D-Adapt AdamW that adapts the + baseline learning rate faster by using a weighting of the gradients that + places higher weights on more recent gradients. + This method works best when combined with a learning rate schedule that + treats 1.0 as the base (usually max) value. + + References: + [Mishchenko & Defazio, 2023](https://arxiv.org/abs/2306.06101) + + Args: + learning_rate: Learning rate scheduling parameter. The recommended schedule + is a linear_schedule with init_value=1.0 and end_value=0, combined with a + 0-20% learning rate warmup. + betas: Betas for the underlying AdamW Optimizer. + beta3: Optional momentum parameter for estimation of D. + eps: eps for the underlying AdamW Optimizer. + estim_lr0: Initial (under-)estimate of the learning rate. + estim_lr_coef: LR estimates are multiplied by this parameter. + weight_decay: AdamW style weight-decay. To use Regular Adam decay, chain + with add_decayed_weights. + + Returns: + A `GradientTransformation` object. + """ + beta1, beta2 = betas + if beta3 is None: + beta3 = beta20.5 + + def init_fn(params: base.Params) -> ProdigyState: + exp_avg = tree_map(lambda p: jnp.zeros(p.shape), params) + exp_avg_sq = tree_map(lambda p: jnp.zeros(p.shape), params) + grad_sum = tree_map(lambda p: jnp.zeros(p.shape), params) + params0 = params + estim_lr = estim_lr0 + numerator_weighted = 0 + count = 0 + return ProdigyState(exp_avg, exp_avg_sq, + grad_sum, params0, estim_lr, + numerator_weighted, count) + + def update_fn(updates: base.Updates, + state: ProdigyState, + params: Optional[base.Params] = None, + ) -> Tuple[base.Updates, ProdigyState]: + if params is None: + raise ValueError(base.NO_PARAMS_MSG) + + count = state.count + sched = learning_rate(count) if callable(learning_rate) else learning_rate + grad_sum = state.grad_sum + params0 = state.params0 + estim_lr = state.estim_lr + numerator_weighted = state.numerator_weighted + + bc = ((1-beta2(count+1))0.5)/(1-beta1(count+1)) + dlr = estim_lr sched * bc + dg = tree_map(lambda g: estim_lr * g, updates) + + param_diff = tree_map(lambda p0, p: p0-p, params0, params) + numerator_acum = tree_utils.tree_vdot(updates, param_diff) + + exp_avg = tree_map(lambda ea, dgk: beta1ea + (1-beta1)dgk, + state.exp_avg, dg) + exp_avg_sq = tree_map(lambda eas, dgk: beta2eas + (1-beta2)dgkdgk, + state.exp_avg_sq, dg) + + grad_sum = tree_map(lambda sk, dgk: beta3sk + dlrdgk/estim_lr0, + grad_sum, dg) + + numerator_weighted = beta3numerator_weighted + numerator_weighted += (estim_lr/estim_lr0)dlrnumerator_acum + + denominator = tree_utils.tree_sum(tree_map(jnp.abs, grad_sum)) + + lr_estimate = estim_lr_coefnumerator_weighted/denominator + estim_lr = jnp.maximum(state.estim_lr, lr_estimate) + + p_update = tree_map(lambda ea, eas, p: + -weight_decaydlrp + - dlrea/(jnp.sqrt(eas) + estim_lr*eps), + exp_avg, exp_avg_sq, params) + + new_state = ProdigyState(exp_avg, exp_avg_sq, grad_sum, params0, + estim_lr, numerator_weighted, + utils.safe_int32_increment(count)) + return p_update, new_state + + return base.GradientTransformation(init_fn, update_fn)	diff --git a/optax/contrib/dadapt_adamw_test.py b/optax/contrib/dadapt_adamw_test.py new file mode 100644 index 000000000..992fe1046 --- /dev/null +++ b/optax/contrib/dadapt_adamw_test.py @@ -0,0 +1,86 @@ +# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Tests for `dadapt_adamw.py`.""" + +from absl.testing import absltest +from absl.testing import parameterized + +import chex +import jax +import jax.numpy as jnp + +from optax import contrib +from optax._src import numerics +from optax._src import update +from optax.tree_utils import _state_utils + + +def _setup_parabola(dtype): + """Quadratic function as an optimization target.""" + initial_params = jnp.array([-1.0, 10.0, 1.0], dtype=dtype) + final_params = jnp.array([1.0, -1.0, 1.0], dtype=dtype) + + @jax.grad + def get_updates(params): + return jnp.sum(numerics.abs_sq(params - final_params)) + + return initial_params, final_params, get_updates + + +def _setup_rosenbrock(dtype): + """Rosenbrock function as an optimization target.""" + a = 1.0 + b = 100.0 + + initial_params = jnp.array([0.0, 0.0], dtype=dtype) + final_params = jnp.array([a, a*2], dtype=dtype) + + @jax.grad + def get_updates(params): + return (numerics.abs_sq(a - params[0]) + + b numerics.abs_sq(params[1] - params[0]2)) + + return initial_params, final_params, get_updates + +class DAdaptAdamWTest(chex.TestCase): + @parameterized.product( + opt_name=('dadapt_adamw',), + target=(_setup_parabola, _setup_rosenbrock), + dtype=(jnp.float32,), + ) + def test_optimization(self, opt_name, target, dtype): + + opt = getattr(contrib, opt_name)() + initial_params, final_params, get_updates = target(dtype) + + @jax.jit + def step(params, state): + updates = get_updates(params) + updates, state = opt.update(updates, state, params) + params = update.apply_updates(params, updates) + return params, state + + params = initial_params + state = opt.init(params) + # A no-op change, to verify that tree map works. + state = _state_utils.tree_map_params(opt, lambda v: v, state) + + for _ in range(15000): + params, state = step(params, state) + + chex.assert_trees_all_close(params, final_params, rtol=3e-2, atol=3e-2) + +if __name__ == '__main__': + absltest.main() diff --git a/optax/contrib/prodigy_test.py b/optax/contrib/prodigy_test.py new file mode 100644 index 000000000..f6bcbabcb --- /dev/null +++ b/optax/contrib/prodigy_test.py @@ -0,0 +1,86 @@ +# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Tests for `prodigy.py`.""" + +from absl.testing import absltest +from absl.testing import parameterized + +import chex +import jax +import jax.numpy as jnp + +from optax import contrib +from optax._src import numerics +from optax._src import update +from optax.tree_utils import _state_utils + + +def _setup_parabola(dtype): + """Quadratic function as an optimization target.""" + initial_params = jnp.array([-1.0, 10.0, 1.0], dtype=dtype) + final_params = jnp.array([1.0, -1.0, 1.0], dtype=dtype) + + @jax.grad + def get_updates(params): + return jnp.sum(numerics.abs_sq(params - final_params)) + + return initial_params, final_params, get_updates + + +def _setup_rosenbrock(dtype): + """Rosenbrock function as an optimization target.""" + a = 1.0 + b = 100.0 + + initial_params = jnp.array([0.0, 0.0], dtype=dtype) + final_params = jnp.array([a, a2], dtype=dtype) + + @jax.grad + def get_updates(params): + return (numerics.abs_sq(a - params[0]) + + b * numerics.abs_sq(params[1] - params[0]**2)) + + return initial_params, final_params, get_updates + +class ProdigyTest(chex.TestCase): + @parameterized.product( + opt_name=('prodigy',), + target=(_setup_parabola, _setup_rosenbrock), + dtype=(jnp.float32,), + ) + def test_optimization(self, opt_name, target, dtype): + + opt = getattr(contrib, opt_name)() + initial_params, final_params, get_updates = target(dtype) + + @jax.jit + def step(params, state): + updates = get_updates(params) + updates, state = opt.update(updates, state, params) + params = update.apply_updates(params, updates) + return params, state + + params = initial_params + state = opt.init(params) + # A no-op change, to verify that tree map works. + state = _state_utils.tree_map_params(opt, lambda v: v, state) + + for _ in range(10000): + params, state = step(params, state) + + chex.assert_trees_all_close(params, final_params, rtol=3e-2, atol=3e-2) + +if __name__ == '__main__': + absltest.main()	diff --git a/docs/api.rst b/docs/api.rst index 9efa959c3..510dc74d6 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -776,6 +776,10 @@ scale_gradient SAMState cocob COCOBState + dadapt_adamw + DAdaptAdamWState + prodigy + ProdigyState Complex-Valued Optimization	[ { "components": [ { "doc": "", "lines": [ 30, 36 ], "name": "DAdaptAdamWState", "signature": "class DAdaptAdamWState(NamedTuple):", "type": "class" }, { "doc": "Learning rate free AdamW by D-Adaptation\n\nAdapts the ba...	[ "optax/contrib/dadapt_adamw_test.py::DAdaptAdamWTest::test_optimization0", "optax/contrib/dadapt_adamw_test.py::DAdaptAdamWTest::test_optimization1", "optax/contrib/prodigy_test.py::ProdigyTest::test_optimization0", "optax/contrib/prodigy_test.py::ProdigyTest::test_optimization1" ]	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> D-Adaptation and Prodigy contrib implementations Implementations of D-Adaptation AdamW and the related method Prodigy based on the official PyTorch implementations. I have verified that they give the same outputs as the PyTorch version on an example problem. Unit tests similar to those used on other optimizers in contrib. https://github.com/facebookresearch/dadaptation https://github.com/konstmish/prodigy These two new optimizers perform learning rate adaptation, similar to Mechanic and COCOB, two optimizers already included in contrib, but by a different mechanism, and so I think these are relevant to Optax and interesting to the community. D-Adaptation won an ICML outstanding paper award and is already gaining a lot of traction in the ML community, particularly for fine-tuning diffusion models with the Prodigy variant. ---------- Thanks @adefazio for the contribution! </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in optax/contrib/dadapt_adamw.py] (definition of DAdaptAdamWState:) class DAdaptAdamWState(NamedTuple): (definition of dadapt_adamw:) def dadapt_adamw(learning_rate: base.ScalarOrSchedule = 1.0, betas=(0.9, 0.999), eps=1e-8, estim_lr0=1e-6, weight_decay=0) -> base.GradientTransformation: """Learning rate free AdamW by D-Adaptation Adapts the baseline learning rate of AdamW automatically by estimating the initial distance to solution in the infinity norm. This method works best when combined with a learning rate schedule that treats 1.0 as the base (usually max) value. References: [Defazio & Mishchenko, 2023](https://arxiv.org/abs/2301.07733) Args: learning_rate: Learning rate scheduling parameter. The recommended schedule is a linear_schedule with init_value=1.0 and end_value=0, combined with a 0-20% learning rate warmup. betas: Betas for the underlying AdamW Optimizer. eps: eps for the underlying AdamW Optimizer. estim_lr0: Initial (under-)estimate of the learning rate. weight_decay: AdamW style weight-decay. To use Regular Adam decay, chain with add_decayed_weights. Returns: A `GradientTransformation` object.""" (definition of dadapt_adamw.init_fn:) def init_fn(params: base.Params) -> DAdaptAdamWState: (definition of dadapt_adamw.update_fn:) def update_fn( updates: base.Updates, state: DAdaptAdamWState, params: Optional[base.Params] = None, ) -> Tuple[base.Updates, DAdaptAdamWState]: [end of new definitions in optax/contrib/dadapt_adamw.py] [start of new definitions in optax/contrib/prodigy.py] (definition of ProdigyState:) class ProdigyState(NamedTuple): (definition of prodigy:) def prodigy(learning_rate: base.ScalarOrSchedule = 0.1, betas=(0.9, 0.999), beta3=None, eps=1e-8, estim_lr0=1e-6, estim_lr_coef=1.0, weight_decay=0) -> base.GradientTransformation: """Learning rate free AdamW with Prodigy Implementation of the Prodigy method from "Prodigy: An Expeditiously Adaptive Parameter-Free Learner", a version of D-Adapt AdamW that adapts the baseline learning rate faster by using a weighting of the gradients that places higher weights on more recent gradients. This method works best when combined with a learning rate schedule that treats 1.0 as the base (usually max) value. References: [Mishchenko & Defazio, 2023](https://arxiv.org/abs/2306.06101) Args: learning_rate: Learning rate scheduling parameter. The recommended schedule is a linear_schedule with init_value=1.0 and end_value=0, combined with a 0-20% learning rate warmup. betas: Betas for the underlying AdamW Optimizer. beta3: Optional momentum parameter for estimation of D. eps: eps for the underlying AdamW Optimizer. estim_lr0: Initial (under-)estimate of the learning rate. estim_lr_coef: LR estimates are multiplied by this parameter. weight_decay: AdamW style weight-decay. To use Regular Adam decay, chain with add_decayed_weights. Returns: A `GradientTransformation` object.""" (definition of prodigy.init_fn:) def init_fn(params: base.Params) -> ProdigyState: (definition of prodigy.update_fn:) def update_fn(updates: base.Updates, state: ProdigyState, params: Optional[base.Params] = None, ) -> Tuple[base.Updates, ProdigyState]: [end of new definitions in optax/contrib/prodigy.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		1e08bccf195ac54e7d9d766eb5e69345bf0e3230
deepset-ai__haystack-6413	6,413	deepset-ai/haystack	null	5353706cf6778443a975fb93c5359c4d676e7173	2023-11-27T08:30:06Z	diff --git a/haystack/pipeline.py b/haystack/pipeline.py index 0478e36988..be8d79583b 100644 --- a/haystack/pipeline.py +++ b/haystack/pipeline.py @@ -1,4 +1,5 @@ -from typing import Any, Dict, Optional, Union, TextIO +from collections import defaultdict +from typing import Any, Dict, Optional, Union, TextIO, Tuple from pathlib import Path import datetime import logging @@ -35,14 +36,76 @@ def __init__( def run(self, data: Dict[str, Any], debug: bool = False) -> Dict[str, Any]: """ - Runs the pipeline. + Runs the pipeline with given input data. + + :param data: A dictionary of inputs for the pipeline's components. Each key is a component name + and its value is a dictionary of that component's input parameters. + :param debug: Set to True to collect and return debug information. + :return: A dictionary containing the pipeline's output. + :raises PipelineRuntimeError: If a component fails or returns unexpected output. + + Example a - Using named components: + Consider a 'Hello' component that takes a 'word' input and outputs a greeting. + + ```python + @component + class Hello: + @component.output_types(output=str) + def run(self, word: str): + return {"output": f"Hello, {word}!"} + ``` + + Create a pipeline with two 'Hello' components connected together: + + ```python + pipeline = Pipeline() + pipeline.add_component("hello", Hello()) + pipeline.add_component("hello2", Hello()) + pipeline.connect("hello.output", "hello2.word") + result = pipeline.run(data={"hello": {"word": "world"}}) + ``` + + This runs the pipeline with the specified input for 'hello', yielding + {'hello2': {'output': 'Hello, Hello, world!!'}}. + + Example b - Using flat inputs: + You can also pass inputs directly without specifying component names: + + ```python + result = pipeline.run(data={"word": "world"}) + ``` + + The pipeline resolves inputs to the correct components, returning + {'hello2': {'output': 'Hello, Hello, world!!'}}. + """ + # check whether the data is a nested dictionary of component inputs where each key is a component name + # and each value is a dictionary of input parameters for that component + is_nested_component_input = all(isinstance(value, dict) for value in data.values()) + if is_nested_component_input: + return self._run_internal(data=data, debug=debug) + else: + # flat input, a dict where keys are input names and values are the corresponding values + # we need to convert it to a nested dictionary of component inputs and then run the pipeline + # just like in the previous case + pipeline_inputs, unresolved_inputs = self._prepare_component_input_data(data) + if unresolved_inputs: + logger.warning( + "Inputs %s were not matched to any component inputs, please check your run parameters.", + list(unresolved_inputs.keys()), + ) + + return self._run_internal(data=pipeline_inputs, debug=debug) + + def _run_internal(self, data: Dict[str, Any], debug: bool = False) -> Dict[str, Any]: + """ + Runs the pipeline by invoking the underlying run to initiate the pipeline execution. :params data: the inputs to give to the input components of the Pipeline. :params debug: whether to collect and return debug information. :returns: A dictionary with the outputs of the output components of the Pipeline. - :raises PipelineRuntimeError: if the any of the components fail or return unexpected output. + :raises PipelineRuntimeError: if any of the components fail or return unexpected output. """ pipeline_running(self) return super().run(data=data, debug=debug) @@ -97,3 +160,41 @@ def load(cls, fp: TextIO, marshaller: Marshaller = DEFAULT_MARSHALLER) -> "Pipel :returns: A `Pipeline` object. """ return cls.from_dict(marshaller.unmarshal(fp.read())) + + def _prepare_component_input_data(self, data: Dict[str, Any]) -> Tuple[Dict[str, Dict[str, Any]], Dict[str, Any]]: + """ + Organizes input data for pipeline components and identifies any inputs that are not matched to any + component's input slots. + + This method processes a flat dictionary of input data, where each key-value pair represents an input name + and its corresponding value. It distributes these inputs to the appropriate pipeline components based on + their input requirements. Inputs that don't match any component's input slots are classified as unresolved. + + :param data: A dictionary with input names as keys and input values as values. + :type data: Dict[str, Any] + :return: A tuple containing two elements: + 1. A dictionary mapping component names to their respective matched inputs. + 2. A dictionary of inputs that were not matched to any component, termed as unresolved keyword arguments. + :rtype: Tuple[Dict[str, Dict[str, Any]], Dict[str, Any]] + """ + pipeline_input_data: Dict[str, Dict[str, Any]] = defaultdict(dict) + unresolved_kwargs = {} + + # Retrieve the input slots for each component in the pipeline + available_inputs: Dict[str, Dict[str, Any]] = self.inputs() + + # Go through all provided to distribute them to the appropriate component inputs + for input_name, input_value in data.items(): + resolved_at_least_once = False + + # Check each component to see if it has a slot for the current kwarg + for component_name, component_inputs in available_inputs.items(): + if input_name in component_inputs: + # If a match is found, add the kwarg to the component's input data + pipeline_input_data[component_name][input_name] = input_value + resolved_at_least_once = True + + if not resolved_at_least_once: + unresolved_kwargs[input_name] = input_value + + return pipeline_input_data, unresolved_kwargs diff --git a/releasenotes/notes/allow-simplified-pipeline-run-input-e3dd98ff38f0bc01.yaml b/releasenotes/notes/allow-simplified-pipeline-run-input-e3dd98ff38f0bc01.yaml new file mode 100644 index 0000000000..6badfe24ed --- /dev/null +++ b/releasenotes/notes/allow-simplified-pipeline-run-input-e3dd98ff38f0bc01.yaml @@ -0,0 +1,6 @@ +--- +preview: + - \| + Adds option to run pipelines without specifying component inputs and their corresponding key/value pairs. Instead, + provide the input keys/values directly, and the pipeline's internal mechanisms will automatically determine the + appropriate components.	diff --git a/test/test_pipeline.py b/test/test_pipeline.py index b5e4aee973..64d5374224 100644 --- a/test/test_pipeline.py +++ b/test/test_pipeline.py @@ -56,3 +56,111 @@ def test_pipeline_load(test_files_path): assert pipeline.max_loops_allowed == 99 assert isinstance(pipeline.get_component("Comp1"), TestComponent) assert isinstance(pipeline.get_component("Comp2"), TestComponent) + + +@pytest.mark.unit +def test_pipeline_resolution_simple_input(): + @component + class Hello: + @component.output_types(output=str) + def run(self, word: str): + """ + Takes a string in input and returns "Hello, <string>!" + in output. + """ + return {"output": f"Hello, {word}!"} + + pipeline = Pipeline() + pipeline.add_component("hello", Hello()) + pipeline.add_component("hello2", Hello()) + + pipeline.connect("hello.output", "hello2.word") + result = pipeline.run(data={"hello": {"word": "world"}}) + assert result == {"hello2": {"output": "Hello, Hello, world!!"}} + + result = pipeline.run(data={"word": "world"}) + assert result == {"hello2": {"output": "Hello, Hello, world!!"}} + + +def test_pipeline_resolution_wrong_input_name(caplog): + @component + class Hello: + @component.output_types(output=str) + def run(self, who: str): + """ + Takes a string in input and returns "Hello, <string>!" + in output. + """ + return {"output": f"Hello, {who}!"} + + pipeline = Pipeline() + pipeline.add_component("hello", Hello()) + pipeline.add_component("hello2", Hello()) + + pipeline.connect("hello.output", "hello2.who") + + # test case with nested component inputs + with pytest.raises(ValueError): + pipeline.run(data={"hello": {"non_existing_input": "world"}}) + + # test case with flat component inputs + with pytest.raises(ValueError): + pipeline.run(data={"non_existing_input": "world"}) + + # important to check that the warning is logged for UX purposes, leave it here + assert "were not matched to any component" in caplog.text + + +def test_pipeline_resolution_with_mixed_correct_and_incorrect_input_names(caplog): + @component + class Hello: + @component.output_types(output=str) + def run(self, who: str): + """ + Takes a string in input and returns "Hello, <string>!" + in output. + """ + return {"output": f"Hello, {who}!"} + + pipeline = Pipeline() + pipeline.add_component("hello", Hello()) + pipeline.add_component("hello2", Hello()) + + pipeline.connect("hello.output", "hello2.who") + + # test case with nested component inputs + # this will raise ValueError because hello component does not have an input named "non_existing_input" + # even though it has an input named "who" + with pytest.raises(ValueError): + pipeline.run(data={"hello": {"non_existing_input": "world", "who": "world"}}) + + # test case with flat component inputs + # this will not raise ValueError because the input "who" will be resolved to the correct component + # and we'll log a warning for the input "non_existing_input" which was not resolved + result = pipeline.run(data={"non_existing_input": "world", "who": "world"}) + assert result == {"hello2": {"output": "Hello, Hello, world!!"}} + + # important to check that the warning is logged for UX purposes, leave it here + assert "were not matched to any component" in caplog.text + + +def test_pipeline_resolution_duplicate_input_names_across_components(): + @component + class Hello: + @component.output_types(output=str) + def run(self, who: str, what: str): + return {"output": f"Hello {who} {what}!"} + + pipe = Pipeline() + pipe.add_component("hello", Hello()) + pipe.add_component("hello2", Hello()) + + pipe.connect("hello.output", "hello2.who") + + result = pipe.run(data={"what": "Haystack", "who": "world"}) + assert result == {"hello2": {"output": "Hello Hello world Haystack! Haystack!"}} + + resolved, _ = pipe._prepare_component_input_data(data={"what": "Haystack", "who": "world"}) + + # why does hello2 have only one input? Because who of hello2 is inserted from hello.output + assert resolved == {"hello": {"what": "Haystack", "who": "world"}, "hello2": {"what": "Haystack"}}	diff --git a/releasenotes/notes/allow-simplified-pipeline-run-input-e3dd98ff38f0bc01.yaml b/releasenotes/notes/allow-simplified-pipeline-run-input-e3dd98ff38f0bc01.yaml new file mode 100644 index 0000000000..6badfe24ed --- /dev/null +++ b/releasenotes/notes/allow-simplified-pipeline-run-input-e3dd98ff38f0bc01.yaml @@ -0,0 +1,6 @@ +--- +preview: + - \| + Adds option to run pipelines without specifying component inputs and their corresponding key/value pairs. Instead, + provide the input keys/values directly, and the pipeline's internal mechanisms will automatically determine the + appropriate components.	[ { "components": [ { "doc": "Runs the pipeline by invoking the underlying run to initiate the pipeline execution.\n\n:params data: the inputs to give to the input components of the Pipeline.\n:params debug: whether to collect and return debug information.\n\n:returns: A dictionary with the outputs ...	[ "[", "test/test_pipeline.py::test_pipeline_resolution_simple_input", "test/test_pipeline.py::test_pipeline_resolution_wrong_input_name", "test/test_pipeline.py::test_pipeline_resolution_with_mixed_correct_and_incorrect_input_names", "test/test_pipeline.py::test_pipeline_resolution_duplicate_input_names_acro...	[ "test/test_pipeline.py::test_pipeline_dumps", "test/test_pipeline.py::test_pipeline_loads", "test/test_pipeline.py::test_pipeline_dump", "test/test_pipeline.py::test_pipeline_load" ]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat: Allow flat dictionary `Pipeline.run()` inputs ### Why: This pull request introduces a significant enhancement to the `Pipeline` class. The main objective is to simplify the way users interact with pipelines, especially in terms of specifying inputs for various components. - fixes https://github.com/deepset-ai/haystack/issues/6101 - supersedes https://github.com/deepset-ai/haystack/pull/6266 ### What: - Modification to `Pipeline.run()`: The `run` method of the `Pipeline` class has been updated to handle both nested and flat input dictionaries. This allows users to run pipelines without explicitly specifying component inputs and their corresponding key/value pairs. - New `_prepare_component_input_data()` Method: A private method `_prepare_component_input_data` has been added. It organizes input data for pipeline components and identifies any inputs that are not matched to any component's input slots. - Release Notes Addition: A new file `allow-simplified-pipeline-run-input-e3dd98ff38f0bc01.yaml` has been added to the `releasenotes/notes` directory, describing the new feature. - Updated Unit Tests: The `test_pipeline.py` file has been updated with new unit tests to cover the changes in pipeline input resolution. ### How can it be used: Users can now run pipelines with simplified input formats. Instead of specifying a nested dictionary with each key being a component name and its value a dictionary of that component's input parameters, users can provide flat input dictionaries. The pipeline's internal mechanisms will automatically determine the appropriate components for each input. This feature enhances usability and reduces the complexity of pipeline executions. ### How did you test it: New unit tests have been added to `test_pipeline.py` to cover the new functionality. These tests include scenarios for both nested and flat input dictionaries, verifying the pipeline's ability to correctly resolve inputs to the appropriate components. The tests also cover cases with incorrect input names to ensure that the pipeline appropriately handles and logs warnings for unmatched inputs. ### Notes for the reviewer: - Please review the changes in the context of overall pipeline functionality to ensure that this new feature integrates well with existing capabilities. - Pay special attention to the new `_prepare_component_input_data()` method to ensure it aligns with the intended use cases and handles edge cases effectively. - The release notes addition should accurately reflect the scope and impact of these changes for end users. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in haystack/pipeline.py] (definition of Pipeline._run_internal:) def _run_internal(self, data: Dict[str, Any], debug: bool = False) -> Dict[str, Any]: """Runs the pipeline by invoking the underlying run to initiate the pipeline execution. :params data: the inputs to give to the input components of the Pipeline. :params debug: whether to collect and return debug information. :returns: A dictionary with the outputs of the output components of the Pipeline. :raises PipelineRuntimeError: if any of the components fail or return unexpected output.""" (definition of Pipeline._prepare_component_input_data:) def _prepare_component_input_data(self, data: Dict[str, Any]) -> Tuple[Dict[str, Dict[str, Any]], Dict[str, Any]]: """Organizes input data for pipeline components and identifies any inputs that are not matched to any component's input slots. This method processes a flat dictionary of input data, where each key-value pair represents an input name and its corresponding value. It distributes these inputs to the appropriate pipeline components based on their input requirements. Inputs that don't match any component's input slots are classified as unresolved. :param data: A dictionary with input names as keys and input values as values. :type data: Dict[str, Any] :return: A tuple containing two elements: 1. A dictionary mapping component names to their respective matched inputs. 2. A dictionary of inputs that were not matched to any component, termed as unresolved keyword arguments. :rtype: Tuple[Dict[str, Dict[str, Any]], Dict[str, Any]]""" [end of new definitions in haystack/pipeline.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		f4d9c2bb917be0ffe132dffcc2ad4f1b0fcc5967
roboflow__supervision-620	620	roboflow/supervision	null	10c44b0143c13b33c1951509f9f11c37c6373752	2023-11-26T10:27:34Z	diff --git a/supervision/draw/color.py b/supervision/draw/color.py index 69bcc9c5e..9d1b4ad98 100644 --- a/supervision/draw/color.py +++ b/supervision/draw/color.py @@ -71,6 +71,21 @@ def from_hex(cls, color_hex: str) -> Color: r, g, b = (int(color_hex[i : i + 2], 16) for i in range(0, 6, 2)) return cls(r, g, b) + def as_hex(self) -> str: + """ + Converts the Color instance to a hex string. + + Returns: + str: The hexadecimal color string. + + Example: + ``` + >>> Color(r=255, g=0, b=255).as_hex() + '#ff00ff' + ``` + """ + return f"#{self.r:02x}{self.g:02x}{self.b:02x}" + def as_rgb(self) -> Tuple[int, int, int]: """ Returns the color as an RGB tuple.	diff --git a/test/draw/test_color.py b/test/draw/test_color.py index 723f7043e..eb4c36574 100644 --- a/test/draw/test_color.py +++ b/test/draw/test_color.py @@ -30,3 +30,22 @@ def test_color_from_hex( with exception: result = Color.from_hex(color_hex=color_hex) assert result == expected_result + + +@pytest.mark.parametrize( + "color, expected_result, exception", + [ + (Color.white(), "#ffffff", DoesNotRaise()), + (Color.black(), "#000000", DoesNotRaise()), + (Color.red(), "#ff0000", DoesNotRaise()), + (Color.green(), "#00ff00", DoesNotRaise()), + (Color.blue(), "#0000ff", DoesNotRaise()), + (Color(r=128, g=128, b=0), "#808000", DoesNotRaise()), + ], +) +def test_color_as_hex( + color: Color, expected_result: Optional[str], exception: Exception +) -> None: + with exception: + result = color.as_hex() + assert result == expected_result		[ { "components": [ { "doc": "Converts the Color instance to a hex string.\n\nReturns:\n str: The hexadecimal color string.\n\nExample:\n ```\n >>> Color(r=255, g=0, b=255).as_hex()\n '#ff00ff'\n ```", "lines": [ 74, 87 ], "name": "Color.as_...	[ "test/draw/test_color.py::test_color_as_hex[color0-#ffffff-exception0]", "test/draw/test_color.py::test_color_as_hex[color1-#000000-exception1]", "test/draw/test_color.py::test_color_as_hex[color2-#ff0000-exception2]", "test/draw/test_color.py::test_color_as_hex[color3-#00ff00-exception3]", "test/draw/test_...	[ "test/draw/test_color.py::test_color_from_hex[fff-expected_result0-exception0]", "test/draw/test_color.py::test_color_from_hex[#fff-expected_result1-exception1]", "test/draw/test_color.py::test_color_from_hex[ffffff-expected_result2-exception2]", "test/draw/test_color.py::test_color_from_hex[#ffffff-expected_...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add 'as_hex' method and corresponding test to `Color` class. ## Type of change Please delete options that are not relevant. - [ ] Bug fix (non-breaking change which fixes an issue) - [x] New feature (non-breaking change which adds functionality) - [ ] This change requires a documentation update ## Docs - [x] Docs updated? What were the changes: ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in supervision/draw/color.py] (definition of Color.as_hex:) def as_hex(self) -> str: """Converts the Color instance to a hex string. Returns: str: The hexadecimal color string. Example: ``` >>> Color(r=255, g=0, b=255).as_hex() '#ff00ff' ```""" [end of new definitions in supervision/draw/color.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		3eb5c0b024e3e46877b7fe4fd66e6177d1308ba0
slackapi__python-slack-sdk-1431	1,431	slackapi/python-slack-sdk	null	3e2d7e825cce2d06a35324772ade72483d7cdec1	2023-11-21T05:36:22Z	diff --git a/slack_sdk/models/blocks/__init__.py b/slack_sdk/models/blocks/__init__.py index 87febae70..96ecfb9e8 100644 --- a/slack_sdk/models/blocks/__init__.py +++ b/slack_sdk/models/blocks/__init__.py @@ -43,6 +43,12 @@ from .block_elements import StaticSelectElement from .block_elements import UserMultiSelectElement from .block_elements import UserSelectElement +from .block_elements import RichTextElement +from .block_elements import RichTextElementParts +from .block_elements import RichTextListElement +from .block_elements import RichTextPreformattedElement +from .block_elements import RichTextQuoteElement +from .block_elements import RichTextSectionElement from .blocks import ActionsBlock from .blocks import Block from .blocks import CallBlock @@ -54,6 +60,7 @@ from .blocks import InputBlock from .blocks import SectionBlock from .blocks import VideoBlock +from .blocks import RichTextBlock __all__ = [ "ButtonStyles", @@ -93,6 +100,12 @@ "StaticSelectElement", "UserMultiSelectElement", "UserSelectElement", + "RichTextElement", + "RichTextElementParts", + "RichTextListElement", + "RichTextPreformattedElement", + "RichTextQuoteElement", + "RichTextSectionElement", "ActionsBlock", "Block", "CallBlock", @@ -104,4 +117,5 @@ "InputBlock", "SectionBlock", "VideoBlock", + "RichTextBlock", ] diff --git a/slack_sdk/models/blocks/block_elements.py b/slack_sdk/models/blocks/block_elements.py index 8b9ac4ed2..bf2518f0c 100644 --- a/slack_sdk/models/blocks/block_elements.py +++ b/slack_sdk/models/blocks/block_elements.py @@ -1834,3 +1834,309 @@ def __init__( self.workflow = workflow self.style = style self.accessibility_label = accessibility_label + + +# ------------------------------------------------- +# Rich text elements +# ------------------------------------------------- + + +class RichTextElement(BlockElement): + pass + + +class RichTextListElement(RichTextElement): + type = "rich_text_list" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"elements", "style", "indent", "offset", "border"}) + + def __init__( + self, + , + elements: Sequence[Union[dict, RichTextElement]], + style: Optional[str] = None, # bullet, ordered + indent: Optional[int] = None, + offset: Optional[int] = None, + border: Optional[int] = None, + others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.elements = elements + self.style = style + self.indent = indent + self.offset = offset + self.border = border + + +class RichTextPreformattedElement(RichTextElement): + type = "rich_text_preformatted" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"elements", "border"}) + + def __init__( + self, + , + elements: Sequence[Union[dict, RichTextElement]], + border: Optional[int] = None, + *others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.elements = elements + self.border = border + + +class RichTextQuoteElement(RichTextElement): + type = "rich_text_quote" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"elements"}) + + def __init__( + self, + , + elements: Sequence[Union[dict, RichTextElement]], + *others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.elements = elements + + +class RichTextSectionElement(RichTextElement): + type = "rich_text_section" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"elements"}) + + def __init__( + self, + , + elements: Sequence[Union[dict, RichTextElement]], + *others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.elements = elements + + +class RichTextElementParts: + class TextStyle: + def __init__( + self, + , + bold: Optional[bool] = None, + italic: Optional[bool] = None, + strike: Optional[bool] = None, + code: Optional[bool] = None, + ): + self.bold = bold + self.italic = italic + self.strike = strike + self.code = code + + def to_dict(self, args) -> dict: + result = { + "bold": self.bold, + "italic": self.italic, + "strike": self.strike, + "code": self.code, + } + return {k: v for k, v in result.items() if v is not None} + + class Text(RichTextElement): + type = "text" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"text", "style"}) + + def __init__( + self, + , + text: str, + style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, + *others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.text = text + self.style = style + + class Channel(RichTextElement): + type = "channel" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"channel_id", "style"}) + + def __init__( + self, + , + channel_id: str, + style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, + *others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.channel_id = channel_id + self.style = style + + class User(RichTextElement): + type = "user" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"user_id", "style"}) + + def __init__( + self, + , + user_id: str, + style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, + *others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.user_id = user_id + self.style = style + + class Emoji(RichTextElement): + type = "emoji" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"name", "skin_tone", "unicode", "style"}) + + def __init__( + self, + , + name: str, + skin_tone: Optional[int] = None, + unicode: Optional[str] = None, + style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, + *others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.name = name + self.skin_tone = skin_tone + self.unicode = unicode + self.style = style + + class Link(RichTextElement): + type = "link" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"url", "text", "style"}) + + def __init__( + self, + , + url: str, + text: Optional[str] = None, + style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, + *others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.url = url + self.text = text + self.style = style + + class Team(RichTextElement): + type = "team" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"team_id", "style"}) + + def __init__( + self, + , + team_id: str, + style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, + *others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.team_id = team_id + self.style = style + + class UserGroup(RichTextElement): + type = "usergroup" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"usergroup_id", "style"}) + + def __init__( + self, + , + usergroup_id: str, + style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, + *others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.usergroup_id = usergroup_id + self.style = style + + class Date(RichTextElement): + type = "date" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"timestamp"}) + + def __init__( + self, + , + timestamp: str, + *others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.timestamp = timestamp + + class Broadcast(RichTextElement): + type = "broadcast" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"range"}) + + def __init__( + self, + , + range: str, # channel, here, .. + *others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.range = range + + class Color(RichTextElement): + type = "color" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"value"}) + + def __init__( + self, + , + value: str, + *others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.value = value diff --git a/slack_sdk/models/blocks/blocks.py b/slack_sdk/models/blocks/blocks.py index 590f8ae26..5bd0171da 100644 --- a/slack_sdk/models/blocks/blocks.py +++ b/slack_sdk/models/blocks/blocks.py @@ -11,7 +11,7 @@ from .basic_components import MarkdownTextObject from .basic_components import PlainTextObject from .basic_components import TextObject -from .block_elements import BlockElement +from .block_elements import BlockElement, RichTextElement from .block_elements import ImageElement from .block_elements import InputInteractiveElement from .block_elements import InteractiveElement @@ -604,3 +604,34 @@ def _validate_title_length(self): @JsonValidator(f"author_name attribute cannot exceed {author_name_max_length} characters") def _validate_author_name_length(self): return self.author_name is None or len(self.author_name) < self.author_name_max_length + + +class RichTextBlock(Block): + type = "rich_text" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"elements"}) + + def __init__( + self, + , + elements: Sequence[Union[dict, RichTextElement]], + block_id: Optional[str] = None, + **others: dict, + ): + """A block that is used to hold interactive elements. + https://api.slack.com/reference/block-kit/blocks#rich_text + + Args: + elements (required): An array of rich text objects - + rich_text_section, rich_text_list, rich_text_quote, rich_text_preformatted + block_id: A unique identifier for a block. If not specified, one will be generated. + Maximum length for this field is 255 characters. + block_id should be unique for each message or view and each iteration of a message or view. + If a message or view is updated, use a new block_id. + """ + super().__init__(type=self.type, block_id=block_id) + show_unknown_key_warning(self, others) + + self.elements = BlockElement.parse_all(elements)	diff --git a/tests/slack_sdk/models/test_blocks.py b/tests/slack_sdk/models/test_blocks.py index 5461ba8d3..4ea1158ef 100644 --- a/tests/slack_sdk/models/test_blocks.py +++ b/tests/slack_sdk/models/test_blocks.py @@ -22,6 +22,12 @@ HeaderBlock, VideoBlock, Option, + RichTextBlock, + RichTextSectionElement, + RichTextListElement, + RichTextQuoteElement, + RichTextPreformattedElement, + RichTextElementParts, ) from . import STRING_3001_CHARS @@ -825,3 +831,219 @@ def test_title_length_200(self): } with self.assertRaises(SlackObjectFormationError): VideoBlock(input).validate_json() + + +# ---------------------------------------------- +# RichTextBlock +# ---------------------------------------------- + + +class RichTextBlockTests(unittest.TestCase): + def test_document(self): + inputs = [ + { + "type": "rich_text", + "elements": [ + { + "type": "rich_text_section", + "elements": [{"type": "text", "text": "Hello there, I am a basic rich text block!"}], + } + ], + }, + { + "type": "rich_text", + "elements": [ + { + "type": "rich_text_section", + "elements": [ + {"type": "text", "text": "Hello there, "}, + {"type": "text", "text": "I am a bold rich text block!", "style": {"bold": True}}, + ], + } + ], + }, + { + "type": "rich_text", + "elements": [ + { + "type": "rich_text_section", + "elements": [ + {"type": "text", "text": "Hello there, "}, + {"type": "text", "text": "I am an italic rich text block!", "style": {"italic": True}}, + ], + } + ], + }, + { + "type": "rich_text", + "elements": [ + { + "type": "rich_text_section", + "elements": [ + {"type": "text", "text": "Hello there, "}, + {"type": "text", "text": "I am a strikethrough rich text block!", "style": {"strike": True}}, + ], + } + ], + }, + ] + for input in inputs: + self.assertDictEqual(input, RichTextBlock(input).to_dict()) + + def test_complex(self): + self.maxDiff = None + dict_block = { + "type": "rich_text", + "block_id": "3Uk3Q", + "elements": [ + { + "type": "rich_text_section", + "elements": [ + {"type": "text", "text": "Hey!", "style": {"bold": True}}, + {"type": "text", "text": " this is "}, + {"type": "text", "text": "very", "style": {"strike": True}}, + {"type": "text", "text": " rich text "}, + {"type": "text", "text": "block", "style": {"code": True}}, + {"type": "text", "text": " "}, + {"type": "text", "text": "test", "style": {"italic": True}}, + {"type": "link", "url": "https://slack.com", "text": "Slack website!"}, + ], + }, + { + "type": "rich_text_list", + "elements": [ + {"type": "rich_text_section", "elements": [{"type": "text", "text": "a"}]}, + {"type": "rich_text_section", "elements": [{"type": "text", "text": "b"}]}, + ], + "style": "ordered", + "indent": 0, + "border": 0, + }, + { + "type": "rich_text_list", + "elements": [{"type": "rich_text_section", "elements": [{"type": "text", "text": "bb"}]}], + "style": "ordered", + "indent": 1, + "border": 0, + }, + { + "type": "rich_text_list", + "elements": [{"type": "rich_text_section", "elements": [{"type": "text", "text": "BBB"}]}], + "style": "ordered", + "indent": 2, + "border": 0, + }, + { + "type": "rich_text_list", + "elements": [{"type": "rich_text_section", "elements": [{"type": "text", "text": "c"}]}], + "style": "ordered", + "indent": 0, + "offset": 2, + "border": 0, + }, + {"type": "rich_text_section", "elements": [{"type": "text", "text": "\n"}]}, + { + "type": "rich_text_list", + "elements": [ + {"type": "rich_text_section", "elements": [{"type": "text", "text": "todo"}]}, + {"type": "rich_text_section", "elements": [{"type": "text", "text": "todo"}]}, + {"type": "rich_text_section", "elements": [{"type": "text", "text": "todo"}]}, + ], + "style": "bullet", + "indent": 0, + "border": 0, + }, + {"type": "rich_text_section", "elements": [{"type": "text", "text": "\n"}]}, + {"type": "rich_text_quote", "elements": [{"type": "text", "text": "this is very important"}]}, + { + "type": "rich_text_preformatted", + "elements": [{"type": "text", "text": 'print("Hello world")'}], + "border": 0, + }, + { + "type": "rich_text_section", + "elements": [ + {"type": "user", "user_id": "WJC6QG0MS"}, + {"type": "text", "text": " "}, + {"type": "usergroup", "usergroup_id": "S01BL602YLU"}, + {"type": "text", "text": " "}, + {"type": "channel", "channel_id": "C02GD0YEHDJ"}, + ], + }, + ], + } + self.assertDictEqual(dict_block, RichTextBlock(**dict_block).to_dict()) + + _ = RichTextElementParts + class_block = RichTextBlock( + block_id="3Uk3Q", + elements=[ + RichTextSectionElement( + elements=[ + _.Text(text="Hey!", style=_.TextStyle(bold=True)), + _.Text(text=" this is "), + _.Text(text="very", style=_.TextStyle(strike=True)), + _.Text(text=" rich text "), + _.Text(text="block", style=_.TextStyle(code=True)), + _.Text(text=" "), + _.Text(text="test", style=_.TextStyle(italic=True)), + _.Link(text="Slack website!", url="https://slack.com"), + ] + ), + RichTextListElement( + elements=[ + RichTextSectionElement(elements=[_.Text(text="a")]), + RichTextSectionElement(elements=[_.Text(text="b")]), + ], + style="ordered", + indent=0, + border=0, + ), + RichTextListElement( + elements=[RichTextSectionElement(elements=[_.Text(text="bb")])], + style="ordered", + indent=1, + border=0, + ), + RichTextListElement( + elements=[RichTextSectionElement(elements=[_.Text(text="BBB")])], + style="ordered", + indent=2, + border=0, + ), + RichTextListElement( + elements=[RichTextSectionElement(elements=[_.Text(text="c")])], + style="ordered", + indent=0, + offset=2, + border=0, + ), + RichTextSectionElement(elements=[_.Text(text="\n")]), + RichTextListElement( + elements=[ + RichTextSectionElement(elements=[_.Text(text="todo")]), + RichTextSectionElement(elements=[_.Text(text="todo")]), + RichTextSectionElement(elements=[_.Text(text="todo")]), + ], + style="bullet", + indent=0, + border=0, + ), + RichTextSectionElement(elements=[_.Text(text="\n")]), + RichTextQuoteElement(elements=[_.Text(text="this is very important")]), + RichTextPreformattedElement( + elements=[_.Text(text='print("Hello world")')], + border=0, + ), + RichTextSectionElement( + elements=[ + _.User(user_id="WJC6QG0MS"), + _.Text(text=" "), + _.UserGroup(usergroup_id="S01BL602YLU"), + _.Text(text=" "), + _.Channel(channel_id="C02GD0YEHDJ"), + ] + ), + ], + ) + self.assertDictEqual(dict_block, class_block.to_dict())		[ { "components": [ { "doc": "", "lines": [ 1844, 1845 ], "name": "RichTextElement", "signature": "class RichTextElement(BlockElement):", "type": "class" }, { "doc": "", "lines": [ 1848, 1871 ...	[ "tests/slack_sdk/models/test_blocks.py::BlockTests::test_eq", "tests/slack_sdk/models/test_blocks.py::BlockTests::test_parse", "tests/slack_sdk/models/test_blocks.py::SectionBlockTests::test_document_1", "tests/slack_sdk/models/test_blocks.py::SectionBlockTests::test_document_2", "tests/slack_sdk/models/tes...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Fix #1428 Add rich_text classes to slack_sdk.models module ## Summary This pull request resolves #1428 ### Category (place an `x` in each of the `[ ]`) - [ ] slack_sdk.web.WebClient (sync/async) (Web API client) - [ ] slack_sdk.webhook.WebhookClient (sync/async) (Incoming Webhook, response_url sender) - [ ] slack_sdk.socket_mode (Socket Mode client) - [ ] slack_sdk.signature (Request Signature Verifier) - [ ] slack_sdk.oauth (OAuth Flow Utilities) - [x] slack_sdk.models (UI component builders) - [ ] slack_sdk.scim (SCIM API client) - [ ] slack_sdk.audit_logs (Audit Logs API client) - [ ] slack_sdk.rtm_v2 (RTM client) - [ ] `/docs-src` (Documents, have you run `./scripts/docs.sh`?) - [ ] `/docs-src-v2` (Documents, have you run `./scripts/docs-v2.sh`?) - [ ] `/tutorial` (PythOnBoardingBot tutorial) - [ ] `tests`/`integration_tests` (Automated tests for this library) ## Requirements (place an `x` in each `[ ]`) - [x] I've read and understood the [Contributing Guidelines](https://github.com/slackapi/python-slack-sdk/blob/main/.github/contributing.md) and have done my best effort to follow them. - [x] I've read and agree to the [Code of Conduct](https://slackhq.github.io/code-of-conduct). - [x] I've run `python3 -m venv .venv && source .venv/bin/activate && ./scripts/run_validation.sh` after making the changes. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in slack_sdk/models/blocks/block_elements.py] (definition of RichTextElement:) class RichTextElement(BlockElement): (definition of RichTextListElement:) class RichTextListElement(RichTextElement): (definition of RichTextListElement.attributes:) def attributes(self) -> Set[str]: (definition of RichTextListElement.__init__:) def __init__( self, , elements: Sequence[Union[dict, RichTextElement]], style: Optional[str] = None, (definition of RichTextPreformattedElement:) class RichTextPreformattedElement(RichTextElement): (definition of RichTextPreformattedElement.attributes:) def attributes(self) -> Set[str]: (definition of RichTextPreformattedElement.__init__:) def __init__( self, , elements: Sequence[Union[dict, RichTextElement]], border: Optional[int] = None, *others: dict, ): (definition of RichTextQuoteElement:) class RichTextQuoteElement(RichTextElement): (definition of RichTextQuoteElement.attributes:) def attributes(self) -> Set[str]: (definition of RichTextQuoteElement.__init__:) def __init__( self, , elements: Sequence[Union[dict, RichTextElement]], *others: dict, ): (definition of RichTextSectionElement:) class RichTextSectionElement(RichTextElement): (definition of RichTextSectionElement.attributes:) def attributes(self) -> Set[str]: (definition of RichTextSectionElement.__init__:) def __init__( self, , elements: Sequence[Union[dict, RichTextElement]], *others: dict, ): (definition of RichTextElementParts:) class RichTextElementParts: (definition of RichTextElementParts.TextStyle:) class TextStyle: (definition of RichTextElementParts.TextStyle.__init__:) def __init__( self, , bold: Optional[bool] = None, italic: Optional[bool] = None, strike: Optional[bool] = None, code: Optional[bool] = None, ): (definition of RichTextElementParts.TextStyle.to_dict:) def to_dict(self, args) -> dict: (definition of RichTextElementParts.Text:) class Text(RichTextElement): (definition of RichTextElementParts.Text.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.Text.__init__:) def __init__( self, , text: str, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, *others: dict, ): (definition of RichTextElementParts.Channel:) class Channel(RichTextElement): (definition of RichTextElementParts.Channel.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.Channel.__init__:) def __init__( self, , channel_id: str, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, *others: dict, ): (definition of RichTextElementParts.User:) class User(RichTextElement): (definition of RichTextElementParts.User.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.User.__init__:) def __init__( self, , user_id: str, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, *others: dict, ): (definition of RichTextElementParts.Emoji:) class Emoji(RichTextElement): (definition of RichTextElementParts.Emoji.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.Emoji.__init__:) def __init__( self, , name: str, skin_tone: Optional[int] = None, unicode: Optional[str] = None, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, *others: dict, ): (definition of RichTextElementParts.Link:) class Link(RichTextElement): (definition of RichTextElementParts.Link.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.Link.__init__:) def __init__( self, , url: str, text: Optional[str] = None, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, *others: dict, ): (definition of RichTextElementParts.Team:) class Team(RichTextElement): (definition of RichTextElementParts.Team.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.Team.__init__:) def __init__( self, , team_id: str, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, *others: dict, ): (definition of RichTextElementParts.UserGroup:) class UserGroup(RichTextElement): (definition of RichTextElementParts.UserGroup.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.UserGroup.__init__:) def __init__( self, , usergroup_id: str, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, *others: dict, ): (definition of RichTextElementParts.Date:) class Date(RichTextElement): (definition of RichTextElementParts.Date.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.Date.__init__:) def __init__( self, , timestamp: str, *others: dict, ): (definition of RichTextElementParts.Broadcast:) class Broadcast(RichTextElement): (definition of RichTextElementParts.Broadcast.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.Broadcast.__init__:) def __init__( self, , range: str, (definition of RichTextElementParts.Color:) class Color(RichTextElement): (definition of RichTextElementParts.Color.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.Color.__init__:) def __init__( self, , value: str, others: dict, ): [end of new definitions in slack_sdk/models/blocks/block_elements.py] [start of new definitions in slack_sdk/models/blocks/blocks.py] (definition of RichTextBlock:) class RichTextBlock(Block): (definition of RichTextBlock.attributes:) def attributes(self) -> Set[str]: (definition of RichTextBlock.__init__:) def __init__( self, , elements: Sequence[Union[dict, RichTextElement]], block_id: Optional[str] = None, **others: dict, ): """A block that is used to hold interactive elements. https://api.slack.com/reference/block-kit/blocks#rich_text Args: elements (required): An array of rich text objects - rich_text_section, rich_text_list, rich_text_quote, rich_text_preformatted block_id: A unique identifier for a block. If not specified, one will be generated. Maximum length for this field is 255 characters. block_id should be unique for each message or view and each iteration of a message or view. If a message or view is updated, use a new block_id.""" [end of new definitions in slack_sdk/models/blocks/blocks.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Add rich_text classes to slack_sdk.models module I'm currently refactoring code using `slack_sdk` models, and most of my modals use `RichText` objects. I've noticed while available in Block Kit Builder and documented thoroughly, there is not a model for it. I created my own (I'd share, but the way it's constructed is significantly different than how I see it done in this project), but when I try to pass this through the `View()` constructor, it skips those blocks because it doesn't recognize the type, despite how well established and integrated into documentation that component appears to be. I'm wondering if there is a plan to add a model for this in place, and if so, where that is on the priority scale? Also hoping to get clarity on what appears should be `LinkTextObject` for use inside a section or list of a `RichTextElement`. Passing `subtype="link"` to TextObject "works", but the url property gets discarded. ### Category (place an `x` in each of the `[ ]`) - [ ] slack_sdk.web.WebClient (sync/async) (Web API client) - [ ] slack_sdk.webhook.WebhookClient (sync/async) (Incoming Webhook, response_url sender) - [x] slack_sdk.models (UI component builders) - [ ] slack_sdk.oauth (OAuth Flow Utilities) - [ ] slack_sdk.socket_mode (Socket Mode client) - [ ] slack_sdk.audit_logs (Audit Logs API client) - [ ] slack_sdk.scim (SCIM API client) - [ ] slack_sdk.rtm (RTM client) - [ ] slack_sdk.signature (Request Signature Verifier) ### Requirements Please read the [Contributing guidelines](https://github.com/slackapi/python-slack-sdk/blob/main/.github/contributing.md) and [Code of Conduct](https://slackhq.github.io/code-of-conduct) before creating this issue or pull request. By submitting, you are agreeing to those rules. ---------- Hi @tj-smith47, thanks for writing in! >'m wondering if there is a plan to add a model for this in place, and if so, where that is on the priority scale? Since Slack's platform unlocked those rich_text blocks to 3rd party apps recently, this project has not yet supported it. However, we definitely plan to add it! (Actually it's already done for Node and Java SDKs). I cannot tell the exact date to publish a new version yet, but it won't take weeks for sure. If everything goes well, a new version including it would be available by the end of this week. >Also hoping to get clarity on what appears should be LinkTextObject for use inside a section or list of a RichTextElement. Passing subtype="link" to TextObject "works", but the url property gets discarded. I won't reuse the TextObject class for the link item in rich text list objects. The TextObject represents a typical property of a block, which possesses either a "plain_text" or "mrkdwn" type (and usually it is supposed to be used for label etc.). This object cannot be an item of "rich_text_section" block element. They are completely different ones. So, when we add rich_text block elements to the model module, we will introduce a new class for the link item. @seratch This is great news! Thank you for your work on this, can't wait to see it! -------------------- </issues>	2997a1786c4fd969b00ce69af888ebae8e8ebed0
conan-io__conan-15136	15,136	conan-io/conan	null	412a0279dbe7da2f3d4dcb1f8940bc51c3baac3a	2023-11-19T20:53:34Z	diff --git a/conan/cli/printers/graph.py b/conan/cli/printers/graph.py index a7a67a09588..6513636f8d4 100644 --- a/conan/cli/printers/graph.py +++ b/conan/cli/printers/graph.py @@ -56,6 +56,11 @@ def _format_resolved(title, reqs_to_print): for k, v in sorted(reqs_to_print.items()): output.info(" {}: {}".format(k, v), Color.BRIGHT_CYAN) + if graph.replaced_requires: + output.info("Replaced requires", Color.BRIGHT_YELLOW) + for k, v in graph.replaced_requires.items(): + output.info(" {}: {}".format(k, v), Color.BRIGHT_CYAN) + _format_resolved("Resolved alias", graph.aliased) if graph.aliased: output.warning("'alias' is a Conan 1.X legacy feature, no longer recommended and " diff --git a/conans/client/graph/graph.py b/conans/client/graph/graph.py index cce23757564..2481c2fadb3 100644 --- a/conans/client/graph/graph.py +++ b/conans/client/graph/graph.py @@ -319,6 +319,7 @@ def __init__(self): self.nodes = [] self.aliased = {} self.resolved_ranges = {} + self.replaced_requires = {} self.error = False def overrides(self): @@ -391,4 +392,5 @@ def serialize(self): result["root"] = {self.root.id: repr(self.root.ref)} # TODO: ref of consumer/virtual result["overrides"] = self.overrides().serialize() result["resolved_ranges"] = {repr(r): s.repr_notime() for r, s in self.resolved_ranges.items()} + result["replaced_requires"] = {k: v for k, v in self.replaced_requires.items()} return result diff --git a/conans/client/graph/graph_builder.py b/conans/client/graph/graph_builder.py index 7d1f6bfdbcf..27d8449d82c 100644 --- a/conans/client/graph/graph_builder.py +++ b/conans/client/graph/graph_builder.py @@ -38,7 +38,7 @@ def load_graph(self, root_node, profile_host, profile_build, graph_lock=None): dep_graph = DepsGraph() self._prepare_node(root_node, profile_host, profile_build, Options()) - self._initialize_requires(root_node, dep_graph, graph_lock) + self._initialize_requires(root_node, dep_graph, graph_lock, profile_build, profile_host) dep_graph.add_node(root_node) open_requires = deque((r, root_node) for r in root_node.conanfile.requires.values()) @@ -51,7 +51,8 @@ def load_graph(self, root_node, profile_host, profile_build, graph_lock=None): new_node = self._expand_require(require, node, dep_graph, profile_host, profile_build, graph_lock) if new_node: - self._initialize_requires(new_node, dep_graph, graph_lock) + self._initialize_requires(new_node, dep_graph, graph_lock, profile_build, + profile_host) open_requires.extendleft((r, new_node) for r in reversed(new_node.conanfile.requires.values())) self._remove_overrides(dep_graph) @@ -160,7 +161,7 @@ def _prepare_node(node, profile_host, profile_build, down_options): node.conanfile.requires.tool_require(tool_require.repr_notime(), raise_if_duplicated=False) - def _initialize_requires(self, node, graph, graph_lock): + def _initialize_requires(self, node, graph, graph_lock, profile_build, profile_host): for require in node.conanfile.requires.values(): alias = require.alias # alias needs to be processed this early if alias is not None: @@ -170,6 +171,7 @@ def _initialize_requires(self, node, graph, graph_lock): # if partial, we might still need to resolve the alias if not resolved: self._resolve_alias(node, require, alias, graph) + self._resolve_replace_requires(node, require, profile_build, profile_host, graph) node.transitive_deps[require] = TransitiveRequirement(require, node=None) def _resolve_alias(self, node, require, alias, graph): @@ -233,6 +235,40 @@ def _resolved_system(node, require, profile_build, profile_host, resolve_prerele require.ref.revision = d.revision return d, ConanFile(str(d)), RECIPE_PLATFORM, None + def _resolve_replace_requires(self, node, require, profile_build, profile_host, graph): + profile = profile_build if node.context == CONTEXT_BUILD else profile_host + replacements = profile.replace_tool_requires if require.build else profile.replace_requires + if not replacements: + return + + for pattern, alternative_ref in replacements.items(): + if pattern.name != require.ref.name: + continue # no match in name + if pattern.version != "": # we need to check versions + rrange = require.version_range + valid = rrange.contains(pattern.version, self._resolve_prereleases) if rrange else \ + require.ref.version == pattern.version + if not valid: + continue + if pattern.user != "" and pattern.user != require.ref.user: + continue + if pattern.channel != "" and pattern.channel != require.ref.channel: + continue + original_require = repr(require.ref) + if alternative_ref.version != "": + require.ref.version = alternative_ref.version + if alternative_ref.user != "": + require.ref.user = alternative_ref.user + if alternative_ref.channel != "": + require.ref.channel = alternative_ref.channel + if alternative_ref.revision != "*": + require.ref.revision = alternative_ref.revision + if require.ref.name != alternative_ref.name: # This requires re-doing dict! + node.conanfile.requires.reindex(require, alternative_ref.name) + require.ref.name = alternative_ref.name + graph.replaced_requires[original_require] = repr(require.ref) + break # First match executes the alternative and finishes checking others + def _create_new_node(self, node, require, graph, profile_host, profile_build, graph_lock): if require.ref.version == "<host_version>": if not require.build or require.visible: diff --git a/conans/client/profile_loader.py b/conans/client/profile_loader.py index 097c18c1566..54b6d3d0140 100644 --- a/conans/client/profile_loader.py +++ b/conans/client/profile_loader.py @@ -223,7 +223,8 @@ def get_profile(profile_text, base_profile=None): "system_tools", # DEPRECATED: platform_tool_requires "platform_requires", "platform_tool_requires", "settings", - "options", "conf", "buildenv", "runenv"]) + "options", "conf", "buildenv", "runenv", + "replace_requires", "replace_tool_requires"]) # Parse doc sections into Conan model, Settings, Options, etc settings, package_settings = _ProfileValueParser._parse_settings(doc) @@ -238,6 +239,26 @@ def get_profile(profile_text, base_profile=None): platform_tool_requires = [RecipeReference.loads(r) for r in doc_platform_tool_requires.splitlines()] platform_requires = [RecipeReference.loads(r) for r in doc_platform_requires.splitlines()] + def load_replace(doc_replace_requires): + result = {} + for r in doc_replace_requires.splitlines(): + r = r.strip() + if not r or r.startswith("#"): + continue + try: + src, target = r.split(":") + target = RecipeReference.loads(target.strip()) + src = RecipeReference.loads(src.strip()) + except Exception as e: + raise ConanException(f"Error in [replace_xxx] '{r}'.\nIt should be in the form" + f" 'pattern: replacement', without package-ids.\n" + f"Original error: {str(e)}") + result[src] = target + return result + + replace_requires = load_replace(doc.replace_requires) if doc.replace_requires else {} + replace_tool = load_replace(doc.replace_tool_requires) if doc.replace_tool_requires else {} + if doc.conf: conf = ConfDefinition() conf.loads(doc.conf, profile=True) @@ -248,6 +269,9 @@ def get_profile(profile_text, base_profile=None): # Create or update the profile base_profile = base_profile or Profile() + base_profile.replace_requires.update(replace_requires) + base_profile.replace_tool_requires.update(replace_tool) + current_platform_tool_requires = {r.name: r for r in base_profile.platform_tool_requires} current_platform_tool_requires.update({r.name: r for r in platform_tool_requires}) base_profile.platform_tool_requires = list(current_platform_tool_requires.values()) diff --git a/conans/model/profile.py b/conans/model/profile.py index df78bb9ba64..7654ed9acf3 100644 --- a/conans/model/profile.py +++ b/conans/model/profile.py @@ -17,6 +17,8 @@ def __init__(self): self.package_settings = defaultdict(OrderedDict) self.options = Options() self.tool_requires = OrderedDict() # ref pattern: list of ref + self.replace_requires = {} + self.replace_tool_requires = {} self.platform_tool_requires = [] self.platform_requires = [] self.conf = ConfDefinition() @@ -120,6 +122,9 @@ def compose_profile(self, other): existing[r.name] = req self.tool_requires[pattern] = list(existing.values()) + self.replace_requires.update(other.replace_requires) + self.replace_tool_requires.update(other.replace_tool_requires) + current_platform_tool_requires = {r.name: r for r in self.platform_tool_requires} current_platform_tool_requires.update({r.name: r for r in other.platform_tool_requires}) self.platform_tool_requires = list(current_platform_tool_requires.values()) diff --git a/conans/model/requires.py b/conans/model/requires.py index 7604e411cbf..fd7c0f62c7a 100644 --- a/conans/model/requires.py +++ b/conans/model/requires.py @@ -467,6 +467,18 @@ def __init__(self, declared=None, declared_build=None, declared_test=None, raise ConanException("Wrong 'tool_requires' definition, " "did you mean 'build_requirements()'?") + def reindex(self, require, new_name): + """ This operation is necessary when the reference name of a package is changed + as a result of an "alternative" replacement of the package name, otherwise the dictionary + gets broken by modified key + """ + result = OrderedDict() + for k, v in self._requires.items(): + if k is require: + k.ref.name = new_name + result[k] = v + self._requires = result + def values(self): return self._requires.values()	diff --git a/conans/test/integration/graph/test_replace_requires.py b/conans/test/integration/graph/test_replace_requires.py new file mode 100644 index 00000000000..9fb129fda07 --- /dev/null +++ b/conans/test/integration/graph/test_replace_requires.py @@ -0,0 +1,144 @@ +import json + +import pytest + +from conans.model.recipe_ref import RecipeReference +from conans.test.assets.genconanfile import GenConanfile +from conans.test.utils.tools import TestClient + + +@pytest.mark.parametrize("require, pattern, alternative, pkg", [ + # PATTERN VERSIONS + # override all dependencies to "dep" to a specific version,user and channel) + # TODO: This is a version override, is this really wanted? + ("dep/1.3", "dep/", "dep/1.1", "dep/1.1"), + ("dep/[>=1.0 <2]", "dep/", "dep/1.1", "dep/1.1"), + # override all dependencies to "dep" to the same version with other user, remove channel) + ("dep/1.3", "dep/", "dep/@system", "dep/1.3@system"), + ("dep/[>=1.0 <2]", "dep/", "dep/@system", "dep/1.1@system"), + # override all dependencies to "dep" to the same version with other user, same channel) + ("dep/1.3@comp/stable", "dep/@/", "dep/@system/", "dep/1.3@system/stable"), + ("dep/[>=1.0 <2]@comp/stable", "dep/@/", "dep/@system/", "dep/1.1@system/stable"), + # EXACT VERSIONS + # replace exact dependency version for one in the system + ("dep/1.1", "dep/1.1", "dep/1.1@system", "dep/1.1@system"), + ("dep/[>=1.0 <2]", "dep/1.1", "dep/1.1@system", "dep/1.1@system"), + ("dep/[>=1.0 <2]@comp", "dep/1.1@", "dep/1.1@/stable", "dep/1.1@comp/stable"), + ("dep/1.1@comp", "dep/1.1@", "dep/1.1@/stable", "dep/1.1@comp/stable"), + # PACKAGE ALTERNATIVES (zlib->zlibng) + ("dep/1.0", "dep/", "depng/", "depng/1.0"), + ("dep/[>=1.0 <2]", "dep/", "depng/", "depng/1.1"), + ("dep/[>=1.0 <2]", "dep/1.1", "depng/1.2", "depng/1.2"), + # NON MATCHING + ("dep/1.3", "dep/1.1", "dep/1.1@system", "dep/1.3"), + ("dep/1.3", "dep/@comp", "dep/@system", "dep/1.3"), + ("dep/[>=1.0 <2]", "dep/2.1", "dep/2.1@system", "dep/1.1"), +]) +@pytest.mark.parametrize("tool_require", [False, True]) +class TestReplaceRequires: + def test_alternative(self, tool_require, require, pattern, alternative, pkg): + c = TestClient() + conanfile = GenConanfile().with_tool_requires(require) if tool_require else \ + GenConanfile().with_requires(require) + profile_tag = "replace_requires" if not tool_require else "replace_tool_requires" + c.save({"dep/conanfile.py": GenConanfile(), + "pkg/conanfile.py": conanfile, + "profile": f"[{profile_tag}]\n{pattern}: {alternative}"}) + ref = RecipeReference.loads(pkg) + user = f"--user={ref.user}" if ref.user else "" + channel = f"--channel={ref.channel}" if ref.channel else "" + c.run(f"create dep --name={ref.name} --version={ref.version} {user} {channel}") + rrev = c.exported_recipe_revision() + c.run("install pkg -pr=profile") + c.assert_listed_require({f"{pkg}#{rrev}": "Cache"}, build=tool_require) + + # Check lockfile + c.run("lock create pkg -pr=profile") + lock = c.load("pkg/conan.lock") + assert f"{pkg}#{rrev}" in lock + + # c.run("create dep2 --version=1.2") + # with lockfile + c.run("install pkg -pr=profile") + c.assert_listed_require({f"{pkg}#{rrev}": "Cache"}, build=tool_require) + + def test_diamond(self, tool_require, require, pattern, alternative, pkg): + c = TestClient() + conanfile = GenConanfile().with_tool_requires(require) if tool_require else \ + GenConanfile().with_requires(require) + profile_tag = "replace_requires" if not tool_require else "replace_tool_requires" + + c.save({"dep/conanfile.py": GenConanfile(), + "libb/conanfile.py": conanfile, + "libc/conanfile.py": conanfile, + "app/conanfile.py": GenConanfile().with_requires("libb/0.1", "libc/0.1"), + "profile": f"[{profile_tag}]\n{pattern}: {alternative}"}) + ref = RecipeReference.loads(pkg) + user = f"--user={ref.user}" if ref.user else "" + channel = f"--channel={ref.channel}" if ref.channel else "" + c.run(f"create dep --name={ref.name} --version={ref.version} {user} {channel}") + rrev = c.exported_recipe_revision() + + c.run("export libb --name=libb --version=0.1") + c.run("export libc --name=libc --version=0.1") + + c.run("install app -pr=profile", assert_error=True) + assert "ERROR: Missing binary: libb/0.1" in c.out + assert "ERROR: Missing binary: libc/0.1" in c.out + + c.run("install app -pr=profile --build=missing") + c.assert_listed_require({f"{pkg}#{rrev}": "Cache"}, build=tool_require) + + # Check lockfile + c.run("lock create app -pr=profile") + lock = c.load("app/conan.lock") + assert f"{pkg}#{rrev}" in lock + + # with lockfile + c.run("install app -pr=profile") + c.assert_listed_require({f"{pkg}#{rrev}": "Cache"}, build=tool_require) + + +@pytest.mark.parametrize("pattern, replace", [ + ("pkg", "pkg/0.1"), + ("pkg/", "pkg"), + ("pkg/:pid1", "pkg/0.1"), + ("pkg/:pid1", "pkg/0.1:pid2"), + ("pkg/", "pkg/0.1:pid2"), + (":", ""), + ("pkg/version:pid", ""), + ("pkg/version:pid", ":") +]) +def test_replace_requires_errors(pattern, replace): + c = TestClient() + c.save({"pkg/conanfile.py": GenConanfile("pkg", "0.1"), + "app/conanfile.py": GenConanfile().with_requires("pkg/0.2"), + "profile": f"[replace_requires]\n{pattern}: {replace}"}) + c.run("create pkg") + c.run("install app -pr=profile", assert_error=True) + assert "ERROR: Error reading 'profile' profile: Error in [replace_xxx]" in c.out + + +def test_replace_requires_invalid_requires_errors(): + """ + replacing for something incorrect not existing is not an error per-se, it is valid that + a recipe requires("pkg/2."), and then it will fail because such package doesn't exist + """ + c = TestClient() + c.save({"app/conanfile.py": GenConanfile().with_requires("pkg/0.2"), + "profile": f"[replace_requires]\npkg/0.2: pkg/2."}) + c.run("install app -pr=profile", assert_error=True) + assert "pkg/0.2: pkg/2." in c.out # The replacement happens + assert "ERROR: Package 'pkg/2.' not resolved" in c.out + + +def test_replace_requires_json_format(): + c = TestClient() + c.save({"pkg/conanfile.py": GenConanfile("pkg", "0.2"), + "app/conanfile.py": GenConanfile().with_requires("pkg/0.1"), + "profile": f"[replace_requires]\npkg/0.1: pkg/0.2"}) + c.run("create pkg") + c.run("install app -pr=profile --format=json") + assert "pkg/0.1: pkg/0.2" in c.out # The replacement happens + graph = json.loads(c.stdout) + assert graph["graph"]["replaced_requires"] == {"pkg/0.1": "pkg/0.2"}		[ { "components": [ { "doc": "", "lines": [ 238, 270 ], "name": "DepsGraphBuilder._resolve_replace_requires", "signature": "def _resolve_replace_requires(self, node, require, profile_build, profile_host, graph):", "type": "function" }...	[ "conans/test/integration/graph/test_replace_requires.py::TestReplaceRequires::test_alternative[False-dep/1.3-dep/*-dep/1.1-dep/1.1]", "conans/test/integration/graph/test_replace_requires.py::TestReplaceRequires::test_alternative[False-dep/[>=1.0", "conans/test/integration/graph/test_replace_requires.py::TestRep...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> require-replaces proposal Changelog: Feature: New ``[replace_requires]`` and ``[replace_tool_requires]`` in profile for redefining requires, useful for package replacements like ``zlibng/zlib``, to solve conflicts, and to replace some dependencies by system alternatives wrapped in another Conan package recipe. Docs: https://github.com/conan-io/docs/pull/3495 Complement https://github.com/conan-io/conan/pull/14871 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conans/client/graph/graph_builder.py] (definition of DepsGraphBuilder._resolve_replace_requires:) def _resolve_replace_requires(self, node, require, profile_build, profile_host, graph): [end of new definitions in conans/client/graph/graph_builder.py] [start of new definitions in conans/client/profile_loader.py] (definition of _ProfileValueParser.get_profile.load_replace:) def load_replace(doc_replace_requires): [end of new definitions in conans/client/profile_loader.py] [start of new definitions in conans/model/requires.py] (definition of Requirements.reindex:) def reindex(self, require, new_name): """This operation is necessary when the reference name of a package is changed as a result of an "alternative" replacement of the package name, otherwise the dictionary gets broken by modified key""" [end of new definitions in conans/model/requires.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		4a5b19a75db9225316c8cb022a2dfb9705a2af34
roboflow__supervision-605	605	roboflow/supervision	null	bb7695a7744932553ef5e9665e8ca0064b458450	2023-11-16T12:59:04Z	diff --git a/supervision/__init__.py b/supervision/__init__.py index 44f25f7f1..93f4626fa 100644 --- a/supervision/__init__.py +++ b/supervision/__init__.py @@ -35,6 +35,7 @@ from supervision.detection.tools.polygon_zone import PolygonZone, PolygonZoneAnnotator from supervision.detection.utils import ( box_iou_batch, + calculate_masks_centroids, filter_polygons_by_area, mask_to_polygons, mask_to_xyxy, diff --git a/supervision/annotators/core.py b/supervision/annotators/core.py index 0e34cc16c..82d299da7 100644 --- a/supervision/annotators/core.py +++ b/supervision/annotators/core.py @@ -760,7 +760,7 @@ def annotate( ![dot-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/dot-annotator-example-purple.png) """ - xy = detections.get_anchor_coordinates(anchor=self.position) + xy = detections.get_anchors_coordinates(anchor=self.position) for detection_idx in range(len(detections)): color = resolve_color( color=self.color, @@ -808,49 +808,46 @@ def __init__( self.text_scale: float = text_scale self.text_thickness: int = text_thickness self.text_padding: int = text_padding - self.text_position: Position = text_position + self.text_anchor: Position = text_position self.color_lookup: ColorLookup = color_lookup @staticmethod def resolve_text_background_xyxy( - detection_xyxy: Tuple[int, int, int, int], + center_coordinates: Tuple[int, int], text_wh: Tuple[int, int], - text_padding: int, position: Position, ) -> Tuple[int, int, int, int]: - padded_text_wh = (text_wh[0] + 2 * text_padding, text_wh[1] + 2 * text_padding) - x1, y1, x2, y2 = detection_xyxy - center_x = (x1 + x2) // 2 - center_y = (y1 + y2) // 2 + center_x, center_y = center_coordinates + text_w, text_h = text_wh if position == Position.TOP_LEFT: - return x1, y1 - padded_text_wh[1], x1 + padded_text_wh[0], y1 + return center_x, center_y - text_h, center_x + text_w, center_y elif position == Position.TOP_RIGHT: - return x2 - padded_text_wh[0], y1 - padded_text_wh[1], x2, y1 + return center_x - text_w, center_y - text_h, center_x, center_y elif position == Position.TOP_CENTER: return ( - center_x - padded_text_wh[0] // 2, - y1 - padded_text_wh[1], - center_x + padded_text_wh[0] // 2, - y1, + center_x - text_w // 2, + center_y - text_h, + center_x + text_w // 2, + center_y, ) - elif position == Position.CENTER: + elif position == Position.CENTER or position == Position.CENTER_OF_MASS: return ( - center_x - padded_text_wh[0] // 2, - center_y - padded_text_wh[1] // 2, - center_x + padded_text_wh[0] // 2, - center_y + padded_text_wh[1] // 2, + center_x - text_w // 2, + center_y - text_h // 2, + center_x + text_w // 2, + center_y + text_h // 2, ) elif position == Position.BOTTOM_LEFT: - return x1, y2, x1 + padded_text_wh[0], y2 + padded_text_wh[1] + return center_x, center_y, center_x + text_w, center_y + text_h elif position == Position.BOTTOM_RIGHT: - return x2 - padded_text_wh[0], y2, x2, y2 + padded_text_wh[1] + return center_x - text_w, center_y, center_x, center_y + text_h elif position == Position.BOTTOM_CENTER: return ( - center_x - padded_text_wh[0] // 2, - y2, - center_x + padded_text_wh[0] // 2, - y2 + padded_text_wh[1], + center_x - text_w // 2, + center_y, + center_x + text_w // 2, + center_y + text_h, ) def annotate( @@ -891,8 +888,10 @@ def annotate( supervision-annotator-examples/label-annotator-example-purple.png) """ font = cv2.FONT_HERSHEY_SIMPLEX - for detection_idx in range(len(detections)): - detection_xyxy = detections.xyxy[detection_idx].astype(int) + anchors_coordinates = detections.get_anchors_coordinates( + anchor=self.text_anchor + ).astype(int) + for detection_idx, center_coordinates in enumerate(anchors_coordinates): color = resolve_color( color=self.color, detections=detections, @@ -906,22 +905,22 @@ def annotate( if (labels is None or len(detections) != len(labels)) else labels[detection_idx] ) - text_wh = cv2.getTextSize( + text_w, text_h = cv2.getTextSize( text=text, fontFace=font, fontScale=self.text_scale, thickness=self.text_thickness, )[0] - + text_w_padded = text_w + 2 * self.text_padding + text_h_padded = text_h + 2 * self.text_padding text_background_xyxy = self.resolve_text_background_xyxy( - detection_xyxy=detection_xyxy, - text_wh=text_wh, - text_padding=self.text_padding, - position=self.text_position, + center_coordinates=tuple(center_coordinates), + text_wh=(text_w_padded, text_h_padded), + position=self.text_anchor, ) text_x = text_background_xyxy[0] + self.text_padding - text_y = text_background_xyxy[1] + self.text_padding + text_wh[1] + text_y = text_background_xyxy[1] + self.text_padding + text_h cv2.rectangle( img=scene, @@ -1181,7 +1180,7 @@ def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: if self.heat_mask is None: self.heat_mask = np.zeros(scene.shape[:2]) mask = np.zeros(scene.shape[:2]) - for xy in detections.get_anchor_coordinates(self.position): + for xy in detections.get_anchors_coordinates(self.position): cv2.circle(mask, (int(xy[0]), int(xy[1])), self.radius, 1, -1) self.heat_mask = mask + self.heat_mask temp = self.heat_mask.copy() diff --git a/supervision/annotators/utils.py b/supervision/annotators/utils.py index 5b4e86cba..e206c8cbb 100644 --- a/supervision/annotators/utils.py +++ b/supervision/annotators/utils.py @@ -102,7 +102,7 @@ def put(self, detections: Detections) -> None: frame_id = np.full(len(detections), self.current_frame_id, dtype=int) self.frame_id = np.concatenate([self.frame_id, frame_id]) self.xy = np.concatenate( - [self.xy, detections.get_anchor_coordinates(self.anchor)] + [self.xy, detections.get_anchors_coordinates(self.anchor)] ) self.tracker_id = np.concatenate([self.tracker_id, detections.tracker_id]) diff --git a/supervision/detection/core.py b/supervision/detection/core.py index 77bfca9da..4079f8966 100644 --- a/supervision/detection/core.py +++ b/supervision/detection/core.py @@ -6,6 +6,7 @@ import numpy as np from supervision.detection.utils import ( + calculate_masks_centroids, extract_ultralytics_masks, non_max_suppression, process_roboflow_result, @@ -600,7 +601,7 @@ def __all_not_none(item_list: List[Any]): tracker_id=tracker_id, ) - def get_anchor_coordinates(self, anchor: Position) -> np.ndarray: + def get_anchors_coordinates(self, anchor: Position) -> np.ndarray: """ Calculates and returns the coordinates of a specific anchor point within the bounding boxes defined by the `xyxy` attribute. The anchor @@ -627,6 +628,12 @@ def get_anchor_coordinates(self, anchor: Position) -> np.ndarray: (self.xyxy[:, 1] + self.xyxy[:, 3]) / 2, ] ).transpose() + elif anchor == Position.CENTER_OF_MASS: + if self.mask is None: + raise ValueError( + "Cannot use `Position.CENTER_OF_MASS` without a detection mask." + ) + return calculate_masks_centroids(masks=self.mask) elif anchor == Position.CENTER_LEFT: return np.array( [ diff --git a/supervision/detection/tools/polygon_zone.py b/supervision/detection/tools/polygon_zone.py index 15ee1aa23..8e18d8bdd 100644 --- a/supervision/detection/tools/polygon_zone.py +++ b/supervision/detection/tools/polygon_zone.py @@ -60,7 +60,7 @@ def trigger(self, detections: Detections) -> np.ndarray: ) clipped_detections = replace(detections, xyxy=clipped_xyxy) clipped_anchors = np.ceil( - clipped_detections.get_anchor_coordinates(anchor=self.triggering_position) + clipped_detections.get_anchors_coordinates(anchor=self.triggering_position) ).astype(int) is_in_zone = self.mask[clipped_anchors[:, 1], clipped_anchors[:, 0]] self.current_count = int(np.sum(is_in_zone)) diff --git a/supervision/detection/utils.py b/supervision/detection/utils.py index 7aa2c846a..1e5fdc351 100644 --- a/supervision/detection/utils.py +++ b/supervision/detection/utils.py @@ -393,3 +393,33 @@ def move_boxes(xyxy: np.ndarray, offset: np.ndarray) -> np.ndarray: (np.ndarray) repositioned bounding boxes """ return xyxy + np.hstack([offset, offset]) + + +def calculate_masks_centroids(masks: np.ndarray) -> np.ndarray: + """ + Calculate the centroids of binary masks in a tensor. + + Parameters: + masks (np.ndarray): A 3D NumPy array of shape (num_masks, height, width). + Each 2D array in the tensor represents a binary mask. + + Returns: + A 2D NumPy array of shape (num_masks, 2), where each row contains the x and y + coordinates (in that order) of the centroid of the corresponding mask. + """ + num_masks, height, width = masks.shape + total_pixels = masks.sum(axis=(1, 2)) + + # offset for 1-based indexing + vertical_indices, horizontal_indices = np.indices((height, width)) + 0.5 + # avoid division by zero for empty masks + total_pixels[total_pixels == 0] = 1 + + def sum_over_mask(indices: np.ndarray, axis: tuple) -> np.ndarray: + return np.tensordot(masks, indices, axes=axis) + + aggregation_axis = ([1, 2], [0, 1]) + centroid_x = sum_over_mask(horizontal_indices, aggregation_axis) / total_pixels + centroid_y = sum_over_mask(vertical_indices, aggregation_axis) / total_pixels + + return np.column_stack((centroid_x, centroid_y)).astype(int) diff --git a/supervision/geometry/core.py b/supervision/geometry/core.py index 1771a356d..d118b5a43 100644 --- a/supervision/geometry/core.py +++ b/supervision/geometry/core.py @@ -19,6 +19,7 @@ class Position(Enum): BOTTOM_LEFT = "BOTTOM_LEFT" BOTTOM_CENTER = "BOTTOM_CENTER" BOTTOM_RIGHT = "BOTTOM_RIGHT" + CENTER_OF_MASS = "CENTER_OF_MASS" @classmethod def list(cls):	diff --git a/test/detection/test_core.py b/test/detection/test_core.py index 9708f338d..0d17e09b3 100644 --- a/test/detection/test_core.py +++ b/test/detection/test_core.py @@ -270,6 +270,6 @@ def test_get_anchor_coordinates( expected_result: np.ndarray, exception: Exception, ) -> None: - result = detections.get_anchor_coordinates(anchor) + result = detections.get_anchors_coordinates(anchor) with exception: assert np.array_equal(result, expected_result) diff --git a/test/detection/test_utils.py b/test/detection/test_utils.py index 6b3249b40..dc8e9e166 100644 --- a/test/detection/test_utils.py +++ b/test/detection/test_utils.py @@ -5,6 +5,7 @@ import pytest from supervision.detection.utils import ( + calculate_masks_centroids, clip_boxes, filter_polygons_by_area, move_boxes, @@ -498,5 +499,97 @@ def test_move_boxes( expected_result: np.ndarray, exception: Exception, ) -> None: - result = move_boxes(xyxy=xyxy, offset=offset) - assert np.array_equal(result, expected_result) + with exception: + result = move_boxes(xyxy=xyxy, offset=offset) + assert np.array_equal(result, expected_result) + + +@pytest.mark.parametrize( + "masks, expected_result, exception", + [ + ( + np.array( + [ + [ + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + ] + ] + ), + np.array([[0, 0]]), + DoesNotRaise(), + ), # single mask with all zeros + ( + np.array( + [ + [ + [1, 1, 1, 1], + [1, 1, 1, 1], + [1, 1, 1, 1], + [1, 1, 1, 1], + ] + ] + ), + np.array([[2, 2]]), + DoesNotRaise(), + ), # single mask with all ones + ( + np.array( + [ + [ + [0, 1, 1, 0], + [1, 1, 1, 1], + [1, 1, 1, 1], + [0, 1, 1, 0], + ] + ] + ), + np.array([[2, 2]]), + DoesNotRaise(), + ), # single mask with symmetric ones + ( + np.array( + [ + [ + [0, 0, 0, 0], + [0, 0, 1, 1], + [0, 0, 1, 1], + [0, 0, 0, 0], + ] + ] + ), + np.array([[3, 2]]), + DoesNotRaise(), + ), # single mask with asymmetric ones + ( + np.array( + [ + [ + [0, 1, 1, 0], + [1, 1, 1, 1], + [1, 1, 1, 1], + [0, 1, 1, 0], + ], + [ + [0, 0, 0, 0], + [0, 0, 1, 1], + [0, 0, 1, 1], + [0, 0, 0, 0], + ], + ] + ), + np.array([[2, 2], [3, 2]]), + DoesNotRaise(), + ), # two masks + ], +) +def test_calculate_masks_centroids( + masks: np.ndarray, + expected_result: np.ndarray, + exception: Exception, +) -> None: + with exception: + result = calculate_masks_centroids(masks=masks) + assert np.array_equal(result, expected_result)		[ { "components": [ { "doc": "Calculates and returns the coordinates of a specific anchor point\nwithin the bounding boxes defined by the `xyxy` attribute. The anchor\npoint can be any of the predefined positions in the `Position` enum,\nsuch as `CENTER`, `CENTER_LEFT`, `BOTTOM_RIGHT`, etc.\n\nArgs:...	[ "test/detection/test_core.py::test_getitem[detections0-index0-expected_result0-exception0]", "test/detection/test_core.py::test_getitem[detections1-index1-expected_result1-exception1]", "test/detection/test_core.py::test_getitem[detections2-index2-expected_result2-exception2]", "test/detection/test_core.py::t...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add centroid calculation for binary masks # Description Added `calculate_centroids` function to compute center of mass for binary mask representations. Method added to `utils.py` and method import added to `core.py`. `Position` enumeration updated with `CENTER_OF_MASS` constant. Test function is added with test cases covering different mask scenarios. Update allows for masks to carry center of mass information too, useful in object detection. ## Type of change Please delete options that are not relevant. - [ ] Bug fix (non-breaking change which fixes an issue) - [x] New feature (non-breaking change which adds functionality) - [ ] This change requires a documentation update ## Docs - [x] Docs updated? What were the changes: ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in supervision/detection/core.py] (definition of Detections.get_anchors_coordinates:) def get_anchors_coordinates(self, anchor: Position) -> np.ndarray: """Calculates and returns the coordinates of a specific anchor point within the bounding boxes defined by the `xyxy` attribute. The anchor point can be any of the predefined positions in the `Position` enum, such as `CENTER`, `CENTER_LEFT`, `BOTTOM_RIGHT`, etc. Args: anchor (Position): An enum specifying the position of the anchor point within the bounding box. Supported positions are defined in the `Position` enum. Returns: np.ndarray: An array of shape `(n, 2)`, where `n` is the number of bounding boxes. Each row contains the `[x, y]` coordinates of the specified anchor point for the corresponding bounding box. Raises: ValueError: If the provided `anchor` is not supported.""" [end of new definitions in supervision/detection/core.py] [start of new definitions in supervision/detection/utils.py] (definition of calculate_masks_centroids:) def calculate_masks_centroids(masks: np.ndarray) -> np.ndarray: """Calculate the centroids of binary masks in a tensor. Parameters: masks (np.ndarray): A 3D NumPy array of shape (num_masks, height, width). Each 2D array in the tensor represents a binary mask. Returns: A 2D NumPy array of shape (num_masks, 2), where each row contains the x and y coordinates (in that order) of the centroid of the corresponding mask.""" (definition of calculate_masks_centroids.sum_over_mask:) def sum_over_mask(indices: np.ndarray, axis: tuple) -> np.ndarray: [end of new definitions in supervision/detection/utils.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		3eb5c0b024e3e46877b7fe4fd66e6177d1308ba0
pyvista__pyvista-5192	5,192	pyvista/pyvista	0.43	673600daf5c1a4633b1750fb0849f77733dfe48a	2023-11-14T01:57:17Z	diff --git a/pyvista/plotting/_property.py b/pyvista/plotting/_property.py index 36c7af1b414..17a5ae55a21 100644 --- a/pyvista/plotting/_property.py +++ b/pyvista/plotting/_property.py @@ -2,6 +2,7 @@ from typing import Union import pyvista +from pyvista import vtk_version_info from pyvista.core.utilities.misc import _check_range, no_new_attr from . import _vtk @@ -107,6 +108,16 @@ class Property(_vtk.vtkProperty): * ``"front"`` - Enable frontface culling * ``'none'`` - Disable both backface and frontface culling + edge_opacity : float, default: :attr:`pyvista.plotting.themes.Theme.edge_opacity` + Edge opacity of the mesh. A single float value that will be applied globally + edge opacity of the mesh and uniformly applied everywhere - should be + between 0 and 1. + + .. note:: + `edge_opacity` uses ``SetEdgeOpacity`` as the underlying method which + requires VTK version 9.3 or higher. If ``SetEdgeOpacity`` is not + available, `edge_opacity` is set to 1. + Examples -------- Create a :class:`pyvista.Actor` and assign properties to it. @@ -166,6 +177,7 @@ def __init__( lighting=None, line_width=None, culling=None, + edge_opacity=None, ): """Initialize this property.""" self._theme = pyvista.themes.Theme() @@ -230,6 +242,16 @@ def __init__( self.line_width = line_width if culling is not None: self.culling = culling + if vtk_version_info < (9, 3) and edge_opacity is not None: # pragma: no cover + import warnings + + warnings.warn( + '`edge_opacity` cannot be used under VTK v9.3.0. Try installing VTK v9.3.0 or newer.', + UserWarning, + ) + if edge_opacity is None: + edge_opacity = self._theme.edge_opacity + self.edge_opacity = edge_opacity @property def style(self) -> str: # numpydoc ignore=RT01 @@ -398,6 +420,51 @@ def opacity(self, value: float): # numpydoc ignore=GL08 _check_range(value, (0, 1), 'opacity') self.SetOpacity(value) + @property + def edge_opacity(self) -> float: # numpydoc ignore=RT01 + """Return or set the edge opacity of this property. + + Edge opacity of the mesh. A single float value that will be applied globally + edge opacity of the mesh and uniformly applied everywhere. Between 0 and 1. + + .. note:: + `edge_opacity` uses ``SetEdgeOpacity`` as the underlying method which + requires VTK version 9.3 or higher. If ``SetEdgeOpacity`` is not + available, `edge_opacity` is set to 1. + + Examples + -------- + Set edge opacity to ``0.5``. + + >>> import pyvista as pv + >>> prop = pv.Property() + >>> prop.show_edges = True + >>> prop.edge_opacity = 0.5 + >>> prop.edge_opacity + 0.5 + + Visualize default edge opacity of ``1.0``. + + >>> prop.edge_opacity = 1.0 + >>> prop.plot() + + Visualize edge opacity of ``0.1``. + + >>> prop.edge_opacity = 0.1 + >>> prop.plot() + + """ + if vtk_version_info < (9, 3): + return 1.0 + else: + return self.GetEdgeOpacity() + + @edge_opacity.setter + def edge_opacity(self, value: float): # numpydoc ignore=GL08 + _check_range(value, (0, 1), 'edge_opacity') + if vtk_version_info >= (9, 3): + self.SetEdgeOpacity(value) + @property def show_edges(self) -> bool: # numpydoc ignore=RT01 """Return or set the visibility of edges. diff --git a/pyvista/plotting/plotter.py b/pyvista/plotting/plotter.py index b9c13003d3c..99c1adf0a55 100644 --- a/pyvista/plotting/plotter.py +++ b/pyvista/plotting/plotter.py @@ -2323,6 +2323,7 @@ def add_composite( color_missing_with_nan=False, copy_mesh=False, show_vertices=None, + edge_opacity=None, *kwargs, ): """Add a composite dataset to the plotter. @@ -2587,6 +2588,16 @@ def add_composite( ``vertex_style`` - Change style to ``'points_gaussian'`` * ``vertex_opacity`` - Control the opacity of the vertices + edge_opacity : float, optional + Edge opacity of the mesh. A single float value that will be applied globally + edge opacity of the mesh and uniformly applied everywhere - should be + between 0 and 1. + + .. note:: + `edge_opacity` uses ``SetEdgeOpacity`` as the underlying method which + requires VTK version 9.3 or higher. If ``SetEdgeOpacity`` is not + available, `edge_opacity` is set to 1. + kwargs : dict, optional Optional keyword arguments. @@ -2710,6 +2721,7 @@ def add_composite( line_width=line_width, opacity=opacity, culling=culling, + edge_opacity=edge_opacity, ) actor.SetProperty(prop) @@ -2847,6 +2859,7 @@ def add_mesh( copy_mesh=False, backface_params=None, show_vertices=None, + edge_opacity=None, kwargs, ): """Add any PyVista/VTK mesh or dataset that PyVista can wrap to the scene. @@ -3180,6 +3193,16 @@ def add_mesh( * ``vertex_style`` - Change style to ``'points_gaussian'`` * ``vertex_opacity`` - Control the opacity of the vertices + edge_opacity : float, optional + Edge opacity of the mesh. A single float value that will be applied globally + edge opacity of the mesh and uniformly applied everywhere - should be + between 0 and 1. + + .. note:: + `edge_opacity` uses ``SetEdgeOpacity`` as the underlying method which + requires VTK version 9.3 or higher. If ``SetEdgeOpacity`` is not + available, `edge_opacity` is set to 1. + **kwargs : dict, optional Optional keyword arguments. diff --git a/pyvista/plotting/themes.py b/pyvista/plotting/themes.py index f724028fe66..a71ea8f6299 100644 --- a/pyvista/plotting/themes.py +++ b/pyvista/plotting/themes.py @@ -1567,6 +1567,7 @@ class Theme(_ThemeConfig): '_opacity', '_before_close_callback', '_logo_file', + '_edge_opacity', ] def __init__(self): @@ -1650,6 +1651,7 @@ def __init__(self): self._lighting_params = _LightingConfig() self._interpolate_before_map = True self._opacity = 1.0 + self._edge_opacity = 1.0 self._logo_file = None @@ -1755,6 +1757,28 @@ def opacity(self, opacity: float): # numpydoc ignore=GL08 _check_range(opacity, (0, 1), 'opacity') self._opacity = float(opacity) + @property + def edge_opacity(self) -> float: # numpydoc ignore=RT01 + """Return or set the edges opacity. + + .. note:: + `edge_opacity` uses ``SetEdgeOpacity`` as the underlying method which + requires VTK version 9.3 or higher. If ``SetEdgeOpacity`` is not + available, `edge_opacity` is set to 1. + + Examples + -------- + >>> import pyvista as pv + >>> pv.global_theme.edge_opacity = 0.5 + + """ + return self._edge_opacity + + @edge_opacity.setter + def edge_opacity(self, edge_opacity: float): # numpydoc ignore=GL08 + _check_range(edge_opacity, (0, 1), 'edge_opacity') + self._edge_opacity = float(edge_opacity) + @property def above_range_color(self) -> Color: # numpydoc ignore=RT01 """Return or set the default above range color.	diff --git a/tests/plotting/test_property.py b/tests/plotting/test_property.py index 3662cc0936b..072ef3040ea 100644 --- a/tests/plotting/test_property.py +++ b/tests/plotting/test_property.py @@ -44,6 +44,15 @@ def test_property_opacity(prop): prop.opacity = 2 +@pytest.mark.skipif(pv.vtk_version_info < (9, 3), reason="Functions not implemented before 9.3.X") +def test_property_edge_opacity(prop): + edge_opacity = 0.5 + prop.edge_opacity = edge_opacity + assert prop.edge_opacity == edge_opacity + with pytest.raises(ValueError): + prop.edge_opacity = 2 + + def test_property_show_edges(prop): value = False prop.show_edges = value		[ { "components": [ { "doc": "", "lines": [ 463, 466 ], "name": "Property.edge_opacity", "signature": "def edge_opacity(self, value: float):", "type": "function" } ], "file": "pyvista/plotting/_property.py" }, { "compo...	[ "tests/plotting/test_property.py::test_property_edge_opacity" ]	[ "tests/plotting/test_property.py::test_check_range", "tests/plotting/test_property.py::test_property_init", "tests/plotting/test_property.py::test_property_style", "tests/plotting/test_property.py::test_property_edge_color", "tests/plotting/test_property.py::test_property_opacity", "tests/plotting/test_pr...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add `edge_opacity` property to `Property` class ### Overview <!-- Please insert a high-level description of this pull request here. --> resolves #5191 <!-- Be sure to link other PRs or issues that relate to this PR here. --> <!-- If this fully addresses an issue, please use the keyword `resolves` in front of that issue number. --> ### Details - [x] `vtk` version 9.3 or later ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pyvista/plotting/_property.py] (definition of Property.edge_opacity:) def edge_opacity(self, value: float): [end of new definitions in pyvista/plotting/_property.py] [start of new definitions in pyvista/plotting/themes.py] (definition of Theme.edge_opacity:) def edge_opacity(self, edge_opacity: float): [end of new definitions in pyvista/plotting/themes.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> add SetEdgeOpacity ### Describe the feature you would like to be added. Is it possible to add `SetEdgeOpacity` ? ### Links to VTK Documentation, Examples, or Class Definitions. https://vtk.org/doc/nightly/html/classvtkProperty.html#abe49ba1d9dfb86de9201fe6d5b16f4be ---------- -------------------- </issues>	25921025e45cafe97b2e274de39c3076b3c84681
googleapis__python-aiplatform-2956	2,956	googleapis/python-aiplatform	null	568d833bf44872b1045a4e2479451aedf592bf9e	2023-11-13T21:07:14Z	diff --git a/google/cloud/aiplatform/compat/types/__init__.py b/google/cloud/aiplatform/compat/types/__init__.py index 83387b064f..f543fb0114 100644 --- a/google/cloud/aiplatform/compat/types/__init__.py +++ b/google/cloud/aiplatform/compat/types/__init__.py @@ -52,6 +52,7 @@ index_endpoint as index_endpoint_v1beta1, hyperparameter_tuning_job as hyperparameter_tuning_job_v1beta1, io as io_v1beta1, + index_service as index_service_v1beta1, job_service as job_service_v1beta1, job_state as job_state_v1beta1, lineage_subgraph as lineage_subgraph_v1beta1, @@ -275,6 +276,7 @@ matching_engine_deployed_index_ref_v1beta1, index_v1beta1, index_endpoint_v1beta1, + index_service_v1beta1, match_service_v1beta1, metadata_service_v1beta1, metadata_schema_v1beta1, diff --git a/google/cloud/aiplatform/matching_engine/matching_engine_index.py b/google/cloud/aiplatform/matching_engine/matching_engine_index.py index 07eff0d325..c0713a83b9 100644 --- a/google/cloud/aiplatform/matching_engine/matching_engine_index.py +++ b/google/cloud/aiplatform/matching_engine/matching_engine_index.py @@ -21,6 +21,7 @@ from google.protobuf import field_mask_pb2 from google.cloud.aiplatform import base from google.cloud.aiplatform.compat.types import ( + index_service_v1beta1 as gca_index_service_v1beta1, matching_engine_deployed_index_ref as gca_matching_engine_deployed_index_ref, matching_engine_index as gca_matching_engine_index, encryption_spec as gca_encryption_spec, @@ -661,6 +662,46 @@ def create_brute_force_index( encryption_spec_key_name=encryption_spec_key_name, ) + def remove_datapoints( + self, + datapoint_ids: Sequence[str], + ) -> "MatchingEngineIndex": + """Remove datapoints for this index. + + Args: + datapoints_ids (Sequence[str]): + Required. The list of datapoints ids to be deleted. + + Returns: + MatchingEngineIndex - Index resource object + """ + self.wait() + + _LOGGER.log_action_start_against_resource( + "Removing datapoints", + "index", + self, + ) + + remove_lro = self.api_client.remove_datapoints( + gca_index_service_v1beta1.RemoveDatapointsRequest( + index=self.resource_name, + datapoint_ids=datapoint_ids, + ) + ) + + _LOGGER.log_action_started_against_resource_with_lro( + "Remove datapoints", "index", self.__class__, remove_lro + ) + + self._gca_resource = remove_lro.result(timeout=None) + + _LOGGER.log_action_completed_against_resource( + "index", "Removed datapoints", self + ) + + return self + _INDEX_UPDATE_METHOD_TO_ENUM_VALUE = { "STREAM_UPDATE": gca_matching_engine_index.Index.IndexUpdateMethod.STREAM_UPDATE,	diff --git a/tests/unit/aiplatform/test_matching_engine_index.py b/tests/unit/aiplatform/test_matching_engine_index.py index 40d12ef0a9..36320a13b3 100644 --- a/tests/unit/aiplatform/test_matching_engine_index.py +++ b/tests/unit/aiplatform/test_matching_engine_index.py @@ -35,6 +35,7 @@ from google.cloud.aiplatform.compat.types import ( index as gca_index, encryption_spec as gca_encryption_spec, + index_service_v1beta1 as gca_index_service_v1beta1, ) import constants as test_constants @@ -110,6 +111,9 @@ # Encryption spec _TEST_ENCRYPTION_SPEC_KEY_NAME = "TEST_ENCRYPTION_SPEC" +# Streaming update +_TEST_DATAPOINT_IDS = ("1", "2") + def uuid_mock(): return uuid.UUID(int=1) @@ -192,6 +196,16 @@ def create_index_mock(): yield create_index_mock +@pytest.fixture +def remove_datapoints_mock(): + with patch.object( + index_service_client.IndexServiceClient, "remove_datapoints" + ) as remove_datapoints_mock: + remove_datapoints_lro_mock = mock.Mock(operation.Operation) + remove_datapoints_mock.return_value = remove_datapoints_lro_mock + yield remove_datapoints_mock + + @pytest.mark.usefixtures("google_auth_mock") class TestMatchingEngineIndex: def setup_method(self): @@ -414,3 +428,19 @@ def test_create_brute_force_index( index=expected, metadata=_TEST_REQUEST_METADATA, ) + + @pytest.mark.usefixtures("get_index_mock") + def test_remove_datapoints(self, remove_datapoints_mock): + aiplatform.init(project=_TEST_PROJECT) + + my_index = aiplatform.MatchingEngineIndex(index_name=_TEST_INDEX_ID) + my_index.remove_datapoints( + datapoint_ids=_TEST_DATAPOINT_IDS, + ) + + remove_datapoints_request = gca_index_service_v1beta1.RemoveDatapointsRequest( + index=_TEST_INDEX_NAME, + datapoint_ids=_TEST_DATAPOINT_IDS, + ) + + remove_datapoints_mock.assert_called_once_with(remove_datapoints_request)		[ { "components": [ { "doc": "Remove datapoints for this index.\n\nArgs:\n datapoints_ids (Sequence[str]):\n Required. The list of datapoints ids to be deleted.\n\nReturns:\n MatchingEngineIndex - Index resource object", "lines": [ 665, 703 ], ...	[ "tests/unit/aiplatform/test_matching_engine_index.py::TestMatchingEngineIndex::test_init_index[index_id]", "tests/unit/aiplatform/test_matching_engine_index.py::TestMatchingEngineIndex::test_init_index[projects/test-project/locations/us-central1/indexes/index_id]", "tests/unit/aiplatform/test_matching_engine_in...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat: add `remove_datapoints()` to `MatchingEngineIndex`. feat: add `remove_datapoints()` to `MatchingEngineIndex`. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in google/cloud/aiplatform/matching_engine/matching_engine_index.py] (definition of MatchingEngineIndex.remove_datapoints:) def remove_datapoints( self, datapoint_ids: Sequence[str], ) -> "MatchingEngineIndex": """Remove datapoints for this index. Args: datapoints_ids (Sequence[str]): Required. The list of datapoints ids to be deleted. Returns: MatchingEngineIndex - Index resource object""" [end of new definitions in google/cloud/aiplatform/matching_engine/matching_engine_index.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		67358fa6a830eb842f6b52d09061af4a41b54af6
google-deepmind__optax-634	634	google-deepmind/optax	null	b7ff8ac43b59b27e4db28769995aade577ce4f99	2023-11-13T17:03:04Z	diff --git a/optax/contrib/mechanic.py b/optax/contrib/mechanic.py index 17e9f6602..aef7d18d4 100644 --- a/optax/contrib/mechanic.py +++ b/optax/contrib/mechanic.py @@ -26,31 +26,18 @@ using Mechanic to be the same for reasonably large batch sizes (>1k). """ - -import functools import operator from typing import NamedTuple, Optional, Tuple import chex import jax import jax.numpy as jnp + +from optax import tree_utils from optax._src import base from optax._src import utils -def _vdot_safe(a, b): - vdot = functools.partial(jnp.vdot, precision=jax.lax.Precision.HIGHEST) - cvdot = vdot(jnp.asarray(a), jnp.asarray(b)) - return cvdot - - -@jax.jit -def _tree_vdot(tree_x, tree_y): - """Compute the inner product <tree_x, tree_y>.""" - vdots = jax.tree_util.tree_map(_vdot_safe, tree_x, tree_y) - return jax.tree_util.tree_reduce(operator.add, vdots) - - @jax.jit def _tree_sum(tree_x): """Compute sum(tree_x).""" @@ -193,7 +180,7 @@ def add_weight_decay(gi, pi): ) # Now we are ready to run the actual Mechanic algorithm. - h = _tree_vdot(updates, delta_prev) + h = tree_utils.tree_vdot(updates, delta_prev) # This clipping was not part of the original paper but we introduced it # a little later. diff --git a/optax/tree_utils/__init__.py b/optax/tree_utils/__init__.py index 68989be69..a0fd7930d 100644 --- a/optax/tree_utils/__init__.py +++ b/optax/tree_utils/__init__.py @@ -12,6 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== -"""The tree_util optimisation sub-package.""" +"""The tree_utils sub-package.""" from optax.tree_utils._state_utils import tree_map_params +from optax.tree_utils._tree_math import tree_vdot diff --git a/optax/tree_utils/_tree_math.py b/optax/tree_utils/_tree_math.py new file mode 100644 index 000000000..e87164e71 --- /dev/null +++ b/optax/tree_utils/_tree_math.py @@ -0,0 +1,54 @@ +# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== + +"""Utilities to perform maths on pytrees.""" + +import functools +import operator +from typing import Any + +import chex +import jax +from jax import tree_util as jtu +import jax.numpy as jnp + + +_vdot = functools.partial(jnp.vdot, precision=jax.lax.Precision.HIGHEST) + + +def _vdot_safe(a, b): + return _vdot(jnp.asarray(a), jnp.asarray(b)) + + +def tree_vdot(tree_x: Any, tree_y: Any) -> chex.Numeric: + r"""Compute the inner product between two pytrees. + + Args: + tree_x: first pytree to use. + tree_y: second pytree to use. + Returns: + inner product between ``tree_x`` and ``tree_y``, a scalar value. + + >>> optax.tree_utils.tree_vdot( + >>> {a: jnp.array([1, 2]), b: jnp.array([1, 2])}, + >>> {a: jnp.array([-1, -1]), b: jnp.array([1, 1])}, + >>> ) + 0.0 + + Implementation detail: we upcast the values to the highest precision to avoid + numerical issues. + """ + vdots = jtu.tree_map(_vdot_safe, tree_x, tree_y) + return jtu.tree_reduce(operator.add, vdots)	diff --git a/optax/tree_utils/_tree_math_test.py b/optax/tree_utils/_tree_math_test.py new file mode 100644 index 000000000..0c7f1210e --- /dev/null +++ b/optax/tree_utils/_tree_math_test.py @@ -0,0 +1,56 @@ +# Copyright 2021 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== + +"""Tests for optax.tree_utils.""" + +from absl.testing import absltest + +import jax.numpy as jnp +import numpy as np + +from optax import tree_utils as tu + + +class TreeUtilsTest(absltest.TestCase): + + def setUp(self): + super().setUp() + rng = np.random.RandomState(0) + + self.tree_a = (rng.randn(20, 10) + 1j * rng.randn(20, 10), rng.randn(20)) + self.tree_b = (rng.randn(20, 10), rng.randn(20)) + + self.tree_a_dict = (1.0, {'k1': 1.0, 'k2': (1.0, 1.0)}, 1.0) + self.tree_b_dict = (1.0, {'k1': 2.0, 'k2': (3.0, 4.0)}, 5.0) + + self.array_a = rng.randn(20) + 1j * rng.randn(20) + self.array_b = rng.randn(20) + + def test_tree_vdot(self): + expected = jnp.vdot(self.array_a, self.array_b) + got = tu.tree_vdot(self.array_a, self.array_b) + np.testing.assert_allclose(expected, got) + + expected = 15.0 + got = tu.tree_vdot(self.tree_a_dict, self.tree_b_dict) + np.testing.assert_allclose(expected, got) + + expected = (jnp.vdot(self.tree_a[0], self.tree_b[0]) + + jnp.vdot(self.tree_a[1], self.tree_b[1])) + got = tu.tree_vdot(self.tree_a, self.tree_b) + np.testing.assert_allclose(expected, got) + +if __name__ == '__main__': + absltest.main()		[ { "components": [ { "doc": "", "lines": [ 31, 32 ], "name": "_vdot_safe", "signature": "def _vdot_safe(a, b):", "type": "function" }, { "doc": "Compute the inner product between two pytrees.\n\nArgs:\n tree_x: first p...	[ "optax/tree_utils/_tree_math_test.py::TreeUtilsTest::test_tree_vdot" ]	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add tree_vdot to tree_utils. Add tree_vdot to tree_utils. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in optax/tree_utils/_tree_math.py] (definition of _vdot_safe:) def _vdot_safe(a, b): (definition of tree_vdot:) def tree_vdot(tree_x: Any, tree_y: Any) -> chex.Numeric: """Compute the inner product between two pytrees. Args: tree_x: first pytree to use. tree_y: second pytree to use. Returns: inner product between ``tree_x`` and ``tree_y``, a scalar value. >>> optax.tree_utils.tree_vdot( >>> {a: jnp.array([1, 2]), b: jnp.array([1, 2])}, >>> {a: jnp.array([-1, -1]), b: jnp.array([1, 1])}, >>> ) 0.0 Implementation detail: we upcast the values to the highest precision to avoid numerical issues.""" [end of new definitions in optax/tree_utils/_tree_math.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		1e08bccf195ac54e7d9d766eb5e69345bf0e3230
google-deepmind__optax-632	632	google-deepmind/optax	null	35920a3712d71992429dc0bd605e75d31cbe2b21	2023-11-13T14:40:27Z	diff --git a/optax/__init__.py b/optax/__init__.py index 0b373684d..6f844478d 100644 --- a/optax/__init__.py +++ b/optax/__init__.py @@ -17,6 +17,7 @@ from optax import contrib from optax import losses from optax import monte_carlo +from optax import projections from optax import schedules from optax import second_order from optax import tree_utils diff --git a/optax/projections/__init__.py b/optax/projections/__init__.py new file mode 100644 index 000000000..9b38aeb6c --- /dev/null +++ b/optax/projections/__init__.py @@ -0,0 +1,18 @@ +# Copyright 2021 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== + +"""The projections sub-package.""" + +from optax.projections._projections import projection_non_negative diff --git a/optax/projections/_projections.py b/optax/projections/_projections.py new file mode 100644 index 000000000..316cd21fb --- /dev/null +++ b/optax/projections/_projections.py @@ -0,0 +1,39 @@ +# Copyright 2021 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== + +"""Euclidean projections.""" + +from typing import Any + +import jax +from jax import tree_util as jtu + + +def projection_non_negative(pytree: Any) -> Any: + r"""Projection onto the non-negative orthant. + + .. math:: + + \underset{p}{\text{argmin}} ~ \|\|x - p\|\|_2^2 \quad + \textrm{subject to} \quad p \ge 0 + + where :math:`x` is the input pytree. + + Args: + pytree: pytree to project. + Returns: + projected pytree, with the same structure as ``pytree``. + """ + return jtu.tree_map(jax.nn.relu, pytree)	diff --git a/optax/projections/_projections_test.py b/optax/projections/_projections_test.py new file mode 100644 index 000000000..15d4f1204 --- /dev/null +++ b/optax/projections/_projections_test.py @@ -0,0 +1,47 @@ +# Copyright 2021 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== + +"""Tests for optax.projections.""" + +from absl.testing import absltest +from absl.testing import parameterized + +import chex +import jax.numpy as jnp +import numpy as np + +from optax import projections as proj + + +class ProjectionsTest(parameterized.TestCase): + + def test_projection_non_negative(self): + # test with array + x = jnp.array([-1.0, 2.0, 3.0]) + expected = jnp.array([0, 2.0, 3.0]) + np.testing.assert_array_equal(proj.projection_non_negative(x), expected) + + # test with tuple + np.testing.assert_array_equal(proj.projection_non_negative((x, x)), + (expected, expected)) + + # test with nested pytree + tree_x = (-1.0, {'k1': 1.0, 'k2': (1.0, 1.0)}, 1.0) + tree_expected = (0.0, {'k1': 1.0, 'k2': (1.0, 1.0)}, 1.0) + chex.assert_trees_all_equal(proj.projection_non_negative(tree_x), + tree_expected) + +if __name__ == '__main__': + absltest.main()		[ { "components": [ { "doc": "Projection onto the non-negative orthant.\n\n.. math::\n\n \\underset{p}{\\text{argmin}} ~ \|\|x - p\|\|_2^2 \\quad\n \\textrm{subject to} \\quad p \\ge 0\n\nwhere :math:`x` is the input pytree.\n\nArgs:\n pytree: pytree to project.\nReturns:\n projected pytree, with th...	[ "optax/projections/_projections_test.py::ProjectionsTest::test_projection_non_negative" ]	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Start optax.projections subpackage and add projection_non_negative. Start optax.projections subpackage and add projection_non_negative. In the future, this subpackage will contain more projections (projection_simplex, projection_l1_ball, etc) as well as non-Euclidean projections. I used typing.Any as a type annotation for pytrees for the time being, as chex.ArrayTree doesn't seem to accept tuples. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in optax/projections/_projections.py] (definition of projection_non_negative:) def projection_non_negative(pytree: Any) -> Any: """Projection onto the non-negative orthant. .. math:: \underset{p}{\text{argmin}} ~ \|\|x - p\|\|_2^2 \quad \textrm{subject to} \quad p \ge 0 where :math:`x` is the input pytree. Args: pytree: pytree to project. Returns: projected pytree, with the same structure as ``pytree``.""" [end of new definitions in optax/projections/_projections.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		1e08bccf195ac54e7d9d766eb5e69345bf0e3230
pvlib__pvlib-python-1907	1,907	pvlib/pvlib-python	0.9	4e99ddca47499715231578c3eae81ec0c4db8573	2023-11-12T20:46:36Z	diff --git a/docs/examples/irradiance-transposition/plot_rtranpose_limitations.py b/docs/examples/irradiance-transposition/plot_rtranpose_limitations.py new file mode 100644 index 0000000000..8df8339ad4 --- /dev/null +++ b/docs/examples/irradiance-transposition/plot_rtranpose_limitations.py @@ -0,0 +1,181 @@ +""" +Reverse transposition limitations +==================================== + +Unfortunately, sometimes there is not a unique solution. + +Author: Anton Driesse + +""" + +# %% +# +# Introduction +# ------------ +# When irradiance is measured on a tilted plane, it is useful to be able to +# estimate the GHI that produces the POA irradiance. +# The estimation requires inverting a GHI-to-POA irradiance model, +# which involves two parts: +# a decomposition of GHI into direct and diffuse components, +# and a transposition model that calculates the direct and diffuse irradiance +# on the tilted plane. +# Recovering GHI from POA irradiance is termed "reverse transposition." +# +# Unfortunately, for a given POA irradiance value, sometimes there is not a +# unique solution for GHI. +# Different GHI values can produce different combinations of direct and +# diffuse irradiance that sum to the same POA irradiance value. +# +# In this example we look at a single point in time and consider a full range +# of possible GHI and POA global values as shown in figures 3 and 4 of [1]_. +# Then we use :py:meth:`pvlib.irradiance.ghi_from_poa_driesse_2023` to estimate +# the original GHI from POA global. +# +# References +# ---------- +# .. [1] Driesse, A., Jensen, A., Perez, R., 2024. A Continuous form of the +# Perez diffuse sky model for forward and reverse transposition. +# Solar Energy vol. 267. :doi:`10.1016/j.solener.2023.112093` +# + +import numpy as np + +import matplotlib +import matplotlib.pyplot as plt + +from pvlib.irradiance import (erbs_driesse, + get_total_irradiance, + ghi_from_poa_driesse_2023, + ) + +matplotlib.rcParams['axes.grid'] = True + +# %% +# +# Define the conditions that were used for figure 3 in [1]_. +# + +dni_extra = 1366.1 +albedo = 0.25 +surface_tilt = 40 +surface_azimuth = 180 + +solar_azimuth = 82 +solar_zenith = 75 + +# %% +# +# Define a range of possible GHI values and calculate the corresponding +# POA global. First estimate DNI and DHI using the Erbs-Driesse model, then +# transpose using the Perez-Driesse model. +# + +ghi = np.linspace(0, 500, 100+1) + +erbsout = erbs_driesse(ghi, solar_zenith, dni_extra=dni_extra) + +dni = erbsout['dni'] +dhi = erbsout['dhi'] + +irrads = get_total_irradiance(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + dni, ghi, dhi, + dni_extra, + model='perez-driesse') + +poa_global = irrads['poa_global'] + +# %% +# +# Suppose you measure that POA global is 200 W/m2. What would GHI be? +# + +poa_test = 200 + +ghi_hat = ghi_from_poa_driesse_2023(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + poa_test, + dni_extra, + full_output=False) + +print('Estimated GHI: %.2f W/m².' % ghi_hat) + +# %% +# +# Show this result on the graph of all possible combinations of GHI and POA. +# + +plt.figure() +plt.plot(ghi, poa_global, 'k-') +plt.axvline(ghi_hat, color='g', lw=1) +plt.axhline(poa_test, color='g', lw=1) +plt.plot(ghi_hat, poa_test, 'gs') +plt.annotate('GHI=%.2f' % (ghi_hat), + xy=(ghi_hat-2, 200+2), + xytext=(ghi_hat-20, 200+20), + ha='right', + arrowprops={'arrowstyle': 'simple'}) +plt.xlim(0, 500) +plt.ylim(0, 250) +plt.xlabel('GHI [W/m²]') +plt.ylabel('POA [W/m²]') +plt.show() + +# %% +# +# Now change the solar azimuth to match the conditions for figure 4 in [1]_. +# + +solar_azimuth = 76 + +# %% +# +# Again, estimate DNI and DHI using the Erbs-Driesse model, then +# transpose using the Perez-Driesse model. +# + +erbsout = erbs_driesse(ghi, solar_zenith, dni_extra=dni_extra) + +dni = erbsout['dni'] +dhi = erbsout['dhi'] + +irrads = get_total_irradiance(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + dni, ghi, dhi, + dni_extra, + model='perez-driesse') + +poa_global = irrads['poa_global'] + +# %% +# +# Now reverse transpose all the POA values and observe that the original +# GHI cannot always be found. There is a range of POA values that +# maps to three possible GHI values, and there is not enough information +# to choose one of them. Sometimes we get lucky and the right one comes +# out, other times not. +# + +result = ghi_from_poa_driesse_2023(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + poa_global, + dni_extra, + full_output=True, + ) + +ghi_hat, conv, niter = result +correct = np.isclose(ghi, ghi_hat, atol=0.01) + +plt.figure() +plt.plot(np.where(correct, ghi, np.nan), np.where(correct, poa_global, np.nan), + 'g.', label='correct GHI found') +plt.plot(ghi[~correct], poa_global[~correct], 'r.', label='unreachable GHI') +plt.plot(ghi[~conv], poa_global[~conv], 'm.', label='out of range (kt > 1.25)') +plt.axhspan(88, 103, color='y', alpha=0.25, label='problem region') + +plt.xlim(0, 500) +plt.ylim(0, 250) +plt.xlabel('GHI [W/m²]') +plt.ylabel('POA [W/m²]') +plt.legend() +plt.show() diff --git a/docs/examples/irradiance-transposition/plot_rtranpose_year.py b/docs/examples/irradiance-transposition/plot_rtranpose_year.py new file mode 100644 index 0000000000..c0b9860bba --- /dev/null +++ b/docs/examples/irradiance-transposition/plot_rtranpose_year.py @@ -0,0 +1,152 @@ +""" +Reverse transposition using one year of hourly data +=================================================== + +With a brief look at accuracy and speed. + +Author: Anton Driesse + +""" +# %% +# +# Introduction +# ------------ +# When irradiance is measured on a tilted plane, it is useful to be able to +# estimate the GHI that produces the POA irradiance. +# The estimation requires inverting a GHI-to-POA irradiance model, +# which involves two parts: +# a decomposition of GHI into direct and diffuse components, +# and a transposition model that calculates the direct and diffuse +# irradiance on the tilted plane. +# Recovering GHI from POA irradiance is termed "reverse transposition." +# +# In this example we start with a TMY file and calculate POA global irradiance. +# Then we use :py:meth:`pvlib.irradiance.ghi_from_poa_driesse_2023` to estimate +# the original GHI from POA global. Details of the method found in [1]_. +# +# Another method for reverse tranposition called GTI-DIRINT is also +# available in pvlib python (:py:meth:`pvlib.irradiance.gti_dirint`). +# More information is available in [2]_. +# +# References +# ---------- +# .. [1] Driesse, A., Jensen, A., Perez, R., 2024. A Continuous form of the +# Perez diffuse sky model for forward and reverse transposition. +# Solar Energy vol. 267. :doi:`10.1016/j.solener.2023.112093` +# +# .. [2] B. Marion, A model for deriving the direct normal and +# diffuse horizontal irradiance from the global tilted +# irradiance, Solar Energy 122, 1037-1046. +# :doi:`10.1016/j.solener.2015.10.024` + +import os +import time +import pandas as pd + +import matplotlib.pyplot as plt + +import pvlib +from pvlib import iotools, location +from pvlib.irradiance import (get_extra_radiation, + get_total_irradiance, + ghi_from_poa_driesse_2023, + aoi, + ) + +# %% +# +# Read a TMY3 file containing weather data and select needed columns. +# + +PVLIB_DIR = pvlib.__path__[0] +DATA_FILE = os.path.join(PVLIB_DIR, 'data', '723170TYA.CSV') + +tmy, metadata = iotools.read_tmy3(DATA_FILE, coerce_year=1990, + map_variables=True) + +df = pd.DataFrame({'ghi': tmy['ghi'], 'dhi': tmy['dhi'], 'dni': tmy['dni'], + 'temp_air': tmy['temp_air'], + 'wind_speed': tmy['wind_speed'], + }) + +# %% +# +# Shift the timestamps to the middle of the hour and calculate sun positions. +# + +df.index = df.index - pd.Timedelta(minutes=30) + +loc = location.Location.from_tmy(metadata) +solpos = loc.get_solarposition(df.index) + +# %% +# +# Estimate global irradiance on a fixed-tilt array (forward transposition). +# The array is tilted 30 degrees and oriented 30 degrees east of south. +# + +TILT = 30 +ORIENT = 150 + +df['dni_extra'] = get_extra_radiation(df.index) + +total_irrad = get_total_irradiance(TILT, ORIENT, + solpos.apparent_zenith, + solpos.azimuth, + df.dni, df.ghi, df.dhi, + dni_extra=df.dni_extra, + model='perez-driesse') + +df['poa_global'] = total_irrad.poa_global +df['aoi'] = aoi(TILT, ORIENT, solpos.apparent_zenith, solpos.azimuth) + +# %% +# +# Now estimate ghi from poa_global using reverse transposition. +# The algorithm uses a simple bisection search, which is quite slow +# because scipy doesn't offer a vectorized version (yet). +# For this reason we'll process a random sample of 1000 timestamps +# rather than the whole year. +# + +df = df[df.ghi > 0].sample(n=1000) +solpos = solpos.reindex(df.index) + +start = time.process_time() + +df['ghi_rev'] = ghi_from_poa_driesse_2023(TILT, ORIENT, + solpos.apparent_zenith, + solpos.azimuth, + df.poa_global, + dni_extra=df.dni_extra) +finish = time.process_time() + +print('Elapsed time for reverse transposition: %.1f s' % (finish - start)) + +# %% +# +# This graph shows the reverse transposed values vs. the original values. +# The markers are color-coded by angle-of-incidence to show that +# errors occur primarily with incidence angle approaching 90° and beyond. +# +# Note that the results look particularly good because the POA values +# were calculated using the same models as used in reverse transposition. +# This isn't cheating though. It's a way of ensuring that the errors +# we see are really due to the reverse transposition algorithm. +# Expect to see larger errors with real-word POA measurements +# because errors from forward and reverse transposition will both be present. +# + +df = df.sort_values('aoi') + +plt.figure() +plt.gca().grid(True, alpha=.5) +pc = plt.scatter(df['ghi'], df['ghi_rev'], c=df['aoi'], s=15, + cmap='jet', vmin=60, vmax=120) +plt.colorbar(label='AOI [°]') +pc.set_alpha(0.5) + +plt.xlabel('GHI original [W/m²]') +plt.ylabel('GHI from POA [W/m²]') + +plt.show() diff --git a/docs/sphinx/source/reference/irradiance/transposition.rst b/docs/sphinx/source/reference/irradiance/transposition.rst index 7b3624e692..22136f0c58 100644 --- a/docs/sphinx/source/reference/irradiance/transposition.rst +++ b/docs/sphinx/source/reference/irradiance/transposition.rst @@ -15,3 +15,4 @@ Transposition models irradiance.klucher irradiance.reindl irradiance.king + irradiance.ghi_from_poa_driesse_2023 diff --git a/docs/sphinx/source/whatsnew/v0.10.3.rst b/docs/sphinx/source/whatsnew/v0.10.3.rst index 007eb8d34b..63f7b90b84 100644 --- a/docs/sphinx/source/whatsnew/v0.10.3.rst +++ b/docs/sphinx/source/whatsnew/v0.10.3.rst @@ -9,6 +9,9 @@ Enhancements ~~~~~~~~~~~~ * Added the continuous Perez-Driesse transposition model. :py:func:`pvlib.irradiance.perez_driesse` (:issue:`1841`, :pull:`1876`) +* Added a reverse transposition algorithm using the Perez-Driesse model. + :py:func:`pvlib.irradiance.ghi_from_poa_driesse_2023` + (:issue:`1901`, :pull:`1907`) * :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance` and :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance_poa` now include shaded fraction in returned variables. (:pull:`1871`) @@ -27,8 +30,10 @@ Documentation ~~~~~~~~~~~~~ * Create :ref:`weatherdata` User's Guide page. (:pull:`1754`) * Fixed a plotting issue in the IV curve gallery example (:pull:`1895`) +* Added two examples to demonstrate reverse transposition (:pull:`1907`) * Fixed `detect_clearsky` example in `clearsky.rst` (:issue:`1914`) + Requirements ~~~~~~~~~~~~ * Minimum version of scipy advanced from 1.4.0 to 1.5.0. (:issue:`1918`, :pull:`1919`) diff --git a/pvlib/irradiance.py b/pvlib/irradiance.py index efae7f6236..f5e9a44b7a 100644 --- a/pvlib/irradiance.py +++ b/pvlib/irradiance.py @@ -11,6 +11,7 @@ import numpy as np import pandas as pd from scipy.interpolate import splev +from scipy.optimize import bisect from pvlib import atmosphere, solarposition, tools import pvlib # used to avoid dni name collision in complete_irradiance @@ -1380,9 +1381,9 @@ def perez_driesse(surface_tilt, surface_azimuth, dhi, dni, dni_extra, References ---------- - .. [1] A. Driesse, A. Jensen, R. Perez, A Continuous Form of the Perez - Diffuse Sky Model for Forward and Reverse Transposition, accepted - for publication in the Solar Energy Journal. + .. [1] Driesse, A., Jensen, A., Perez, R., 2024. A Continuous form of the + Perez diffuse sky model for forward and reverse transposition. + Solar Energy vol. 267. :doi:`10.1016/j.solener.2023.112093` .. [2] Perez, R., Ineichen, P., Seals, R., Michalsky, J., Stewart, R., 1990. Modeling daylight availability and irradiance components from @@ -1444,6 +1445,170 @@ def perez_driesse(surface_tilt, surface_azimuth, dhi, dni, dni_extra, return sky_diffuse +def _poa_from_ghi(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + ghi, + dni_extra, airmass, albedo): + ''' + Transposition function that includes decomposition of GHI using the + continuous Erbs-Driesse model. + + Helper function for ghi_from_poa_driesse_2023. + ''' + # Contributed by Anton Driesse (@adriesse), PV Performance Labs. Nov., 2023 + + erbsout = erbs_driesse(ghi, solar_zenith, dni_extra=dni_extra) + + dni = erbsout['dni'] + dhi = erbsout['dhi'] + + irrads = get_total_irradiance(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + dni, ghi, dhi, + dni_extra, airmass, albedo, + model='perez-driesse') + + return irrads['poa_global'] + + +def _ghi_from_poa(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + poa_global, + dni_extra, airmass, albedo, + xtol=0.01): + ''' + Reverse transposition function that uses the scalar bisection from scipy. + + Helper function for ghi_from_poa_driesse_2023. + ''' + # Contributed by Anton Driesse (@adriesse), PV Performance Labs. Nov., 2023 + + # propagate nans and zeros quickly + if np.isnan(poa_global): + return np.nan, False, 0 + if poa_global <= 0: + return 0.0, True, 0 + + # function whose root needs to be found + def poa_error(ghi): + poa_hat = _poa_from_ghi(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + ghi, + dni_extra, airmass, albedo) + return poa_hat - poa_global + + # calculate an upper bound for ghi using clearness index 1.25 + ghi_clear = dni_extra * tools.cosd(solar_zenith) + ghi_high = np.maximum(10, 1.25 * ghi_clear) + + try: + result = bisect(poa_error, + a=0, + b=ghi_high, + xtol=xtol, + maxiter=25, + full_output=True, + disp=False, + ) + except ValueError: + # this occurs when poa_error has the same sign at both end points + ghi = np.nan + conv = False + niter = -1 + else: + ghi = result[0] + conv = result[1].converged + niter = result[1].iterations + + return ghi, conv, niter + + +def ghi_from_poa_driesse_2023(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + poa_global, + dni_extra=None, airmass=None, albedo=0.25, + xtol=0.01, + full_output=False): + ''' + Estimate global horizontal irradiance (GHI) from global plane-of-array + (POA) irradiance. This reverse transposition algorithm uses a bisection + search together with the continuous Perez-Driesse transposition and + continuous Erbs-Driesse decomposition models, as described in [1]_. + + Parameters + ---------- + surface_tilt : numeric + Panel tilt from horizontal. [degree] + surface_azimuth : numeric + Panel azimuth from north. [degree] + solar_zenith : numeric + Solar zenith angle. [degree] + solar_azimuth : numeric + Solar azimuth angle. [degree] + poa_global : numeric + Plane-of-array global irradiance, aka global tilted irradiance. [W/m^2] + dni_extra : None or numeric, default None + Extraterrestrial direct normal irradiance. [W/m^2] + airmass : None or numeric, default None + Relative airmass (not adjusted for pressure). [unitless] + albedo : numeric, default 0.25 + Ground surface albedo. [unitless] + xtol : numeric, default 0.01 + Convergence criterion. The estimated GHI will be within xtol of the + true value. [W/m^2] + full_output : boolean, default False + If full_output is False, only ghi is returned, otherwise the return + value is (ghi, converged, niter). (see Returns section for details). + + Returns + ------- + ghi : numeric + Estimated GHI. [W/m^2] + converged : boolean, optional + Present if full_output=True. Indicates which elements converged + successfully. + niter : integer, optional + Present if full_output=True. Indicates how many bisection iterations + were done. + + Notes + ----- + Since :py:func:`scipy.optimize.bisect` is not vectorized, high-resolution + time series can be quite slow to process. + + References + ---------- + .. [1] Driesse, A., Jensen, A., Perez, R., 2024. A Continuous form of the + Perez diffuse sky model for forward and reverse transposition. + Solar Energy vol. 267. :doi:`10.1016/j.solener.2023.112093` + + See also + -------- + perez_driesse + erbs_driesse + gti_dirint + ''' + # Contributed by Anton Driesse (@adriesse), PV Performance Labs. Nov., 2023 + + ghi_from_poa_array = np.vectorize(_ghi_from_poa) + + ghi, conv, niter = ghi_from_poa_array(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + poa_global, + dni_extra, airmass, albedo, + xtol=0.01) + + if isinstance(poa_global, pd.Series): + ghi = pd.Series(ghi, poa_global.index) + conv = pd.Series(conv, poa_global.index) + niter = pd.Series(niter, poa_global.index) + + if full_output: + return ghi, conv, niter + else: + return ghi + + def clearsky_index(ghi, clearsky_ghi, max_clearsky_index=2.0): """ Calculate the clearsky index. @@ -2567,8 +2732,9 @@ def erbs_driesse(ghi, zenith, datetime_or_doy=None, dni_extra=None, References ---------- - .. [1] A. Driesse, A. Jensen, R. Perez, A Continuous Form of the Perez - Diffuse Sky Model for Forward and Reverse Transposition, forthcoming. + .. [1] Driesse, A., Jensen, A., Perez, R., 2024. A Continuous form of the + Perez diffuse sky model for forward and reverse transposition. + Solar Energy vol. 267. :doi:`10.1016/j.solener.2023.112093` .. [2] D. G. Erbs, S. A. Klein and J. A. Duffie, Estimation of the diffuse radiation fraction for hourly, daily and monthly-average	diff --git a/pvlib/tests/test_irradiance.py b/pvlib/tests/test_irradiance.py index ba66f4dc36..55fef490ba 100644 --- a/pvlib/tests/test_irradiance.py +++ b/pvlib/tests/test_irradiance.py @@ -782,6 +782,50 @@ def test_dirint_min_cos_zenith_max_zenith(): assert_series_equal(out, expected, check_less_precise=True) +def test_ghi_from_poa_driesse(): + # inputs copied from test_gti_dirint + times = pd.DatetimeIndex( + ['2014-06-24T06-0700', '2014-06-24T09-0700', '2014-06-24T12-0700']) + poa_global = np.array([20, 300, 1000]) + zenith = np.array([80, 45, 20]) + azimuth = np.array([90, 135, 180]) + surface_tilt = 30 + surface_azimuth = 180 + + # test core function + output = irradiance.ghi_from_poa_driesse_2023( + surface_tilt, surface_azimuth, zenith, azimuth, + poa_global, dni_extra=1366.1) + + expected = [22.089, 304.088, 931.143] + assert_allclose(expected, output, atol=0.001) + + # test series output + poa_global = pd.Series([20, 300, 1000], index=times) + + output = irradiance.ghi_from_poa_driesse_2023( + surface_tilt, surface_azimuth, zenith, azimuth, + poa_global, dni_extra=1366.1) + + assert isinstance(output, pd.Series) + + # test full_output option and special cases + poa_global = np.array([0, 1500, np.nan]) + + ghi, conv, niter = irradiance.ghi_from_poa_driesse_2023( + surface_tilt, surface_azimuth, zenith, azimuth, + poa_global, dni_extra=1366.1, full_output=True) + + expected = [0, np.nan, np.nan] + assert_allclose(expected, ghi, atol=0.001) + + expected = [True, False, False] + assert_allclose(expected, conv) + + expected = [0, -1, 0] + assert_allclose(expected, niter) + + def test_gti_dirint(): times = pd.DatetimeIndex( ['2014-06-24T06-0700', '2014-06-24T09-0700', '2014-06-24T12-0700'])	diff --git a/docs/sphinx/source/reference/irradiance/transposition.rst b/docs/sphinx/source/reference/irradiance/transposition.rst index 7b3624e692..22136f0c58 100644 --- a/docs/sphinx/source/reference/irradiance/transposition.rst +++ b/docs/sphinx/source/reference/irradiance/transposition.rst @@ -15,3 +15,4 @@ Transposition models irradiance.klucher irradiance.reindl irradiance.king + irradiance.ghi_from_poa_driesse_2023 diff --git a/docs/sphinx/source/whatsnew/v0.10.3.rst b/docs/sphinx/source/whatsnew/v0.10.3.rst index 007eb8d34b..63f7b90b84 100644 --- a/docs/sphinx/source/whatsnew/v0.10.3.rst +++ b/docs/sphinx/source/whatsnew/v0.10.3.rst @@ -9,6 +9,9 @@ Enhancements ~~~~~~~~~~~~ * Added the continuous Perez-Driesse transposition model. :py:func:`pvlib.irradiance.perez_driesse` (:issue:`1841`, :pull:`1876`) +* Added a reverse transposition algorithm using the Perez-Driesse model. + :py:func:`pvlib.irradiance.ghi_from_poa_driesse_2023` + (:issue:`1901`, :pull:`1907`) * :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance` and :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance_poa` now include shaded fraction in returned variables. (:pull:`1871`) @@ -27,8 +30,10 @@ Documentation ~~~~~~~~~~~~~ * Create :ref:`weatherdata` User's Guide page. (:pull:`1754`) * Fixed a plotting issue in the IV curve gallery example (:pull:`1895`) +* Added two examples to demonstrate reverse transposition (:pull:`1907`) * Fixed `detect_clearsky` example in `clearsky.rst` (:issue:`1914`) + Requirements ~~~~~~~~~~~~ * Minimum version of scipy advanced from 1.4.0 to 1.5.0. (:issue:`1918`, :pull:`1919`)	[ { "components": [ { "doc": "Transposition function that includes decomposition of GHI using the\ncontinuous Erbs-Driesse model.\n\nHelper function for ghi_from_poa_driesse_2023.", "lines": [ 1448, 1471 ], "name": "_poa_from_ghi", "signature": "de...	[ "pvlib/tests/test_irradiance.py::test_ghi_from_poa_driesse" ]	[ "pvlib/tests/test_irradiance.py::test_get_extra_radiation[asce-300-1383.636203]", "pvlib/tests/test_irradiance.py::test_get_extra_radiation[asce-300.0-1383.636203]", "pvlib/tests/test_irradiance.py::test_get_extra_radiation[asce-testval2-1383.636203]", "pvlib/tests/test_irradiance.py::test_get_extra_radiation...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Implement reverse transposition using Perez-Driesse forward transposition <!-- Thank you for your contribution! The following items must be addressed before the code can be merged. Please don't hesitate to ask for help if you're unsure of how to accomplish any of the items. Feel free to remove checklist items that are not relevant to your change. --> - [x] Closes #1901 - [x] I am familiar with the [contributing guidelines](https://pvlib-python.readthedocs.io/en/latest/contributing.html) - [x] Tests added - [x] Updates entries in [`docs/sphinx/source/reference`](https://github.com/pvlib/pvlib-python/blob/main/docs/sphinx/source/reference) for API changes. - [x] Adds description and name entries in the appropriate "what's new" file in [`docs/sphinx/source/whatsnew`](https://github.com/pvlib/pvlib-python/tree/main/docs/sphinx/source/whatsnew) for all changes. Includes link to the GitHub Issue with `` :issue:`num` `` or this Pull Request with `` :pull:`num` ``. Includes contributor name and/or GitHub username (link with `` :ghuser:`user` ``). - [x] New code is fully documented. Includes [numpydoc](https://numpydoc.readthedocs.io/en/latest/format.html) compliant docstrings, examples, and comments where necessary. - [x] Pull request is nearly complete and ready for detailed review. - [x] Maintainer: Appropriate GitHub Labels (including `remote-data`) and Milestone are assigned to the Pull Request and linked Issue. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pvlib/irradiance.py] (definition of _poa_from_ghi:) def _poa_from_ghi(surface_tilt, surface_azimuth, solar_zenith, solar_azimuth, ghi, dni_extra, airmass, albedo): """Transposition function that includes decomposition of GHI using the continuous Erbs-Driesse model. Helper function for ghi_from_poa_driesse_2023.""" (definition of _ghi_from_poa:) def _ghi_from_poa(surface_tilt, surface_azimuth, solar_zenith, solar_azimuth, poa_global, dni_extra, airmass, albedo, xtol=0.01): """Reverse transposition function that uses the scalar bisection from scipy. Helper function for ghi_from_poa_driesse_2023.""" (definition of _ghi_from_poa.poa_error:) def poa_error(ghi): (definition of ghi_from_poa_driesse_2023:) def ghi_from_poa_driesse_2023(surface_tilt, surface_azimuth, solar_zenith, solar_azimuth, poa_global, dni_extra=None, airmass=None, albedo=0.25, xtol=0.01, full_output=False): """Estimate global horizontal irradiance (GHI) from global plane-of-array (POA) irradiance. This reverse transposition algorithm uses a bisection search together with the continuous Perez-Driesse transposition and continuous Erbs-Driesse decomposition models, as described in [1]_. Parameters ---------- surface_tilt : numeric Panel tilt from horizontal. [degree] surface_azimuth : numeric Panel azimuth from north. [degree] solar_zenith : numeric Solar zenith angle. [degree] solar_azimuth : numeric Solar azimuth angle. [degree] poa_global : numeric Plane-of-array global irradiance, aka global tilted irradiance. [W/m^2] dni_extra : None or numeric, default None Extraterrestrial direct normal irradiance. [W/m^2] airmass : None or numeric, default None Relative airmass (not adjusted for pressure). [unitless] albedo : numeric, default 0.25 Ground surface albedo. [unitless] xtol : numeric, default 0.01 Convergence criterion. The estimated GHI will be within xtol of the true value. [W/m^2] full_output : boolean, default False If full_output is False, only ghi is returned, otherwise the return value is (ghi, converged, niter). (see Returns section for details). Returns ------- ghi : numeric Estimated GHI. [W/m^2] converged : boolean, optional Present if full_output=True. Indicates which elements converged successfully. niter : integer, optional Present if full_output=True. Indicates how many bisection iterations were done. Notes ----- Since :py:func:`scipy.optimize.bisect` is not vectorized, high-resolution time series can be quite slow to process. References ---------- .. [1] Driesse, A., Jensen, A., Perez, R., 2024. A Continuous form of the Perez diffuse sky model for forward and reverse transposition. Solar Energy vol. 267. :doi:`10.1016/j.solener.2023.112093` See also -------- perez_driesse erbs_driesse gti_dirint""" [end of new definitions in pvlib/irradiance.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Demonstrate reverse transposition using Perez-Driesse forward transposition Is your feature request related to a problem? Please describe. One of the motivations for developing the Perez-Driesse transposition #1841 was to facilitate and improve reverse transposition. So it would be great to see this in action. Describe the solution you'd like Add reverse transposition function(s). Describe alternatives you've considered Add reverse transposition as an example only. References _A. Driesse, A. Jensen, R. Perez, A Continuous Form of the Perez Diffuse Sky Model for Forward and Reverse Transposition, Solar Energy Journal._ https://doi.org/10.1016/j.solener.2023.112093 ---------- -------------------- </issues>	d53f97e984bfdd268aa92f8bf482ced0edda0110
google-deepmind__optax-629	629	google-deepmind/optax	null	83360c55f5afe0959b996e8653a9e2c85a310821	2023-11-10T22:49:29Z	diff --git a/docs/api.rst b/docs/api.rst index 39b129d0b..8552cd33a 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -619,6 +619,7 @@ Schedules .. autofunction:: piecewise_constant_schedule .. autofunction:: piecewise_interpolate_schedule .. autofunction:: polynomial_schedule +.. autofunction:: optax.contrib.reduce_on_plateau .. autofunction:: sgdr_schedule .. autofunction:: warmup_cosine_decay_schedule .. autofunction:: warmup_exponential_decay_schedule diff --git a/optax/contrib/__init__.py b/optax/contrib/__init__.py index ce85ff06b..ebb850148 100644 --- a/optax/contrib/__init__.py +++ b/optax/contrib/__init__.py @@ -25,6 +25,8 @@ from optax.contrib.privacy import differentially_private_aggregate from optax.contrib.privacy import DifferentiallyPrivateAggregateState from optax.contrib.privacy import dpsgd +from optax.contrib.reduce_on_plateau import reduce_on_plateau +from optax.contrib.reduce_on_plateau import ReduceLROnPlateauState from optax.contrib.prodigy import prodigy from optax.contrib.prodigy import ProdigyState from optax.contrib.sam import normalize diff --git a/optax/contrib/reduce_on_plateau.py b/optax/contrib/reduce_on_plateau.py new file mode 100644 index 000000000..218f03f0a --- /dev/null +++ b/optax/contrib/reduce_on_plateau.py @@ -0,0 +1,141 @@ +# Copyright 2023 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Reduce Learning Rate on Plateau callback. + +This callback monitors a quantity and if no improvement is seen for a 'patience' +number of epochs, the learning rate is reduced by a factor of 'reduce_factor'. +Optionally, a cooldown period can be specified during which the learning rate +will not be reduced. +""" +from typing import NamedTuple + +import jax +import jax.numpy as jnp + +from optax._src import base + + +class ReduceLROnPlateauState(NamedTuple): + """State for the ReduceLROnPlateau callback.""" + reduce_factor: float + patience: int + min_improvement: float + best_loss: float + plateau_count: int + lr: float + cooldown_counter: int + cooldown: int + + +def reduce_on_plateau( + reduce_factor: float, + patience: int, + min_improvement: float, + cooldown: int +) -> base.GradientTransformationExtraArgs: + """ Reduce learning rate when a metric has stopped improving. + + Models often benefit from reducing the learning once learning stagnates. + his scheduler reads a metrics quantity and if no improvement is seen for + a ‘patience’ number of epochs, the learning rate is reduced. + + Args: + + reduce_factor: Factor by which the learning rate will be reduced. + new_lr = lr * factor. + patience: Number of iterations with no improvement after which learning + rate will be reduced. + min_improvement: Threshold for measuring the new optimum, to only focus on + significant changes. + cooldown: Number of iterations to wait before resuming normal operation + after lr has been reduced. + """ + + + def init_fn(params): + del params + return ReduceLROnPlateauState(patience=patience, + reduce_factor=reduce_factor, + min_improvement=min_improvement, + cooldown=cooldown, + cooldown_counter=0, + plateau_count=0, + best_loss=float("inf"), + lr=1, + ) + + def update_fn( + updates, + state, + params=None, + extra_args=None, + ): + del params + if extra_args is None: + extra_args = {} + current_loss = extra_args.get("loss") + + # Check if the current loss is the best so far + best_loss = state.best_loss + # Update plateau count and check if plateaued + has_improved = jnp.where( + (current_loss / best_loss - 1) < -state.min_improvement, 1, 0 + ) + new_best_loss = jnp.where(has_improved, current_loss, best_loss) + + curr_plateau_count = jnp.where(has_improved, 0, state.plateau_count + 1) + + + # We're in cooldown, so reduce the counter and ignore any bad epochs + def in_cooldown(): + new_plateau_count = 0 + new_lr = state.lr + new_cooldown_counter = state.cooldown_counter - 1 + return new_plateau_count, new_lr, new_cooldown_counter + + # We're not in cooldown, so update the plateau count and lr as usual + def not_in_cooldown(): + new_plateau_count = jnp.where( + curr_plateau_count == state.patience, 0, curr_plateau_count + ) + new_lr = jnp.where( + curr_plateau_count == state.patience, + state.lr * state.reduce_factor, + state.lr, + ) + new_cooldown_counter = jnp.where( + curr_plateau_count == state.patience, state.cooldown, 0 + ) + return new_plateau_count, new_lr, new_cooldown_counter + + new_plateau_count, new_lr, new_cooldown_counter = jax.lax.cond( + state.cooldown_counter > 0, in_cooldown, not_in_cooldown) + + updates = jax.tree_util.tree_map(lambda g: new_lr * g, updates) + + new_state = ReduceLROnPlateauState( + patience=state.patience, + reduce_factor=state.reduce_factor, + min_improvement=state.min_improvement, + plateau_count=new_plateau_count, + best_loss=new_best_loss, + lr=new_lr, + cooldown_counter=new_cooldown_counter, + cooldown=state.cooldown, + ) + return updates, new_state + + + return base.GradientTransformationExtraArgs(init_fn, update_fn)	diff --git a/optax/contrib/reduce_on_plateau_test.py b/optax/contrib/reduce_on_plateau_test.py new file mode 100644 index 000000000..97980ceb3 --- /dev/null +++ b/optax/contrib/reduce_on_plateau_test.py @@ -0,0 +1,110 @@ +# Copyright 2023 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Tests for `reduce_on_plateau.py`.""" + +from absl.testing import absltest + +from optax.contrib.reduce_on_plateau import ReduceLROnPlateauState, reduce_on_plateau + + +class ReduceLROnPlateauTest(absltest.TestCase): + def test_learning_rate_reduced_after_cooldown_period_is_over(self): + """Test that learning rate is reduced again after cooldown period is over. + """ + # Define a state where cooldown_counter is zero + state = ReduceLROnPlateauState( + reduce_factor=0.5, + patience=5, + min_improvement=1e-4, + best_loss=0.1, + ## + plateau_count=4, + ## + lr=0.01, + cooldown=5, + cooldown_counter=0, + ) + # Define a dummy update and extra_args + updates = {'params': 1} + extra_args = {'loss': 0.15} + # Apply the transformation to the updates and state + transform = reduce_on_plateau( + reduce_factor=0.5, patience=5, min_improvement=1e-4, cooldown=5) + _, new_state = transform.update( + updates=updates, state=state, extra_args=extra_args) + # Check that learning rate is reduced + assert new_state.lr == 0.005 + assert new_state.plateau_count == 0 + assert new_state.cooldown_counter == 5 + _, new_state = transform.update( + updates=updates, state=new_state, extra_args=extra_args) + assert new_state.lr == 0.005 + assert new_state.plateau_count == 0 + assert new_state.cooldown_counter == 4 + + + def test_learning_rate_is_not_reduced(self): + """Test that plateau count resets after a new best loss is found.""" + state = ReduceLROnPlateauState( + reduce_factor=0.5, + patience=5, + min_improvement=1e-4, + best_loss=0.1, + plateau_count=3, + lr=0.01, + cooldown_counter=0, + cooldown=5, + ) + # Define a dummy update and extra_args + updates = {'params': 1} + extra_args = {'loss': 0.01} + # Apply the transformation to the updates and state + transform = reduce_on_plateau( + reduce_factor=0.5, patience=5, min_improvement=1e-4, cooldown=5) + _, new_state = transform.update( + updates=updates, state=state, extra_args=extra_args) + # Check that plateau count resets + assert new_state.plateau_count == 0 + assert new_state.best_loss == 0.01 + + + def test_learning_rate_not_reduced_during_cooldown(self): + """Test that learning rate is not reduced during cooldown.""" + # Define a state where cooldown_counter is positive + state = ReduceLROnPlateauState( + reduce_factor=0.5, + patience=5, + min_improvement=1e-4, + best_loss=0.1, + plateau_count=4, + lr=0.01, + cooldown=5, + cooldown_counter=3, + ) + # Define a dummy update and extra_args + updates = {'params': 1} + extra_args = {'loss': 0.15} + # Apply the transformation to the updates and state + transform = reduce_on_plateau( + reduce_factor=0.5, patience=5, min_improvement=1e-4, cooldown=5) + _, new_state = transform.update( + updates=updates, state=state, extra_args=extra_args) + # Check that learning rate is not reduced + assert new_state.lr == 0.01 + + +if __name__ == '__main__': + absltest.main() + \ No newline at end of file	diff --git a/docs/api.rst b/docs/api.rst index 39b129d0b..8552cd33a 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -619,6 +619,7 @@ Schedules .. autofunction:: piecewise_constant_schedule .. autofunction:: piecewise_interpolate_schedule .. autofunction:: polynomial_schedule +.. autofunction:: optax.contrib.reduce_on_plateau .. autofunction:: sgdr_schedule .. autofunction:: warmup_cosine_decay_schedule .. autofunction:: warmup_exponential_decay_schedule	[ { "components": [ { "doc": "State for the ReduceLROnPlateau callback.", "lines": [ 30, 39 ], "name": "ReduceLROnPlateauState", "signature": "class ReduceLROnPlateauState(NamedTuple):", "type": "class" }, { "doc": "Redu...	[ "optax/contrib/reduce_on_plateau_test.py::ReduceLROnPlateauTest::test_learning_rate_is_not_reduced", "optax/contrib/reduce_on_plateau_test.py::ReduceLROnPlateauTest::test_learning_rate_not_reduced_during_cooldown", "optax/contrib/reduce_on_plateau_test.py::ReduceLROnPlateauTest::test_learning_rate_reduced_after...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add reduce_on_plateau LR scheduler to contrib directory. Following pull request #505 and issue #221 with @mtthss suggestions on changing where the scheduler is located (contrib) and using GradientTransformationExtraArgs API. Let me know if there's anything else that needs to be done to merge this. Cheers. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in optax/contrib/reduce_on_plateau.py] (definition of ReduceLROnPlateauState:) class ReduceLROnPlateauState(NamedTuple): """State for the ReduceLROnPlateau callback.""" (definition of reduce_on_plateau:) def reduce_on_plateau( reduce_factor: float, patience: int, min_improvement: float, cooldown: int ) -> base.GradientTransformationExtraArgs: """Reduce learning rate when a metric has stopped improving. Models often benefit from reducing the learning once learning stagnates. his scheduler reads a metrics quantity and if no improvement is seen for a ‘patience’ number of epochs, the learning rate is reduced. Args: reduce_factor: Factor by which the learning rate will be reduced. new_lr = lr * factor. patience: Number of iterations with no improvement after which learning rate will be reduced. min_improvement: Threshold for measuring the new optimum, to only focus on significant changes. cooldown: Number of iterations to wait before resuming normal operation after lr has been reduced.""" (definition of reduce_on_plateau.init_fn:) def init_fn(params): (definition of reduce_on_plateau.update_fn:) def update_fn( updates, state, params=None, extra_args=None, ): (definition of reduce_on_plateau.update_fn.in_cooldown:) def in_cooldown(): (definition of reduce_on_plateau.update_fn.not_in_cooldown:) def not_in_cooldown(): [end of new definitions in optax/contrib/reduce_on_plateau.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		1e08bccf195ac54e7d9d766eb5e69345bf0e3230
tobymao__sqlglot-2531	2,531	tobymao/sqlglot	null	08d5d779c79736859471d52e4acf82ad77f16483	2023-11-08T20:42:53Z	diff --git a/sqlglot/dialects/hive.py b/sqlglot/dialects/hive.py index 4f18e75a27..b5b02f3e46 100644 --- a/sqlglot/dialects/hive.py +++ b/sqlglot/dialects/hive.py @@ -242,10 +242,10 @@ class Tokenizer(tokens.Tokenizer): "ADD JAR": TokenType.COMMAND, "ADD JARS": TokenType.COMMAND, "MSCK REPAIR": TokenType.COMMAND, - "REFRESH": TokenType.COMMAND, - "WITH SERDEPROPERTIES": TokenType.SERDE_PROPERTIES, + "REFRESH": TokenType.REFRESH, "TIMESTAMP AS OF": TokenType.TIMESTAMP_SNAPSHOT, "VERSION AS OF": TokenType.VERSION_SNAPSHOT, + "WITH SERDEPROPERTIES": TokenType.SERDE_PROPERTIES, } NUMERIC_LITERALS = { diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index 161fecd39f..cc4bf3c153 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -1021,6 +1021,10 @@ class Uncache(Expression): arg_types = {"this": True, "exists": False} +class Refresh(Expression): + pass + + class DDL(Expression): @property def ctes(self): diff --git a/sqlglot/generator.py b/sqlglot/generator.py index 21cb70bfa9..b89c30ad9c 100644 --- a/sqlglot/generator.py +++ b/sqlglot/generator.py @@ -3030,6 +3030,11 @@ def forin_sql(self, expression: exp.ForIn) -> str: expression_sql = self.sql(expression, "expression") return f"FOR {this} DO {expression_sql}" + def refresh_sql(self, expression: exp.Refresh) -> str: + this = self.sql(expression, "this") + table = "" if isinstance(expression.this, exp.Literal) else "TABLE " + return f"REFRESH {table}{this}" + def _simplify_unless_literal(self, expression: E) -> E: if not isinstance(expression, exp.Literal): from sqlglot.optimizer.simplify import simplify diff --git a/sqlglot/parser.py b/sqlglot/parser.py index c4d3f62b4b..ba25910381 100644 --- a/sqlglot/parser.py +++ b/sqlglot/parser.py @@ -302,6 +302,7 @@ class Parser(metaclass=_Parser): TokenType.RANGE, TokenType.RECURSIVE, TokenType.REFERENCES, + TokenType.REFRESH, TokenType.RIGHT, TokenType.ROW, TokenType.ROWS, @@ -563,6 +564,7 @@ class Parser(metaclass=_Parser): TokenType.MERGE: lambda self: self._parse_merge(), TokenType.PIVOT: lambda self: self._parse_simplified_pivot(), TokenType.PRAGMA: lambda self: self.expression(exp.Pragma, this=self._parse_expression()), + TokenType.REFRESH: lambda self: self._parse_refresh(), TokenType.ROLLBACK: lambda self: self._parse_commit_or_rollback(), TokenType.SET: lambda self: self._parse_set(), TokenType.UNCACHE: lambda self: self._parse_uncache(), @@ -5050,6 +5052,10 @@ def _parse_commit_or_rollback(self) -> exp.Commit \| exp.Rollback: return self.expression(exp.Commit, chain=chain) + def _parse_refresh(self) -> exp.Refresh: + self._match(TokenType.TABLE) + return self.expression(exp.Refresh, this=self._parse_string() or self._parse_table()) + def _parse_add_column(self) -> t.Optional[exp.Expression]: if not self._match_text_seq("ADD"): return None diff --git a/sqlglot/tokens.py b/sqlglot/tokens.py index 270e6301c6..e55579376e 100644 --- a/sqlglot/tokens.py +++ b/sqlglot/tokens.py @@ -297,6 +297,7 @@ class TokenType(AutoName): QUOTE = auto() RANGE = auto() RECURSIVE = auto() + REFRESH = auto() REPLACE = auto() RETURNING = auto() REFERENCES = auto()	diff --git a/tests/dialects/test_spark.py b/tests/dialects/test_spark.py index 841a005365..97427f234b 100644 --- a/tests/dialects/test_spark.py +++ b/tests/dialects/test_spark.py @@ -230,11 +230,18 @@ def test_spark(self): self.assertIsInstance(expr.args.get("ignore_nulls"), exp.Boolean) self.assertEqual(expr.sql(dialect="spark"), "ANY_VALUE(col, TRUE)") + self.assertEqual( + parse_one("REFRESH TABLE t", read="spark").assert_is(exp.Refresh).sql(dialect="spark"), + "REFRESH TABLE t", + ) + + self.validate_identity("REFRESH 'hdfs://path/to/table'") + self.validate_identity("REFRESH TABLE tempDB.view1") self.validate_identity("SELECT CASE WHEN a = NULL THEN 1 ELSE 2 END") self.validate_identity("SELECT * FROM t1 SEMI JOIN t2 ON t1.x = t2.x") self.validate_identity("SELECT TRANSFORM(ARRAY(1, 2, 3), x -> x + 1)") self.validate_identity("SELECT TRANSFORM(ARRAY(1, 2, 3), (x, i) -> x + i)") - self.validate_identity("REFRESH table a.b.c") + self.validate_identity("REFRESH TABLE a.b.c") self.validate_identity("INTERVAL -86 days") self.validate_identity("SELECT UNIX_TIMESTAMP()") self.validate_identity("TRIM(' SparkSQL ')")		[]	[ "tests/dialects/test_spark.py::TestSpark::test_spark" ]	[ "tests/dialects/test_spark.py::TestSpark::test_bool_or", "tests/dialects/test_spark.py::TestSpark::test_current_user", "tests/dialects/test_spark.py::TestSpark::test_ddl", "tests/dialects/test_spark.py::TestSpark::test_explode_to_unnest", "tests/dialects/test_spark.py::TestSpark::test_hint", "tests/dialec...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat(hive): add fine-grained parsing for REFRESH Fixes #2530 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> `REFRESH TABLE table.name` doesn't seem to parse as expected Read: Spark Fully reproducible code snippet ```python import sqlglot sqlglot.parse_one("REFRESH TABLE table.name", read="spark") ``` ``` > (COMMAND this: REFRESH, expression: (LITERAL this: TABLE table.name, is_string: True)) ``` I'd expect something like ``` > (COMMAND this: REFRESH TABLE, expression: (TABLE this: (IDENTIFIER this: name, quoted: False), db: (IDENTIFIER this: table, quoted: False)))) ``` Official Documentation For the first change (REFRESH vs REFRESH TABLE), seems like they are distinct statements in the dialect: - [REFRESH](https://spark.apache.org/docs/latest/sql-ref-syntax-aux-cache-refresh.html) - [REFRESH TABLE](https://spark.apache.org/docs/latest/sql-ref-syntax-aux-cache-refresh-table.html) ---------- -------------------- </issues>	ceb42fabad60312699e4b15936aeebac00e22e4d
huggingface__datasets-6391	6,391	huggingface/datasets	null	27d1fe52857c6a25a29cac63a296405136b2797c	2023-11-08T17:31:59Z	diff --git a/docs/source/image_dataset.mdx b/docs/source/image_dataset.mdx index 030406f6a46..8ec6d867b1f 100644 --- a/docs/source/image_dataset.mdx +++ b/docs/source/image_dataset.mdx @@ -148,6 +148,46 @@ Upload your dataset with [`~datasets.DatasetDict.push_to_hub`]: >>> dataset.push_to_hub("stevhliu/my-image-captioning-dataset") ``` +## WebDataset + +The [WebDataset](https://github.com/webdataset/webdataset) format is based on TAR archives and is suitable for big image datasets. +Indeed you can group your images in TAR archives (e.g. 1GB of images per TAR archive) and have thousands of TAR archives: + +``` +folder/train/00000.tar +folder/train/00001.tar +folder/train/00002.tar +... +``` + +In the archives, each example is made of files sharing the same prefix: + +``` +e39871fd9fd74f55.jpg +e39871fd9fd74f55.json +f18b91585c4d3f3e.jpg +f18b91585c4d3f3e.json +ede6e66b2fb59aab.jpg +ede6e66b2fb59aab.json +ed600d57fcee4f94.jpg +ed600d57fcee4f94.json +... +``` + +You can put your images labels/captions/bounding boxes using JSON or text files for example. + +For more details on the WebDataset format and the python library, please check the [WebDataset documentation](https://webdataset.github.io/webdataset). + +Load your WebDataset and it will create on column per file suffix (here "jpg" and "json"): + +```python +>>> from datasets import load_dataset + +>>> dataset = load_dataset("webdataset", data_dir="/path/to/folder", split="train") +>>> dataset[0]["json"] +{"bbox": [[302.0, 109.0, 73.0, 52.0]], "categories": [0]} +``` + ## Loading script Write a dataset loading script to share a dataset. It defines a dataset's splits and configurations, and handles downloading and generating a dataset. The script is located in the same folder or repository as the dataset and should have the same name. diff --git a/docs/source/image_load.mdx b/docs/source/image_load.mdx index 2f09f227784..b150bd04e73 100644 --- a/docs/source/image_load.mdx +++ b/docs/source/image_load.mdx @@ -1,6 +1,6 @@ # Load image data -Image datasets are loaded from the `image` column, which contains a PIL object. +Image datasets have [`Image`] type columns, which contain PIL objects. <Tip> @@ -8,7 +8,7 @@ To work with image datasets, you need to have the `vision` dependency installed. </Tip> -When you load an image dataset and call the `image` column, the [`Image`] feature automatically decodes the PIL object into an image: +When you load an image dataset and call the image column, the images are decoded as PIL Images: ```py >>> from datasets import load_dataset, Image @@ -93,3 +93,16 @@ To ignore the information in the metadata file, set `drop_labels=False` in [`loa For more information about creating your own `ImageFolder` dataset, take a look at the [Create an image dataset](./image_dataset) guide. </Tip> + +## WebDataset + +The [WebDataset](https://github.com/webdataset/webdataset) format is based on a folder of TAR archives and is suitable for big image datasets. +Because of their size, WebDatasets are generally loaded in streaming mode (using `streaming=True`). + +You can load a WebDataset like this: + +```python +>>> from datasets import load_dataset + +>>> dataset = load_dataset("webdataset", data_dir="/path/to/folder", streaming=True) +``` diff --git a/docs/source/loading.mdx b/docs/source/loading.mdx index 7ca48559dc6..aa907ac1774 100644 --- a/docs/source/loading.mdx +++ b/docs/source/loading.mdx @@ -224,6 +224,31 @@ For more details, check out the [how to load tabular datasets from SQL databases </Tip> +### WebDataset + +The [WebDataset](https://github.com/webdataset/webdataset) format is based on TAR archives and is suitable for big image datasets. +Because of their size, WebDatasets are generally loaded in streaming mode (using `streaming=True`). + +You can load a WebDataset like this: + +```python +>>> from datasets import load_dataset +>>> +>>> path = "path/to/train/.tar" +>>> dataset = load_dataset("webdataset", data_files={"train": path}, split="train", streaming=True) +``` + +To load remote WebDatasets via HTTP, pass the URLs instead: + +```python +>>> from datasets import load_dataset +>>> +>>> base_url = "https://huggingface.co/datasets/lhoestq/small-publaynet-wds/resolve/main/publaynet-train-{i:06d}.tar" +>>> urls = [base_url.format(i=i) for i in range(4)] +>>> dataset = load_dataset("webdataset", data_files={"train": urls}, split="train", streaming=True) +``` + + ## Multiprocessing When a dataset is made of several files (that we call "shards"), it is possible to significantly speed up the dataset downloading and preparation step. diff --git a/docs/source/package_reference/loading_methods.mdx b/docs/source/package_reference/loading_methods.mdx index d91714cb41c..6401708e762 100644 --- a/docs/source/package_reference/loading_methods.mdx +++ b/docs/source/package_reference/loading_methods.mdx @@ -96,3 +96,7 @@ load_dataset("csv", data_dir="path/to/data/dir", sep="\t") [[autodoc]] datasets.packaged_modules.audiofolder.AudioFolderConfig [[autodoc]] datasets.packaged_modules.audiofolder.AudioFolder + +### WebDataset + +[[autodoc]] datasets.packaged_modules.webdataset.WebDataset diff --git a/src/datasets/config.py b/src/datasets/config.py index 3e1f20475ac..6197144a5ba 100644 --- a/src/datasets/config.py +++ b/src/datasets/config.py @@ -141,7 +141,6 @@ LZ4_AVAILABLE = importlib.util.find_spec("lz4") is not None PY7ZR_AVAILABLE = importlib.util.find_spec("py7zr") is not None - # Cache location DEFAULT_XDG_CACHE_HOME = "~/.cache" XDG_CACHE_HOME = os.getenv("XDG_CACHE_HOME", DEFAULT_XDG_CACHE_HOME) diff --git a/src/datasets/packaged_modules/__init__.py b/src/datasets/packaged_modules/__init__.py index dc9409040b0..2acccc37880 100644 --- a/src/datasets/packaged_modules/__init__.py +++ b/src/datasets/packaged_modules/__init__.py @@ -12,6 +12,7 @@ from .parquet import parquet from .sql import sql # noqa F401 from .text import text +from .webdataset import webdataset def _hash_python_lines(lines: List[str]) -> str: @@ -37,6 +38,7 @@ def _hash_python_lines(lines: List[str]) -> str: "text": (text.__name__, _hash_python_lines(inspect.getsource(text).splitlines())), "imagefolder": (imagefolder.__name__, _hash_python_lines(inspect.getsource(imagefolder).splitlines())), "audiofolder": (audiofolder.__name__, _hash_python_lines(inspect.getsource(audiofolder).splitlines())), + "webdataset": (webdataset.__name__, _hash_python_lines(inspect.getsource(webdataset).splitlines())), } # Used to infer the module to use based on the data files extensions @@ -48,6 +50,7 @@ def _hash_python_lines(lines: List[str]) -> str: ".parquet": ("parquet", {}), ".arrow": ("arrow", {}), ".txt": ("text", {}), + ".tar": ("webdataset", {}), } _EXTENSION_TO_MODULE.update({ext: ("imagefolder", {}) for ext in imagefolder.ImageFolder.EXTENSIONS}) _EXTENSION_TO_MODULE.update({ext.upper(): ("imagefolder", {}) for ext in imagefolder.ImageFolder.EXTENSIONS}) diff --git a/src/datasets/packaged_modules/webdataset/__init__.py b/src/datasets/packaged_modules/webdataset/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/src/datasets/packaged_modules/webdataset/_tenbin.py b/src/datasets/packaged_modules/webdataset/_tenbin.py new file mode 100644 index 00000000000..cd8c054842e --- /dev/null +++ b/src/datasets/packaged_modules/webdataset/_tenbin.py @@ -0,0 +1,285 @@ +# +# Copyright (c) 2017-2021 NVIDIA CORPORATION. All rights reserved. +# This file coems from the WebDataset library. +# See the LICENSE file for licensing terms (BSD-style). +# + +""" +Binary tensor encodings for PyTorch and NumPy. + +This defines efficient binary encodings for tensors. The format is 8 byte +aligned and can be used directly for computations when transmitted, say, +via RDMA. The format is supported by WebDataset with the `.ten` filename +extension. It is also used by Tensorcom, Tensorcom RDMA, and can be used +for fast tensor storage with LMDB and in disk files (which can be memory +mapped) + +Data is encoded as a series of chunks: + +- magic number (int64) +- length in bytes (int64) +- bytes (multiple of 64 bytes long) + +Arrays are a header chunk followed by a data chunk. +Header chunks have the following structure: + +- dtype (int64) +- 8 byte array name +- ndim (int64) +- dim[0] +- dim[1] +- ... +""" + +import struct +import sys + +import numpy as np + + +def bytelen(a): + """Determine the length of a in bytes.""" + if hasattr(a, "nbytes"): + return a.nbytes + elif isinstance(a, (bytearray, bytes)): + return len(a) + else: + raise ValueError(a, "cannot determine nbytes") + + +def bytedata(a): + """Return a the raw data corresponding to a.""" + if isinstance(a, (bytearray, bytes, memoryview)): + return a + elif hasattr(a, "data"): + return a.data + else: + raise ValueError(a, "cannot return bytedata") + + +# tables for converting between long/short NumPy dtypes + +long_to_short = """ +float16 f2 +float32 f4 +float64 f8 +int8 i1 +int16 i2 +int32 i4 +int64 i8 +uint8 u1 +uint16 u2 +unit32 u4 +uint64 u8 +""".strip() +long_to_short = [x.split() for x in long_to_short.split("\n")] +long_to_short = {x[0]: x[1] for x in long_to_short} +short_to_long = {v: k for k, v in long_to_short.items()} + + +def check_acceptable_input_type(data, allow64): + """Check that the data has an acceptable type for tensor encoding. + + :param data: array + :param allow64: allow 64 bit types + """ + for a in data: + if a.dtype.name not in long_to_short: + raise ValueError("unsupported dataypte") + if not allow64 and a.dtype.name not in ["float64", "int64", "uint64"]: + raise ValueError("64 bit datatypes not allowed unless explicitly enabled") + + +def str64(s): + """Convert a string to an int64.""" + s = s + "\0" (8 - len(s)) + s = s.encode("ascii") + return struct.unpack("@q", s)[0] + + +def unstr64(i): + """Convert an int64 to a string.""" + b = struct.pack("@q", i) + return b.decode("ascii").strip("\0") + + +def check_infos(data, infos, required_infos=None): + """Verify the info strings.""" + if required_infos is False or required_infos is None: + return data + if required_infos is True: + return data, infos + if not isinstance(required_infos, (tuple, list)): + raise ValueError("required_infos must be tuple or list") + for required, actual in zip(required_infos, infos): + raise ValueError(f"actual info {actual} doesn't match required info {required}") + return data + + +def encode_header(a, info=""): + """Encode an array header as a byte array.""" + if a.ndim >= 10: + raise ValueError("too many dimensions") + if a.nbytes != np.prod(a.shape) * a.itemsize: + raise ValueError("mismatch between size and shape") + if a.dtype.name not in long_to_short: + raise ValueError("unsupported array type") + header = [str64(long_to_short[a.dtype.name]), str64(info), len(a.shape)] + list(a.shape) + return bytedata(np.array(header, dtype="i8")) + + +def decode_header(h): + """Decode a byte array into an array header.""" + h = np.frombuffer(h, dtype="i8") + if unstr64(h[0]) not in short_to_long: + raise ValueError("unsupported array type") + dtype = np.dtype(short_to_long[unstr64(h[0])]) + info = unstr64(h[1]) + rank = int(h[2]) + shape = tuple(h[3 : 3 + rank]) + return shape, dtype, info + + +def encode_list(l, infos=None): # noqa: E741 + """Given a list of arrays, encode them into a list of byte arrays.""" + if infos is None: + infos = [""] + else: + if len(l) != len(infos): + raise ValueError(f"length of list {l} must muatch length of infos {infos}") + result = [] + for i, a in enumerate(l): + header = encode_header(a, infos[i % len(infos)]) + result += [header, bytedata(a)] + return result + + +def decode_list(l, infos=False): # noqa: E741 + """Given a list of byte arrays, decode them into arrays.""" + result = [] + infos0 = [] + for header, data in zip(l[::2], l[1::2]): + shape, dtype, info = decode_header(header) + a = np.frombuffer(data, dtype=dtype, count=np.prod(shape)).reshape(shape) + result += [a] + infos0 += [info] + return check_infos(result, infos0, infos) + + +magic_str = "~TenBin~" +magic = str64(magic_str) +magic_bytes = unstr64(magic).encode("ascii") + + +def roundup(n, k=64): + """Round up to the next multiple of 64.""" + return k ((n + k - 1) // k) + + +def encode_chunks(l): # noqa: E741 + """Encode a list of chunks into a single byte array, with lengths and magics..""" + size = sum(16 + roundup(b.nbytes) for b in l) + result = bytearray(size) + offset = 0 + for b in l: + result[offset : offset + 8] = magic_bytes + offset += 8 + result[offset : offset + 8] = struct.pack("@q", b.nbytes) + offset += 8 + result[offset : offset + bytelen(b)] = b + offset += roundup(bytelen(b)) + return result + + +def decode_chunks(buf): + """Decode a byte array into a list of chunks.""" + result = [] + offset = 0 + total = bytelen(buf) + while offset < total: + if magic_bytes != buf[offset : offset + 8]: + raise ValueError("magic bytes mismatch") + offset += 8 + nbytes = struct.unpack("@q", buf[offset : offset + 8])[0] + offset += 8 + b = buf[offset : offset + nbytes] + offset += roundup(nbytes) + result.append(b) + return result + + +def encode_buffer(l, infos=None): # noqa: E741 + """Encode a list of arrays into a single byte array.""" + if not isinstance(l, list): + raise ValueError("requires list") + return encode_chunks(encode_list(l, infos=infos)) + + +def decode_buffer(buf, infos=False): + """Decode a byte array into a list of arrays.""" + return decode_list(decode_chunks(buf), infos=infos) + + +def write_chunk(stream, buf): + """Write a byte chunk to the stream with magics, length, and padding.""" + nbytes = bytelen(buf) + stream.write(magic_bytes) + stream.write(struct.pack("@q", nbytes)) + stream.write(bytedata(buf)) + padding = roundup(nbytes) - nbytes + if padding > 0: + stream.write(b"\0" * padding) + + +def read_chunk(stream): + """Read a byte chunk from a stream with magics, length, and padding.""" + magic = stream.read(8) + if magic == b"": + return None + if magic != magic_bytes: + raise ValueError("magic number does not match") + nbytes = stream.read(8) + nbytes = struct.unpack("@q", nbytes)[0] + if nbytes < 0: + raise ValueError("negative nbytes") + data = stream.read(nbytes) + padding = roundup(nbytes) - nbytes + if padding > 0: + stream.read(padding) + return data + + +def write(stream, l, infos=None): # noqa: E741 + """Write a list of arrays to a stream, with magics, length, and padding.""" + for chunk in encode_list(l, infos=infos): + write_chunk(stream, chunk) + + +def read(stream, n=sys.maxsize, infos=False): + """Read a list of arrays from a stream, with magics, length, and padding.""" + chunks = [] + for _ in range(n): + header = read_chunk(stream) + if header is None: + break + data = read_chunk(stream) + if data is None: + raise ValueError("premature EOF") + chunks += [header, data] + return decode_list(chunks, infos=infos) + + +def save(fname, *args, infos=None, nocheck=False): + """Save a list of arrays to a file, with magics, length, and padding.""" + if not nocheck and not fname.endswith(".ten"): + raise ValueError("file name should end in .ten") + with open(fname, "wb") as stream: + write(stream, args, infos=infos) + + +def load(fname, infos=False, nocheck=False): + """Read a list of arrays from a file, with magics, length, and padding.""" + if not nocheck and not fname.endswith(".ten"): + raise ValueError("file name should end in .ten") + with open(fname, "rb") as stream: + return read(stream, infos=infos) diff --git a/src/datasets/packaged_modules/webdataset/webdataset.py b/src/datasets/packaged_modules/webdataset/webdataset.py new file mode 100644 index 00000000000..e44bf50857c --- /dev/null +++ b/src/datasets/packaged_modules/webdataset/webdataset.py @@ -0,0 +1,242 @@ +import io +import json +from itertools import islice +from typing import Any, Callable, Dict, List + +import numpy as np +import pyarrow as pa + +import datasets + + +logger = datasets.utils.logging.get_logger(__name__) + + +class WebDataset(datasets.GeneratorBasedBuilder): + DEFAULT_WRITER_BATCH_SIZE = 100 + IMAGE_EXTENSIONS: List[str] # definition at the bottom of the script + DECODERS: Dict[str, Callable[[Any], Any]] # definition at the bottom of the script + NUM_EXAMPLES_FOR_FEATURES_INFERENCE = 5 + + @classmethod + def _get_pipeline_from_tar(cls, tar_path, tar_iterator): + current_example = {} + for filename, f in tar_iterator: + if "." in filename: + example_key, field_name = filename.split(".", 1) + if current_example and current_example["__key__"] != example_key: + yield current_example + current_example = {} + current_example["__key__"] = example_key + current_example["__url__"] = tar_path + current_example[field_name.lower()] = f.read() + if field_name in cls.DECODERS: + current_example[field_name] = cls.DECODERS[field_name](current_example[field_name]) + if current_example: + yield current_example + + def _info(self) -> datasets.DatasetInfo: + return datasets.DatasetInfo() + + def _split_generators(self, dl_manager): + """We handle string, list and dicts in datafiles""" + # Download the data files + if not self.config.data_files: + raise ValueError(f"At least one data file must be specified, but got data_files={self.config.data_files}") + data_files = dl_manager.download(self.config.data_files) + if isinstance(data_files, (str, list, tuple)): + tar_paths = data_files + if isinstance(tar_paths, str): + tar_paths = [tar_paths] + tar_iterators = [dl_manager.iter_archive(tar_path) for tar_path in tar_paths] + splits = [ + datasets.SplitGenerator( + name=datasets.Split.TRAIN, gen_kwargs={"tar_paths": tar_paths, "tar_iterators": tar_iterators} + ) + ] + else: + splits = [] + for split_name, tar_paths in data_files.items(): + if isinstance(tar_paths, str): + tar_paths = [tar_paths] + tar_iterators = [dl_manager.iter_archive(tar_path) for tar_path in tar_paths] + splits.append( + datasets.SplitGenerator( + name=split_name, gen_kwargs={"tar_paths": tar_paths, "tar_iterators": tar_iterators} + ) + ) + + # Get one example to get the feature types + pipeline = self._get_pipeline_from_tar(tar_paths[0], tar_iterators[0]) + first_examples = list(islice(pipeline, self.NUM_EXAMPLES_FOR_FEATURES_INFERENCE)) + if any(example.keys() != first_examples[0].keys() for example in first_examples): + raise ValueError( + "The TAR archives of the dataset should be in WebDataset format, " + "but the files in the archive don't share the same prefix or the same types." + ) + inferred_arrow_schema = pa.Table.from_pylist(first_examples[:1]).schema + features = datasets.Features.from_arrow_schema(inferred_arrow_schema) + + # Set Image types + for field_name in first_examples[0]: + extension = field_name.rsplit(".", 1)[-1] + if extension in self.IMAGE_EXTENSIONS: + features[field_name] = datasets.Image() + self.info.features = features + + return splits + + def _generate_examples(self, tar_paths, tar_iterators): + image_field_names = [ + field_name for field_name, feature in self.info.features.items() if isinstance(feature, datasets.Image) + ] + for tar_idx, (tar_path, tar_iterator) in enumerate(zip(tar_paths, tar_iterators)): + for example_idx, example in enumerate(self._get_pipeline_from_tar(tar_path, tar_iterator)): + for field_name in image_field_names: + example[field_name] = {"path": example["__key__"] + "." + field_name, "bytes": example[field_name]} + yield f"{tar_idx}_{example_idx}", example + + +# Obtained with: +# ``` +# import PIL.Image +# IMAGE_EXTENSIONS = [] +# PIL.Image.init() +# for ext, format in PIL.Image.EXTENSION.items(): +# if format in PIL.Image.OPEN: +# IMAGE_EXTENSIONS.append(ext[1:]) +# ``` +# We intentionally do not run this code on launch because: +# (1) Pillow is an optional dependency, so importing Pillow in global namespace is not allowed +# (2) To ensure the list of supported extensions is deterministic +IMAGE_EXTENSIONS = [ + "blp", + "bmp", + "dib", + "bufr", + "cur", + "pcx", + "dcx", + "dds", + "ps", + "eps", + "fit", + "fits", + "fli", + "flc", + "ftc", + "ftu", + "gbr", + "gif", + "grib", + "h5", + "hdf", + "png", + "apng", + "jp2", + "j2k", + "jpc", + "jpf", + "jpx", + "j2c", + "icns", + "ico", + "im", + "iim", + "tif", + "tiff", + "jfif", + "jpe", + "jpg", + "jpeg", + "mpg", + "mpeg", + "msp", + "pcd", + "pxr", + "pbm", + "pgm", + "ppm", + "pnm", + "psd", + "bw", + "rgb", + "rgba", + "sgi", + "ras", + "tga", + "icb", + "vda", + "vst", + "webp", + "wmf", + "emf", + "xbm", + "xpm", +] +WebDataset.IMAGE_EXTENSIONS = IMAGE_EXTENSIONS + + +def text_loads(data: bytes): + return data.decode("utf-8") + + +def tenbin_loads(data: bytes): + from . import _tenbin + + return _tenbin.decode_buffer(data) + + +def msgpack_loads(data: bytes): + import msgpack + + return msgpack.unpackb(data) + + +def npy_loads(data: bytes): + import numpy.lib.format + + stream = io.BytesIO(data) + return numpy.lib.format.read_array(stream, allow_pickle=False) + + +def npz_loads(data: bytes): + return np.load(io.BytesIO(data), allow_pickle=False) + + +def cbor_loads(data: bytes): + import cbor + + return cbor.loads(data) + + +# Obtained by checking `decoders` in `webdataset.autodecode` +# and removing unsafe extension decoders. +# Removed Pickle decoders: +# - "pyd": lambda data: pickle.loads(data) +# - "pickle": lambda data: pickle.loads(data) +# Removed Torch decoders: +# - "pth": lambda data: torch_loads(data) +# Modified NumPy decoders to fix CVE-2019-6446 (add allow_pickle=False): +# - "npy": npy_loads, +# - "npz": lambda data: np.load(io.BytesIO(data)), +DECODERS = { + "txt": text_loads, + "text": text_loads, + "transcript": text_loads, + "cls": int, + "cls2": int, + "index": int, + "inx": int, + "id": int, + "json": json.loads, + "jsn": json.loads, + "ten": tenbin_loads, + "tb": tenbin_loads, + "mp": msgpack_loads, + "msg": msgpack_loads, + "npy": npy_loads, + "npz": npz_loads, + "cbor": cbor_loads, +} +WebDataset.DECODERS = DECODERS	diff --git a/tests/packaged_modules/test_webdataset.py b/tests/packaged_modules/test_webdataset.py new file mode 100644 index 00000000000..c9b032dfa51 --- /dev/null +++ b/tests/packaged_modules/test_webdataset.py @@ -0,0 +1,63 @@ +import tarfile + +import pytest + +from datasets import DownloadManager, Features, Image, Value +from datasets.packaged_modules.webdataset.webdataset import WebDataset + +from ..utils import require_pil + + +@pytest.fixture +def tar_file(tmp_path, image_file, text_file): + filename = tmp_path / "file.tar" + num_examples = 3 + with tarfile.open(str(filename), "w") as f: + for example_idx in range(num_examples): + f.add(text_file, f"{example_idx:05d}.txt") + f.add(image_file, f"{example_idx:05d}.jpg") + return str(filename) + + +@pytest.fixture +def bad_tar_file(tmp_path, image_file, text_file): + filename = tmp_path / "bad_file.tar" + with tarfile.open(str(filename), "w") as f: + f.add(image_file) + f.add(text_file) + return str(filename) + + +@require_pil +def test_webdataset(tar_file): + import PIL.Image + + data_files = {"train": [tar_file]} + webdataset = WebDataset(data_files=data_files) + split_generators = webdataset._split_generators(DownloadManager()) + assert webdataset.info.features == Features( + { + "__key__": Value("string"), + "__url__": Value("string"), + "txt": Value("string"), + "jpg": Image(), + } + ) + assert len(split_generators) == 1 + split_generator = split_generators[0] + assert split_generator.name == "train" + generator = webdataset._generate_examples(*split_generator.gen_kwargs) + _, examples = zip(generator) + assert len(examples) == 3 + assert isinstance(examples[0]["txt"], str) + assert isinstance(examples[0]["jpg"], dict) # keep encoded to avoid unecessary copies + decoded = webdataset.info.features.decode_example(examples[0]) + assert isinstance(decoded["txt"], str) + assert isinstance(decoded["jpg"], PIL.Image.Image) + + +def test_webdataset_errors_on_bad_file(bad_tar_file): + data_files = {"train": [bad_tar_file]} + webdataset = WebDataset(data_files=data_files) + with pytest.raises(ValueError): + webdataset._split_generators(DownloadManager())	diff --git a/docs/source/image_dataset.mdx b/docs/source/image_dataset.mdx index 030406f6a46..8ec6d867b1f 100644 --- a/docs/source/image_dataset.mdx +++ b/docs/source/image_dataset.mdx @@ -148,6 +148,46 @@ Upload your dataset with [`~datasets.DatasetDict.push_to_hub`]: >>> dataset.push_to_hub("stevhliu/my-image-captioning-dataset") ``` +## WebDataset + +The [WebDataset](https://github.com/webdataset/webdataset) format is based on TAR archives and is suitable for big image datasets. +Indeed you can group your images in TAR archives (e.g. 1GB of images per TAR archive) and have thousands of TAR archives: + +``` +folder/train/00000.tar +folder/train/00001.tar +folder/train/00002.tar +... +``` + +In the archives, each example is made of files sharing the same prefix: + +``` +e39871fd9fd74f55.jpg +e39871fd9fd74f55.json +f18b91585c4d3f3e.jpg +f18b91585c4d3f3e.json +ede6e66b2fb59aab.jpg +ede6e66b2fb59aab.json +ed600d57fcee4f94.jpg +ed600d57fcee4f94.json +... +``` + +You can put your images labels/captions/bounding boxes using JSON or text files for example. + +For more details on the WebDataset format and the python library, please check the [WebDataset documentation](https://webdataset.github.io/webdataset). + +Load your WebDataset and it will create on column per file suffix (here "jpg" and "json"): + +```python +>>> from datasets import load_dataset + +>>> dataset = load_dataset("webdataset", data_dir="/path/to/folder", split="train") +>>> dataset[0]["json"] +{"bbox": [[302.0, 109.0, 73.0, 52.0]], "categories": [0]} +``` + ## Loading script Write a dataset loading script to share a dataset. It defines a dataset's splits and configurations, and handles downloading and generating a dataset. The script is located in the same folder or repository as the dataset and should have the same name. diff --git a/docs/source/image_load.mdx b/docs/source/image_load.mdx index 2f09f227784..b150bd04e73 100644 --- a/docs/source/image_load.mdx +++ b/docs/source/image_load.mdx @@ -1,6 +1,6 @@ # Load image data -Image datasets are loaded from the `image` column, which contains a PIL object. +Image datasets have [`Image`] type columns, which contain PIL objects. <Tip> @@ -8,7 +8,7 @@ To work with image datasets, you need to have the `vision` dependency installed. </Tip> -When you load an image dataset and call the `image` column, the [`Image`] feature automatically decodes the PIL object into an image: +When you load an image dataset and call the image column, the images are decoded as PIL Images: ```py >>> from datasets import load_dataset, Image @@ -93,3 +93,16 @@ To ignore the information in the metadata file, set `drop_labels=False` in [`loa For more information about creating your own `ImageFolder` dataset, take a look at the [Create an image dataset](./image_dataset) guide. </Tip> + +## WebDataset + +The [WebDataset](https://github.com/webdataset/webdataset) format is based on a folder of TAR archives and is suitable for big image datasets. +Because of their size, WebDatasets are generally loaded in streaming mode (using `streaming=True`). + +You can load a WebDataset like this: + +```python +>>> from datasets import load_dataset + +>>> dataset = load_dataset("webdataset", data_dir="/path/to/folder", streaming=True) +``` diff --git a/docs/source/loading.mdx b/docs/source/loading.mdx index 7ca48559dc6..aa907ac1774 100644 --- a/docs/source/loading.mdx +++ b/docs/source/loading.mdx @@ -224,6 +224,31 @@ For more details, check out the [how to load tabular datasets from SQL databases </Tip> +### WebDataset + +The [WebDataset](https://github.com/webdataset/webdataset) format is based on TAR archives and is suitable for big image datasets. +Because of their size, WebDatasets are generally loaded in streaming mode (using `streaming=True`). + +You can load a WebDataset like this: + +```python +>>> from datasets import load_dataset +>>> +>>> path = "path/to/train/*.tar" +>>> dataset = load_dataset("webdataset", data_files={"train": path}, split="train", streaming=True) +``` + +To load remote WebDatasets via HTTP, pass the URLs instead: + +```python +>>> from datasets import load_dataset +>>> +>>> base_url = "https://huggingface.co/datasets/lhoestq/small-publaynet-wds/resolve/main/publaynet-train-{i:06d}.tar" +>>> urls = [base_url.format(i=i) for i in range(4)] +>>> dataset = load_dataset("webdataset", data_files={"train": urls}, split="train", streaming=True) +``` + + ## Multiprocessing When a dataset is made of several files (that we call "shards"), it is possible to significantly speed up the dataset downloading and preparation step. diff --git a/docs/source/package_reference/loading_methods.mdx b/docs/source/package_reference/loading_methods.mdx index d91714cb41c..6401708e762 100644 --- a/docs/source/package_reference/loading_methods.mdx +++ b/docs/source/package_reference/loading_methods.mdx @@ -96,3 +96,7 @@ load_dataset("csv", data_dir="path/to/data/dir", sep="\t") [[autodoc]] datasets.packaged_modules.audiofolder.AudioFolderConfig [[autodoc]] datasets.packaged_modules.audiofolder.AudioFolder + +### WebDataset + +[[autodoc]] datasets.packaged_modules.webdataset.WebDataset	[ { "components": [ { "doc": "Determine the length of a in bytes.", "lines": [ 40, 47 ], "name": "bytelen", "signature": "def bytelen(a):", "type": "function" }, { "doc": "Return a the raw data corresponding to a.", ...	[ "tests/packaged_modules/test_webdataset.py::test_webdataset_errors_on_bad_file" ]	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Webdataset dataset builder Allow `load_dataset` to support the Webdataset format. It allows users to download/stream data from local files or from the Hugging Face Hub. Moreover it will enable the Dataset Viewer for Webdataset datasets on HF. ## Implementation details - I added a new Webdataset builder - dataset with TAR files are now read using the Webdataset builder - Basic decoding from `webdataset` is used by default, except unsafe ones like pickle - HF authentication support is done with `xopen` ## TODOS - [x] tests - [x] docs ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/datasets/packaged_modules/webdataset/_tenbin.py] (definition of bytelen:) def bytelen(a): """Determine the length of a in bytes.""" (definition of bytedata:) def bytedata(a): """Return a the raw data corresponding to a.""" (definition of check_acceptable_input_type:) def check_acceptable_input_type(data, allow64): """Check that the data has an acceptable type for tensor encoding. :param data: array :param allow64: allow 64 bit types""" (definition of str64:) def str64(s): """Convert a string to an int64.""" (definition of unstr64:) def unstr64(i): """Convert an int64 to a string.""" (definition of check_infos:) def check_infos(data, infos, required_infos=None): """Verify the info strings.""" (definition of encode_header:) def encode_header(a, info=""): """Encode an array header as a byte array.""" (definition of decode_header:) def decode_header(h): """Decode a byte array into an array header.""" (definition of encode_list:) def encode_list(l, infos=None): """Given a list of arrays, encode them into a list of byte arrays.""" (definition of decode_list:) def decode_list(l, infos=False): """Given a list of byte arrays, decode them into arrays.""" (definition of roundup:) def roundup(n, k=64): """Round up to the next multiple of 64.""" (definition of encode_chunks:) def encode_chunks(l): """Encode a list of chunks into a single byte array, with lengths and magics..""" (definition of decode_chunks:) def decode_chunks(buf): """Decode a byte array into a list of chunks.""" (definition of encode_buffer:) def encode_buffer(l, infos=None): """Encode a list of arrays into a single byte array.""" (definition of decode_buffer:) def decode_buffer(buf, infos=False): """Decode a byte array into a list of arrays.""" (definition of write_chunk:) def write_chunk(stream, buf): """Write a byte chunk to the stream with magics, length, and padding.""" (definition of read_chunk:) def read_chunk(stream): """Read a byte chunk from a stream with magics, length, and padding.""" (definition of write:) def write(stream, l, infos=None): """Write a list of arrays to a stream, with magics, length, and padding.""" (definition of read:) def read(stream, n=sys.maxsize, infos=False): """Read a list of arrays from a stream, with magics, length, and padding.""" (definition of save:) def save(fname, *args, infos=None, nocheck=False): """Save a list of arrays to a file, with magics, length, and padding.""" (definition of load:) def load(fname, infos=False, nocheck=False): """Read a list of arrays from a file, with magics, length, and padding.""" [end of new definitions in src/datasets/packaged_modules/webdataset/_tenbin.py] [start of new definitions in src/datasets/packaged_modules/webdataset/webdataset.py] (definition of WebDataset:) class WebDataset(datasets.GeneratorBasedBuilder): (definition of WebDataset._get_pipeline_from_tar:) def _get_pipeline_from_tar(cls, tar_path, tar_iterator): (definition of WebDataset._info:) def _info(self) -> datasets.DatasetInfo: (definition of WebDataset._split_generators:) def _split_generators(self, dl_manager): """We handle string, list and dicts in datafiles""" (definition of WebDataset._generate_examples:) def _generate_examples(self, tar_paths, tar_iterators): (definition of text_loads:) def text_loads(data: bytes): (definition of tenbin_loads:) def tenbin_loads(data: bytes): (definition of msgpack_loads:) def msgpack_loads(data: bytes): (definition of npy_loads:) def npy_loads(data: bytes): (definition of npz_loads:) def npz_loads(data: bytes): (definition of cbor_loads:) def cbor_loads(data: bytes): [end of new definitions in src/datasets/packaged_modules/webdataset/webdataset.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		5142a8cf61d8a4495eda3d91dc4283a6df01ea14
Project-MONAI__MONAI-7198	7,198	Project-MONAI/MONAI	null	97678fa75a851c411c713658059bac3b2ce5cf70	2023-11-03T21:24:28Z	diff --git a/docs/source/transforms.rst b/docs/source/transforms.rst index 8990e7991d..bd3feb3497 100644 --- a/docs/source/transforms.rst +++ b/docs/source/transforms.rst @@ -661,6 +661,27 @@ Post-processing :members: :special-members: __call__ +Regularization +^^^^^^^^^^^^^^ + +`CutMix` +"""""""" +.. autoclass:: CutMix + :members: + :special-members: __call__ + +`CutOut` +"""""""" +.. autoclass:: CutOut + :members: + :special-members: __call__ + +`MixUp` +""""""" +.. autoclass:: MixUp + :members: + :special-members: __call__ + Signal ^^^^^^^ @@ -1707,6 +1728,27 @@ Post-processing (Dict) :members: :special-members: __call__ +Regularization (Dict) +^^^^^^^^^^^^^^^^^^^^^ + +`CutMixd` +""""""""" +.. autoclass:: CutMixd + :members: + :special-members: __call__ + +`CutOutd` +""""""""" +.. autoclass:: CutOutd + :members: + :special-members: __call__ + +`MixUpd` +"""""""" +.. autoclass:: MixUpd + :members: + :special-members: __call__ + Signal (Dict) ^^^^^^^^^^^^^ diff --git a/docs/source/transforms_idx.rst b/docs/source/transforms_idx.rst index f4d02a483f..650d45db71 100644 --- a/docs/source/transforms_idx.rst +++ b/docs/source/transforms_idx.rst @@ -74,6 +74,16 @@ Post-processing post.array post.dictionary +Regularization +^^^^^^^^^^^^^^ + +.. autosummary:: + :toctree: _gen + :nosignatures: + + regularization.array + regularization.dictionary + Signal ^^^^^^ diff --git a/monai/transforms/__init__.py b/monai/transforms/__init__.py index 2aa8fbf8a1..349533fb3e 100644 --- a/monai/transforms/__init__.py +++ b/monai/transforms/__init__.py @@ -336,6 +336,18 @@ VoteEnsembled, VoteEnsembleDict, ) +from .regularization.array import CutMix, CutOut, MixUp +from .regularization.dictionary import ( + CutMixd, + CutMixD, + CutMixDict, + CutOutd, + CutOutD, + CutOutDict, + MixUpd, + MixUpD, + MixUpDict, +) from .signal.array import ( SignalContinuousWavelet, SignalFillEmpty, diff --git a/monai/transforms/regularization/__init__.py b/monai/transforms/regularization/__init__.py new file mode 100644 index 0000000000..1e97f89407 --- /dev/null +++ b/monai/transforms/regularization/__init__.py @@ -0,0 +1,10 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/monai/transforms/regularization/array.py b/monai/transforms/regularization/array.py new file mode 100644 index 0000000000..6c9022d647 --- /dev/null +++ b/monai/transforms/regularization/array.py @@ -0,0 +1,173 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import annotations + +from abc import abstractmethod +from math import ceil, sqrt + +import torch + +from ..transform import RandomizableTransform + +__all__ = ["MixUp", "CutMix", "CutOut", "Mixer"] + + +class Mixer(RandomizableTransform): + def __init__(self, batch_size: int, alpha: float = 1.0) -> None: + """ + Mixer is a base class providing the basic logic for the mixup-class of + augmentations. In all cases, we need to sample the mixing weights for each + sample (lambda in the notation used in the papers). Also, pairs of samples + being mixed are picked by randomly shuffling the batch samples. + + Args: + batch_size (int): number of samples per batch. That is, samples are expected tp + be of size batchsize x channels [x depth] x height x width. + alpha (float, optional): mixing weights are sampled from the Beta(alpha, alpha) + distribution. Defaults to 1.0, the uniform distribution. + """ + super().__init__() + if alpha <= 0: + raise ValueError(f"Expected positive number, but got {alpha = }") + self.alpha = alpha + self.batch_size = batch_size + + @abstractmethod + def apply(self, data: torch.Tensor): + raise NotImplementedError() + + def randomize(self, data=None) -> None: + """ + Sometimes you need may to apply the same transform to different tensors. + The idea is to get a sample and then apply it with apply() as often + as needed. You need to call this method everytime you apply the transform to a new + batch. + """ + self._params = ( + torch.from_numpy(self.R.beta(self.alpha, self.alpha, self.batch_size)).type(torch.float32), + self.R.permutation(self.batch_size), + ) + + +class MixUp(Mixer): + """MixUp as described in: + Hongyi Zhang, Moustapha Cisse, Yann N. Dauphin, David Lopez-Paz. + mixup: Beyond Empirical Risk Minimization, ICLR 2018 + + Class derived from :py:class:`monai.transforms.Mixer`. See corresponding + documentation for details on the constructor parameters. + """ + + def apply(self, data: torch.Tensor): + weight, perm = self._params + nsamples, dims = data.shape + if len(weight) != nsamples: + raise ValueError(f"Expected batch of size: {len(weight)}, but got {nsamples}") + + if len(dims) not in [3, 4]: + raise ValueError("Unexpected number of dimensions") + + mixweight = weight[(Ellipsis,) + (None,) len(dims)] + return mixweight * data + (1 - mixweight) * data[perm, ...] + + def __call__(self, data: torch.Tensor, labels: torch.Tensor \| None = None): + self.randomize() + if labels is None: + return self.apply(data) + return self.apply(data), self.apply(labels) + + +class CutMix(Mixer): + """CutMix augmentation as described in: + Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, Youngjoon Yoo. + CutMix: Regularization Strategy to Train Strong Classifiers with Localizable Features, + ICCV 2019 + + Class derived from :py:class:`monai.transforms.Mixer`. See corresponding + documentation for details on the constructor parameters. Here, alpha not only determines + the mixing weight but also the size of the random rectangles used during for mixing. + Please refer to the paper for details. + + The most common use case is something close to: + + .. code-block:: python + + cm = CutMix(batch_size=8, alpha=0.5) + for batch in loader: + images, labels = batch + augimg, auglabels = cm(images, labels) + output = model(augimg) + loss = loss_function(output, auglabels) + ... + + """ + + def apply(self, data: torch.Tensor): + weights, perm = self._params + nsamples, _, dims = data.shape + if len(weights) != nsamples: + raise ValueError(f"Expected batch of size: {len(weights)}, but got {nsamples}") + + mask = torch.ones_like(data) + for s, weight in enumerate(weights): + coords = [torch.randint(0, d, size=(1,)) for d in dims] + lengths = [d sqrt(1 - weight) for d in dims] + idx = [slice(None)] + [slice(c, min(ceil(c + ln), d)) for c, ln, d in zip(coords, lengths, dims)] + mask[s][idx] = 0 + + return mask * data + (1 - mask) * data[perm, ...] + + def apply_on_labels(self, labels: torch.Tensor): + weights, perm = self._params + nsamples, dims = labels.shape + if len(weights) != nsamples: + raise ValueError(f"Expected batch of size: {len(weights)}, but got {nsamples}") + + mixweight = weights[(Ellipsis,) + (None,) len(dims)] + return mixweight * labels + (1 - mixweight) * labels[perm, ...] + + def __call__(self, data: torch.Tensor, labels: torch.Tensor \| None = None): + self.randomize() + augmented = self.apply(data) + return (augmented, self.apply_on_labels(labels)) if labels is not None else augmented + + +class CutOut(Mixer): + """Cutout as described in the paper: + Terrance DeVries, Graham W. Taylor. + Improved Regularization of Convolutional Neural Networks with Cutout, + arXiv:1708.04552 + + Class derived from :py:class:`monai.transforms.Mixer`. See corresponding + documentation for details on the constructor parameters. Here, alpha not only determines + the mixing weight but also the size of the random rectangles being cut put. + Please refer to the paper for details. + """ + + def apply(self, data: torch.Tensor): + weights, _ = self._params + nsamples, _, dims = data.shape + if len(weights) != nsamples: + raise ValueError(f"Expected batch of size: {len(weights)}, but got {nsamples}") + + mask = torch.ones_like(data) + for s, weight in enumerate(weights): + coords = [torch.randint(0, d, size=(1,)) for d in dims] + lengths = [d sqrt(1 - weight) for d in dims] + idx = [slice(None)] + [slice(c, min(ceil(c + ln), d)) for c, ln, d in zip(coords, lengths, dims)] + mask[s][idx] = 0 + + return mask * data + + def __call__(self, data: torch.Tensor): + self.randomize() + return self.apply(data) diff --git a/monai/transforms/regularization/dictionary.py b/monai/transforms/regularization/dictionary.py new file mode 100644 index 0000000000..373913da99 --- /dev/null +++ b/monai/transforms/regularization/dictionary.py @@ -0,0 +1,97 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import annotations + +from monai.config import KeysCollection +from monai.utils.misc import ensure_tuple + +from ..transform import MapTransform +from .array import CutMix, CutOut, MixUp + +__all__ = ["MixUpd", "MixUpD", "MixUpDict", "CutMixd", "CutMixD", "CutMixDict", "CutOutd", "CutOutD", "CutOutDict"] + + +class MixUpd(MapTransform): + """ + Dictionary-based version :py:class:`monai.transforms.MixUp`. + + Notice that the mixup transformation will be the same for all entries + for consistency, i.e. images and labels must be applied the same augmenation. + """ + + def __init__( + self, keys: KeysCollection, batch_size: int, alpha: float = 1.0, allow_missing_keys: bool = False + ) -> None: + super().__init__(keys, allow_missing_keys) + self.mixup = MixUp(batch_size, alpha) + + def __call__(self, data): + self.mixup.randomize() + result = dict(data) + for k in self.keys: + result[k] = self.mixup.apply(data[k]) + return result + + +class CutMixd(MapTransform): + """ + Dictionary-based version :py:class:`monai.transforms.CutMix`. + + Notice that the mixture weights will be the same for all entries + for consistency, i.e. images and labels must be aggregated with the same weights, + but the random crops are not. + """ + + def __init__( + self, + keys: KeysCollection, + batch_size: int, + label_keys: KeysCollection \| None = None, + alpha: float = 1.0, + allow_missing_keys: bool = False, + ) -> None: + super().__init__(keys, allow_missing_keys) + self.mixer = CutMix(batch_size, alpha) + self.label_keys = ensure_tuple(label_keys) if label_keys is not None else [] + + def __call__(self, data): + self.mixer.randomize() + result = dict(data) + for k in self.keys: + result[k] = self.mixer.apply(data[k]) + for k in self.label_keys: + result[k] = self.mixer.apply_on_labels(data[k]) + return result + + +class CutOutd(MapTransform): + """ + Dictionary-based version :py:class:`monai.transforms.CutOut`. + + Notice that the cutout is different for every entry in the dictionary. + """ + + def __init__(self, keys: KeysCollection, batch_size: int, allow_missing_keys: bool = False) -> None: + super().__init__(keys, allow_missing_keys) + self.cutout = CutOut(batch_size) + + def __call__(self, data): + result = dict(data) + self.cutout.randomize() + for k in self.keys: + result[k] = self.cutout(data[k]) + return result + + +MixUpD = MixUpDict = MixUpd +CutMixD = CutMixDict = CutMixd +CutOutD = CutOutDict = CutOutd	diff --git a/tests/test_regularization.py b/tests/test_regularization.py new file mode 100644 index 0000000000..d381ea72ca --- /dev/null +++ b/tests/test_regularization.py @@ -0,0 +1,90 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import annotations + +import unittest + +import torch + +from monai.transforms import CutMix, CutMixd, CutOut, MixUp, MixUpd + + +class TestMixup(unittest.TestCase): + def test_mixup(self): + for dims in [2, 3]: + shape = (6, 3) + (32,) * dims + sample = torch.rand(shape, dtype=torch.float32) + mixup = MixUp(6, 1.0) + output = mixup(sample) + self.assertEqual(output.shape, sample.shape) + self.assertTrue(any(not torch.allclose(sample, mixup(sample)) for _ in range(10))) + + with self.assertRaises(ValueError): + MixUp(6, -0.5) + + mixup = MixUp(6, 0.5) + for dims in [2, 3]: + with self.assertRaises(ValueError): + shape = (5, 3) + (32,) dims + sample = torch.rand(shape, dtype=torch.float32) + mixup(sample) + + def test_mixupd(self): + for dims in [2, 3]: + shape = (6, 3) + (32,) dims + t = torch.rand(shape, dtype=torch.float32) + sample = {"a": t, "b": t} + mixup = MixUpd(["a", "b"], 6) + output = mixup(sample) + self.assertTrue(torch.allclose(output["a"], output["b"])) + + with self.assertRaises(ValueError): + MixUpd(["k1", "k2"], 6, -0.5) + + +class TestCutMix(unittest.TestCase): + def test_cutmix(self): + for dims in [2, 3]: + shape = (6, 3) + (32,) dims + sample = torch.rand(shape, dtype=torch.float32) + cutmix = CutMix(6, 1.0) + output = cutmix(sample) + self.assertEqual(output.shape, sample.shape) + self.assertTrue(any(not torch.allclose(sample, cutmix(sample)) for _ in range(10))) + + def test_cutmixd(self): + for dims in [2, 3]: + shape = (6, 3) + (32,) dims + t = torch.rand(shape, dtype=torch.float32) + label = torch.randint(0, 1, shape) + sample = {"a": t, "b": t, "lbl1": label, "lbl2": label} + cutmix = CutMixd(["a", "b"], 6, label_keys=("lbl1", "lbl2")) + output = cutmix(sample) + # croppings are different on each application + self.assertTrue(not torch.allclose(output["a"], output["b"])) + # but mixing of labels is not affected by it + self.assertTrue(torch.allclose(output["lbl1"], output["lbl2"])) + + +class TestCutOut(unittest.TestCase): + def test_cutout(self): + for dims in [2, 3]: + shape = (6, 3) + (32,) dims + sample = torch.rand(*shape, dtype=torch.float32) + cutout = CutOut(6, 1.0) + output = cutout(sample) + self.assertEqual(output.shape, sample.shape) + self.assertTrue(any(not torch.allclose(sample, cutout(sample)) for _ in range(10))) + + +if __name__ == "__main__": + unittest.main()	diff --git a/docs/source/transforms.rst b/docs/source/transforms.rst index 8990e7991d..bd3feb3497 100644 --- a/docs/source/transforms.rst +++ b/docs/source/transforms.rst @@ -661,6 +661,27 @@ Post-processing :members: :special-members: __call__ +Regularization +^^^^^^^^^^^^^^ + +`CutMix` +"""""""" +.. autoclass:: CutMix + :members: + :special-members: __call__ + +`CutOut` +"""""""" +.. autoclass:: CutOut + :members: + :special-members: __call__ + +`MixUp` +""""""" +.. autoclass:: MixUp + :members: + :special-members: __call__ + Signal ^^^^^^^ @@ -1707,6 +1728,27 @@ Post-processing (Dict) :members: :special-members: __call__ +Regularization (Dict) +^^^^^^^^^^^^^^^^^^^^^ + +`CutMixd` +""""""""" +.. autoclass:: CutMixd + :members: + :special-members: __call__ + +`CutOutd` +""""""""" +.. autoclass:: CutOutd + :members: + :special-members: __call__ + +`MixUpd` +"""""""" +.. autoclass:: MixUpd + :members: + :special-members: __call__ + Signal (Dict) ^^^^^^^^^^^^^ diff --git a/docs/source/transforms_idx.rst b/docs/source/transforms_idx.rst index f4d02a483f..650d45db71 100644 --- a/docs/source/transforms_idx.rst +++ b/docs/source/transforms_idx.rst @@ -74,6 +74,16 @@ Post-processing post.array post.dictionary +Regularization +^^^^^^^^^^^^^^ + +.. autosummary:: + :toctree: _gen + :nosignatures: + + regularization.array + regularization.dictionary + Signal ^^^^^^	[ { "components": [ { "doc": "", "lines": [ 24, 57 ], "name": "Mixer", "signature": "class Mixer(RandomizableTransform):", "type": "class" }, { "doc": "Mixer is a base class providing the basic logic for the mixup-class ...	[ "tests/test_regularization.py::TestMixup::test_mixup", "tests/test_regularization.py::TestMixup::test_mixupd", "tests/test_regularization.py::TestCutMix::test_cutmix", "tests/test_regularization.py::TestCutMix::test_cutmixd", "tests/test_regularization.py::TestCutOut::test_cutout" ]	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> 2872 implementation of mixup, cutmix and cutout Fixes #2872 ### Description Implementation of mixup, cutmix and cutout as described in the original papers. Current implementation support both, the dictionary-based batches and tuples of tensors. ### Types of changes <!--- Put an `x` in all the boxes that apply, and remove the not applicable items --> - [x] Non-breaking change (fix or new feature that would not break existing functionality). - [ ] Breaking change (fix or new feature that would cause existing functionality to change). - [x] New tests added to cover the changes. - [ ] Integration tests passed locally by running `./runtests.sh -f -u --net --coverage`. - [x] Quick tests passed locally by running `./runtests.sh --quick --unittests --disttests`. - [x] In-line docstrings updated. - [x] Documentation updated, tested `make html` command in the `docs/` folder. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in monai/transforms/regularization/array.py] (definition of Mixer:) class Mixer(RandomizableTransform): (definition of Mixer.__init__:) def __init__(self, batch_size: int, alpha: float = 1.0) -> None: """Mixer is a base class providing the basic logic for the mixup-class of augmentations. In all cases, we need to sample the mixing weights for each sample (lambda in the notation used in the papers). Also, pairs of samples being mixed are picked by randomly shuffling the batch samples. Args: batch_size (int): number of samples per batch. That is, samples are expected tp be of size batchsize x channels [x depth] x height x width. alpha (float, optional): mixing weights are sampled from the Beta(alpha, alpha) distribution. Defaults to 1.0, the uniform distribution.""" (definition of Mixer.apply:) def apply(self, data: torch.Tensor): (definition of Mixer.randomize:) def randomize(self, data=None) -> None: """Sometimes you need may to apply the same transform to different tensors. The idea is to get a sample and then apply it with apply() as often as needed. You need to call this method everytime you apply the transform to a new batch.""" (definition of MixUp:) class MixUp(Mixer): """MixUp as described in: Hongyi Zhang, Moustapha Cisse, Yann N. Dauphin, David Lopez-Paz. mixup: Beyond Empirical Risk Minimization, ICLR 2018 Class derived from :py:class:`monai.transforms.Mixer`. See corresponding documentation for details on the constructor parameters.""" (definition of MixUp.apply:) def apply(self, data: torch.Tensor): (definition of MixUp.__call__:) def __call__(self, data: torch.Tensor, labels: torch.Tensor \| None = None): (definition of CutMix:) class CutMix(Mixer): """CutMix augmentation as described in: Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, Youngjoon Yoo. CutMix: Regularization Strategy to Train Strong Classifiers with Localizable Features, ICCV 2019 Class derived from :py:class:`monai.transforms.Mixer`. See corresponding documentation for details on the constructor parameters. Here, alpha not only determines the mixing weight but also the size of the random rectangles used during for mixing. Please refer to the paper for details. The most common use case is something close to: .. code-block:: python cm = CutMix(batch_size=8, alpha=0.5) for batch in loader: images, labels = batch augimg, auglabels = cm(images, labels) output = model(augimg) loss = loss_function(output, auglabels) ...""" (definition of CutMix.apply:) def apply(self, data: torch.Tensor): (definition of CutMix.apply_on_labels:) def apply_on_labels(self, labels: torch.Tensor): (definition of CutMix.__call__:) def __call__(self, data: torch.Tensor, labels: torch.Tensor \| None = None): (definition of CutOut:) class CutOut(Mixer): """Cutout as described in the paper: Terrance DeVries, Graham W. Taylor. Improved Regularization of Convolutional Neural Networks with Cutout, arXiv:1708.04552 Class derived from :py:class:`monai.transforms.Mixer`. See corresponding documentation for details on the constructor parameters. Here, alpha not only determines the mixing weight but also the size of the random rectangles being cut put. Please refer to the paper for details.""" (definition of CutOut.apply:) def apply(self, data: torch.Tensor): (definition of CutOut.__call__:) def __call__(self, data: torch.Tensor): [end of new definitions in monai/transforms/regularization/array.py] [start of new definitions in monai/transforms/regularization/dictionary.py] (definition of MixUpd:) class MixUpd(MapTransform): """Dictionary-based version :py:class:`monai.transforms.MixUp`. Notice that the mixup transformation will be the same for all entries for consistency, i.e. images and labels must be applied the same augmenation.""" (definition of MixUpd.__init__:) def __init__( self, keys: KeysCollection, batch_size: int, alpha: float = 1.0, allow_missing_keys: bool = False ) -> None: (definition of MixUpd.__call__:) def __call__(self, data): (definition of CutMixd:) class CutMixd(MapTransform): """Dictionary-based version :py:class:`monai.transforms.CutMix`. Notice that the mixture weights will be the same for all entries for consistency, i.e. images and labels must be aggregated with the same weights, but the random crops are not.""" (definition of CutMixd.__init__:) def __init__( self, keys: KeysCollection, batch_size: int, label_keys: KeysCollection \| None = None, alpha: float = 1.0, allow_missing_keys: bool = False, ) -> None: (definition of CutMixd.__call__:) def __call__(self, data): (definition of CutOutd:) class CutOutd(MapTransform): """Dictionary-based version :py:class:`monai.transforms.CutOut`. Notice that the cutout is different for every entry in the dictionary.""" (definition of CutOutd.__init__:) def __init__(self, keys: KeysCollection, batch_size: int, allow_missing_keys: bool = False) -> None: (definition of CutOutd.__call__:) def __call__(self, data): [end of new definitions in monai/transforms/regularization/dictionary.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Mismatch result in "integration_segmentation_3d" ``` ====================================================================== ERROR: test_timing (__main__.IntegrationSegmentation3D) ---------------------------------------------------------------------- ValueError: no matched results for integration_segmentation_3d, losses. [0.5442982316017151, 0.4741817444562912, 0.4535954713821411, 0.44163046181201937, 0.4307525992393494, 0.428487154841423]. The above exception was the direct cause of the following exception: Traceback (most recent call last): File "/workspace/MONAI/tests/utils.py", line 628, in _wrapper raise RuntimeError(res.traceback) from res RuntimeError: Traceback (most recent call last): File "/workspace/MONAI/tests/utils.py", line 580, in run_process output = func(args, kwargs) File "/workspace/MONAI/tests/utils.py", line 660, in _call_original_func return f(args, **kwargs) File "/workspace/MONAI/tests/test_integration_segmentation_3d.py", line 301, in test_timing self.train_and_infer(idx=3) File "/workspace/MONAI/tests/test_integration_segmentation_3d.py", line 284, in train_and_infer self.assertTrue(test_integration_value(TASK, key="losses", data=results[:6], rtol=1e-3)) File "/workspace/MONAI/tests/testing_data/integration_answers.py", line 616, in test_integration_value raise ValueError(f"no matched results for {test_name}, {key}. {data}.") ValueError: no matched results for integration_segmentation_3d, losses. [0.5442982316017151, 0.4741817444562912, 0.4535954713821411, 0.44163046181201937, 0.4307525992393494, 0.428487154841423]. ====================================================================== ERROR: test_training (__main__.IntegrationSegmentation3D) ---------------------------------------------------------------------- Traceback (most recent call last): File "/workspace/MONAI/tests/test_integration_segmentation_3d.py", line 293, in test_training results = self.train_and_infer(i) File "/workspace/MONAI/tests/test_integration_segmentation_3d.py", line 284, in train_and_infer self.assertTrue(test_integration_value(TASK, key="losses", data=results[:6], rtol=1e-3)) File "/workspace/MONAI/tests/testing_data/integration_answers.py", line 616, in test_integration_value raise ValueError(f"no matched results for {test_name}, {key}. {data}.") ValueError: no matched results for integration_segmentation_3d, losses. [0.5442982316017151, 0.4741817444562912, 0.4535954713821411, 0.44163046181201937, 0.4307525992393494, 0.428487154841423]. ---------------------------------------------------------------------- Ran 2 tests in 243.671s FAILED (errors=2) losses [0.5442982316017151, 0.4741817444562912, 0.4535954713821411, 0.44163046181201937, 0.4307525992393494, 0.428487154841423] best metric 0.9314384460449219 infer metric 0.9315622448921204 [0.14268704426414708, 0.1528672845845743, 0.1521782248125706, 0.14028769128068194, 0.1889830671664784, 0.16999075690664475, 0.14736282992708227, 0.16877952654821815, 0.15779597155181269, 0.17987829927082263, 0.16320253928314676, 0.16854299322173155, 0.14497470986956967, 0.11437140546369519, 0.1624117412960871, 0.20156009294443875, 0.1764654154256958, 0.0982348259217418, 0.1942436068604293, 0.20359421536407518, 0.19661953116976483, 0.2088326101468625, 0.16273043545239807, 0.1326107887439663, 0.1489245275752285, 0.143107476635514, 0.23189027677929547, 0.1613818424566088, 0.14889532196775188, 0.10332622984492143, 0.11940054688302351, 0.13040496302762658, 0.11472123087193181, 0.15307044007394474, 0.16371989575844717, 0.1942898223272055, 0.2230120930471398, 0.1814679187634795, 0.19069496508164732, 0.07537197031940022] ``` ---------- -------------------- </issues>	e73257caa79309dcce1e93abf1632f4bfd75b11f
tobymao__sqlglot-2484	2,484	tobymao/sqlglot	null	df0a69842daf3ec957effba206b79e27a97c91b4	2023-10-30T16:11:39Z	diff --git a/sqlglot/dialects/spark.py b/sqlglot/dialects/spark.py index 8461920fe8..ba73ac01ab 100644 --- a/sqlglot/dialects/spark.py +++ b/sqlglot/dialects/spark.py @@ -56,7 +56,11 @@ class Parser(Spark2.Parser): def _parse_generated_as_identity( self, - ) -> exp.GeneratedAsIdentityColumnConstraint \| exp.ComputedColumnConstraint: + ) -> ( + exp.GeneratedAsIdentityColumnConstraint + \| exp.ComputedColumnConstraint + \| exp.GeneratedAsRowColumnConstraint + ): this = super()._parse_generated_as_identity() if this.expression: return self.expression(exp.ComputedColumnConstraint, this=this.expression) diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index 7740382d7c..cafaeb4ff7 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -1297,6 +1297,10 @@ class AutoIncrementColumnConstraint(ColumnConstraintKind): pass +class PeriodForSystemTimeConstraint(ColumnConstraintKind): + arg_types = {"this": True, "expression": True} + + class CaseSpecificColumnConstraint(ColumnConstraintKind): arg_types = {"not_": True} @@ -1351,6 +1355,10 @@ class GeneratedAsIdentityColumnConstraint(ColumnConstraintKind): } +class GeneratedAsRowColumnConstraint(ColumnConstraintKind): + arg_types = {"start": True, "hidden": False} + + # https://dev.mysql.com/doc/refman/8.0/en/create-table.html class IndexColumnConstraint(ColumnConstraintKind): arg_types = { @@ -2243,6 +2251,11 @@ class WithJournalTableProperty(Property): arg_types = {"this": True} +class WithSystemVersioningProperty(Property): + # this -> history table name, expression -> data consistency check + arg_types = {"this": True, "expression": False} + + class Properties(Expression): arg_types = {"expressions": True} diff --git a/sqlglot/generator.py b/sqlglot/generator.py index e2d8edf750..5e369aa120 100644 --- a/sqlglot/generator.py +++ b/sqlglot/generator.py @@ -328,6 +328,7 @@ class Generator: exp.VolatileProperty: exp.Properties.Location.POST_CREATE, exp.WithDataProperty: exp.Properties.Location.POST_EXPRESSION, exp.WithJournalTableProperty: exp.Properties.Location.POST_NAME, + exp.WithSystemVersioningProperty: exp.Properties.Location.POST_SCHEMA, } # Keywords that can't be used as unquoted identifier names @@ -748,6 +749,18 @@ def generatedasidentitycolumnconstraint_sql( return f"GENERATED{this} AS {expr}{sequence_opts}" + def generatedasrowcolumnconstraint_sql( + self, expression: exp.GeneratedAsRowColumnConstraint + ) -> str: + start = "START" if expression.args["start"] else "END" + hidden = " HIDDEN" if expression.args.get("hidden") else "" + return f"GENERATED ALWAYS AS ROW {start}{hidden}" + + def periodforsystemtimeconstraint_sql( + self, expression: exp.PeriodForSystemTimeConstraint + ) -> str: + return f"PERIOD FOR SYSTEM_TIME ({self.sql(expression, 'this')}, {self.sql(expression, 'expression')})" + def notnullcolumnconstraint_sql(self, expression: exp.NotNullColumnConstraint) -> str: return f"{'' if expression.args.get('allow_null') else 'NOT '}NULL" @@ -1255,6 +1268,20 @@ def withdataproperty_sql(self, expression: exp.WithDataProperty) -> str: statistics_sql = f" AND {'NO ' if not statistics else ''}STATISTICS" return f"{data_sql}{statistics_sql}" + def withsystemversioningproperty_sql(self, expression: exp.WithSystemVersioningProperty) -> str: + sql = "WITH(SYSTEM_VERSIONING=ON" + if expression.this is None: + return f"{sql})" + + history_table = self.sql(expression.this) + sql = f"{sql}(HISTORY_TABLE={history_table}" + if expression.expression is None: + return f"{sql}))" + + data_consistency_check = "ON" if expression.expression else "OFF" + sql = f"{sql}, DATA_CONSISTENCY_CHECK={data_consistency_check}" + return f"{sql}))" + def insert_sql(self, expression: exp.Insert) -> str: overwrite = expression.args.get("overwrite") diff --git a/sqlglot/parser.py b/sqlglot/parser.py index f8256fe858..4dfc008f5a 100644 --- a/sqlglot/parser.py +++ b/sqlglot/parser.py @@ -696,6 +696,7 @@ class Parser(metaclass=_Parser): exp.StabilityProperty, this=exp.Literal.string("STABLE") ), "STORED": lambda self: self._parse_stored(), + "SYSTEM_VERSIONING": lambda self: self._parse_system_versioning_property(), "TBLPROPERTIES": lambda self: self._parse_wrapped_csv(self._parse_property), "TEMP": lambda self: self.expression(exp.TemporaryProperty), "TEMPORARY": lambda self: self.expression(exp.TemporaryProperty), @@ -753,6 +754,7 @@ class Parser(metaclass=_Parser): ) or self.expression(exp.OnProperty, this=self._parse_id_var()), "PATH": lambda self: self.expression(exp.PathColumnConstraint, this=self._parse_string()), + "PERIOD": lambda self: self._parse_period_for_system_time(), "PRIMARY KEY": lambda self: self._parse_primary_key(), "REFERENCES": lambda self: self._parse_references(match=False), "TITLE": lambda self: self.expression( @@ -774,7 +776,7 @@ class Parser(metaclass=_Parser): "RENAME": lambda self: self._parse_alter_table_rename(), } - SCHEMA_UNNAMED_CONSTRAINTS = {"CHECK", "FOREIGN KEY", "LIKE", "PRIMARY KEY", "UNIQUE"} + SCHEMA_UNNAMED_CONSTRAINTS = {"CHECK", "FOREIGN KEY", "LIKE", "PRIMARY KEY", "UNIQUE", "PERIOD"} NO_PAREN_FUNCTION_PARSERS = { "ANY": lambda self: self.expression(exp.Any, this=self._parse_bitwise()), @@ -1523,6 +1525,19 @@ def _parse_volatile_property(self) -> exp.VolatileProperty \| exp.StabilityProper return self.expression(exp.StabilityProperty, this=exp.Literal.string("VOLATILE")) + def _parse_system_versioning_property(self) -> exp.WithSystemVersioningProperty: + self._match_pair(TokenType.EQ, TokenType.ON) + self._match_l_paren() + self._match_text_seq("HISTORY_TABLE") + self._match(TokenType.EQ) + this = self.expression(exp.WithSystemVersioningProperty, this=self._parse_table_parts()) + if self._match(TokenType.COMMA): + self._match_text_seq("DATA_CONSISTENCY_CHECK") + self._match(TokenType.EQ) + this.set("expression", self._match_texts(("ON", "OFF"))) + self._match_r_paren() + return this + def _parse_with_property( self, ) -> t.Optional[exp.Expression] \| t.List[exp.Expression]: @@ -3864,7 +3879,11 @@ def _parse_compress(self) -> exp.CompressColumnConstraint: def _parse_generated_as_identity( self, - ) -> exp.GeneratedAsIdentityColumnConstraint \| exp.ComputedColumnConstraint: + ) -> ( + exp.GeneratedAsIdentityColumnConstraint + \| exp.ComputedColumnConstraint + \| exp.GeneratedAsRowColumnConstraint + ): if self._match_text_seq("BY", "DEFAULT"): on_null = self._match_pair(TokenType.ON, TokenType.NULL) this = self.expression( @@ -3875,6 +3894,14 @@ def _parse_generated_as_identity( this = self.expression(exp.GeneratedAsIdentityColumnConstraint, this=True) self._match(TokenType.ALIAS) + + if self._match_text_seq("ROW"): + start = self._match_text_seq("START") + if not start: + self._match(TokenType.END) + hidden = self._match_text_seq("HIDDEN") + return self.expression(exp.GeneratedAsRowColumnConstraint, start=start, hidden=hidden) + identity = self._match_text_seq("IDENTITY") if self._match(TokenType.L_PAREN): @@ -4047,6 +4074,16 @@ def _parse_foreign_key(self) -> exp.ForeignKey: def _parse_primary_key_part(self) -> t.Optional[exp.Expression]: return self._parse_field() + def _parse_period_for_system_time(self) -> exp.PeriodForSystemTimeConstraint: + self._match(TokenType.TIMESTAMP_SNAPSHOT) + + id_vars = self._parse_wrapped_id_vars() + return self.expression( + exp.PeriodForSystemTimeConstraint, + this=seq_get(id_vars, 0), + expression=seq_get(id_vars, 1), + ) + def _parse_primary_key( self, wrapped_optional: bool = False, in_props: bool = False ) -> exp.PrimaryKeyColumnConstraint \| exp.PrimaryKey:	diff --git a/tests/dialects/test_tsql.py b/tests/dialects/test_tsql.py index 47750207f2..240b2fbe02 100644 --- a/tests/dialects/test_tsql.py +++ b/tests/dialects/test_tsql.py @@ -1256,6 +1256,20 @@ def test_temp_table(self): }, ) + def test_temporal_table(self): + self.validate_identity( + """CREATE TABLE test ("data" CHAR(7), "valid_from" DATETIME2(2) GENERATED ALWAYS AS ROW START HIDDEN NOT NULL, "valid_to" DATETIME2(2) GENERATED ALWAYS AS ROW END HIDDEN NOT NULL, PERIOD FOR SYSTEM_TIME ("valid_from", "valid_to")) WITH(SYSTEM_VERSIONING=ON(HISTORY_TABLE="dbo"."benchmark_history", DATA_CONSISTENCY_CHECK=ON))""" + ) + self.validate_identity( + """CREATE TABLE test ("data" CHAR(7), "valid_from" DATETIME2(2) GENERATED ALWAYS AS ROW START NOT NULL, "valid_to" DATETIME2(2) GENERATED ALWAYS AS ROW END NOT NULL, PERIOD FOR SYSTEM_TIME ("valid_from", "valid_to")) WITH(SYSTEM_VERSIONING=ON(HISTORY_TABLE="dbo"."benchmark_history", DATA_CONSISTENCY_CHECK=ON))""" + ) + self.validate_identity( + """CREATE TABLE test ("data" CHAR(7), "valid_from" DATETIME2(2) GENERATED ALWAYS AS ROW START NOT NULL, "valid_to" DATETIME2(2) GENERATED ALWAYS AS ROW END NOT NULL, PERIOD FOR SYSTEM_TIME ("valid_from", "valid_to")) WITH(SYSTEM_VERSIONING=ON(HISTORY_TABLE="dbo"."benchmark_history"))""" + ) + self.validate_identity( + """CREATE TABLE test ("data" CHAR(7), "valid_from" DATETIME2(2) GENERATED ALWAYS AS ROW START NOT NULL, "valid_to" DATETIME2(2) GENERATED ALWAYS AS ROW END NOT NULL, PERIOD FOR SYSTEM_TIME ("valid_from", "valid_to")) WITH(SYSTEM_VERSIONING=ON(HISTORY_TABLE="dbo"."benchmark_history"))""" + ) + def test_system_time(self): self.validate_all( "SELECT [x] FROM [a].[b] FOR SYSTEM_TIME AS OF 'foo'",		[]	[ "tests/dialects/test_tsql.py::TestTSQL::test_temporal_table" ]	[ "tests/dialects/test_tsql.py::TestTSQL::test__types_ints", "tests/dialects/test_tsql.py::TestTSQL::test_add_date", "tests/dialects/test_tsql.py::TestTSQL::test_charindex", "tests/dialects/test_tsql.py::TestTSQL::test_commit", "tests/dialects/test_tsql.py::TestTSQL::test_convert_date_format", "tests/dialec...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat(tsql): add PERIOD FOR SYSTEM_TIME constraint, SYSTEM_VERSIONING property Add GENERATED ALWAYS AS ROW START/END column constraint, PERIOD FOR SYSTEM_TIME table constraint, and SYSTEM_VERSIONING property, following the [T-SQL spec for CREATE TABLE](https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql#full-syntax). ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		ceb42fabad60312699e4b15936aeebac00e22e4d
astropy__astropy-15545	15,545	astropy/astropy	v5.3	955e810650f1bf8cd159f71b54afe7ea6f43a77d	2023-10-27T17:09:27Z	diff --git a/astropy/modeling/functional_models.py b/astropy/modeling/functional_models.py index 769b4a80b935..97acf450c41a 100644 --- a/astropy/modeling/functional_models.py +++ b/astropy/modeling/functional_models.py @@ -27,6 +27,7 @@ "Disk2D", "Gaussian1D", "Gaussian2D", + "GeneralSersic2D", "Linear1D", "Lorentz1D", "RickerWavelet1D", @@ -3234,7 +3235,7 @@ class Sersic2D(Fittable2DModel): See Also -------- - Gaussian2D, Moffat2D + GeneralSersic2D, Gaussian2D, Moffat2D Notes ----- @@ -3246,7 +3247,6 @@ class Sersic2D(Fittable2DModel): -b_{n} \left[\left(\frac{r(x, y)}{r_{e}}\right)^{(1/n)} -1\right]\right\} - where :math:`I_{e}` is the ``amplitude``, :math:`r_{e}` is ``reff``, and :math:`r(x, y)` is a rotated ellipse defined as: @@ -3318,33 +3318,31 @@ class Sersic2D(Fittable2DModel): "Rotation angle either as a float (in radians) or a \|Quantity\| angle" ), ) - _gammaincinv = None @classmethod - def evaluate(cls, x, y, amplitude, r_eff, n, x_0, y_0, ellip, theta): + def evaluate(cls, x, y, amplitude, r_eff, n, x_0, y_0, ellip, theta, c=0): """Two dimensional Sersic profile function.""" - if cls._gammaincinv is None: - from scipy.special import gammaincinv - - cls._gammaincinv = gammaincinv + from scipy.special import gammaincinv - bn = cls._gammaincinv(2.0 * n, 0.5) - a, b = r_eff, (1 - ellip) * r_eff - cos_theta, sin_theta = np.cos(theta), np.sin(theta) - x_maj = (x - x_0) * cos_theta + (y - y_0) * sin_theta - x_min = -(x - x_0) * sin_theta + (y - y_0) * cos_theta - z = np.sqrt((x_maj / a) 2 + (x_min / b) 2) + bn = gammaincinv(2.0 * n, 0.5) + cos_theta = np.cos(theta) + sin_theta = np.sin(theta) + x_maj = np.abs((x - x_0) * cos_theta + (y - y_0) * sin_theta) + x_min = np.abs(-(x - x_0) * sin_theta + (y - y_0) * cos_theta) - return amplitude * np.exp(-bn * (z ** (1 / n) - 1)) + b = (1 - ellip) * r_eff + expon = 2.0 + c + inv_expon = 1.0 / expon + z = ((x_maj / r_eff) expon + (x_min / b) expon) ** inv_expon + return amplitude * np.exp(-bn * (z ** (1 / n) - 1.0)) @property def input_units(self): - if self.x_0.input_unit is None: - return None - return { - self.inputs[0]: self.x_0.input_unit, - self.inputs[1]: self.y_0.input_unit, - } + if self.x_0.input_unit is not None: + return { + self.inputs[0]: self.x_0.input_unit, + self.inputs[1]: self.y_0.input_unit, + } def _parameter_units_for_data_units(self, inputs_unit, outputs_unit): # Note that here we need to make sure that x and y are in the same @@ -3361,6 +3359,164 @@ def _parameter_units_for_data_units(self, inputs_unit, outputs_unit): } +class GeneralSersic2D(Sersic2D): + r""" + Generalized two dimensional Sersic surface brightness profile that + allows for "boxy" or "disky" (kite-like) isophote shapes. + + Parameters + ---------- + amplitude : float + Surface brightness at ``r_eff``. + r_eff : float + Effective (half-light) radius. + n : float + Sersic index controlling the shape of the profile. Particular + values of ``n`` are equivalent to the following profiles: + + * n=4 : `de Vaucouleurs <https://en.wikipedia.org/wiki/De_Vaucouleurs%27s_law>`_ :math:`r^{1/4}` profile + * n=1 : Exponential profile + * n=0.5 : Gaussian profile + x_0 : float, optional + x position of the center. + y_0 : float, optional + y position of the center. + ellip : float, optional + Ellipticity of the isophote, defined as 1.0 minus the ratio of + the lengths of the semimajor and semiminor axes: + + .. math:: ellip = 1 - \frac{b}{a} + theta : float or `~astropy.units.Quantity`, optional + The rotation angle as an angular quantity + (`~astropy.units.Quantity` or `~astropy.coordinates.Angle`) + or a value in radians (as a float). The rotation angle + increases counterclockwise from the positive x axis. + c : float, optional + Parameter controlling the shape of the generalized ellipses. + Negative values correspond to disky (kite-like) isophotes and + positive values correspond to boxy isophotes. Setting ``c=0`` + provides perfectly elliptical isophotes (the same model as + `Sersic2D`). + + See Also + -------- + Sersic2D, Gaussian2D, Moffat2D + + Notes + ----- + Model formula: + + .. math:: + + I(x, y) = I_{e} \exp\left\{ + -b_{n} \left[\left(\frac{r(x, y)}{r_{e}}\right)^{(1/n)} + -1\right]\right\} + + where :math:`I_{e}` is the ``amplitude``, :math:`r_{e}` + is ``reff``, and :math:`r(x, y)` is a rotated + "generalized" ellipse (see `Athanassoula et al. 1990 + <https://ui.adsabs.harvard.edu/abs/1990MNRAS.245..130A/abstract>`_) + defined as: + + .. math:: + + r(x, y)^2 = \|A\|^{c + 2} + + \left(\frac{\|B\|}{1 - ellip}\right)^{c + 2} + + .. math:: + + A = (x - x_0) \cos(\theta) + (y - y_0) \sin(\theta) + + .. math:: + + B = -(x - x_0) \sin(\theta) + (y - y_0) \cos(\theta) + + The constant :math:`b_{n}` is defined such that :math:`r_{e}` + contains half the total luminosity. It can be solved for numerically + from the following equation: + + .. math:: + + \Gamma(2n) = 2\gamma (2n, b_{n}) + + where :math:`\Gamma(a)` is the `gamma function + <https://en.wikipedia.org/wiki/Gamma_function>`_ and + :math:`\gamma(a, x)` is the `lower incomplete gamma function + <https://en.wikipedia.org/wiki/Incomplete_gamma_function>`_. + + Examples + -------- + .. plot:: + :include-source: + + import numpy as np + from astropy.modeling.models import GeneralSersic2D + import matplotlib.pyplot as plt + + x, y = np.meshgrid(np.arange(100), np.arange(100)) + + mod = GeneralSersic2D(amplitude=1, r_eff=25, n=4, x_0=50, y_0=50, + c=-1.0, ellip=0.5, theta=-1) + img = mod(x, y) + log_img = np.log10(img) + + fig, ax = plt.subplots() + im = ax.imshow(log_img, origin='lower', interpolation='nearest', + vmin=-1, vmax=2) + cbar = fig.colorbar(im, ax=ax) + cbar.set_label('Log Brightness', rotation=270, labelpad=25) + cbar.set_ticks([-1, 0, 1, 2]) + plt.title('Disky isophote with c=-1.0') + plt.xlabel('x') + plt.ylabel('y') + plt.show() + + .. plot:: + :include-source: + + import numpy as np + from astropy.modeling.models import GeneralSersic2D + import matplotlib.pyplot as plt + + x, y = np.meshgrid(np.arange(100), np.arange(100)) + + mod = GeneralSersic2D(amplitude=1, r_eff=25, n=4, x_0=50, y_0=50, + c=1.0, ellip=0.5, theta=-1) + img = mod(x, y) + log_img = np.log10(img) + + fig, ax = plt.subplots() + im = ax.imshow(log_img, origin='lower', interpolation='nearest', + vmin=-1, vmax=2) + cbar = fig.colorbar(im, ax=ax) + cbar.set_label('Log Brightness', rotation=270, labelpad=25) + cbar.set_ticks([-1, 0, 1, 2]) + plt.title('Boxy isophote with c=1.0') + plt.xlabel('x') + plt.ylabel('y') + plt.show() + + References + ---------- + .. [1] http://ned.ipac.caltech.edu/level5/March05/Graham/Graham2.html + .. [2] https://ui.adsabs.harvard.edu/abs/1990MNRAS.245..130A/abstract + """ + + amplitude = Parameter(default=1, description="Surface brightness at r_eff") + r_eff = Parameter(default=1, description="Effective (half-light) radius") + n = Parameter(default=4, description="Sersic Index") + x_0 = Parameter(default=0, description="X position of the center") + y_0 = Parameter(default=0, description="Y position of the center") + ellip = Parameter(default=0, description="Ellipticity") + theta = Parameter( + default=0.0, + description=( + "Rotation angle either as a float (in radians) or a \|Quantity\| angle" + ), + ) + c = Parameter(default=0, description="Isophote shape parameter") + + class KingProjectedAnalytic1D(Fittable1DModel): """ Projected (surface density) analytic King Model. diff --git a/docs/changes/modeling/15545.feature.rst b/docs/changes/modeling/15545.feature.rst new file mode 100644 index 000000000000..4768112a91e8 --- /dev/null +++ b/docs/changes/modeling/15545.feature.rst @@ -0,0 +1,2 @@ +Added a ``GeneralSersic2D`` model that can have "boxy" or "disky" +isophotes. diff --git a/docs/modeling/predef_models2D.rst b/docs/modeling/predef_models2D.rst index 770a7e4a6620..c61e790020fd 100644 --- a/docs/modeling/predef_models2D.rst +++ b/docs/modeling/predef_models2D.rst @@ -54,6 +54,11 @@ an amplitude. a Sersic profile with an effective half-light radius, rotation, and Sersic index +- :class:`~astropy.modeling.functional_models.GeneralSersic2D` model + computes a generalized Sersic profile with an effective half-light + radius, rotation, Sersic index, and a parameter to control the shape of + the isophotes (e.g., boxy or disky) + - :class:`~astropy.modeling.functional_models.TrapezoidDisk2D` model computes a disk with a radius and slope @@ -69,7 +74,8 @@ an amplitude. from astropy.modeling.models import (AiryDisk2D, Box2D, Disk2D, Ellipse2D, Gaussian2D, Moffat2D, RickerWavelet2D, - Sersic2D, TrapezoidDisk2D, Ring2D) + Sersic2D, GeneralSersic2D, + TrapezoidDisk2D, Ring2D) x = np.linspace(-4.0, 6.0, num=100) r = np.logspace(-1.0, 2.0, num=100) @@ -95,18 +101,23 @@ an amplitude. Moffat2D(amplitude=10.0, x_0=1.0, y_0=2.0, alpha=3, gamma=4), RickerWavelet2D(amplitude=10.0, x_0=1.0, y_0=2.0, sigma=1.0), Sersic2D(amplitude=10.0, x_0=1.0, y_0=2.0, r_eff=1.0, ellip=0.5, theta=math.pi/4.), + GeneralSersic2D(amplitude=10.0, x_0=1.0, y_0=2.0, r_eff=1.0, ellip=0.5, theta=math.pi/4., c=-1), + GeneralSersic2D(amplitude=10.0, x_0=1.0, y_0=2.0, r_eff=1.0, ellip=0.5, theta=math.pi/4., c=1), TrapezoidDisk2D(amplitude=10.0, x_0=1.0, y_0=2.0, R_0=1.0, slope=5.0), Ring2D(amplitude=10.0, x_0=1.0, y_0=2.0, r_in=1.0, r_out=2.0)] for k, mod in enumerate(mods): cname = mod.__class__.__name__ - ax[k].set_title(cname) if cname == "AiryDisk2D": normfunc = LogNorm(vmin=0.001, vmax=10.) - elif cname in ["Gaussian2D", "Sersic2D"]: + elif cname in ["Gaussian2D", "Sersic2D", "GeneralSersic2D"]: normfunc = LogNorm(vmin=0.1, vmax=10.) else: normfunc = None + if cname == "GeneralSersic2D": + cname = f'{cname}, c={mod.c.value:.1f}' + ax[k].set_title(cname) + ax[k].imshow(mod(X, Y), extent=[x0, x1, y0, y1], origin="lower", cmap=plt.cm.gray_r, norm=normfunc) diff --git a/docs/whatsnew/6.0.rst b/docs/whatsnew/6.0.rst index 466e3e709b54..126e42dab79b 100644 --- a/docs/whatsnew/6.0.rst +++ b/docs/whatsnew/6.0.rst @@ -21,6 +21,8 @@ In particular, this release includes: * :ref:`whatsnew-6.0-model-annotation-in-votable` * :ref:`whatsnew-6.0-time-delta-quantity-str` * :ref:`whatsnew-6.0-votable-parquet-serialization` +* :ref:`whatsnew-6.0-fits-decompression` +* :ref:`whatsnew-6.0-general-sersic2d` In addition to these major changes, Astropy v6.0 includes a large number of smaller improvements and bug fixes, which are described in the :ref:`changelog`. @@ -443,6 +445,17 @@ decompressing the whole file at once. With the new keyword ``fits.open(..., decompress_in_memory=True)`` it is now possible to decompress the whole file in memory, which will be faster in some cases. +.. _whatsnew-6.0-general-sersic2d: + +New ``GeneralSersic2D`` model +============================= + +A new :class:`~astropy.modeling.functional_models.GeneralSersic2D` model +has been added to the modeling package. This model is a generalized two +dimensional Sersic surface brightness profile that allows for "boxy" or +"disky" (kite-like) isophote shapes. + + Full change log ===============	diff --git a/astropy/modeling/tests/example_models.py b/astropy/modeling/tests/example_models.py index ae79024f1bed..bf90be1e1c9a 100644 --- a/astropy/modeling/tests/example_models.py +++ b/astropy/modeling/tests/example_models.py @@ -66,6 +66,7 @@ Exponential1D, Gaussian1D, Gaussian2D, + GeneralSersic2D, KingProjectedAnalytic1D, Linear1D, Logarithmic1D, @@ -439,6 +440,15 @@ "x_lim": [1, 1e10], "y_lim": [1, 1e10], }, + GeneralSersic2D: { + "parameters": [1, 25, 4, 50, 50, 0.5, -1, 1.0], + "x_values": [0.0, 1, 10, 100], + "y_values": [1, 100, 0.0, 10], + "z_values": [0.01711221, 0.10471922, 0.02426327, 0.1201565], + "requires_scipy": True, + "x_lim": [1, 1e10], + "y_lim": [1, 1e10], + }, Planar2D: { "parameters": [1, 1, 0], "x_values": [0, np.pi, 42, -1], diff --git a/astropy/modeling/tests/test_models_quantities.py b/astropy/modeling/tests/test_models_quantities.py index 42bc409af0d3..404dc3b4c7c3 100644 --- a/astropy/modeling/tests/test_models_quantities.py +++ b/astropy/modeling/tests/test_models_quantities.py @@ -28,6 +28,7 @@ Exponential1D, Gaussian1D, Gaussian2D, + GeneralSersic2D, KingProjectedAnalytic1D, Linear1D, Logarithmic1D, @@ -405,6 +406,23 @@ "evaluation": [(3 * u.arcsec, 2.5 * u.arcsec, 2.829990489 * u.MJy / u.sr)], "bounding_box": False, }, + { + "class": GeneralSersic2D, + "parameters": { + "amplitude": 3 * u.MJy / u.sr, + "x_0": 1 * u.arcsec, + "y_0": 2 * u.arcsec, + "r_eff": 2 * u.arcsec, + "n": 4, + "c": 1, + "ellip": 0, + "theta": 0, + }, + "evaluation": [ + (3 * u.arcsec, 2.5 * u.arcsec, 2.9704014001846475 * u.MJy / u.sr) + ], + "bounding_box": False, + }, { "class": Planar2D, "parameters": {"slope_x": 2 * u.m, "slope_y": 3 * u.m, "intercept": 4 * u.m}, @@ -550,13 +568,14 @@ + POLY_MODELS ) -SCIPY_MODELS = {Sersic1D, Sersic2D, AiryDisk2D} +SCIPY_MODELS = {Sersic1D, Sersic2D, GeneralSersic2D, AiryDisk2D} # These models will fail fitting test, because built in fitting data # will produce non-finite values NON_FINITE_LevMar_MODELS = [ Sersic1D, Sersic2D, + GeneralSersic2D, ArcSine1D, ArcCosine1D, PowerLaw1D, @@ -572,6 +591,7 @@ ArcCosine1D, Sersic1D, Sersic2D, + GeneralSersic2D, PowerLaw1D, ExponentialCutoffPowerLaw1D, BrokenPowerLaw1D, @@ -587,12 +607,14 @@ Schechter1D, ExponentialCutoffPowerLaw1D, BrokenPowerLaw1D, + GeneralSersic2D, ] # These models will fail the DogBoxLSQFitter fitting test due to non-finite NON_FINITE_DogBox_MODELS = [ Sersic1D, Sersic2D, + GeneralSersic2D, ArcSine1D, ArcCosine1D, SmoothlyBrokenPowerLaw1D,	diff --git a/docs/changes/modeling/15545.feature.rst b/docs/changes/modeling/15545.feature.rst new file mode 100644 index 000000000000..4768112a91e8 --- /dev/null +++ b/docs/changes/modeling/15545.feature.rst @@ -0,0 +1,2 @@ +Added a ``GeneralSersic2D`` model that can have "boxy" or "disky" +isophotes. diff --git a/docs/modeling/predef_models2D.rst b/docs/modeling/predef_models2D.rst index 770a7e4a6620..c61e790020fd 100644 --- a/docs/modeling/predef_models2D.rst +++ b/docs/modeling/predef_models2D.rst @@ -54,6 +54,11 @@ an amplitude. a Sersic profile with an effective half-light radius, rotation, and Sersic index +- :class:`~astropy.modeling.functional_models.GeneralSersic2D` model + computes a generalized Sersic profile with an effective half-light + radius, rotation, Sersic index, and a parameter to control the shape of + the isophotes (e.g., boxy or disky) + - :class:`~astropy.modeling.functional_models.TrapezoidDisk2D` model computes a disk with a radius and slope @@ -69,7 +74,8 @@ an amplitude. from astropy.modeling.models import (AiryDisk2D, Box2D, Disk2D, Ellipse2D, Gaussian2D, Moffat2D, RickerWavelet2D, - Sersic2D, TrapezoidDisk2D, Ring2D) + Sersic2D, GeneralSersic2D, + TrapezoidDisk2D, Ring2D) x = np.linspace(-4.0, 6.0, num=100) r = np.logspace(-1.0, 2.0, num=100) @@ -95,18 +101,23 @@ an amplitude. Moffat2D(amplitude=10.0, x_0=1.0, y_0=2.0, alpha=3, gamma=4), RickerWavelet2D(amplitude=10.0, x_0=1.0, y_0=2.0, sigma=1.0), Sersic2D(amplitude=10.0, x_0=1.0, y_0=2.0, r_eff=1.0, ellip=0.5, theta=math.pi/4.), + GeneralSersic2D(amplitude=10.0, x_0=1.0, y_0=2.0, r_eff=1.0, ellip=0.5, theta=math.pi/4., c=-1), + GeneralSersic2D(amplitude=10.0, x_0=1.0, y_0=2.0, r_eff=1.0, ellip=0.5, theta=math.pi/4., c=1), TrapezoidDisk2D(amplitude=10.0, x_0=1.0, y_0=2.0, R_0=1.0, slope=5.0), Ring2D(amplitude=10.0, x_0=1.0, y_0=2.0, r_in=1.0, r_out=2.0)] for k, mod in enumerate(mods): cname = mod.__class__.__name__ - ax[k].set_title(cname) if cname == "AiryDisk2D": normfunc = LogNorm(vmin=0.001, vmax=10.) - elif cname in ["Gaussian2D", "Sersic2D"]: + elif cname in ["Gaussian2D", "Sersic2D", "GeneralSersic2D"]: normfunc = LogNorm(vmin=0.1, vmax=10.) else: normfunc = None + if cname == "GeneralSersic2D": + cname = f'{cname}, c={mod.c.value:.1f}' + ax[k].set_title(cname) + ax[k].imshow(mod(X, Y), extent=[x0, x1, y0, y1], origin="lower", cmap=plt.cm.gray_r, norm=normfunc) diff --git a/docs/whatsnew/6.0.rst b/docs/whatsnew/6.0.rst index 466e3e709b54..126e42dab79b 100644 --- a/docs/whatsnew/6.0.rst +++ b/docs/whatsnew/6.0.rst @@ -21,6 +21,8 @@ In particular, this release includes: * :ref:`whatsnew-6.0-model-annotation-in-votable` * :ref:`whatsnew-6.0-time-delta-quantity-str` * :ref:`whatsnew-6.0-votable-parquet-serialization` +* :ref:`whatsnew-6.0-fits-decompression` +* :ref:`whatsnew-6.0-general-sersic2d` In addition to these major changes, Astropy v6.0 includes a large number of smaller improvements and bug fixes, which are described in the :ref:`changelog`. @@ -443,6 +445,17 @@ decompressing the whole file at once. With the new keyword ``fits.open(..., decompress_in_memory=True)`` it is now possible to decompress the whole file in memory, which will be faster in some cases. +.. _whatsnew-6.0-general-sersic2d: + +New ``GeneralSersic2D`` model +============================= + +A new :class:`~astropy.modeling.functional_models.GeneralSersic2D` model +has been added to the modeling package. This model is a generalized two +dimensional Sersic surface brightness profile that allows for "boxy" or +"disky" (kite-like) isophote shapes. + + Full change log ===============	[ { "components": [ { "doc": "Generalized two dimensional Sersic surface brightness profile that\nallows for \"boxy\" or \"disky\" (kite-like) isophote shapes.\n\nParameters\n----------\namplitude : float\n Surface brightness at ``r_eff``.\nr_eff : float\n Effective (half-light) radius.\nn : f...	[ "astropy/modeling/tests/test_models_quantities.py::test_models_evaluate_without_units[model0]", "astropy/modeling/tests/test_models_quantities.py::test_models_evaluate_without_units[model2]", "astropy/modeling/tests/test_models_quantities.py::test_models_evaluate_without_units[model3]", "astropy/modeling/test...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add GeneralSersic2D model <!-- These comments are hidden when you submit the pull request, so you do not need to remove them! --> <!-- Please be sure to check out our contributing guidelines, https://github.com/astropy/astropy/blob/main/CONTRIBUTING.md . Please be sure to check out our code of conduct, https://github.com/astropy/astropy/blob/main/CODE_OF_CONDUCT.md . --> <!-- If you are new or need to be re-acquainted with Astropy contributing workflow, please see http://docs.astropy.org/en/latest/development/workflow/development_workflow.html . There is even a practical example at https://docs.astropy.org/en/latest/development/workflow/git_edit_workflow_examples.html#astropy-fix-example . --> <!-- Please just have a quick search on GitHub to see if a similar pull request has already been posted. We have old closed pull requests that might provide useful code or ideas that directly tie in with your pull request. --> <!-- We have several automatic features that run when a pull request is open. They can appear daunting but do not worry because maintainers will help you navigate them, if necessary. --> ### Description <!-- Provide a general description of what your pull request does. Complete the following sentence and add relevant details as you see fit. --> <!-- In addition please ensure that the pull request title is descriptive and allows maintainers to infer the applicable subpackage(s). --> <!-- READ THIS FOR MANUAL BACKPORT FROM A MAINTAINER: Apply "skip-basebranch-check" label before you open the PR! --> This PR adds a `GeneralSersic2D` model, which is a generalized two dimensional Sersic surface brightness profile that allows for "boxy" or "disky" (kite-like) isophote shapes. <!-- If the pull request closes any open issues you can add this. If you replace <Issue Number> with a number, GitHub will automatically link it. If this pull request is unrelated to any issues, please remove the following line. --> <!-- Optional opt-out --> - [x] By checking this box, the PR author has requested that maintainers do NOT use the "Squash and Merge" button. Maintainers should respect this when possible; however, the final decision is at the discretion of the maintainer that merges the PR. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in astropy/modeling/functional_models.py] (definition of GeneralSersic2D:) class GeneralSersic2D(Sersic2D): """Generalized two dimensional Sersic surface brightness profile that allows for "boxy" or "disky" (kite-like) isophote shapes. Parameters ---------- amplitude : float Surface brightness at ``r_eff``. r_eff : float Effective (half-light) radius. n : float Sersic index controlling the shape of the profile. Particular values of ``n`` are equivalent to the following profiles: * n=4 : `de Vaucouleurs <https://en.wikipedia.org/wiki/De_Vaucouleurs%27s_law>`_ :math:`r^{1/4}` profile * n=1 : Exponential profile * n=0.5 : Gaussian profile x_0 : float, optional x position of the center. y_0 : float, optional y position of the center. ellip : float, optional Ellipticity of the isophote, defined as 1.0 minus the ratio of the lengths of the semimajor and semiminor axes: .. math:: ellip = 1 - \frac{b}{a} theta : float or `~astropy.units.Quantity`, optional The rotation angle as an angular quantity (`~astropy.units.Quantity` or `~astropy.coordinates.Angle`) or a value in radians (as a float). The rotation angle increases counterclockwise from the positive x axis. c : float, optional Parameter controlling the shape of the generalized ellipses. Negative values correspond to disky (kite-like) isophotes and positive values correspond to boxy isophotes. Setting ``c=0`` provides perfectly elliptical isophotes (the same model as `Sersic2D`). See Also -------- Sersic2D, Gaussian2D, Moffat2D Notes ----- Model formula: .. math:: I(x, y) = I_{e} \exp\left\{ -b_{n} \left[\left(\frac{r(x, y)}{r_{e}}\right)^{(1/n)} -1\right]\right\} where :math:`I_{e}` is the ``amplitude``, :math:`r_{e}` is ``reff``, and :math:`r(x, y)` is a rotated "generalized" ellipse (see `Athanassoula et al. 1990 <https://ui.adsabs.harvard.edu/abs/1990MNRAS.245..130A/abstract>`_) defined as: .. math:: r(x, y)^2 = \|A\|^{c + 2} + \left(\frac{\|B\|}{1 - ellip}\right)^{c + 2} .. math:: A = (x - x_0) \cos(\theta) + (y - y_0) \sin(\theta) .. math:: B = -(x - x_0) \sin(\theta) + (y - y_0) \cos(\theta) The constant :math:`b_{n}` is defined such that :math:`r_{e}` contains half the total luminosity. It can be solved for numerically from the following equation: .. math:: \Gamma(2n) = 2\gamma (2n, b_{n}) where :math:`\Gamma(a)` is the `gamma function <https://en.wikipedia.org/wiki/Gamma_function>`_ and :math:`\gamma(a, x)` is the `lower incomplete gamma function <https://en.wikipedia.org/wiki/Incomplete_gamma_function>`_. Examples -------- .. plot:: :include-source: import numpy as np from astropy.modeling.models import GeneralSersic2D import matplotlib.pyplot as plt x, y = np.meshgrid(np.arange(100), np.arange(100)) mod = GeneralSersic2D(amplitude=1, r_eff=25, n=4, x_0=50, y_0=50, c=-1.0, ellip=0.5, theta=-1) img = mod(x, y) log_img = np.log10(img) fig, ax = plt.subplots() im = ax.imshow(log_img, origin='lower', interpolation='nearest', vmin=-1, vmax=2) cbar = fig.colorbar(im, ax=ax) cbar.set_label('Log Brightness', rotation=270, labelpad=25) cbar.set_ticks([-1, 0, 1, 2]) plt.title('Disky isophote with c=-1.0') plt.xlabel('x') plt.ylabel('y') plt.show() .. plot:: :include-source: import numpy as np from astropy.modeling.models import GeneralSersic2D import matplotlib.pyplot as plt x, y = np.meshgrid(np.arange(100), np.arange(100)) mod = GeneralSersic2D(amplitude=1, r_eff=25, n=4, x_0=50, y_0=50, c=1.0, ellip=0.5, theta=-1) img = mod(x, y) log_img = np.log10(img) fig, ax = plt.subplots() im = ax.imshow(log_img, origin='lower', interpolation='nearest', vmin=-1, vmax=2) cbar = fig.colorbar(im, ax=ax) cbar.set_label('Log Brightness', rotation=270, labelpad=25) cbar.set_ticks([-1, 0, 1, 2]) plt.title('Boxy isophote with c=1.0') plt.xlabel('x') plt.ylabel('y') plt.show() References ---------- .. [1] http://ned.ipac.caltech.edu/level5/March05/Graham/Graham2.html .. [2] https://ui.adsabs.harvard.edu/abs/1990MNRAS.245..130A/abstract""" [end of new definitions in astropy/modeling/functional_models.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		2d281019494aaebf522f6626c0dae37510c16688
tobymao__sqlglot-2467	2,467	tobymao/sqlglot	null	7407568a428e18de42ed6fe82a21a3958a2d8db3	2023-10-27T03:06:02Z	diff --git a/sqlglot/dialects/dialect.py b/sqlglot/dialects/dialect.py index 739e8d7254..acdd17eaf2 100644 --- a/sqlglot/dialects/dialect.py +++ b/sqlglot/dialects/dialect.py @@ -809,13 +809,6 @@ def isnull_to_is_null(args: t.List) -> exp.Expression: return exp.Paren(this=exp.Is(this=seq_get(args, 0), expression=exp.null())) -def move_insert_cte_sql(self: Generator, expression: exp.Insert) -> str: - if expression.expression.args.get("with"): - expression = expression.copy() - expression.set("with", expression.expression.args["with"].pop()) - return self.insert_sql(expression) - - def generatedasidentitycolumnconstraint_sql( self: Generator, expression: exp.GeneratedAsIdentityColumnConstraint ) -> str: diff --git a/sqlglot/dialects/hive.py b/sqlglot/dialects/hive.py index fee08578a1..e28b803f17 100644 --- a/sqlglot/dialects/hive.py +++ b/sqlglot/dialects/hive.py @@ -413,6 +413,7 @@ class Generator(generator.Generator): INDEX_ON = "ON TABLE" EXTRACT_ALLOWS_QUOTES = False NVL2_SUPPORTED = False + SUPPORTS_NESTED_CTES = False TYPE_MAPPING = { generator.Generator.TYPE_MAPPING, diff --git a/sqlglot/dialects/spark.py b/sqlglot/dialects/spark.py index 8461920fe8..1abfce6151 100644 --- a/sqlglot/dialects/spark.py +++ b/sqlglot/dialects/spark.py @@ -63,6 +63,8 @@ def _parse_generated_as_identity( return this class Generator(Spark2.Generator): + SUPPORTS_NESTED_CTES = True + TYPE_MAPPING = { Spark2.Generator.TYPE_MAPPING, exp.DataType.Type.MONEY: "DECIMAL(15, 4)", diff --git a/sqlglot/dialects/spark2.py b/sqlglot/dialects/spark2.py index 2fd4f4efca..515d03a5f0 100644 --- a/sqlglot/dialects/spark2.py +++ b/sqlglot/dialects/spark2.py @@ -7,7 +7,6 @@ binary_from_function, format_time_lambda, is_parse_json, - move_insert_cte_sql, pivot_column_names, rename_func, trim_sql, @@ -188,7 +187,6 @@ class Generator(Hive.Generator): exp.DayOfYear: rename_func("DAYOFYEAR"), exp.FileFormatProperty: lambda self, e: f"USING {e.name.upper()}", exp.From: transforms.preprocess([_unalias_pivot]), - exp.Insert: move_insert_cte_sql, exp.LogicalAnd: rename_func("BOOL_AND"), exp.LogicalOr: rename_func("BOOL_OR"), exp.Map: _map_sql, diff --git a/sqlglot/dialects/tsql.py b/sqlglot/dialects/tsql.py index 867e4e4792..f3ecc07d67 100644 --- a/sqlglot/dialects/tsql.py +++ b/sqlglot/dialects/tsql.py @@ -11,7 +11,6 @@ generatedasidentitycolumnconstraint_sql, max_or_greatest, min_or_least, - move_insert_cte_sql, parse_date_delta, rename_func, timestrtotime_sql, @@ -596,6 +595,8 @@ class Generator(generator.Generator): ALTER_TABLE_ADD_COLUMN_KEYWORD = False LIMIT_FETCH = "FETCH" COMPUTED_COLUMN_WITH_TYPE = False + SUPPORTS_NESTED_CTES = False + CTE_RECURSIVE_KEYWORD_REQUIRED = False TYPE_MAPPING = { *generator.Generator.TYPE_MAPPING, @@ -622,7 +623,6 @@ class Generator(generator.Generator): exp.GeneratedAsIdentityColumnConstraint: generatedasidentitycolumnconstraint_sql, exp.GroupConcat: _string_agg_sql, exp.If: rename_func("IIF"), - exp.Insert: move_insert_cte_sql, exp.Max: max_or_greatest, exp.MD5: lambda self, e: self.func("HASHBYTES", exp.Literal.string("MD5"), e.this), exp.Min: min_or_least, @@ -714,7 +714,7 @@ def create_sql(self, expression: exp.Create) -> str: elif expression.args.get("replace"): sql = sql.replace("CREATE OR REPLACE ", "CREATE OR ALTER ", 1) - return sql + return self.prepend_ctes(expression, sql) def offset_sql(self, expression: exp.Offset) -> str: return f"{super().offset_sql(expression)} ROWS" diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index 7740382d7c..b4275b104a 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -5168,7 +5168,7 @@ class Use(Expression): class Merge(Expression): - arg_types = {"this": True, "using": True, "on": True, "expressions": True} + arg_types = {"this": True, "using": True, "on": True, "expressions": True, "with": False} class When(Func): diff --git a/sqlglot/generator.py b/sqlglot/generator.py index e2d8edf750..6a3ba5ebdc 100644 --- a/sqlglot/generator.py +++ b/sqlglot/generator.py @@ -230,6 +230,12 @@ class Generator: # Whether or not data types support additional specifiers like e.g. CHAR or BYTE (oracle) DATA_TYPE_SPECIFIERS_ALLOWED = False + # Whether or not nested CTEs (e.g. defined inside of subqueries) are allowed + SUPPORTS_NESTED_CTES = True + + # Whether or not the "RECURSIVE" keyword is required when defining recursive CTEs + CTE_RECURSIVE_KEYWORD_REQUIRED = True + TYPE_MAPPING = { exp.DataType.Type.NCHAR: "CHAR", exp.DataType.Type.NVARCHAR: "VARCHAR", @@ -468,6 +474,20 @@ def generate( if cache is not None: self._cache = cache + # Some dialects only support CTEs at the top level expression, so we need to bubble up nested + # CTEs to that level in order to produce a syntactically valid expression. This transformation + # happens here to minimize code duplication, since many expressions support CTEs. + if ( + not self.SUPPORTS_NESTED_CTES + and isinstance(expression, exp.Expression) + and not expression.parent + and "with" in expression.arg_types + and any(node.parent is not expression for node in expression.find_all(exp.With)) + ): + from sqlglot.transforms import move_ctes_to_top_level + + expression = move_ctes_to_top_level(expression.copy()) + self.unsupported_messages = [] sql = self.sql(expression).strip() self._cache = None @@ -879,7 +899,11 @@ def prepend_ctes(self, expression: exp.Expression, sql: str) -> str: def with_sql(self, expression: exp.With) -> str: sql = self.expressions(expression, flat=True) - recursive = "RECURSIVE " if expression.args.get("recursive") else "" + recursive = ( + "RECURSIVE " + if self.CTE_RECURSIVE_KEYWORD_REQUIRED and expression.args.get("recursive") + else "" + ) return f"WITH {recursive}{sql}" @@ -2792,7 +2816,9 @@ def merge_sql(self, expression: exp.Merge) -> str: on = f"ON {self.sql(expression, 'on')}" expressions = self.expressions(expression, sep=" ") - return f"MERGE INTO {this}{table_alias} {using} {on} {expressions}" + return self.prepend_ctes( + expression, f"MERGE INTO {this}{table_alias} {using} {on} {expressions}" + ) def tochar_sql(self, expression: exp.ToChar) -> str: if expression.args.get("format"): diff --git a/sqlglot/transforms.py b/sqlglot/transforms.py index 80b6623337..c59d66fc1e 100644 --- a/sqlglot/transforms.py +++ b/sqlglot/transforms.py @@ -398,6 +398,36 @@ def eliminate_full_outer_join(expression: exp.Expression) -> exp.Expression: return expression +def move_ctes_to_top_level(expression: exp.Expression) -> exp.Expression: + """ + Some dialects (e.g. Hive, T-SQL, Spark prior to version 3) only allow CTEs to be + defined at the top-level, so for example queries like: + + SELECT FROM (WITH t(c) AS (SELECT 1) SELECT * FROM t) AS subq + + are invalid in those dialects. This transformation can be used to ensure all CTEs are + moved to the top level so that the final SQL code is valid from a syntax standpoint. + + TODO: handle name clashes whilst moving CTEs (it can get quite tricky & costly). + """ + top_level_with = expression.args.get("with") + for node in expression.find_all(exp.With): + if node.parent is expression: + continue + + inner_with = node.pop() + if not top_level_with: + top_level_with = inner_with + expression.set("with", top_level_with) + else: + if inner_with.recursive: + top_level_with.set("recursive", True) + + top_level_with.expressions.extend(inner_with.expressions) + + return expression + + def preprocess( transforms: t.List[t.Callable[[exp.Expression], exp.Expression]], ) -> t.Callable[[Generator, exp.Expression], str]:	diff --git a/tests/dialects/test_dialect.py b/tests/dialects/test_dialect.py index 0d43b2aea1..7bf780f17d 100644 --- a/tests/dialects/test_dialect.py +++ b/tests/dialects/test_dialect.py @@ -1861,3 +1861,41 @@ def test_qualify(self): "tsql": "SELECT * FROM (SELECT , COUNT() OVER () AS _w FROM t) AS _t WHERE _w > 1", }, ) + + def test_nested_ctes(self): + self.validate_all( + "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + write={ + "bigquery": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "clickhouse": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "databricks": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "duckdb": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "hive": "WITH t AS (SELECT 1 AS c) SELECT * FROM (SELECT c FROM t) AS subq", + "mysql": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "postgres": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "presto": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "redshift": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "snowflake": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "spark": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "spark2": "WITH t AS (SELECT 1 AS c) SELECT * FROM (SELECT c FROM t) AS subq", + "sqlite": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "trino": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "tsql": "WITH t AS (SELECT 1 AS c) SELECT * FROM (SELECT c FROM t) AS subq", + }, + ) + self.validate_all( + "SELECT * FROM (SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq1) AS subq2", + write={ + "bigquery": "SELECT * FROM (SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq1) AS subq2", + "duckdb": "SELECT * FROM (SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq1) AS subq2", + "hive": "WITH t AS (SELECT 1 AS c) SELECT * FROM (SELECT * FROM (SELECT c FROM t) AS subq1) AS subq2", + "tsql": "WITH t AS (SELECT 1 AS c) SELECT * FROM (SELECT * FROM (SELECT c FROM t) AS subq1) AS subq2", + }, + ) + self.validate_all( + "WITH t1(x) AS (SELECT 1) SELECT * FROM (WITH t2(y) AS (SELECT 2) SELECT y FROM t2) AS subq", + write={ + "duckdb": "WITH t1(x) AS (SELECT 1) SELECT * FROM (WITH t2(y) AS (SELECT 2) SELECT y FROM t2) AS subq", + "tsql": "WITH t1(x) AS (SELECT 1), t2(y) AS (SELECT 2) SELECT * FROM (SELECT y FROM t2) AS subq", + }, + ) diff --git a/tests/dialects/test_spark.py b/tests/dialects/test_spark.py index e08915b75d..841a005365 100644 --- a/tests/dialects/test_spark.py +++ b/tests/dialects/test_spark.py @@ -592,9 +592,10 @@ def test_insert_cte(self): self.validate_all( "INSERT OVERWRITE TABLE table WITH cte AS (SELECT cola FROM other_table) SELECT cola FROM cte", write={ - "spark": "WITH cte AS (SELECT cola FROM other_table) INSERT OVERWRITE TABLE table SELECT cola FROM cte", + "databricks": "INSERT OVERWRITE TABLE table WITH cte AS (SELECT cola FROM other_table) SELECT cola FROM cte", + "hive": "WITH cte AS (SELECT cola FROM other_table) INSERT OVERWRITE TABLE table SELECT cola FROM cte", + "spark": "INSERT OVERWRITE TABLE table WITH cte AS (SELECT cola FROM other_table) SELECT cola FROM cte", "spark2": "WITH cte AS (SELECT cola FROM other_table) INSERT OVERWRITE TABLE table SELECT cola FROM cte", - "databricks": "WITH cte AS (SELECT cola FROM other_table) INSERT OVERWRITE TABLE table SELECT cola FROM cte", }, ) diff --git a/tests/dialects/test_tsql.py b/tests/dialects/test_tsql.py index 47750207f2..479f87b9e9 100644 --- a/tests/dialects/test_tsql.py +++ b/tests/dialects/test_tsql.py @@ -6,6 +6,36 @@ class TestTSQL(Validator): dialect = "tsql" def test_tsql(self): + self.validate_all( + "WITH t(c) AS (SELECT 1) SELECT * INTO foo FROM (SELECT c FROM t) AS temp", + read={ + "duckdb": "CREATE TABLE foo AS WITH t(c) AS (SELECT 1) SELECT c FROM t", + }, + ) + self.validate_all( + "WITH y AS (SELECT 2 AS c) INSERT INTO t SELECT * FROM y", + read={ + "duckdb": "WITH y AS (SELECT 2 AS c) INSERT INTO t SELECT * FROM y", + }, + ) + self.validate_all( + "WITH t(c) AS (SELECT 1) SELECT 1 AS c UNION (SELECT c FROM t)", + read={ + "duckdb": "SELECT 1 AS c UNION (WITH t(c) AS (SELECT 1) SELECT c FROM t)", + }, + ) + self.validate_all( + "WITH t(c) AS (SELECT 1) MERGE INTO x AS z USING (SELECT c FROM t) AS y ON a = b WHEN MATCHED THEN UPDATE SET a = y.b", + read={ + "postgres": "MERGE INTO x AS z USING (WITH t(c) AS (SELECT 1) SELECT c FROM t) AS y ON a = b WHEN MATCHED THEN UPDATE SET a = y.b", + }, + ) + self.validate_all( + "WITH t(n) AS (SELECT 1 AS n UNION ALL SELECT n + 1 AS n FROM t WHERE n < 4) SELECT * FROM (SELECT SUM(n) AS s4 FROM t) AS subq", + read={ + "duckdb": "SELECT * FROM (WITH RECURSIVE t(n) AS (SELECT 1 AS n UNION ALL SELECT n + 1 AS n FROM t WHERE n < 4) SELECT SUM(n) AS s4 FROM t) AS subq", + }, + ) self.validate_all( "CREATE TABLE #mytemptable (a INTEGER)", read={		[]	[ "tests/dialects/test_dialect.py::TestDialect::test_nested_ctes", "tests/dialects/test_spark.py::TestSpark::test_insert_cte", "tests/dialects/test_tsql.py::TestTSQL::test_tsql" ]	[ "tests/dialects/test_dialect.py::TestDialect::test_alias", "tests/dialects/test_dialect.py::TestDialect::test_array", "tests/dialects/test_dialect.py::TestDialect::test_cast", "tests/dialects/test_dialect.py::TestDialect::test_cast_to_user_defined_type", "tests/dialects/test_dialect.py::TestDialect::test_co...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat!(hive,tsql): move CTEs to top-level, fix T-SQL recursive CTEs This PR: - Moves all CTEs to the top-level expression for Hive, Spark2 and T-SQL, since they don't allow nested CTEs - Fixes a transpilation issue towards T-SQL related to recursive CTEs (the `RECURSIVE` keyword needs to be omitted) - Adds support for parsing & generating CTEs in `MERGE` statements The motivation behind touching `generate` instead of adding new entries in `TRANSFORMS` was mainly to avoid duplicating the same code for ~10 expressions that support CTEs x2 dialects (Hive, T-SQL). One downside of the current approach is that Hive and T-SQL suffer from an additional perf. hit due to the preemptive `copy` call that happens in `move_ctes_to_top_level` when the input expression is 1) at the root of the AST and 2) supports CTEs. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		ceb42fabad60312699e4b15936aeebac00e22e4d
boto__botocore-3044	3,044	boto/botocore	null	b0c6a7630fc612529037d17b6f16f70343c3d87e	2023-10-26T01:49:05Z	diff --git a/.changes/next-release/feature-ContainerProvider-78717.json b/.changes/next-release/feature-ContainerProvider-78717.json new file mode 100644 index 0000000000..0f856432a5 --- /dev/null +++ b/.changes/next-release/feature-ContainerProvider-78717.json @@ -0,0 +1,5 @@ +{ + "type": "feature", + "category": "ContainerProvider", + "description": "Added Support for EKS container credentials" +} diff --git a/botocore/credentials.py b/botocore/credentials.py index 6c2d72013c..2f3b969466 100644 --- a/botocore/credentials.py +++ b/botocore/credentials.py @@ -1886,6 +1886,7 @@ class ContainerProvider(CredentialProvider): ENV_VAR = 'AWS_CONTAINER_CREDENTIALS_RELATIVE_URI' ENV_VAR_FULL = 'AWS_CONTAINER_CREDENTIALS_FULL_URI' ENV_VAR_AUTH_TOKEN = 'AWS_CONTAINER_AUTHORIZATION_TOKEN' + ENV_VAR_AUTH_TOKEN_FILE = 'AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE' def __init__(self, environ=None, fetcher=None): if environ is None: @@ -1919,10 +1920,21 @@ def _retrieve_or_fail(self): ) def _build_headers(self): - auth_token = self._environ.get(self.ENV_VAR_AUTH_TOKEN) + auth_token = None + if self.ENV_VAR_AUTH_TOKEN_FILE in self._environ: + auth_token_file_path = self._environ[self.ENV_VAR_AUTH_TOKEN_FILE] + with open(auth_token_file_path) as token_file: + auth_token = token_file.read() + elif self.ENV_VAR_AUTH_TOKEN in self._environ: + auth_token = self._environ[self.ENV_VAR_AUTH_TOKEN] if auth_token is not None: + self._validate_auth_token(auth_token) return {'Authorization': auth_token} + def _validate_auth_token(self, auth_token): + if "\r" in auth_token or "\n" in auth_token: + raise ValueError("Auth token value is not a legal header value") + def _create_fetcher(self, full_uri, headers): def fetch_creds(): try: diff --git a/botocore/utils.py b/botocore/utils.py index 266d204629..6ce4f008fa 100644 --- a/botocore/utils.py +++ b/botocore/utils.py @@ -25,6 +25,7 @@ import time import warnings import weakref +from ipaddress import ip_address from pathlib import Path from urllib.request import getproxies, proxy_bypass @@ -2903,7 +2904,12 @@ class ContainerMetadataFetcher: RETRY_ATTEMPTS = 3 SLEEP_TIME = 1 IP_ADDRESS = '169.254.170.2' - _ALLOWED_HOSTS = [IP_ADDRESS, 'localhost', '127.0.0.1'] + _ALLOWED_HOSTS = [ + IP_ADDRESS, + '169.254.170.23', + 'fd00:ec2::23', + 'localhost', + ] def __init__(self, session=None, sleep=time.sleep): if session is None: @@ -2927,21 +2933,29 @@ def retrieve_full_uri(self, full_url, headers=None): def _validate_allowed_url(self, full_url): parsed = botocore.compat.urlparse(full_url) + if self._is_loopback_address(parsed.hostname): + return is_whitelisted_host = self._check_if_whitelisted_host(parsed.hostname) if not is_whitelisted_host: raise ValueError( - "Unsupported host '%s'. Can only " - "retrieve metadata from these hosts: %s" - % (parsed.hostname, ', '.join(self._ALLOWED_HOSTS)) + f"Unsupported host '{parsed.hostname}'. Can only retrieve metadata " + f"from a loopback address or one of these hosts: {', '.join(self._ALLOWED_HOSTS)}" ) + def _is_loopback_address(self, hostname): + try: + ip = ip_address(hostname) + return ip.is_loopback + except ValueError: + return False + def _check_if_whitelisted_host(self, host): if host in self._ALLOWED_HOSTS: return True return False def retrieve_uri(self, relative_uri): - """Retrieve JSON metadata from ECS metadata. + """Retrieve JSON metadata from container metadata. :type relative_uri: str :param relative_uri: A relative URI, e.g "/foo/bar?id=123" @@ -2983,22 +2997,20 @@ def _get_response(self, full_url, headers, timeout): if response.status_code != 200: raise MetadataRetrievalError( error_msg=( - "Received non 200 response (%s) from ECS metadata: %s" + f"Received non 200 response {response.status_code} " + f"from container metadata: {response_text}" ) - % (response.status_code, response_text) ) try: return json.loads(response_text) except ValueError: - error_msg = ( - "Unable to parse JSON returned from ECS metadata services" - ) + error_msg = "Unable to parse JSON returned from container metadata services" logger.debug('%s:%s', error_msg, response_text) raise MetadataRetrievalError(error_msg=error_msg) except RETRYABLE_HTTP_ERRORS as e: error_msg = ( "Received error when attempting to retrieve " - "ECS metadata: %s" % e + f"container metadata: {e}" ) raise MetadataRetrievalError(error_msg=error_msg)	diff --git a/tests/unit/test_credentials.py b/tests/unit/test_credentials.py index 4301b6446f..089fcc8695 100644 --- a/tests/unit/test_credentials.py +++ b/tests/unit/test_credentials.py @@ -2968,6 +2968,14 @@ def test_refresh_giving_expired_credentials_raises_exception(self): class TestContainerProvider(BaseEnvVar): + def setUp(self): + super().setUp() + self.tempdir = tempfile.mkdtemp() + + def tearDown(self): + super().tearDown() + shutil.rmtree(self.tempdir) + def test_noop_if_env_var_is_not_set(self): # The 'AWS_CONTAINER_CREDENTIALS_RELATIVE_URI' env var # is not present as an env var. @@ -3128,6 +3136,58 @@ def test_can_pass_basic_auth_token(self): self.assertEqual(creds.token, 'token') self.assertEqual(creds.method, 'container-role') + def test_can_pass_auth_token_from_file(self): + token_file_path = os.path.join(self.tempdir, 'token.jwt') + with open(token_file_path, 'w') as token_file: + token_file.write('Basic auth-token') + environ = { + 'AWS_CONTAINER_CREDENTIALS_FULL_URI': 'http://localhost/foo', + 'AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE': token_file_path, + } + fetcher = self.create_fetcher() + timeobj = datetime.now(tzlocal()) + timestamp = (timeobj + timedelta(hours=24)).isoformat() + fetcher.retrieve_full_uri.return_value = { + "AccessKeyId": "access_key", + "SecretAccessKey": "secret_key", + "Token": "token", + "Expiration": timestamp, + } + provider = credentials.ContainerProvider(environ, fetcher) + creds = provider.load() + + fetcher.retrieve_full_uri.assert_called_with( + 'http://localhost/foo', + headers={'Authorization': 'Basic auth-token'}, + ) + self.assertEqual(creds.access_key, 'access_key') + self.assertEqual(creds.secret_key, 'secret_key') + self.assertEqual(creds.token, 'token') + self.assertEqual(creds.method, 'container-role') + + def test_throws_error_on_invalid_token_file(self): + token_file_path = '/some/path/token.jwt' + environ = { + 'AWS_CONTAINER_CREDENTIALS_FULL_URI': 'http://localhost/foo', + 'AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE': token_file_path, + } + fetcher = self.create_fetcher() + provider = credentials.ContainerProvider(environ, fetcher) + + with self.assertRaises(FileNotFoundError): + provider.load() + + def test_throws_error_on_illegal_header(self): + environ = { + 'AWS_CONTAINER_CREDENTIALS_FULL_URI': 'http://localhost/foo', + 'AWS_CONTAINER_AUTHORIZATION_TOKEN': 'invalid\r\ntoken', + } + fetcher = self.create_fetcher() + provider = credentials.ContainerProvider(environ, fetcher) + + with self.assertRaises(ValueError): + provider.load() + class TestProcessProvider(BaseEnvVar): def setUp(self): diff --git a/tests/unit/test_utils.py b/tests/unit/test_utils.py index ddd3c80b34..d79976329f 100644 --- a/tests/unit/test_utils.py +++ b/tests/unit/test_utils.py @@ -2218,7 +2218,7 @@ def get_s3_accesspoint_request( self, accesspoint_name=None, accesspoint_context=None, - s3_request_kwargs + s3_request_kwargs, ): if not accesspoint_name: accesspoint_name = self.accesspoint_name @@ -2579,9 +2579,8 @@ def test_error_raised_on_no_json_response(self): self.assertEqual(self.http.send.call_count, fetcher.RETRY_ATTEMPTS) def test_can_retrieve_full_uri_with_fixed_ip(self): - self.assert_can_retrieve_metadata_from( - 'http://%s/foo?id=1' % ContainerMetadataFetcher.IP_ADDRESS - ) + uri = f'http://{ContainerMetadataFetcher.IP_ADDRESS}/foo?id=1' + self.assert_can_retrieve_metadata_from(uri) def test_localhost_http_is_allowed(self): self.assert_can_retrieve_metadata_from('http://localhost/foo') @@ -2598,6 +2597,21 @@ def test_can_use_127_ip_addr(self): def test_can_use_127_ip_addr_with_port(self): self.assert_can_retrieve_metadata_from('https://127.0.0.1:8080/foo') + def test_can_use_eks_ipv4_addr(self): + uri = 'http://169.254.170.23/credentials' + self.assert_can_retrieve_metadata_from(uri) + + def test_can_use_eks_ipv6_addr(self): + uri = 'http://[fd00:ec2::23]/credentials' + self.assert_can_retrieve_metadata_from(uri) + + def test_can_use_eks_ipv6_addr_with_port(self): + uri = 'https://[fd00:ec2::23]:8000' + self.assert_can_retrieve_metadata_from(uri) + + def test_can_use_loopback_v6_uri(self): + self.assert_can_retrieve_metadata_from('http://[::1]/credentials') + def test_link_local_http_is_not_allowed(self): self.assert_host_is_not_allowed('http://169.254.0.1/foo')	diff --git a/.changes/next-release/feature-ContainerProvider-78717.json b/.changes/next-release/feature-ContainerProvider-78717.json new file mode 100644 index 0000000000..0f856432a5 --- /dev/null +++ b/.changes/next-release/feature-ContainerProvider-78717.json @@ -0,0 +1,5 @@ +{ + "type": "feature", + "category": "ContainerProvider", + "description": "Added Support for EKS container credentials" +}	[ { "components": [ { "doc": "", "lines": [ 1934, 1936 ], "name": "ContainerProvider._validate_auth_token", "signature": "def _validate_auth_token(self, auth_token):", "type": "function" } ], "file": "botocore/credentials.py" ...	[ "tests/unit/test_credentials.py::TestContainerProvider::test_can_pass_auth_token_from_file", "tests/unit/test_credentials.py::TestContainerProvider::test_throws_error_on_illegal_header", "tests/unit/test_credentials.py::TestContainerProvider::test_throws_error_on_invalid_token_file", "tests/unit/test_utils.py...	[ "tests/unit/test_credentials.py::TestCredentials::test_detect_nonascii_character", "tests/unit/test_credentials.py::TestCredentials::test_unicode_input", "tests/unit/test_credentials.py::TestRefreshableCredentials::test_detect_nonascii_character", "tests/unit/test_credentials.py::TestRefreshableCredentials::t...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feature eks credentials This PR updates the existing container credential fetcher to support retrieving credentials from EKS ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in botocore/credentials.py] (definition of ContainerProvider._validate_auth_token:) def _validate_auth_token(self, auth_token): [end of new definitions in botocore/credentials.py] [start of new definitions in botocore/utils.py] (definition of ContainerMetadataFetcher._is_loopback_address:) def _is_loopback_address(self, hostname): [end of new definitions in botocore/utils.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		5e4b564dd0f9aab16a404251ebd3e675c9681492
sqlfluff__sqlfluff-5349	5,349	sqlfluff/sqlfluff	2.2	65328e6b701f46ebb25b758c10b7572111f130ab	2023-10-24T22:53:18Z	diff --git a/examples/05_simple_api_config.py b/examples/05_simple_api_config.py index 1f52f9e6018..a8dfe885d69 100644 --- a/examples/05_simple_api_config.py +++ b/examples/05_simple_api_config.py @@ -19,9 +19,17 @@ config = FluffConfig(configs={"core": {"dialect": "bigquery"}}) # 3b. FluffConfig objects can be created from a config file in a string. config = FluffConfig.from_string("[sqlfluff]\ndialect=bigquery\n") -# 3c. FluffConfig objects can be created from a path containing a config file. +# 3c. FluffConfig objects can be created from a config file in multiple strings +# to simulate the effect of multiple nested config strings. +config = FluffConfig.from_strings( + # NOTE: Given these two strings, the resulting dialect would be "mysql" + # as the later files take precedence. + "[sqlfluff]\ndialect=bigquery\n", + "[sqlfluff]\ndialect=mysql\n", +) +# 3d. FluffConfig objects can be created from a path containing a config file. config = FluffConfig.from_path("test/fixtures/") -# 3c. FluffConfig objects can be from keyword arguments +# 3e. FluffConfig objects can be from keyword arguments config = FluffConfig.from_kwargs(dialect="bigquery", rules=["LT01"]) # The FluffConfig is then provided via a config argument. diff --git a/src/sqlfluff/core/config.py b/src/sqlfluff/core/config.py index 997d537d8e7..14f3825ef40 100644 --- a/src/sqlfluff/core/config.py +++ b/src/sqlfluff/core/config.py @@ -1,5 +1,7 @@ """Module for loading config.""" +from __future__ import annotations + try: from importlib.resources import files except ImportError: # pragma: no cover @@ -359,7 +361,7 @@ def __init__(self) -> None: self._config_cache: Dict[str, Dict[str, Any]] = {} @classmethod - def get_global(cls) -> "ConfigLoader": + def get_global(cls) -> ConfigLoader: """Get the singleton loader.""" global global_loader if not global_loader: @@ -1022,7 +1024,7 @@ def from_root( ignore_local_config: bool = False, overrides: Optional[Dict[str, Any]] = None, *kw: Any, - ) -> "FluffConfig": + ) -> FluffConfig: """Loads a config object just based on the root directory.""" loader = ConfigLoader.get_global() c = loader.load_config_up_to_path( @@ -1046,8 +1048,8 @@ def from_string( ignore_local_config: bool = False, overrides: Optional[Dict[str, Any]] = None, plugin_manager: Optional[pluggy.PluginManager] = None, - ) -> "FluffConfig": - """Loads a config object given a particular path.""" + ) -> FluffConfig: + """Loads a config object from a single config string.""" loader = ConfigLoader.get_global() c = loader.load_config_string(config_string) return cls( @@ -1058,6 +1060,35 @@ def from_string( plugin_manager=plugin_manager, ) + @classmethod + def from_strings( + cls, + config_strings: str, + extra_config_path: Optional[str] = None, + ignore_local_config: bool = False, + overrides: Optional[Dict[str, Any]] = None, + plugin_manager: Optional[pluggy.PluginManager] = None, + ) -> FluffConfig: + """Loads a config object given a series of nested config strings. + + Config strings are incorporated from first to last, treating the + first element as the "root" config, and then later config strings + will take precedence over any earlier values. + """ + loader = ConfigLoader.get_global() + config_state: Dict[str, Any] = {} + for config_string in config_strings: + config_state = loader.load_config_string( + config_string, configs=config_state + ) + return cls( + configs=config_state, + extra_config_path=extra_config_path, + ignore_local_config=ignore_local_config, + overrides=overrides, + plugin_manager=plugin_manager, + ) + @classmethod def from_path( cls, @@ -1066,7 +1097,7 @@ def from_path( ignore_local_config: bool = False, overrides: Optional[Dict[str, Any]] = None, plugin_manager: Optional[pluggy.PluginManager] = None, - ) -> "FluffConfig": + ) -> FluffConfig: """Loads a config object given a particular path.""" loader = ConfigLoader.get_global() c = loader.load_config_up_to_path( @@ -1085,12 +1116,12 @@ def from_path( @classmethod def from_kwargs( cls, - config: Optional["FluffConfig"] = None, + config: Optional[FluffConfig] = None, dialect: Optional[str] = None, rules: Optional[List[str]] = None, exclude_rules: Optional[List[str]] = None, require_dialect: bool = True, - ) -> "FluffConfig": + ) -> FluffConfig: """Instantiate a config from either an existing config or kwargs. This is a convenience method for the ways that the public classes @@ -1143,7 +1174,7 @@ def get_templater( "{}".format(templater_name, ", ".join(templater_lookup.keys())) ) - def make_child_from_path(self, path: str) -> "FluffConfig": + def make_child_from_path(self, path: str) -> FluffConfig: """Make a child config at a path but pass on overrides and extra_config_path.""" return self.from_path( path, @@ -1153,7 +1184,7 @@ def make_child_from_path(self, path: str) -> "FluffConfig": plugin_manager=self._plugin_manager, ) - def diff_to(self, other: "FluffConfig") -> Dict[str, Any]: + def diff_to(self, other: FluffConfig) -> Dict[str, Any]: """Compare this config to another. Args:	diff --git a/test/core/config_test.py b/test/core/config_test.py index 673b8061938..707f98bcb3f 100644 --- a/test/core/config_test.py +++ b/test/core/config_test.py @@ -100,6 +100,19 @@ def test__config__load_from_string(): assert cfg == config_a +def test__config__from_strings(): + """Test loading config from multiple strings.""" + strings = [ + "[sqlfluff]\ndialect=mysql\ntesting_val=foobar", + "[sqlfluff]\ndialect=postgres\ntesting_val2=bar", + "[sqlfluff]\ndialect=mysql\ntesting_val=foo", + ] + cfg = FluffConfig.from_strings(*strings) + assert cfg.get("dialect") == "mysql" + assert cfg.get("testing_val2") == "bar" + assert cfg.get("testing_val") == "foo" + + def test__config__load_file_f(): """Test loading config from a file path.""" c = ConfigLoader()		[ { "components": [ { "doc": "Loads a config object given a series of nested config strings.\n\nConfig strings are incorporated from first to last, treating the\nfirst element as the \"root\" config, and then later config strings\nwill take precedence over any earlier values.", "lines": [ ...	[ "test/core/config_test.py::test__config__from_strings" ]	[ "test/core/config_test.py::test__config__nested_combine", "test/core/config_test.py::test__config__dict_diff", "test/core/config_test.py::test__config__load_file_dir", "test/core/config_test.py::test__config__load_from_string", "test/core/config_test.py::test__config__load_file_f", "test/core/config_test....	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add a public API for nesting config strings. This PR resolves #5207. This mostly uses existing machinery to create nested configs, but exposes it in an easier way and includes an example in the API examples folder. Eventually we might want to deprecate `from_string` and only allow `from_strings`, but that turns this into a more breaking release than it needs to be. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/sqlfluff/core/config.py] (definition of FluffConfig.from_strings:) def from_strings( cls, *config_strings: str, extra_config_path: Optional[str] = None, ignore_local_config: bool = False, overrides: Optional[Dict[str, Any]] = None, plugin_manager: Optional[pluggy.PluginManager] = None, ) -> FluffConfig: """Loads a config object given a series of nested config strings. Config strings are incorporated from first to last, treating the first element as the "root" config, and then later config strings will take precedence over any earlier values.""" [end of new definitions in src/sqlfluff/core/config.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Public API to build nested configs ### Search before asking - [X] I searched the [issues](https://github.com/sqlfluff/sqlfluff/issues) and found no similar issues. ### Description I want to have a public API to be able to build `FluffConfig` instance from several config files which override one another, replicating the behaviour with nested `.sqlfluff` configs in the filesystem. ### Use case I'm building a lint functionality which uses SQLFluff. I want the user to be able to provide nested `.sqlfluff` config files in the service's virtual filesystem, so I need to build the config in my own code. I have tried using `nested_combine` like this: ```Python class LintConfigFile: content: str def build_config(config_files: Optional[List[LintConfigFile]]) -> FluffConfig: if not config_files: return None loader = ConfigLoader.get_global() config_dicts = [ loader.load_config_string(config_file.content) for config_file in config_files ] config = nested_combine(config_dicts) return FluffConfig.from_kwargs(config=config) ``` However, this fails to combine contents of two different config files with this simple unit test: ``` def test_build_config_multiple(self): config = build_config( [ LintConfigFile( content=""" [sqlfluff] dialect = duckdb """ ), LintConfigFile( content=""" [sqlfluff] max_line_length = 120 """ ), ] ) > assert config.get("dialect") == "duckdb" E AssertionError: assert None == 'duckdb' ``` So I ended up using this: ```Python def build_config( config_files: Optional[List[LintConfigFile]], ) -> Optional[FluffConfig]: if not config_files: return None # We build a temporary directory with the config files to replicate sqlfluff # nesting config behavior with tempfile.TemporaryDirectory(dir=TMP_DIR) as temp_dir_path: cur_path = temp_dir_path for i, config_file in enumerate(config_files): cur_path = cur_path + f"/config-{i}" os.makedirs(cur_path) config_path = f"{cur_path}/.sqlfluff" with open(config_path, "w") as f: f.write(config_file.content) return FluffConfig.from_path(cur_path) ``` Which behaves exactly as I expect, but looks to be very unoptimal. ### Dialect not related to particular dialect ### Are you willing to work on and submit a PR to address the issue? - [X] Yes I am willing to submit a PR! ### Code of Conduct - [X] I agree to follow this project's [Code of Conduct](https://github.com/sqlfluff/sqlfluff/blob/main/CODE_OF_CONDUCT.md) ---------- With some experimentation, was able to find a way to achieve creating a config from multiple strings, though still relies on undocumented internals: ```python class LintConfigFile: content: str def build_config( config_files: Optional[List[LintConfigFile]], ) -> Optional[FluffConfig]: loader = ConfigLoader.get_global() configs = nested_combine([ loader.load_config_string(config_file.content) for config_file in config_files ]) return FluffConfig(configs=configs) ``` would still be nice to have a method off `FluffConfig` that does this for us. @golergka & @MasterOdin - thanks both for posting a great issue here. I think this should be fairly easy to do. So that I understand what you're thinking, would you imagine a nested combination of strings (i.e. nested combine of unparsed config files) or a nested combine of `FluffConfig` objects? I think the former is slightly easier, and that seems to be more like what you're suggesting in the example test cases, but I thought I should check. The former, where given a list of strings, we get back a `FluffConfig` with them parsed/combined. Rewriting my example function with a proposed API: ``` class LintConfigFile: content: str def build_config( config_files: List[LintConfigFile], ) -> FluffConfig: return FluffConfig.from_strings(config_strings=[config_file.content for config_file in config_files]) ``` -------------------- </issues>	65328e6b701f46ebb25b758c10b7572111f130ab
tobymao__sqlglot-2454	2,454	tobymao/sqlglot	null	c8e87b6cab18924b6fa307252f19e83eef4f2f03	2023-10-24T17:42:27Z	diff --git a/sqlglot/dataframe/sql/functions.py b/sqlglot/dataframe/sql/functions.py index 1abbef18a8..a424ea4516 100644 --- a/sqlglot/dataframe/sql/functions.py +++ b/sqlglot/dataframe/sql/functions.py @@ -84,11 +84,11 @@ def min(col: ColumnOrName) -> Column: def max_by(col: ColumnOrName, ord: ColumnOrName) -> Column: - return Column.invoke_anonymous_function(col, "MAX_BY", ord) + return Column.invoke_expression_over_column(col, expression.ArgMax, expression=ord) def min_by(col: ColumnOrName, ord: ColumnOrName) -> Column: - return Column.invoke_anonymous_function(col, "MIN_BY", ord) + return Column.invoke_expression_over_column(col, expression.ArgMin, expression=ord) def count(col: ColumnOrName) -> Column: diff --git a/sqlglot/dialects/bigquery.py b/sqlglot/dialects/bigquery.py index 8cb8698bd2..51baba2300 100644 --- a/sqlglot/dialects/bigquery.py +++ b/sqlglot/dialects/bigquery.py @@ -8,6 +8,7 @@ from sqlglot._typing import E from sqlglot.dialects.dialect import ( Dialect, + arg_max_or_min_no_count, binary_from_function, date_add_interval_sql, datestrtodate_sql, @@ -434,6 +435,8 @@ class Generator(generator.Generator): TRANSFORMS = { generator.Generator.TRANSFORMS, exp.ApproxDistinct: rename_func("APPROX_COUNT_DISTINCT"), + exp.ArgMax: arg_max_or_min_no_count("MAX_BY"), + exp.ArgMin: arg_max_or_min_no_count("MIN_BY"), exp.ArraySize: rename_func("ARRAY_LENGTH"), exp.Cast: transforms.preprocess([transforms.remove_precision_parameterized_types]), exp.CollateProperty: lambda self, e: f"DEFAULT COLLATE {self.sql(e, 'this')}" diff --git a/sqlglot/dialects/clickhouse.py b/sqlglot/dialects/clickhouse.py index a935cce36a..30f728c796 100644 --- a/sqlglot/dialects/clickhouse.py +++ b/sqlglot/dialects/clickhouse.py @@ -5,6 +5,7 @@ from sqlglot import exp, generator, parser, tokens, transforms from sqlglot.dialects.dialect import ( Dialect, + arg_max_or_min_no_count, inline_array_sql, no_pivot_sql, rename_func, @@ -373,6 +374,8 @@ class Generator(generator.Generator): exp.Select: transforms.preprocess([transforms.eliminate_qualify]), exp.AnyValue: rename_func("any"), exp.ApproxDistinct: rename_func("uniq"), + exp.ArgMax: arg_max_or_min_no_count("argMax"), + exp.ArgMin: arg_max_or_min_no_count("argMin"), exp.Array: inline_array_sql, exp.CastToStrType: rename_func("CAST"), exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"), diff --git a/sqlglot/dialects/dialect.py b/sqlglot/dialects/dialect.py index ac6b42cb06..739e8d7254 100644 --- a/sqlglot/dialects/dialect.py +++ b/sqlglot/dialects/dialect.py @@ -822,3 +822,13 @@ def generatedasidentitycolumnconstraint_sql( start = self.sql(expression, "start") or "1" increment = self.sql(expression, "increment") or "1" return f"IDENTITY({start}, {increment})" + + +def arg_max_or_min_no_count(name: str) -> t.Callable[[Generator, exp.ArgMax \| exp.ArgMin], str]: + def _arg_max_or_min_sql(self: Generator, expression: exp.ArgMax \| exp.ArgMin) -> str: + if expression.args.get("count"): + self.unsupported(f"Only two arguments are supported in function {name}.") + + return self.func(name, expression.this, expression.expression) + + return _arg_max_or_min_sql diff --git a/sqlglot/dialects/duckdb.py b/sqlglot/dialects/duckdb.py index 7bbe4eecaf..287e03afd1 100644 --- a/sqlglot/dialects/duckdb.py +++ b/sqlglot/dialects/duckdb.py @@ -6,6 +6,7 @@ from sqlglot.dialects.dialect import ( Dialect, approx_count_distinct_sql, + arg_max_or_min_no_count, arrow_json_extract_scalar_sql, arrow_json_extract_sql, binary_from_function, @@ -249,6 +250,8 @@ class Generator(generator.Generator): if e.expressions and e.expressions[0].find(exp.Select) else inline_array_sql(self, e), exp.ArraySize: rename_func("ARRAY_LENGTH"), + exp.ArgMax: arg_max_or_min_no_count("ARG_MAX"), + exp.ArgMin: arg_max_or_min_no_count("ARG_MIN"), exp.ArraySort: _array_sort_sql, exp.ArraySum: rename_func("LIST_SUM"), exp.BitwiseXor: rename_func("XOR"), diff --git a/sqlglot/dialects/hive.py b/sqlglot/dialects/hive.py index 23a6f3e294..7bff553396 100644 --- a/sqlglot/dialects/hive.py +++ b/sqlglot/dialects/hive.py @@ -6,6 +6,7 @@ from sqlglot.dialects.dialect import ( Dialect, approx_count_distinct_sql, + arg_max_or_min_no_count, create_with_partitions_sql, format_time_lambda, if_sql, @@ -431,6 +432,8 @@ class Generator(generator.Generator): exp.Property: _property_sql, exp.AnyValue: rename_func("FIRST"), exp.ApproxDistinct: approx_count_distinct_sql, + exp.ArgMax: arg_max_or_min_no_count("MAX_BY"), + exp.ArgMin: arg_max_or_min_no_count("MIN_BY"), exp.ArrayConcat: rename_func("CONCAT"), exp.ArrayJoin: lambda self, e: self.func("CONCAT_WS", e.expression, e.this), exp.ArraySize: rename_func("SIZE"), diff --git a/sqlglot/dialects/presto.py b/sqlglot/dialects/presto.py index 791e82dc64..aac368cb70 100644 --- a/sqlglot/dialects/presto.py +++ b/sqlglot/dialects/presto.py @@ -280,6 +280,8 @@ class Generator(generator.Generator): exp.AnyValue: rename_func("ARBITRARY"), exp.ApproxDistinct: _approx_distinct_sql, exp.ApproxQuantile: rename_func("APPROX_PERCENTILE"), + exp.ArgMax: rename_func("MAX_BY"), + exp.ArgMin: rename_func("MIN_BY"), exp.Array: lambda self, e: f"ARRAY[{self.expressions(e, flat=True)}]", exp.ArrayConcat: rename_func("CONCAT"), exp.ArrayContains: rename_func("CONTAINS"), diff --git a/sqlglot/dialects/snowflake.py b/sqlglot/dialects/snowflake.py index 3ad170f2a4..07be65b95e 100644 --- a/sqlglot/dialects/snowflake.py +++ b/sqlglot/dialects/snowflake.py @@ -460,6 +460,8 @@ class Generator(generator.Generator): TRANSFORMS = { generator.Generator.TRANSFORMS, + exp.ArgMax: rename_func("MAX_BY"), + exp.ArgMin: rename_func("MIN_BY"), exp.Array: inline_array_sql, exp.ArrayConcat: rename_func("ARRAY_CAT"), exp.ArrayJoin: rename_func("ARRAY_TO_STRING"), diff --git a/sqlglot/dialects/teradata.py b/sqlglot/dialects/teradata.py index 0aeb0d693a..152afa6a14 100644 --- a/sqlglot/dialects/teradata.py +++ b/sqlglot/dialects/teradata.py @@ -3,7 +3,7 @@ import typing as t from sqlglot import exp, generator, parser, tokens, transforms -from sqlglot.dialects.dialect import Dialect, max_or_greatest, min_or_least +from sqlglot.dialects.dialect import Dialect, max_or_greatest, min_or_least, rename_func from sqlglot.tokens import TokenType @@ -169,6 +169,8 @@ class Generator(generator.Generator): TRANSFORMS = { **generator.Generator.TRANSFORMS, + exp.ArgMax: rename_func("MAX_BY"), + exp.ArgMin: rename_func("MIN_BY"), exp.Max: max_or_greatest, exp.Min: min_or_least, exp.Select: transforms.preprocess( diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index 2d1ebc2d78..5b012b156b 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -4189,6 +4189,16 @@ class Abs(Func): pass +class ArgMax(AggFunc): + arg_types = {"this": True, "expression": True, "count": False} + _sql_names = ["ARG_MAX", "ARGMAX", "MAX_BY"] + + +class ArgMin(AggFunc): + arg_types = {"this": True, "expression": True, "count": False} + _sql_names = ["ARG_MIN", "ARGMIN", "MIN_BY"] + + class ApproxTopK(AggFunc): arg_types = {"this": True, "expression": False, "counters": False}	diff --git a/tests/dialects/test_presto.py b/tests/dialects/test_presto.py index 96a2512882..ed734b6da6 100644 --- a/tests/dialects/test_presto.py +++ b/tests/dialects/test_presto.py @@ -558,6 +558,37 @@ def test_presto(self, logger): "SELECT SPLIT_TO_MAP('a:1;b:2;a:3', ';', ':', (k, v1, v2) -> CONCAT(v1, v2))" ) + self.validate_all( + "SELECT MAX_BY(a.id, a.timestamp) FROM a", + read={ + "bigquery": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + "clickhouse": "SELECT argMax(a.id, a.timestamp) FROM a", + "duckdb": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + "snowflake": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + "spark": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + "teradata": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + }, + write={ + "bigquery": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + "clickhouse": "SELECT argMax(a.id, a.timestamp) FROM a", + "duckdb": "SELECT ARG_MAX(a.id, a.timestamp) FROM a", + "presto": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + "snowflake": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + "spark": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + "teradata": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + }, + ) + self.validate_all( + "SELECT MIN_BY(a.id, a.timestamp, 3) FROM a", + write={ + "clickhouse": "SELECT argMin(a.id, a.timestamp) FROM a", + "duckdb": "SELECT ARG_MIN(a.id, a.timestamp) FROM a", + "presto": "SELECT MIN_BY(a.id, a.timestamp, 3) FROM a", + "snowflake": "SELECT MIN_BY(a.id, a.timestamp, 3) FROM a", + "spark": "SELECT MIN_BY(a.id, a.timestamp) FROM a", + "teradata": "SELECT MIN_BY(a.id, a.timestamp, 3) FROM a", + }, + ) self.validate_all( """JSON '"foo"'""", write={		[]	[ "tests/dialects/test_presto.py::TestPresto::test_presto" ]	[ "tests/dialects/test_presto.py::TestPresto::test_cast", "tests/dialects/test_presto.py::TestPresto::test_ddl", "tests/dialects/test_presto.py::TestPresto::test_encode_decode", "tests/dialects/test_presto.py::TestPresto::test_hex_unhex", "tests/dialects/test_presto.py::TestPresto::test_interval_plural_to_sin...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat: add ArgMax, ArgMin expressions, fix their transpilation Fixes #2453 References: - https://clickhouse.com/docs/en/sql-reference/aggregate-functions/reference/argmin - https://clickhouse.com/docs/en/sql-reference/aggregate-functions/reference/argmax - https://trino.io/docs/current/functions/aggregate.html?highlight=max_by#max_by - https://duckdb.org/docs/sql/aggregates.html - https://spark.apache.org/docs/latest/api/sql/index.html - https://teradata.github.io/presto/docs/0.167-t/functions/aggregate.html - https://docs.snowflake.com/en/sql-reference/functions/min_by - https://cloud.google.com/bigquery/docs/reference/standard-sql/aggregate_functions#max_by ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Clickhouse/Trino/Duckdb max_by() doesn't transpile Trino and Duckdb have an aggregate function `max_by` which returns the value corresponding to the maximum of the 2nd argument. Clickhouse calls their function `argMax`. sqlglot currently ignores this function instead of renaming it. ```python In [120]: import sqlglot In [121]: sql = "SELECT max_by(a.id, a.timestamp) FROM a" In [122]: sqlglot.transpile(sql, read="trino", write="clickhouse")[0] Out[122]: 'SELECT max_by(a.id, a.timestamp) FROM a' In [123]: sqlglot.transpile(sql, read="duckdb", write="clickhouse")[0] Out[123]: 'SELECT max_by(a.id, a.timestamp) FROM a' In [124]: sqlglot.transpile(sql, read="trino", write="duckdb")[0] Out[124]: 'SELECT MAX_BY(a.id, a.timestamp) FROM a' # NOTE this is valid because duckdb has an argmax alias for arg_max (also max_by). In [125]: sqlglot.transpile("SELECT argMax(a.id, a.timestamp) FROM a", read="clickhouse", write="duckdb")[0] Out[125]: 'SELECT ARGMAX(a.id, a.timestamp) FROM a' In [126]: sqlglot.transpile("SELECT argMax(a.id, a.timestamp) FROM a", read="clickhouse", write="trino")[0] Out[126]: 'SELECT ARGMAX(a.id, a.timestamp) FROM a' ``` Official Documentation Please include links to official SQL documentation related to your issue. https://clickhouse.com/docs/en/sql-reference/aggregate-functions/reference/argmax https://trino.io/docs/current/functions/aggregate.html?highlight=max_by#max_by https://duckdb.org/docs/sql/aggregates.html ---------- -------------------- </issues>	ceb42fabad60312699e4b15936aeebac00e22e4d
spec-first__connexion-1754	1,754	spec-first/connexion	null	1b72019b1bcd31191d4a37c2e4e7212dfe94566b	2023-10-23T22:27:23Z	diff --git a/connexion/apps/abstract.py b/connexion/apps/abstract.py index f70767984..c8912be1e 100644 --- a/connexion/apps/abstract.py +++ b/connexion/apps/abstract.py @@ -10,10 +10,12 @@ from starlette.types import ASGIApp, Receive, Scope, Send from connexion.jsonifier import Jsonifier +from connexion.lifecycle import ConnexionRequest, ConnexionResponse from connexion.middleware import ConnexionMiddleware, MiddlewarePosition, SpecMiddleware from connexion.middleware.lifespan import Lifespan from connexion.options import SwaggerUIOptions from connexion.resolver import Resolver +from connexion.types import MaybeAwaitable from connexion.uri_parsing import AbstractURIParser @@ -250,14 +252,18 @@ def decorator(func: t.Callable) -> t.Callable: @abc.abstractmethod def add_error_handler( - self, code_or_exception: t.Union[int, t.Type[Exception]], function: t.Callable + self, + code_or_exception: t.Union[int, t.Type[Exception]], + function: t.Callable[ + [ConnexionRequest, Exception], MaybeAwaitable[ConnexionResponse] + ], ) -> None: """ Register a callable to handle application errors. :param code_or_exception: An exception class or the status code of HTTP exceptions to handle. - :param function: Callable that will handle exception. + :param function: Callable that will handle exception, may be async. """ def test_client(self, kwargs): diff --git a/connexion/apps/asynchronous.py b/connexion/apps/asynchronous.py index 9974381fd..9ab08a401 100644 --- a/connexion/apps/asynchronous.py +++ b/connexion/apps/asynchronous.py @@ -14,11 +14,13 @@ from connexion.apps.abstract import AbstractApp from connexion.decorators import StarletteDecorator from connexion.jsonifier import Jsonifier +from connexion.lifecycle import ConnexionRequest, ConnexionResponse from connexion.middleware.abstract import RoutedAPI, RoutedMiddleware from connexion.middleware.lifespan import Lifespan from connexion.operations import AbstractOperation from connexion.options import SwaggerUIOptions from connexion.resolver import Resolver +from connexion.types import MaybeAwaitable from connexion.uri_parsing import AbstractURIParser logger = logging.getLogger(__name__) @@ -88,7 +90,7 @@ def make_operation(self, operation: AbstractOperation) -> AsyncOperation: ) -class AsyncMiddlewareApp(RoutedMiddleware[AsyncApi]): +class AsyncASGIApp(RoutedMiddleware[AsyncApi]): api_cls = AsyncApi @@ -176,7 +178,7 @@ def __init__( :param security_map: A dictionary of security handlers to use. Defaults to :obj:`security.SECURITY_HANDLERS` """ - self._middleware_app: AsyncMiddlewareApp = AsyncMiddlewareApp() + self._middleware_app: AsyncASGIApp = AsyncASGIApp() super().__init__( import_name, @@ -205,6 +207,10 @@ def add_url_rule( ) def add_error_handler( - self, code_or_exception: t.Union[int, t.Type[Exception]], function: t.Callable + self, + code_or_exception: t.Union[int, t.Type[Exception]], + function: t.Callable[ + [ConnexionRequest, Exception], MaybeAwaitable[ConnexionResponse] + ], ) -> None: self.middleware.add_error_handler(code_or_exception, function) diff --git a/connexion/apps/flask.py b/connexion/apps/flask.py index a584c344b..98345ff8d 100644 --- a/connexion/apps/flask.py +++ b/connexion/apps/flask.py @@ -6,23 +6,22 @@ import typing as t import flask -import werkzeug.exceptions from a2wsgi import WSGIMiddleware from flask import Response as FlaskResponse -from flask import signals from starlette.types import Receive, Scope, Send from connexion.apps.abstract import AbstractApp from connexion.decorators import FlaskDecorator -from connexion.exceptions import InternalServerError, ProblemException, ResolverError +from connexion.exceptions import ResolverError from connexion.frameworks import flask as flask_utils from connexion.jsonifier import Jsonifier +from connexion.lifecycle import ConnexionRequest, ConnexionResponse from connexion.middleware.abstract import AbstractRoutingAPI, SpecMiddleware from connexion.middleware.lifespan import Lifespan from connexion.operations import AbstractOperation from connexion.options import SwaggerUIOptions -from connexion.problem import problem from connexion.resolver import Resolver +from connexion.types import MaybeAwaitable from connexion.uri_parsing import AbstractURIParser @@ -117,44 +116,20 @@ def add_url_rule( return self.blueprint.add_url_rule(rule, endpoint, view_func, options) -class FlaskMiddlewareApp(SpecMiddleware): +class FlaskASGIApp(SpecMiddleware): def __init__(self, import_name, server_args: dict, kwargs): self.app = flask.Flask(import_name, server_args) self.app.json = flask_utils.FlaskJSONProvider(self.app) self.app.url_map.converters["float"] = flask_utils.NumberConverter self.app.url_map.converters["int"] = flask_utils.IntegerConverter - self.set_errors_handlers() + # Propagate Errors so we can handle them in the middleware + self.app.config["PROPAGATE_EXCEPTIONS"] = True + self.app.config["TRAP_BAD_REQUEST_ERRORS"] = True + self.app.config["TRAP_HTTP_EXCEPTIONS"] = True self.asgi_app = WSGIMiddleware(self.app.wsgi_app) - def set_errors_handlers(self): - for error_code in werkzeug.exceptions.default_exceptions: - self.app.register_error_handler(error_code, self.common_error_handler) - - self.app.register_error_handler(ProblemException, self.common_error_handler) - - def common_error_handler(self, exception: Exception) -> FlaskResponse: - """Default error handler.""" - if isinstance(exception, ProblemException): - response = exception.to_problem() - else: - if not isinstance(exception, werkzeug.exceptions.HTTPException): - exception = InternalServerError() - - response = problem( - title=exception.name, - detail=exception.description, - status=exception.code, - ) - - if response.status_code >= 500: - signals.got_request_exception.send(self.app, exception=exception) - - return flask.make_response( - (response.body, response.status_code, response.headers) - ) - def add_api(self, specification, , name: str = None, kwargs): api = FlaskApi(specification, kwargs) @@ -177,7 +152,7 @@ async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None: class FlaskApp(AbstractApp): """Connexion Application based on ConnexionMiddleware wrapping a Flask application.""" - _middleware_app: FlaskMiddlewareApp + _middleware_app: FlaskASGIApp def __init__( self, @@ -237,7 +212,7 @@ def __init__( :param security_map: A dictionary of security handlers to use. Defaults to :obj:`security.SECURITY_HANDLERS` """ - self._middleware_app = FlaskMiddlewareApp(import_name, server_args or {}) + self._middleware_app = FlaskASGIApp(import_name, server_args or {}) self.app = self._middleware_app.app super().__init__( import_name, @@ -266,6 +241,10 @@ def add_url_rule( ) def add_error_handler( - self, code_or_exception: t.Union[int, t.Type[Exception]], function: t.Callable + self, + code_or_exception: t.Union[int, t.Type[Exception]], + function: t.Callable[ + [ConnexionRequest, Exception], MaybeAwaitable[ConnexionResponse] + ], ) -> None: self.app.register_error_handler(code_or_exception, function) diff --git a/connexion/context.py b/connexion/context.py index b72fa079d..e21128c70 100644 --- a/connexion/context.py +++ b/connexion/context.py @@ -3,7 +3,7 @@ from starlette.types import Receive, Scope from werkzeug.local import LocalProxy -from connexion.lifecycle import ASGIRequest +from connexion.lifecycle import ConnexionRequest from connexion.operations import AbstractOperation UNBOUND_MESSAGE = ( @@ -25,5 +25,5 @@ scope = LocalProxy(_scope, unbound_message=UNBOUND_MESSAGE) request = LocalProxy( - lambda: ASGIRequest(scope, receive), unbound_message=UNBOUND_MESSAGE + lambda: ConnexionRequest(scope, receive), unbound_message=UNBOUND_MESSAGE ) diff --git a/connexion/decorators/parameter.py b/connexion/decorators/parameter.py index 3ae1e0fb0..ea12a69bc 100644 --- a/connexion/decorators/parameter.py +++ b/connexion/decorators/parameter.py @@ -16,7 +16,7 @@ from connexion.context import context, operation from connexion.frameworks.abstract import Framework from connexion.http_facts import FORM_CONTENT_TYPES -from connexion.lifecycle import ASGIRequest, WSGIRequest +from connexion.lifecycle import ConnexionRequest, WSGIRequest from connexion.operations import AbstractOperation, Swagger2Operation from connexion.utils import ( deep_merge, @@ -43,7 +43,7 @@ def __init__( def _maybe_get_body( self, - request: t.Union[WSGIRequest, ASGIRequest], + request: t.Union[WSGIRequest, ConnexionRequest], , arguments: t.List[str], has_kwargs: bool, @@ -95,7 +95,7 @@ def __call__(self, function: t.Callable) -> t.Callable: arguments, has_kwargs = inspect_function_arguments(unwrapped_function) @functools.wraps(function) - async def wrapper(request: ASGIRequest) -> t.Any: + async def wrapper(request: ConnexionRequest) -> t.Any: request_body = self._maybe_get_body( request, arguments=arguments, has_kwargs=has_kwargs ) @@ -118,7 +118,7 @@ async def wrapper(request: ASGIRequest) -> t.Any: def prep_kwargs( - request: t.Union[WSGIRequest, ASGIRequest], + request: t.Union[WSGIRequest, ConnexionRequest], , request_body: t.Any, files: t.Dict[str, t.Any], diff --git a/connexion/frameworks/starlette.py b/connexion/frameworks/starlette.py index 702c7e48f..097c10e54 100644 --- a/connexion/frameworks/starlette.py +++ b/connexion/frameworks/starlette.py @@ -8,7 +8,7 @@ from starlette.types import Receive, Scope from connexion.frameworks.abstract import Framework -from connexion.lifecycle import ASGIRequest +from connexion.lifecycle import ConnexionRequest from connexion.uri_parsing import AbstractURIParser @@ -48,8 +48,8 @@ def build_response( ) @staticmethod - def get_request(, scope: Scope, receive: Receive, uri_parser: AbstractURIParser, *kwargs) -> ASGIRequest: # type: ignore - return ASGIRequest(scope, receive, uri_parser=uri_parser) + def get_request(, scope: Scope, receive: Receive, uri_parser: AbstractURIParser, *kwargs) -> ConnexionRequest: # type: ignore + return ConnexionRequest(scope, receive, uri_parser=uri_parser) PATH_PARAMETER = re.compile(r"\{([^}])\}") diff --git a/connexion/lifecycle.py b/connexion/lifecycle.py index e002207e0..a388d79e2 100644 --- a/connexion/lifecycle.py +++ b/connexion/lifecycle.py @@ -130,7 +130,7 @@ def __getattr__(self, item): return getattr(self._werkzeug_request, item) -class ASGIRequest(_RequestInterface): +class ConnexionRequest(_RequestInterface): """ Implementation of the Connexion :code:`_RequestInterface` representing an ASGI request. @@ -142,7 +142,9 @@ class ASGIRequest(_RequestInterface): """ def __init__(self, args, uri_parser=None, kwargs): - self._starlette_request = StarletteRequest(args, *kwargs) + # Might be set in `from_starlette_request` class method + if not hasattr(self, "_starlette_request"): + self._starlette_request = StarletteRequest(args, *kwargs) self.uri_parser = uri_parser self._context = None @@ -152,6 +154,16 @@ def __init__(self, args, uri_parser=None, kwargs): self._form = None self._files = None + @classmethod + def from_starlette_request( + cls, request: StarletteRequest, uri_parser=None + ) -> "ConnexionRequest": + # Instantiate the class, and set the `_starlette_request` property before initializing. + self = cls.__new__(cls) + self._starlette_request = request + self.__init__(uri_parser=uri_parser) # type: ignore + return self + @property def context(self): if self._context is None: @@ -226,7 +238,8 @@ async def get_body(self): return await self.body() or None def __getattr__(self, item): - return getattr(self._starlette_request, item) + if self.__getattribute__("_starlette_request"): + return getattr(self._starlette_request, item) class ConnexionResponse: diff --git a/connexion/middleware/exceptions.py b/connexion/middleware/exceptions.py index cba002d7b..e76f4b93e 100644 --- a/connexion/middleware/exceptions.py +++ b/connexion/middleware/exceptions.py @@ -1,68 +1,114 @@ +import asyncio import logging +import typing as t +import werkzeug.exceptions +from starlette.concurrency import run_in_threadpool from starlette.exceptions import HTTPException from starlette.middleware.exceptions import ( ExceptionMiddleware as StarletteExceptionMiddleware, ) from starlette.requests import Request as StarletteRequest -from starlette.responses import Response +from starlette.responses import Response as StarletteResponse from starlette.types import ASGIApp, Receive, Scope, Send from connexion.exceptions import InternalServerError, ProblemException, problem +from connexion.lifecycle import ConnexionRequest, ConnexionResponse +from connexion.types import MaybeAwaitable logger = logging.getLogger(__name__) -class ExceptionMiddleware(StarletteExceptionMiddleware): - """Subclass of starlette ExceptionMiddleware to change handling of HTTP exceptions to - existing connexion behavior.""" +def connexion_wrapper( + handler: t.Callable[ + [ConnexionRequest, Exception], MaybeAwaitable[ConnexionResponse] + ] +) -> t.Callable[[StarletteRequest, Exception], t.Awaitable[StarletteResponse]]: + """Wrapper that translates Starlette requests to Connexion requests before passing + them to the error handler, and translates the returned Connexion responses to + Starlette responses.""" - def __init__(self, next_app: ASGIApp): - super().__init__(next_app) - self.add_exception_handler(ProblemException, self.problem_handler) - self.add_exception_handler(Exception, self.common_error_handler) + async def wrapper(request: StarletteRequest, exc: Exception) -> StarletteResponse: + request = ConnexionRequest.from_starlette_request(request) - @staticmethod - def problem_handler(_request: StarletteRequest, exc: ProblemException): - logger.error("%r", exc) + if asyncio.iscoroutinefunction(handler): + response = await handler(request, exc) # type: ignore + else: + response = await run_in_threadpool(handler, request, exc) - response = exc.to_problem() - - return Response( + return StarletteResponse( content=response.body, status_code=response.status_code, media_type=response.mimetype, headers=response.headers, ) - @staticmethod - def http_exception(_request: StarletteRequest, exc: HTTPException) -> Response: - logger.error("%r", exc) + return wrapper + - headers = exc.headers +class ExceptionMiddleware(StarletteExceptionMiddleware): + """Subclass of starlette ExceptionMiddleware to change handling of HTTP exceptions to + existing connexion behavior.""" - connexion_response = problem( - title=exc.detail, detail=exc.detail, status=exc.status_code, headers=headers + def __init__(self, next_app: ASGIApp): + super().__init__(next_app) + self.add_exception_handler(ProblemException, self.problem_handler) # type: ignore + self.add_exception_handler( + werkzeug.exceptions.HTTPException, self.flask_error_handler ) + self.add_exception_handler(Exception, self.common_error_handler) - return Response( - content=connexion_response.body, - status_code=connexion_response.status_code, - media_type=connexion_response.mimetype, - headers=connexion_response.headers, + def add_exception_handler( + self, + exc_class_or_status_code: t.Union[int, t.Type[Exception]], + handler: t.Callable[[ConnexionRequest, Exception], StarletteResponse], + ) -> None: + super().add_exception_handler( + exc_class_or_status_code, handler=connexion_wrapper(handler) ) @staticmethod - def common_error_handler(_request: StarletteRequest, exc: Exception) -> Response: - logger.error("%r", exc, exc_info=exc) + def problem_handler(_request: ConnexionRequest, exc: ProblemException): + """Default handler for Connexion ProblemExceptions""" + logger.error("%r", exc) + return exc.to_problem() - response = InternalServerError().to_problem() + @staticmethod + @connexion_wrapper + def http_exception( + _request: StarletteRequest, exc: HTTPException, kwargs + ) -> StarletteResponse: + """Default handler for Starlette HTTPException""" + logger.error("%r", exc) + return problem( + title=exc.detail, + detail=exc.detail, + status=exc.status_code, + headers=exc.headers, + ) - return Response( - content=response.body, - status_code=response.status_code, - media_type=response.mimetype, - headers=response.headers, + @staticmethod + def common_error_handler( + _request: StarletteRequest, exc: Exception + ) -> ConnexionResponse: + """Default handler for any unhandled Exception""" + logger.error("%r", exc, exc_info=exc) + return InternalServerError().to_problem() + + def flask_error_handler( + self, request: StarletteRequest, exc: werkzeug.exceptions.HTTPException + ) -> ConnexionResponse: + """Default handler for Flask / werkzeug HTTPException""" + # If a handler is registered for the received status_code, call it instead. + # This is only done automatically for Starlette HTTPExceptions + if handler := self._status_handlers.get(exc.code): + starlette_exception = HTTPException(exc.code, detail=exc.description) + return handler(request, starlette_exception) + + return problem( + title=exc.name, + detail=exc.description, + status=exc.code, ) async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None: diff --git a/connexion/middleware/main.py b/connexion/middleware/main.py index ded10d925..075fac664 100644 --- a/connexion/middleware/main.py +++ b/connexion/middleware/main.py @@ -12,6 +12,7 @@ from connexion import utils from connexion.handlers import ResolverErrorHandler from connexion.jsonifier import Jsonifier +from connexion.lifecycle import ConnexionRequest, ConnexionResponse from connexion.middleware.abstract import SpecMiddleware from connexion.middleware.context import ContextMiddleware from connexion.middleware.exceptions import ExceptionMiddleware @@ -23,6 +24,7 @@ from connexion.middleware.swagger_ui import SwaggerUIMiddleware from connexion.options import SwaggerUIOptions from connexion.resolver import Resolver +from connexion.types import MaybeAwaitable from connexion.uri_parsing import AbstractURIParser from connexion.utils import inspect_function_arguments @@ -419,14 +421,18 @@ def add_api( self.apis.append(api) def add_error_handler( - self, code_or_exception: t.Union[int, t.Type[Exception]], function: t.Callable + self, + code_or_exception: t.Union[int, t.Type[Exception]], + function: t.Callable[ + [ConnexionRequest, Exception], MaybeAwaitable[ConnexionResponse] + ], ) -> None: """ Register a callable to handle application errors. :param code_or_exception: An exception class or the status code of HTTP exceptions to handle. - :param function: Callable that will handle exception. + :param function: Callable that will handle exception, may be async. """ if self.middleware_stack is not None: raise RuntimeError( diff --git a/connexion/middleware/security.py b/connexion/middleware/security.py index 6c4d9010f..7180c56e6 100644 --- a/connexion/middleware/security.py +++ b/connexion/middleware/security.py @@ -5,7 +5,7 @@ from starlette.types import ASGIApp, Receive, Scope, Send from connexion.exceptions import ProblemException -from connexion.lifecycle import ASGIRequest +from connexion.lifecycle import ConnexionRequest from connexion.middleware.abstract import RoutedAPI, RoutedMiddleware from connexion.operations import AbstractOperation from connexion.security import SecurityHandlerFactory @@ -95,7 +95,7 @@ async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None: await self.next_app(scope, receive, send) return - request = ASGIRequest(scope) + request = ConnexionRequest(scope) await self.verification_fn(request) await self.next_app(scope, receive, send) diff --git a/connexion/security.py b/connexion/security.py index c9e273cd2..692d34d91 100644 --- a/connexion/security.py +++ b/connexion/security.py @@ -54,7 +54,7 @@ from connexion.decorators.parameter import inspect_function_arguments from connexion.exceptions import OAuthProblem, OAuthResponseProblem, OAuthScopeProblem -from connexion.lifecycle import ASGIRequest +from connexion.lifecycle import ConnexionRequest from connexion.utils import get_function_from_name logger = logging.getLogger(__name__) @@ -248,7 +248,7 @@ def get_fn(self, security_scheme, required_scopes): def _get_verify_func(self, api_key_info_func, loc, name): check_api_key_func = self.check_api_key(api_key_info_func) - def wrapper(request: ASGIRequest): + def wrapper(request: ConnexionRequest): if loc == "query": api_key = request.query_params.get(name) elif loc == "header": diff --git a/connexion/types.py b/connexion/types.py new file mode 100644 index 000000000..ee20ecfa3 --- /dev/null +++ b/connexion/types.py @@ -0,0 +1,4 @@ +import typing as t + +ReturnType = t.TypeVar("ReturnType") +MaybeAwaitable = t.Union[t.Awaitable[ReturnType], ReturnType] diff --git a/docs/context.rst b/docs/context.rst index 288fd56ea..de344674c 100644 --- a/docs/context.rst +++ b/docs/context.rst @@ -24,12 +24,13 @@ See below for an explanation of the different variables. request ------- -A ``Request`` object representing the incoming request. This is an instance of the ``ASGIRequest``. +A ``Request`` object representing the incoming request. This is an instance of the +``ConnexionRequest``. -.. dropdown:: View a detailed reference of the ``ASGIRequest`` class +.. dropdown:: View a detailed reference of the ``ConnexionRequest`` class :icon: eye - .. autoclass:: connexion.lifecycle.ASGIRequest + .. autoclass:: connexion.lifecycle.ConnexionRequest :noindex: :members: :undoc-members: diff --git a/docs/request.rst b/docs/request.rst index 18faaa3b1..308ad0df6 100644 --- a/docs/request.rst +++ b/docs/request.rst @@ -488,7 +488,7 @@ request. .. dropdown:: View a detailed reference of the ``connexion.request`` class :icon: eye - .. autoclass:: connexion.lifecycle.ASGIRequest + .. autoclass:: connexion.lifecycle.ConnexionRequest :members: :undoc-members: :inherited-members: diff --git a/docs/routing.rst b/docs/routing.rst index f01f97063..e12611700 100644 --- a/docs/routing.rst +++ b/docs/routing.rst @@ -59,7 +59,7 @@ operation: Note that :code:`HEAD` requests will be handled by the :code:`operationId` specified under the :code:`GET` operation in the specification. :code:`Connexion.request.method` can be used to -determine which request was made. See :class:`.ASGIRequest`. +determine which request was made. See :class:`.ConnexionRequest`. Automatic routing ----------------- diff --git a/docs/v3.rst b/docs/v3.rst index 8c8b4859b..578c62813 100644 --- a/docs/v3.rst +++ b/docs/v3.rst @@ -127,6 +127,8 @@ Smaller breaking changes has been added to work with Flask's ``MethodView`` specifically. * Built-in support for uWSGI has been removed. You can re-add this functionality using a custom middleware. * The request body is now passed through for ``GET``, ``HEAD``, ``DELETE``, ``CONNECT`` and ``OPTIONS`` methods as well. +* Error handlers registered on the on the underlying Flask app directly will be ignored. You + should register them on the Connexion app directly. Non-breaking changes	diff --git a/tests/decorators/test_security.py b/tests/decorators/test_security.py index 41695072d..abb88eb01 100644 --- a/tests/decorators/test_security.py +++ b/tests/decorators/test_security.py @@ -10,7 +10,7 @@ OAuthResponseProblem, OAuthScopeProblem, ) -from connexion.lifecycle import ASGIRequest +from connexion.lifecycle import ConnexionRequest from connexion.security import ( NO_VALUE, ApiKeySecurityHandler, @@ -61,7 +61,7 @@ def somefunc(token): somefunc, security_handler.validate_scope, ["admin"] ) - request = ASGIRequest(scope={"type": "http", "headers": []}) + request = ConnexionRequest(scope={"type": "http", "headers": []}) assert wrapped_func(request) is NO_VALUE @@ -83,7 +83,7 @@ async def get_tokeninfo_response(args, *kwargs): token_info_func, security_handler.validate_scope, ["admin"] ) - request = ASGIRequest( + request = ConnexionRequest( scope={"type": "http", "headers": [[b"authorization", b"Bearer 123"]]} ) @@ -124,7 +124,7 @@ def somefunc(token): somefunc, security_handler.validate_scope, ["admin"] ) - request = ASGIRequest( + request = ConnexionRequest( scope={"type": "http", "headers": [[b"authorization", b"Bearer 123"]]} ) @@ -143,7 +143,7 @@ def token_info(token): token_info, security_handler.validate_scope, ["admin"] ) - request = ASGIRequest( + request = ConnexionRequest( scope={"type": "http", "headers": [[b"authorization", b"Bearer 123"]]} ) @@ -178,7 +178,7 @@ def somefunc(username, password, required_scopes=None): security_handler = BasicSecurityHandler() wrapped_func = security_handler._get_verify_func(somefunc) - request = ASGIRequest( + request = ConnexionRequest( scope={"type": "http", "headers": [[b"authorization", b"Bearer 123"]]} ) @@ -194,7 +194,7 @@ def basic_info(username, password, required_scopes=None): security_handler = BasicSecurityHandler() wrapped_func = security_handler._get_verify_func(basic_info) - request = ASGIRequest( + request = ConnexionRequest( scope={"type": "http", "headers": [[b"authorization", b"Basic Zm9vOmJhcg=="]]} ) @@ -212,7 +212,7 @@ def apikey_info(apikey, required_scopes=None): apikey_info, "query", "auth" ) - request = ASGIRequest(scope={"type": "http", "query_string": b"auth=foobar"}) + request = ConnexionRequest(scope={"type": "http", "query_string": b"auth=foobar"}) assert await wrapped_func(request) is not None @@ -228,7 +228,9 @@ def apikey_info(apikey, required_scopes=None): apikey_info, "header", "X-Auth" ) - request = ASGIRequest(scope={"type": "http", "headers": [[b"x-auth", b"foobar"]]}) + request = ConnexionRequest( + scope={"type": "http", "headers": [[b"x-auth", b"foobar"]]} + ) assert await wrapped_func(request) is not None @@ -259,16 +261,20 @@ def apikey2_info(apikey, required_scopes=None): wrapped_func = security_handler_factory.verify_multiple_schemes(schemes) # Single key does not succeed - request = ASGIRequest(scope={"type": "http", "headers": [[b"x-auth-1", b"foobar"]]}) + request = ConnexionRequest( + scope={"type": "http", "headers": [[b"x-auth-1", b"foobar"]]} + ) assert await wrapped_func(request) is NO_VALUE - request = ASGIRequest(scope={"type": "http", "headers": [[b"x-auth-2", b"bar"]]}) + request = ConnexionRequest( + scope={"type": "http", "headers": [[b"x-auth-2", b"bar"]]} + ) assert await wrapped_func(request) is NO_VALUE # Supplying both keys does succeed - request = ASGIRequest( + request = ConnexionRequest( scope={ "type": "http", "headers": [[b"x-auth-1", b"foobar"], [b"x-auth-2", b"bar"]], @@ -287,7 +293,7 @@ async def test_verify_security_oauthproblem(): security_handler_factory = SecurityHandlerFactory() security_func = security_handler_factory.verify_security([]) - request = MagicMock(spec_set=ASGIRequest) + request = MagicMock(spec_set=ConnexionRequest) with pytest.raises(OAuthProblem) as exc_info: await security_func(request)	diff --git a/docs/context.rst b/docs/context.rst index 288fd56ea..de344674c 100644 --- a/docs/context.rst +++ b/docs/context.rst @@ -24,12 +24,13 @@ See below for an explanation of the different variables. request ------- -A ``Request`` object representing the incoming request. This is an instance of the ``ASGIRequest``. +A ``Request`` object representing the incoming request. This is an instance of the +``ConnexionRequest``. -.. dropdown:: View a detailed reference of the ``ASGIRequest`` class +.. dropdown:: View a detailed reference of the ``ConnexionRequest`` class :icon: eye - .. autoclass:: connexion.lifecycle.ASGIRequest + .. autoclass:: connexion.lifecycle.ConnexionRequest :noindex: :members: :undoc-members: diff --git a/docs/request.rst b/docs/request.rst index 18faaa3b1..308ad0df6 100644 --- a/docs/request.rst +++ b/docs/request.rst @@ -488,7 +488,7 @@ request. .. dropdown:: View a detailed reference of the ``connexion.request`` class :icon: eye - .. autoclass:: connexion.lifecycle.ASGIRequest + .. autoclass:: connexion.lifecycle.ConnexionRequest :members: :undoc-members: :inherited-members: diff --git a/docs/routing.rst b/docs/routing.rst index f01f97063..e12611700 100644 --- a/docs/routing.rst +++ b/docs/routing.rst @@ -59,7 +59,7 @@ operation: Note that :code:`HEAD` requests will be handled by the :code:`operationId` specified under the :code:`GET` operation in the specification. :code:`Connexion.request.method` can be used to -determine which request was made. See :class:`.ASGIRequest`. +determine which request was made. See :class:`.ConnexionRequest`. Automatic routing ----------------- diff --git a/docs/v3.rst b/docs/v3.rst index 8c8b4859b..578c62813 100644 --- a/docs/v3.rst +++ b/docs/v3.rst @@ -127,6 +127,8 @@ Smaller breaking changes has been added to work with Flask's ``MethodView`` specifically. * Built-in support for uWSGI has been removed. You can re-add this functionality using a custom middleware. * The request body is now passed through for ``GET``, ``HEAD``, ``DELETE``, ``CONNECT`` and ``OPTIONS`` methods as well. +* Error handlers registered on the on the underlying Flask app directly will be ignored. You + should register them on the Connexion app directly. Non-breaking changes	[ { "components": [ { "doc": "", "lines": [ 93, 120 ], "name": "AsyncASGIApp", "signature": "class AsyncASGIApp(RoutedMiddleware[AsyncApi]):", "type": "class" }, { "doc": "", "lines": [ 97, 10...	[ "tests/decorators/test_security.py::test_get_tokeninfo_url", "tests/decorators/test_security.py::test_verify_oauth_missing_auth_header", "tests/decorators/test_security.py::test_verify_basic_missing_auth_header", "tests/decorators/test_security.py::test_raise_most_specific[errors0-OAuthProblem]", "tests/dec...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Centralize error handling in ExceptionMiddleware I was writing the documentation on exception handling, and I noticed that it was very hard to explain our current behavior. Error handlers can be registered either on the internal Flask app (not the Starlette one) or on the Connexion app, which leads to some undefined (actually just really hard to explain) behavior. Eg. - Registering error handlers on a status code would capture `starlette.HTTPException` errors on the Connexion app, and `werkzeug.HTTPException` errors on the Flask App, which means that registering an error handler on a status code doesn't catch all the errors with that status code. - Flask does some default error handling which leads to some exceptions never reaching the error handlers registered on the Connexion app. So I made the following changes: - Replaced the default error handlers we registered on the Flask app with a default handler on the `ExceptionMiddleware` that takes into account other handlers registered on status codes. - Configured Flask to propagate exceptions instead of catching them. - Abstracted away the Starlette `Request` and `Response` types, so users can and must now use `ConnexionRequest` and `ConnexionResponse` types in error handlers. - Renamed the `ASGIRequest` class to `ConnexionRequest` since it is the only Request class part of the high level Connexion interface. We could also rename `ConnexionRequest` and `ConnexionResponse` to just `Request` and `Response`. Wdyt? ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in connexion/apps/asynchronous.py] (definition of AsyncASGIApp:) class AsyncASGIApp(RoutedMiddleware[AsyncApi]): (definition of AsyncASGIApp.__init__:) def __init__(self) -> None: (definition of AsyncASGIApp.add_api:) def add_api(self, args, name: str = None, kwargs): (definition of AsyncASGIApp.add_url_rule:) def add_url_rule( self, rule, endpoint: str = None, view_func: t.Callable = None, methods: t.List[str] = None, options, ): [end of new definitions in connexion/apps/asynchronous.py] [start of new definitions in connexion/apps/flask.py] (definition of FlaskASGIApp:) class FlaskASGIApp(SpecMiddleware): (definition of FlaskASGIApp.__init__:) def __init__(self, import_name, server_args: dict, kwargs): (definition of FlaskASGIApp.add_api:) def add_api(self, specification, , name: str = None, kwargs): (definition of FlaskASGIApp.add_url_rule:) def add_url_rule( self, rule, endpoint: str = None, view_func: t.Callable = None, options ): [end of new definitions in connexion/apps/flask.py] [start of new definitions in connexion/lifecycle.py] (definition of ConnexionRequest:) class ConnexionRequest(_RequestInterface): """Implementation of the Connexion :code:`_RequestInterface` representing an ASGI request. .. attribute:: _starlette_request This class wraps a Starlette `Request <https://www.starlette.io/requests/#request>`_, and provides access to its attributes by proxy.""" (definition of ConnexionRequest.__init__:) def __init__(self, args, uri_parser=None, *kwargs): (definition of ConnexionRequest.from_starlette_request:) def from_starlette_request( cls, request: StarletteRequest, uri_parser=None ) -> "ConnexionRequest": (definition of ConnexionRequest.context:) def context(self): (definition of ConnexionRequest.content_type:) def content_type(self): (definition of ConnexionRequest.mimetype:) def mimetype(self): (definition of ConnexionRequest.path_params:) def path_params(self) -> t.Dict[str, t.Any]: (definition of ConnexionRequest.query_params:) def query_params(self): (definition of ConnexionRequest.__getattr__:) def __getattr__(self, item): [end of new definitions in connexion/lifecycle.py] [start of new definitions in connexion/middleware/exceptions.py] (definition of connexion_wrapper:) def connexion_wrapper( handler: t.Callable[ [ConnexionRequest, Exception], MaybeAwaitable[ConnexionResponse] ] ) -> t.Callable[[StarletteRequest, Exception], t.Awaitable[StarletteResponse]]: """Wrapper that translates Starlette requests to Connexion requests before passing them to the error handler, and translates the returned Connexion responses to Starlette responses.""" (definition of ExceptionMiddleware.add_exception_handler:) def add_exception_handler( self, exc_class_or_status_code: t.Union[int, t.Type[Exception]], handler: t.Callable[[ConnexionRequest, Exception], StarletteResponse], ) -> None: (definition of ExceptionMiddleware.flask_error_handler:) def flask_error_handler( self, request: StarletteRequest, exc: werkzeug.exceptions.HTTPException ) -> ConnexionResponse: """Default handler for Flask / werkzeug HTTPException""" [end of new definitions in connexion/middleware/exceptions.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		ee399fbfe627f86c461b353132e4d710f7127440
tobymao__sqlglot-2450	2,450	tobymao/sqlglot	null	7ded2536f348a0470af044b56fa0fd6cfb09bb0d	2023-10-23T18:49:30Z	diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index 67b4111047..7df8be234b 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -4174,6 +4174,10 @@ class Abs(Func): pass +class ApproxTopK(AggFunc): + arg_types = {"this": True, "expression": False, "counters": False} + + class Flatten(Func): pass	diff --git a/tests/dialects/test_snowflake.py b/tests/dialects/test_snowflake.py index 78dfabe5c1..65b77ea047 100644 --- a/tests/dialects/test_snowflake.py +++ b/tests/dialects/test_snowflake.py @@ -9,6 +9,10 @@ class TestSnowflake(Validator): dialect = "snowflake" def test_snowflake(self): + expr = parse_one("SELECT APPROX_TOP_K(C4, 3, 5) FROM t") + expr.selects[0].assert_is(exp.AggFunc) + self.assertEqual(expr.sql(dialect="snowflake"), "SELECT APPROX_TOP_K(C4, 3, 5) FROM t") + self.validate_identity("SELECT DAYOFMONTH(CURRENT_TIMESTAMP())") self.validate_identity("SELECT DAYOFYEAR(CURRENT_TIMESTAMP())") self.validate_identity("LISTAGG(data['some_field'], ',')")		[]	[ "tests/dialects/test_snowflake.py::TestSnowflake::test_snowflake" ]	[ "tests/dialects/test_snowflake.py::TestSnowflake::test_ddl", "tests/dialects/test_snowflake.py::TestSnowflake::test_describe_table", "tests/dialects/test_snowflake.py::TestSnowflake::test_flatten", "tests/dialects/test_snowflake.py::TestSnowflake::test_match_recognize", "tests/dialects/test_snowflake.py::Te...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat(snowflake): register APPROX_TOP_K as AggFunc Fixes #2449 Reference: https://docs.snowflake.com/en/sql-reference/functions/approx_top_k ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> approx_top_k is not recognized as an aggregation function in Snowflake Fully reproducible code snippet ```python from sqlglot import Dialects, exp, parse_one query = "SELECT approx_top_k(field, 5) FROM some_table" parsed_query = parse_one(query, read=Dialects.SNOWFLAKE.value) agg_funcs = parsed_query.find_all(exp.AggFunc) has_agg_funcs = any(agg_funcs) # getting False, expected True ``` Official Documentation https://docs.snowflake.com/en/sql-reference/functions/approx_top_k ---------- -------------------- </issues>	ceb42fabad60312699e4b15936aeebac00e22e4d
tobymao__sqlglot-2447	2,447	tobymao/sqlglot	null	00e3515ff3157105d84f21f56cfb64bae3267640	2023-10-23T15:56:49Z	diff --git a/sqlglot/dialects/snowflake.py b/sqlglot/dialects/snowflake.py index a1a1e3428a..3ad170f2a4 100644 --- a/sqlglot/dialects/snowflake.py +++ b/sqlglot/dialects/snowflake.py @@ -545,6 +545,12 @@ class Generator(generator.Generator): exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED, } + def log_sql(self, expression: exp.Log) -> str: + if not expression.expression: + return self.func("LN", expression.this) + + return super().log_sql(expression) + def unnest_sql(self, expression: exp.Unnest) -> str: selects = ["value"] unnest_alias = expression.args.get("alias") diff --git a/sqlglot/parser.py b/sqlglot/parser.py index 703ddff0c5..bc6e4c2915 100644 --- a/sqlglot/parser.py +++ b/sqlglot/parser.py @@ -3625,6 +3625,32 @@ def _parse_function( functions: t.Optional[t.Dict[str, t.Callable]] = None, anonymous: bool = False, optional_parens: bool = True, + ) -> t.Optional[exp.Expression]: + # This allows us to also parse {fn <function>} syntax (Snowflake, MySQL support this) + # See: https://community.snowflake.com/s/article/SQL-Escape-Sequences + fn_syntax = False + if ( + self._match(TokenType.L_BRACE, advance=False) + and self._next + and self._next.text.upper() == "FN" + ): + self._advance(2) + fn_syntax = True + + func = self._parse_function_call( + functions=functions, anonymous=anonymous, optional_parens=optional_parens + ) + + if fn_syntax: + self._match(TokenType.R_BRACE) + + return func + + def _parse_function_call( + self, + functions: t.Optional[t.Dict[str, t.Callable]] = None, + anonymous: bool = False, + optional_parens: bool = True, ) -> t.Optional[exp.Expression]: if not self._curr: return None	diff --git a/tests/dialects/test_snowflake.py b/tests/dialects/test_snowflake.py index 5f8948abd3..78dfabe5c1 100644 --- a/tests/dialects/test_snowflake.py +++ b/tests/dialects/test_snowflake.py @@ -61,6 +61,18 @@ def test_snowflake(self): "SELECT {'test': 'best'}::VARIANT", "SELECT CAST(OBJECT_CONSTRUCT('test', 'best') AS VARIANT)", ) + self.validate_identity( + "SELECT {fn DAYNAME('2022-5-13')}", + "SELECT DAYNAME('2022-5-13')", + ) + self.validate_identity( + "SELECT {fn LOG(5)}", + "SELECT LN(5)", + ) + self.validate_identity( + "SELECT {fn CEILING(5.3)}", + "SELECT CEIL(5.3)", + ) self.validate_all("CAST(x AS BYTEINT)", write={"snowflake": "CAST(x AS INT)"}) self.validate_all("CAST(x AS CHAR VARYING)", write={"snowflake": "CAST(x AS VARCHAR)"})		[]	[ "tests/dialects/test_snowflake.py::TestSnowflake::test_snowflake" ]	[ "tests/dialects/test_snowflake.py::TestSnowflake::test_ddl", "tests/dialects/test_snowflake.py::TestSnowflake::test_describe_table", "tests/dialects/test_snowflake.py::TestSnowflake::test_flatten", "tests/dialects/test_snowflake.py::TestSnowflake::test_match_recognize", "tests/dialects/test_snowflake.py::Te...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat: add support for {fn ...} function syntax Related Slack thread: https://tobiko-data.slack.com/archives/C0448SFS3PF/p1697922425207749 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		ceb42fabad60312699e4b15936aeebac00e22e4d
huggingface__datasets-6318	6,318	huggingface/datasets	null	3aeb078ba1afd713e901df43343c160877403d07	2023-10-19T12:19:13Z	diff --git a/src/datasets/utils/py_utils.py b/src/datasets/utils/py_utils.py index 912824fa7f3..243bc0f99c9 100644 --- a/src/datasets/utils/py_utils.py +++ b/src/datasets/utils/py_utils.py @@ -736,6 +736,29 @@ def proxy(func): return proxy +if config.DILL_VERSION < version.parse("0.3.6"): + + @pklregister(set) + def _save_set(pickler, obj): + dill._dill.log.info(f"Se: {obj}") + from datasets.fingerprint import Hasher + + args = (sorted(obj, key=Hasher.hash),) + pickler.save_reduce(set, args, obj=obj) + dill._dill.log.info("# Se") + +elif config.DILL_VERSION.release[:3] in [version.parse("0.3.6").release, version.parse("0.3.7").release]: + + @pklregister(set) + def _save_set(pickler, obj): + dill._dill.logger.trace(pickler, "Se: %s", obj) + from datasets.fingerprint import Hasher + + args = (sorted(obj, key=Hasher.hash),) + pickler.save_reduce(set, args, obj=obj) + dill._dill.logger.trace(pickler, "# Se") + + if config.DILL_VERSION < version.parse("0.3.6"): @pklregister(CodeType)	diff --git a/tests/test_fingerprint.py b/tests/test_fingerprint.py index 5538f27554e..f4d5d65744e 100644 --- a/tests/test_fingerprint.py +++ b/tests/test_fingerprint.py @@ -2,6 +2,7 @@ import os import pickle import subprocess +from functools import partial from hashlib import md5 from pathlib import Path from tempfile import gettempdir @@ -10,6 +11,7 @@ from unittest import TestCase from unittest.mock import patch +import numpy as np import pytest from multiprocess import Pool @@ -254,6 +256,22 @@ def test_hash_same_strings(self): self.assertEqual(hash1, hash2) self.assertEqual(hash1, hash3) + def test_set_stable(self): + rng = np.random.default_rng(42) + set_ = {rng.random() for _ in range(10_000)} + expected_hash = Hasher.hash(set_) + assert expected_hash == Pool(1).apply_async(partial(Hasher.hash, set(set_))).get() + + def test_set_doesnt_depend_on_order(self): + set_ = set("abc") + hash1 = md5(datasets.utils.py_utils.dumps(set_)).hexdigest() + set_ = set("def") + hash2 = md5(datasets.utils.py_utils.dumps(set_)).hexdigest() + set_ = set("cba") + hash3 = md5(datasets.utils.py_utils.dumps(set_)).hexdigest() + self.assertEqual(hash1, hash3) + self.assertNotEqual(hash1, hash2) + @require_tiktoken def test_hash_tiktoken_encoding(self): import tiktoken		[ { "components": [ { "doc": "", "lines": [ 753, 759 ], "name": "_save_set", "signature": "def _save_set(pickler, obj):", "type": "function" } ], "file": "src/datasets/utils/py_utils.py" } ]	[ "tests/test_fingerprint.py::HashingTest::test_set_stable" ]	[ "tests/test_fingerprint.py::RecurseDumpTest::test_dump_ignores_line_definition_of_function", "tests/test_fingerprint.py::RecurseDumpTest::test_dump_ipython_function", "tests/test_fingerprint.py::RecurseDumpTest::test_recurse_dump_for_class", "tests/test_fingerprint.py::RecurseDumpTest::test_recurse_dump_for_f...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Deterministic set hash Sort the items in a set according to their `datasets.fingerprint.Hasher.hash` hash to get a deterministic hash of sets. This is useful to get deterministic hashes of tokenizers that use a trie based on python sets. reported in https://github.com/huggingface/datasets/issues/3847 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/datasets/utils/py_utils.py] (definition of _save_set:) def _save_set(pickler, obj): [end of new definitions in src/datasets/utils/py_utils.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		5142a8cf61d8a4495eda3d91dc4283a6df01ea14
roboflow__supervision-500	500	roboflow/supervision	null	aed9221307104c0b0ffcf3f3dcffdbf971031e62	2023-10-18T22:30:42Z	diff --git a/supervision/__init__.py b/supervision/__init__.py index 16de484a3..816142b90 100644 --- a/supervision/__init__.py +++ b/supervision/__init__.py @@ -44,6 +44,7 @@ from supervision.detection.tools.smoother import DetectionsSmoother from supervision.detection.utils import ( box_iou_batch, + box_non_max_merge, box_non_max_suppression, calculate_masks_centroids, clip_boxes, diff --git a/supervision/detection/core.py b/supervision/detection/core.py index 0ba9e4f42..f85d403d7 100644 --- a/supervision/detection/core.py +++ b/supervision/detection/core.py @@ -8,6 +8,8 @@ from supervision.config import CLASS_NAME_DATA_FIELD, ORIENTED_BOX_COORDINATES from supervision.detection.utils import ( + box_iou_batch, + box_non_max_merge, box_non_max_suppression, calculate_masks_centroids, extract_ultralytics_masks, @@ -1150,3 +1152,193 @@ def with_nms( ) return self[indices] + + def with_nmm( + self, threshold: float = 0.5, class_agnostic: bool = False + ) -> Detections: + """ + Perform non-maximum merging on the current set of object detections. + + Args: + threshold (float, optional): The intersection-over-union threshold + to use for non-maximum merging. Defaults to 0.5. + class_agnostic (bool, optional): Whether to perform class-agnostic + non-maximum merging. If True, the class_id of each detection + will be ignored. Defaults to False. + + Returns: + Detections: A new Detections object containing the subset of detections + after non-maximum merging. + + Raises: + AssertionError: If `confidence` is None or `class_id` is None and + class_agnostic is False. + """ + if len(self) == 0: + return self + + assert ( + self.confidence is not None + ), "Detections confidence must be given for NMM to be executed." + + if class_agnostic: + predictions = np.hstack((self.xyxy, self.confidence.reshape(-1, 1))) + else: + assert self.class_id is not None, ( + "Detections class_id must be given for NMM to be executed. If you" + " intended to perform class agnostic NMM set class_agnostic=True." + ) + predictions = np.hstack( + ( + self.xyxy, + self.confidence.reshape(-1, 1), + self.class_id.reshape(-1, 1), + ) + ) + + merge_groups = box_non_max_merge( + predictions=predictions, iou_threshold=threshold + ) + + result = [] + for merge_group in merge_groups: + unmerged_detections = [self[i] for i in merge_group] + merged_detections = merge_inner_detections_objects( + unmerged_detections, threshold + ) + result.append(merged_detections) + + return Detections.merge(result) + + +def merge_inner_detection_object_pair( + detections_1: Detections, detections_2: Detections +) -> Detections: + """ + Merges two Detections object into a single Detections object. + Assumes each Detections contains exactly one object. + + A `winning` detection is determined based on the confidence score of the two + input detections. This winning detection is then used to specify which + `class_id`, `tracker_id`, and `data` to include in the merged Detections object. + + The resulting `confidence` of the merged object is calculated by the weighted + contribution of ea detection to the merged object. + The bounding boxes and masks of the two input detections are merged into a + single bounding box and mask, respectively. + + Args: + detections_1 (Detections): + The first Detections object + detections_2 (Detections): + The second Detections object + + Returns: + Detections: A new Detections object, with merged attributes. + + Raises: + ValueError: If the input Detections objects do not have exactly 1 detected + object. + + Example: + ```python + import cv2 + import supervision as sv + from inference import get_model + + image = cv2.imread(<SOURCE_IMAGE_PATH>) + model = get_model(model_id="yolov8s-640") + + result = model.infer(image)[0] + detections = sv.Detections.from_inference(result) + + merged_detections = merge_object_detection_pair( + detections[0], detections[1]) + ``` + """ + if len(detections_1) != 1 or len(detections_2) != 1: + raise ValueError("Both Detections should have exactly 1 detected object.") + + validate_fields_both_defined_or_none(detections_1, detections_2) + + xyxy_1 = detections_1.xyxy[0] + xyxy_2 = detections_2.xyxy[0] + if detections_1.confidence is None and detections_2.confidence is None: + merged_confidence = None + else: + detection_1_area = (xyxy_1[2] - xyxy_1[0]) * (xyxy_1[3] - xyxy_1[1]) + detections_2_area = (xyxy_2[2] - xyxy_2[0]) * (xyxy_2[3] - xyxy_2[1]) + merged_confidence = ( + detection_1_area * detections_1.confidence[0] + + detections_2_area * detections_2.confidence[0] + ) / (detection_1_area + detections_2_area) + merged_confidence = np.array([merged_confidence]) + + merged_x1, merged_y1 = np.minimum(xyxy_1[:2], xyxy_2[:2]) + merged_x2, merged_y2 = np.maximum(xyxy_1[2:], xyxy_2[2:]) + merged_xyxy = np.array([[merged_x1, merged_y1, merged_x2, merged_y2]]) + + if detections_1.mask is None and detections_2.mask is None: + merged_mask = None + else: + merged_mask = np.logical_or(detections_1.mask, detections_2.mask) + + if detections_1.confidence is None and detections_2.confidence is None: + winning_detection = detections_1 + elif detections_1.confidence[0] >= detections_2.confidence[0]: + winning_detection = detections_1 + else: + winning_detection = detections_2 + + return Detections( + xyxy=merged_xyxy, + mask=merged_mask, + confidence=merged_confidence, + class_id=winning_detection.class_id, + tracker_id=winning_detection.tracker_id, + data=winning_detection.data, + ) + + +def merge_inner_detections_objects( + detections: List[Detections], threshold=0.5 +) -> Detections: + """ + Given N detections each of length 1 (exactly one object inside), combine them into a + single detection object of length 1. The contained inner object will be the merged + result of all the input detections. + + For example, this lets you merge N boxes into one big box, N masks into one mask, + etc. + """ + detections_1 = detections[0] + for detections_2 in detections[1:]: + box_iou = box_iou_batch(detections_1.xyxy, detections_2.xyxy)[0] + if box_iou < threshold: + break + detections_1 = merge_inner_detection_object_pair(detections_1, detections_2) + return detections_1 + + +def validate_fields_both_defined_or_none( + detections_1: Detections, detections_2: Detections +) -> None: + """ + Verify that for each optional field in the Detections, both instances either have + the field set to None or both have it set to non-None values. + + `data` field is ignored. + + Raises: + ValueError: If one field is None and the other is not, for any of the fields. + """ + attributes = ["mask", "confidence", "class_id", "tracker_id"] + for attribute in attributes: + value_1 = getattr(detections_1, attribute) + value_2 = getattr(detections_2, attribute) + + if (value_1 is None) != (value_2 is None): + raise ValueError( + f"Field '{attribute}' should be consistently None or not None in both " + "Detections." + ) diff --git a/supervision/detection/utils.py b/supervision/detection/utils.py index 9232089e5..74726995e 100644 --- a/supervision/detection/utils.py +++ b/supervision/detection/utils.py @@ -3,6 +3,7 @@ import cv2 import numpy as np +import numpy.typing as npt from supervision.config import CLASS_NAME_DATA_FIELD @@ -274,6 +275,91 @@ def box_non_max_suppression( return keep[sort_index.argsort()] +def group_overlapping_boxes( + predictions: npt.NDArray[np.float64], iou_threshold: float = 0.5 +) -> List[List[int]]: + """ + Apply greedy version of non-maximum merging to avoid detecting too many + overlapping bounding boxes for a given object. + + Args: + predictions (npt.NDArray[np.float64]): An array of shape `(n, 5)` containing + the bounding boxes coordinates in format `[x1, y1, x2, y2]` + and the confidence scores. + iou_threshold (float, optional): The intersection-over-union threshold + to use for non-maximum suppression. Defaults to 0.5. + + Returns: + List[List[int]]: Groups of prediction indices be merged. + Each group may have 1 or more elements. + """ + merge_groups: List[List[int]] = [] + + scores = predictions[:, 4] + order = scores.argsort() + + while len(order) > 0: + idx = int(order[-1]) + + order = order[:-1] + if len(order) == 0: + merge_groups.append([idx]) + break + + merge_candidate = np.expand_dims(predictions[idx], axis=0) + ious = box_iou_batch(predictions[order][:, :4], merge_candidate[:, :4]) + ious = ious.flatten() + + above_threshold = ious >= iou_threshold + merge_group = [idx] + np.flip(order[above_threshold]).tolist() + merge_groups.append(merge_group) + order = order[~above_threshold] + return merge_groups + + +def box_non_max_merge( + predictions: npt.NDArray[np.float64], + iou_threshold: float = 0.5, +) -> List[List[int]]: + """ + Apply greedy version of non-maximum merging per category to avoid detecting + too many overlapping bounding boxes for a given object. + + Args: + predictions (npt.NDArray[np.float64]): An array of shape `(n, 5)` or `(n, 6)` + containing the bounding boxes coordinates in format `[x1, y1, x2, y2]`, + the confidence scores and class_ids. Omit class_id column to allow + detections of different classes to be merged. + iou_threshold (float, optional): The intersection-over-union threshold + to use for non-maximum suppression. Defaults to 0.5. + + Returns: + List[List[int]]: Groups of prediction indices be merged. + Each group may have 1 or more elements. + """ + if predictions.shape[1] == 5: + return group_overlapping_boxes(predictions, iou_threshold) + + category_ids = predictions[:, 5] + merge_groups = [] + for category_id in np.unique(category_ids): + curr_indices = np.where(category_ids == category_id)[0] + merge_class_groups = group_overlapping_boxes( + predictions[curr_indices], iou_threshold + ) + + for merge_class_group in merge_class_groups: + merge_groups.append(curr_indices[merge_class_group].tolist()) + + for merge_group in merge_groups: + if len(merge_group) == 0: + raise ValueError( + f"Empty group detected when non-max-merging " + f"detections: {merge_groups}" + ) + return merge_groups + + def clip_boxes(xyxy: np.ndarray, resolution_wh: Tuple[int, int]) -> np.ndarray: """ Clips bounding boxes coordinates to fit within the frame resolution. @@ -346,7 +432,7 @@ def mask_to_xyxy(masks: np.ndarray) -> np.ndarray: `(x_min, y_min, x_max, y_max)` for each mask """ n = masks.shape[0] - bboxes = np.zeros((n, 4), dtype=int) + xyxy = np.zeros((n, 4), dtype=int) for i, mask in enumerate(masks): rows, cols = np.where(mask) @@ -354,9 +440,9 @@ def mask_to_xyxy(masks: np.ndarray) -> np.ndarray: if len(rows) > 0 and len(cols) > 0: x_min, x_max = np.min(cols), np.max(cols) y_min, y_max = np.min(rows), np.max(rows) - bboxes[i, :] = [x_min, y_min, x_max, y_max] + xyxy[i, :] = [x_min, y_min, x_max, y_max] - return bboxes + return xyxy def mask_to_polygons(mask: np.ndarray) -> List[np.ndarray]: @@ -592,16 +678,18 @@ def process_roboflow_result( return xyxy, confidence, class_id, masks, tracker_id, data -def move_boxes(xyxy: np.ndarray, offset: np.ndarray) -> np.ndarray: +def move_boxes( + xyxy: npt.NDArray[np.float64], offset: npt.NDArray[np.int32] +) -> npt.NDArray[np.float64]: """ Parameters: - xyxy (np.ndarray): An array of shape `(n, 4)` containing the bounding boxes - coordinates in format `[x1, y1, x2, y2]` + xyxy (npt.NDArray[np.float64]): An array of shape `(n, 4)` containing the + bounding boxes coordinates in format `[x1, y1, x2, y2]` offset (np.array): An array of shape `(2,)` containing offset values in format is `[dx, dy]`. Returns: - np.ndarray: Repositioned bounding boxes. + npt.NDArray[np.float64]: Repositioned bounding boxes. Example: ```python @@ -622,24 +710,25 @@ def move_boxes(xyxy: np.ndarray, offset: np.ndarray) -> np.ndarray: def move_masks( - masks: np.ndarray, - offset: np.ndarray, - resolution_wh: Tuple[int, int] = None, -) -> np.ndarray: + masks: npt.NDArray[np.bool_], + offset: npt.NDArray[np.int32], + resolution_wh: Tuple[int, int], +) -> npt.NDArray[np.bool_]: """ Offset the masks in an array by the specified (x, y) amount. Args: - masks (np.ndarray): A 3D array of binary masks corresponding to the predictions. - Shape: `(N, H, W)`, where N is the number of predictions, and H, W are the - dimensions of each mask. - offset (np.ndarray): An array of shape `(2,)` containing non-negative int values - `[dx, dy]`. + masks (npt.NDArray[np.bool_]): A 3D array of binary masks corresponding to the + predictions. Shape: `(N, H, W)`, where N is the number of predictions, and + H, W are the dimensions of each mask. + offset (npt.NDArray[np.int32]): An array of shape `(2,)` containing non-negative + int values `[dx, dy]`. resolution_wh (Tuple[int, int]): The width and height of the desired mask resolution. Returns: - (np.ndarray) repositioned masks, optionally padded to the specified shape. + (npt.NDArray[np.bool_]) repositioned masks, optionally padded to the specified + shape. """ if offset[0] < 0 or offset[1] < 0: @@ -655,19 +744,21 @@ def move_masks( return mask_array -def scale_boxes(xyxy: np.ndarray, factor: float) -> np.ndarray: +def scale_boxes( + xyxy: npt.NDArray[np.float64], factor: float +) -> npt.NDArray[np.float64]: """ Scale the dimensions of bounding boxes. Parameters: - xyxy (np.ndarray): An array of shape `(n, 4)` containing the bounding boxes - coordinates in format `[x1, y1, x2, y2]` + xyxy (npt.NDArray[np.float64]): An array of shape `(n, 4)` containing the + bounding boxes coordinates in format `[x1, y1, x2, y2]` factor (float): A float value representing the factor by which the box dimensions are scaled. A factor greater than 1 enlarges the boxes, while a factor less than 1 shrinks them. Returns: - np.ndarray: Scaled bounding boxes. + npt.NDArray[np.float64]: Scaled bounding boxes. Example: ```python @@ -735,19 +826,19 @@ def is_data_equal(data_a: Dict[str, np.ndarray], data_b: Dict[str, np.ndarray]) def merge_data( - data_list: List[Dict[str, Union[np.ndarray, List]]], -) -> Dict[str, Union[np.ndarray, List]]: + data_list: List[Dict[str, Union[npt.NDArray[np.generic], List]]], +) -> Dict[str, Union[npt.NDArray[np.generic], List]]: """ Merges the data payloads of a list of Detections instances. Args: data_list: The data payloads of the Detections instances. Each data payload is a dictionary with the same keys, and the values are either lists or - np.ndarray. + npt.NDArray[np.generic]. Returns: A single data payload containing the merged data, preserving the original data - types (list or np.ndarray). + types (list or npt.NDArray[np.generic]). Raises: ValueError: If data values within a single object have different lengths or if	diff --git a/test/detection/test_core.py b/test/detection/test_core.py index 12f3de281..af1d58762 100644 --- a/test/detection/test_core.py +++ b/test/detection/test_core.py @@ -5,7 +5,7 @@ import numpy as np import pytest -from supervision.detection.core import Detections +from supervision.detection.core import Detections, merge_inner_detection_object_pair from supervision.geometry.core import Position PREDICTIONS = np.array( @@ -421,3 +421,172 @@ def test_equal( detections_a: Detections, detections_b: Detections, expected_result: bool ) -> None: assert (detections_a == detections_b) == expected_result + + +@pytest.mark.parametrize( + "detection_1, detection_2, expected_result, exception", + [ + ( + mock_detections( + xyxy=[[10, 10, 30, 30]], + ), + mock_detections( + xyxy=[[10, 10, 30, 30]], + ), + mock_detections( + xyxy=[[10, 10, 30, 30]], + ), + DoesNotRaise(), + ), # Merge with self + ( + mock_detections( + xyxy=[[10, 10, 30, 30]], + ), + Detections.empty(), + None, + pytest.raises(ValueError), + ), # merge with empty: error + ( + mock_detections( + xyxy=[[10, 10, 30, 30]], + ), + mock_detections( + xyxy=[[10, 10, 30, 30], [40, 40, 60, 60]], + ), + None, + pytest.raises(ValueError), + ), # merge with 2+ objects: error + ( + mock_detections( + xyxy=[[10, 10, 30, 30]], + confidence=[0.1], + class_id=[1], + mask=[np.array([[1, 1, 0], [1, 1, 0], [0, 0, 0]], dtype=bool)], + tracker_id=[1], + data={"key_1": [1]}, + ), + mock_detections( + xyxy=[[20, 20, 40, 40]], + confidence=[0.1], + class_id=[2], + mask=[np.array([[0, 0, 0], [0, 1, 1], [0, 1, 1]], dtype=bool)], + tracker_id=[2], + data={"key_2": [2]}, + ), + mock_detections( + xyxy=[[10, 10, 40, 40]], + confidence=[0.1], + class_id=[1], + mask=[np.array([[1, 1, 0], [1, 1, 1], [0, 1, 1]], dtype=bool)], + tracker_id=[1], + data={"key_1": [1]}, + ), + DoesNotRaise(), + ), # Same confidence - merge box & mask, tie-break to detection_1 + ( + mock_detections( + xyxy=[[0, 0, 20, 20]], + confidence=[0.1], + class_id=[1], + mask=[np.array([[1, 1, 0], [1, 1, 0], [0, 0, 0]], dtype=bool)], + tracker_id=[1], + data={"key_1": [1]}, + ), + mock_detections( + xyxy=[[10, 10, 50, 50]], + confidence=[0.2], + class_id=[2], + mask=[np.array([[0, 0, 0], [0, 1, 1], [0, 1, 1]], dtype=bool)], + tracker_id=[2], + data={"key_2": [2]}, + ), + mock_detections( + xyxy=[[0, 0, 50, 50]], + confidence=[(1 * 0.1 + 4 * 0.2) / 5], + class_id=[2], + mask=[np.array([[1, 1, 0], [1, 1, 1], [0, 1, 1]], dtype=bool)], + tracker_id=[2], + data={"key_2": [2]}, + ), + DoesNotRaise(), + ), # Different confidence, different area + ( + mock_detections( + xyxy=[[10, 10, 30, 30]], + confidence=None, + class_id=[1], + mask=[np.array([[1, 1, 0], [1, 1, 0], [0, 0, 0]], dtype=bool)], + tracker_id=[1], + data={"key_1": [1]}, + ), + mock_detections( + xyxy=[[20, 20, 40, 40]], + confidence=None, + class_id=[2], + mask=[np.array([[0, 0, 0], [0, 1, 1], [0, 1, 1]], dtype=bool)], + tracker_id=[2], + data={"key_2": [2]}, + ), + mock_detections( + xyxy=[[10, 10, 40, 40]], + confidence=None, + class_id=[1], + mask=[np.array([[1, 1, 0], [1, 1, 1], [0, 1, 1]], dtype=bool)], + tracker_id=[1], + data={"key_1": [1]}, + ), + DoesNotRaise(), + ), # No confidence at all + ( + mock_detections( + xyxy=[[0, 0, 20, 20]], + confidence=None, + ), + mock_detections( + xyxy=[[10, 10, 30, 30]], + confidence=[0.2], + ), + None, + pytest.raises(ValueError), + ), # confidence: None + [x] + ( + mock_detections( + xyxy=[[0, 0, 20, 20]], + mask=[np.array([[1, 1, 0], [1, 1, 0], [0, 0, 0]], dtype=bool)], + ), + mock_detections( + xyxy=[[10, 10, 30, 30]], + mask=None, + ), + None, + pytest.raises(ValueError), + ), # mask: None + [x] + ( + mock_detections(xyxy=[[0, 0, 20, 20]], tracker_id=[1]), + mock_detections( + xyxy=[[10, 10, 30, 30]], + tracker_id=None, + ), + None, + pytest.raises(ValueError), + ), # tracker_id: None + [] + ( + mock_detections(xyxy=[[0, 0, 20, 20]], class_id=[1]), + mock_detections( + xyxy=[[10, 10, 30, 30]], + class_id=None, + ), + None, + pytest.raises(ValueError), + ), # class_id: None + [] + ], +) +def test_merge_inner_detection_object_pair( + detection_1: Detections, + detection_2: Detections, + expected_result: Optional[Detections], + exception: Exception, +): + with exception: + result = merge_inner_detection_object_pair(detection_1, detection_2) + assert result == expected_result diff --git a/test/detection/test_utils.py b/test/detection/test_utils.py index 097c5c6e5..b62faa619 100644 --- a/test/detection/test_utils.py +++ b/test/detection/test_utils.py @@ -11,6 +11,7 @@ clip_boxes, filter_polygons_by_area, get_data_item, + group_overlapping_boxes, mask_non_max_suppression, merge_data, move_boxes, @@ -127,6 +128,133 @@ def test_box_non_max_suppression( assert np.array_equal(result, expected_result) +@pytest.mark.parametrize( + "predictions, iou_threshold, expected_result, exception", + [ + ( + np.empty(shape=(0, 5), dtype=float), + 0.5, + [], + DoesNotRaise(), + ), + ( + np.array([[0, 0, 10, 10, 1.0]]), + 0.5, + [[0]], + DoesNotRaise(), + ), + ( + np.array([[0, 0, 10, 10, 1.0], [0, 0, 9, 9, 1.0]]), + 0.5, + [[1, 0]], + DoesNotRaise(), + ), # High overlap, tie-break to second det + ( + np.array([[0, 0, 10, 10, 1.0], [0, 0, 9, 9, 0.99]]), + 0.5, + [[0, 1]], + DoesNotRaise(), + ), # High overlap, merge to high confidence + ( + np.array([[0, 0, 10, 10, 0.99], [0, 0, 9, 9, 1.0]]), + 0.5, + [[1, 0]], + DoesNotRaise(), + ), # (test symmetry) High overlap, merge to high confidence + ( + np.array([[0, 0, 10, 10, 0.90], [0, 0, 9, 9, 1.0]]), + 0.5, + [[1, 0]], + DoesNotRaise(), + ), # (test symmetry) High overlap, merge to high confidence + ( + np.array([[0, 0, 10, 10, 1.0], [0, 0, 9, 9, 1.0]]), + 1.0, + [[1], [0]], + DoesNotRaise(), + ), # High IOU required + ( + np.array([[0, 0, 10, 10, 1.0], [0, 0, 9, 9, 1.0]]), + 0.0, + [[1, 0]], + DoesNotRaise(), + ), # No IOU required + ( + np.array([[0, 0, 10, 10, 1.0], [0, 0, 5, 5, 0.9]]), + 0.25, + [[0, 1]], + DoesNotRaise(), + ), # Below IOU requirement + ( + np.array([[0, 0, 10, 10, 1.0], [0, 0, 5, 5, 0.9]]), + 0.26, + [[0], [1]], + DoesNotRaise(), + ), # Above IOU requirement + ( + np.array([[0, 0, 10, 10, 1.0], [0, 0, 9, 9, 1.0], [0, 0, 8, 8, 1.0]]), + 0.5, + [[2, 1, 0]], + DoesNotRaise(), + ), # 3 boxes + ( + np.array( + [ + [0, 0, 10, 10, 1.0], + [0, 0, 9, 9, 1.0], + [5, 5, 10, 10, 1.0], + [6, 6, 10, 10, 1.0], + [9, 9, 10, 10, 1.0], + ] + ), + 0.5, + [[4], [3, 2], [1, 0]], + DoesNotRaise(), + ), # 5 boxes, 2 merges, 1 separate + ( + np.array( + [ + [0, 0, 2, 1, 1.0], + [1, 0, 3, 1, 1.0], + [2, 0, 4, 1, 1.0], + [3, 0, 5, 1, 1.0], + [4, 0, 6, 1, 1.0], + ] + ), + 0.33, + [[4, 3], [2, 1], [0]], + DoesNotRaise(), + ), # sequential merge, half overlap + ( + np.array( + [ + [0, 0, 2, 1, 0.9], + [1, 0, 3, 1, 0.9], + [2, 0, 4, 1, 1.0], + [3, 0, 5, 1, 0.9], + [4, 0, 6, 1, 0.9], + ] + ), + 0.33, + [[2, 3, 1], [4], [0]], + DoesNotRaise(), + ), # confidence + ], +) +def test_group_overlapping_boxes( + predictions: np.ndarray, + iou_threshold: float, + expected_result: List[List[int]], + exception: Exception, +) -> None: + with exception: + result = group_overlapping_boxes( + predictions=predictions, iou_threshold=iou_threshold + ) + + assert result == expected_result + + @pytest.mark.parametrize( "predictions, masks, iou_threshold, expected_result, exception", [		[ { "components": [ { "doc": "Perform non-maximum merging on the current set of object detections.\n\nArgs:\n threshold (float, optional): The intersection-over-union threshold\n to use for non-maximum merging. Defaults to 0.5.\n class_agnostic (bool, optional): Whether to perform class...	[ "test/detection/test_core.py::test_getitem[detections0-index0-expected_result0-exception0]", "test/detection/test_core.py::test_getitem[detections1-index1-expected_result1-exception1]", "test/detection/test_core.py::test_getitem[detections2-index2-expected_result2-exception2]", "test/detection/test_core.py::t...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add Non-Maximum Merging (NMM) to Detections # Description Currently it is only possible to apply Non-Maximum Suppression (NMS) to Detections. In an attempt to increase the accuracy of object detection and segmentation, especially when using the InferenceSlicer, I added the ability to apply NMM instead of NMS to the merged Detections [merge_detections](https://github.com/mario-dg/supervision/blob/6f4704625b16ba69068b3a19f6d55bc21c80c434/supervision/detection/tools/inference_slicer.py#L125C8-L125C8). NMM merges bounding boxes and masks, that would have originally been discarded, when applying NMS. This results in more accurate detections/segmentations. The implementation of this algorithm closely follows the one from [SAHI](https://github.com/obss/sahi/blob/b115f08f0c0aeeb151adf24e47c222d3483cc931/sahi/postprocess/combine.py#L533). In addition, also inspired by SAHI, the InferenceSlicer can increase the detection accuracy of larger objects, by running inference on the whole image on top of all slices [perform_standard_pred](https://github.com/mario-dg/supervision/blob/6f4704625b16ba69068b3a19f6d55bc21c80c434/supervision/detection/tools/inference_slicer.py#L122C8-L122C8). The whole image detections will be merged with the sliced image detections. I would be happy to discuss implementation changes and design choices. This PR should serve as a first implementation and is far from perfect. Any ideas, critic or comments are more than welcome :) ## Type of change Please delete options that are not relevant. - [x] New feature (non-breaking change which adds functionality) - [x] This change requires a documentation update ## How has this change been tested, please provide a testcase or example of how you tested the change? NMS: ![nms](https://github.com/roboflow/supervision/assets/46304415/f932d262-a262-4221-a4ba-20cdaa42e4ba) NMM: ![nmm](https://github.com/roboflow/supervision/assets/46304415/52d213c6-335e-4ad1-83a5-11620ae4b9ad) SAHI: ![sahi](https://github.com/roboflow/supervision/assets/46304415/21ac5442-dcfa-4d77-8677-bb69bfca70ee) The code sample that was used to create these two images: ```python import cv2 import numpy as np import supervision as sv from supervision.detection.core import Detections from supervision.detection.tools.inference_slicer import InferenceSlicer from PIL import Image from ultralytics.models.yolo import YOLO model = YOLO("yolov8s.pt") def callback(x): result = model(x[:, :, ::-1])[0] dets = Detections.from_ultralytics(result) return dets[dets.confidence > 0.3] # get image from here: https://ultralytics.com/images/bus.jpg slicer = InferenceSlicer(callback=callback, slice_wh=(512, 512), overlap_ratio_wh=(0.4, 0.4), iou_threshold=0.1, merge_detections=True, perform_standard_pred=True) ba = sv.BoundingBoxAnnotator() la = sv.LabelAnnotator() image = np.array(Image.open("bus.jpg")) nmm_dets = slicer(image) nmm_ann = ba.annotate(scene=image.copy(), detections=nmm_dets) nmm_ann = la.annotate(scene=nmm_ann, detections=nmm_dets) cv2.imwrite("nmm.jpg", nmm_ann) slicer.merge_detections = False nms_dets = slicer(image) nms_ann = ba.annotate(scene=image.copy(), detections=nms_dets) nms_ann = la.annotate(scene=nms_ann, detections=nms_dets) cv2.imwrite("bms.jpg", nms_ann) ``` ## Any specific deployment considerations The two additional parameters that were added to InferenceSlicer are optional and default to `False`, thus neither breaking, nor changing the results of existing implementations. ## Docs - [ ] Docs updated? What were the changes: I will update the docs in the near future. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in supervision/detection/core.py] (definition of Detections.with_nmm:) def with_nmm( self, threshold: float = 0.5, class_agnostic: bool = False ) -> Detections: """Perform non-maximum merging on the current set of object detections. Args: threshold (float, optional): The intersection-over-union threshold to use for non-maximum merging. Defaults to 0.5. class_agnostic (bool, optional): Whether to perform class-agnostic non-maximum merging. If True, the class_id of each detection will be ignored. Defaults to False. Returns: Detections: A new Detections object containing the subset of detections after non-maximum merging. Raises: AssertionError: If `confidence` is None or `class_id` is None and class_agnostic is False.""" (definition of merge_inner_detection_object_pair:) def merge_inner_detection_object_pair( detections_1: Detections, detections_2: Detections ) -> Detections: """Merges two Detections object into a single Detections object. Assumes each Detections contains exactly one object. A `winning` detection is determined based on the confidence score of the two input detections. This winning detection is then used to specify which `class_id`, `tracker_id`, and `data` to include in the merged Detections object. The resulting `confidence` of the merged object is calculated by the weighted contribution of ea detection to the merged object. The bounding boxes and masks of the two input detections are merged into a single bounding box and mask, respectively. Args: detections_1 (Detections): The first Detections object detections_2 (Detections): The second Detections object Returns: Detections: A new Detections object, with merged attributes. Raises: ValueError: If the input Detections objects do not have exactly 1 detected object. Example: ```python import cv2 import supervision as sv from inference import get_model image = cv2.imread(<SOURCE_IMAGE_PATH>) model = get_model(model_id="yolov8s-640") result = model.infer(image)[0] detections = sv.Detections.from_inference(result) merged_detections = merge_object_detection_pair( detections[0], detections[1]) ```""" (definition of merge_inner_detections_objects:) def merge_inner_detections_objects( detections: List[Detections], threshold=0.5 ) -> Detections: """Given N detections each of length 1 (exactly one object inside), combine them into a single detection object of length 1. The contained inner object will be the merged result of all the input detections. For example, this lets you merge N boxes into one big box, N masks into one mask, etc.""" (definition of validate_fields_both_defined_or_none:) def validate_fields_both_defined_or_none( detections_1: Detections, detections_2: Detections ) -> None: """Verify that for each optional field in the Detections, both instances either have the field set to None or both have it set to non-None values. `data` field is ignored. Raises: ValueError: If one field is None and the other is not, for any of the fields.""" [end of new definitions in supervision/detection/core.py] [start of new definitions in supervision/detection/utils.py] (definition of group_overlapping_boxes:) def group_overlapping_boxes( predictions: npt.NDArray[np.float64], iou_threshold: float = 0.5 ) -> List[List[int]]: """Apply greedy version of non-maximum merging to avoid detecting too many overlapping bounding boxes for a given object. Args: predictions (npt.NDArray[np.float64]): An array of shape `(n, 5)` containing the bounding boxes coordinates in format `[x1, y1, x2, y2]` and the confidence scores. iou_threshold (float, optional): The intersection-over-union threshold to use for non-maximum suppression. Defaults to 0.5. Returns: List[List[int]]: Groups of prediction indices be merged. Each group may have 1 or more elements.""" (definition of box_non_max_merge:) def box_non_max_merge( predictions: npt.NDArray[np.float64], iou_threshold: float = 0.5, ) -> List[List[int]]: """Apply greedy version of non-maximum merging per category to avoid detecting too many overlapping bounding boxes for a given object. Args: predictions (npt.NDArray[np.float64]): An array of shape `(n, 5)` or `(n, 6)` containing the bounding boxes coordinates in format `[x1, y1, x2, y2]`, the confidence scores and class_ids. Omit class_id column to allow detections of different classes to be merged. iou_threshold (float, optional): The intersection-over-union threshold to use for non-maximum suppression. Defaults to 0.5. Returns: List[List[int]]: Groups of prediction indices be merged. Each group may have 1 or more elements.""" [end of new definitions in supervision/detection/utils.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		3eb5c0b024e3e46877b7fe4fd66e6177d1308ba0
joke2k__faker-1932	1,932	joke2k/faker	null	4cc139115e5201e353ccd662cfdefcbb50082c14	2023-10-18T05:32:20Z	diff --git a/faker/providers/color/cs_CZ/__init__.py b/faker/providers/color/cs_CZ/__init__.py new file mode 100644 index 0000000000..507f1451a5 --- /dev/null +++ b/faker/providers/color/cs_CZ/__init__.py @@ -0,0 +1,23 @@ +from .. import Provider as ColorProvider + + +class Provider(ColorProvider): + """Implement color provider for ``cs_CZ`` locale.""" + + safe_colors = ( + "černá", + "kaštanová", + "zelená", + "námořnická", + "olivová", + "fialová", + "zelenomodrá", + "limetková", + "modrá", + "stříbrná", + "šedá", + "žlutá", + "fuchsiová", + "aquamarinová", + "bílá", + )	diff --git a/tests/providers/test_color.py b/tests/providers/test_color.py index 608277eb8e..9c581e90a1 100644 --- a/tests/providers/test_color.py +++ b/tests/providers/test_color.py @@ -16,6 +16,7 @@ from faker.providers.color.hy_AM import Provider as HyAmColorProvider from faker.providers.color.id_ID import Provider as IdIdColorProvider from faker.providers.color.sk_SK import Provider as SkSkColorProvider +from faker.providers.color.cs_CZ import Provider as CsCzColorProvider class TestColorProvider: @@ -401,6 +402,15 @@ def test_safe_color_name(self, faker, num_samples): assert isinstance(safe_color_name, str) assert safe_color_name in SkSkColorProvider.safe_colors +class TestCsCz: + """Test cs_CZ color provider methods""" + + def test_safe_color_name(self, faker, num_samples): + for _ in range(num_samples): + safe_color_name = faker.safe_color_name() + assert isinstance(safe_color_name, str) + assert safe_color_name in CsCzColorProvider.safe_colors + class TestHeIl: """Test he_IL color provider methods"""		[ { "components": [ { "doc": "Implement color provider for ``cs_CZ`` locale.", "lines": [ 4, 22 ], "name": "Provider", "signature": "class Provider(ColorProvider):", "type": "class" } ], "file": "faker/providers/color/cs_CZ/__...	[ "tests/providers/test_color.py::TestColorProvider::test_safe_hex_color", "tests/providers/test_color.py::TestColorProvider::test_hex_color", "tests/providers/test_color.py::TestColorProvider::test_rgb_color", "tests/providers/test_color.py::TestColorProvider::test_rgb_css_color", "tests/providers/test_color...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Color for cs_CZ ### What does this change Add provider for color for cs_CZ ### What was wrong Missing color provider for cs_CZ ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in faker/providers/color/cs_CZ/__init__.py] (definition of Provider:) class Provider(ColorProvider): """Implement color provider for ``cs_CZ`` locale.""" [end of new definitions in faker/providers/color/cs_CZ/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		6edfdbf6ae90b0153309e3bf066aa3b2d16494a7
tobymao__sqlglot-2417	2,417	tobymao/sqlglot	null	77446481dd59c213368fe554e8011e9a7f5c0f71	2023-10-17T16:17:51Z	diff --git a/sqlglot/dataframe/sql/functions.py b/sqlglot/dataframe/sql/functions.py index d98feeec9e..7043086464 100644 --- a/sqlglot/dataframe/sql/functions.py +++ b/sqlglot/dataframe/sql/functions.py @@ -1113,7 +1113,7 @@ def reverse(col: ColumnOrName) -> Column: def flatten(col: ColumnOrName) -> Column: - return Column.invoke_anonymous_function(col, "FLATTEN") + return Column.invoke_expression_over_column(None, expression.Flatten, expressions=[col]) def map_keys(col: ColumnOrName) -> Column: diff --git a/sqlglot/dialects/snowflake.py b/sqlglot/dialects/snowflake.py index fc3e0faa93..e319ebb10d 100644 --- a/sqlglot/dialects/snowflake.py +++ b/sqlglot/dialects/snowflake.py @@ -262,6 +262,7 @@ class Parser(parser.Parser): ), "DATEDIFF": _parse_datediff, "DIV0": _div0_to_if, + "FLATTEN": exp.Explode.from_arg_list, "IFF": exp.If.from_arg_list, "LISTAGG": exp.GroupConcat.from_arg_list, "NULLIFZERO": _nullifzero_to_if, @@ -325,6 +326,22 @@ class Parser(parser.Parser): TokenType.MOD, TokenType.SLASH, } + FLATTEN_COLUMNS = ["SEQ", "KEY", "PATH", "INDEX", "VALUE", "THIS"] + + def _parse_lateral(self) -> t.Optional[exp.Lateral]: + lateral = super()._parse_lateral() + if not lateral: + return lateral + + if isinstance(lateral.this, exp.Explode): + table_alias = lateral.args.get("alias") + columns = [exp.to_identifier(col) for col in self.FLATTEN_COLUMNS] + if table_alias and not table_alias.args.get("columns"): + table_alias.set("columns", columns) + elif not table_alias: + exp.alias_(lateral, "_flattened", table=columns, copy=False) + + return lateral def _parse_table_parts(self, schema: bool = False) -> exp.Table: # https://docs.snowflake.com/en/user-guide/querying-stage @@ -452,6 +469,7 @@ class Generator(generator.Generator): exp.DateStrToDate: datestrtodate_sql, exp.DataType: _datatype_sql, exp.DayOfWeek: rename_func("DAYOFWEEK"), + exp.Explode: rename_func("FLATTEN"), exp.Extract: rename_func("DATE_PART"), exp.GenerateSeries: lambda self, e: self.func( "ARRAY_GENERATE_RANGE", e.args["start"], e.args["end"] + 1, e.args.get("step") diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index b94b1e13b6..897f5320ad 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -4168,6 +4168,11 @@ class Abs(Func): pass +class Flatten(Func): + arg_types = {"expressions": True} + is_var_len_args = True + + # https://spark.apache.org/docs/latest/api/sql/index.html#transform class Transform(Func): arg_types = {"this": True, "expression": True} @@ -4540,8 +4545,10 @@ class Exp(Func): pass +# https://docs.snowflake.com/en/sql-reference/functions/flatten class Explode(Func): - pass + arg_types = {"this": True, "expressions": False} + is_var_len_args = True class ExplodeOuter(Explode):	diff --git a/tests/dialects/test_snowflake.py b/tests/dialects/test_snowflake.py index 7c36bea494..532968636a 100644 --- a/tests/dialects/test_snowflake.py +++ b/tests/dialects/test_snowflake.py @@ -911,7 +911,23 @@ def test_flatten(self): f.value AS "Contact", f1.value['type'] AS "Type", f1.value['content'] AS "Details" -FROM persons AS p, LATERAL FLATTEN(input => p.c, path => 'contact') AS f, LATERAL FLATTEN(input => f.value['business']) AS f1""", +FROM persons AS p, LATERAL FLATTEN(input => p.c, path => 'contact') AS f(SEQ, KEY, PATH, INDEX, VALUE, THIS), LATERAL FLATTEN(input => f.value['business']) AS f1(SEQ, KEY, PATH, INDEX, VALUE, THIS)""", + }, + pretty=True, + ) + + self.validate_all( + """ + SELECT id as "ID", + value AS "Contact" + FROM persons p, + lateral flatten(input => p.c, path => 'contact') + """, + write={ + "snowflake": """SELECT + id AS "ID", + value AS "Contact" +FROM persons AS p, LATERAL FLATTEN(input => p.c, path => 'contact') AS _flattened(SEQ, KEY, PATH, INDEX, VALUE, THIS)""", }, pretty=True, ) diff --git a/tests/test_lineage.py b/tests/test_lineage.py index 0fd9da867d..c3378d7fd8 100644 --- a/tests/test_lineage.py +++ b/tests/test_lineage.py @@ -199,3 +199,22 @@ def test_lineage_union(self) -> None: "SELECT x FROM (SELECT ax AS x FROM a UNION SELECT bx FROM b UNION SELECT cx FROM c)", ) assert len(node.downstream) == 3 + + def test_lineage_lateral_flatten(self) -> None: + node = lineage( + "VALUE", + "SELECT FLATTENED.VALUE FROM TEST_TABLE, LATERAL FLATTEN(INPUT => RESULT, OUTER => TRUE) FLATTENED", + dialect="snowflake", + ) + self.assertEqual(node.name, "VALUE") + + downstream = node.downstream[0] + self.assertEqual(downstream.name, "FLATTENED.VALUE") + self.assertEqual( + downstream.source.sql(dialect="snowflake"), + "LATERAL FLATTEN(INPUT => TEST_TABLE.RESULT, OUTER => TRUE) AS FLATTENED(SEQ, KEY, PATH, INDEX, VALUE, THIS)", + ) + self.assertEqual( + downstream.expression.sql(dialect="snowflake"), + "VALUE", + )		[]	[ "tests/dialects/test_snowflake.py::TestSnowflake::test_flatten", "tests/test_lineage.py::TestLineage::test_lineage_lateral_flatten" ]	[ "tests/dialects/test_snowflake.py::TestSnowflake::test_ddl", "tests/dialects/test_snowflake.py::TestSnowflake::test_describe_table", "tests/dialects/test_snowflake.py::TestSnowflake::test_match_recognize", "tests/dialects/test_snowflake.py::TestSnowflake::test_minus", "tests/dialects/test_snowflake.py::Test...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat(optimizer): qualify lateral flatten for snowflake Adds columns created by the FLATTEN function in snowflake to the TableAlias created when using it in a FROM ..., LATERAL FLATTEN call following the solution suggested by @GeorgeSittas. To get the full lineage I had to make each column created by the function an alias of the flatten function so we could get the lineage back to the source column flatten was reading from. It seems a little gross, so also wanted to check if there should be a exp.Flatten AST node that encapsulates this behaviour instead. Closes #2413 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Support lineage through a LATERAL FLATTEN from clause in Snowflake Is your feature request related to a problem? Please describe. I have a Snowflake SQL query like `SELECT VALUE FROM TABLE_A, LATERAL FLATTEN(TABLE_A.VARIANT_COLUMN)`. I would like to be able to use the `lineage` function to get the lineage tree of the column "VALUE" (in case TABLE_A is actually a subquery, cte, etc). Describe the solution you'd like lineage should understand that VALUE's lineage is through TABLE_A.VARIANT_COLUMN (or through a subquery or CTE in place of TABLE_A). The `FLATTEN` function, when the Snowflake dialect is selected, should be treated as a select expression that adds the columns documented as [its output](https://docs.snowflake.com/en/sql-reference/functions/flatten#output). The lineage tree of value should look something like VALUE -> FLATTEN(TABLE_A>VARIANT_COLUMN) -> TABLE_A.VARIANT_COLUMN -> TABLE_A. Describe alternatives you've considered My plan was to have the Snowflake dialect parser produce a TableAlias expression when it parses a FLATTEN function populated with with the columns produces by the expression. Right now a TableAlias is produced, but it has no columns, so lineage fails raising a ValueError. I'm happy to work on this feature if it's something you want to support in sqlglot but wanted to open this issue to make sure my suggestion of an implementation strategy make sense and is something you'd accept. ---------- I see, what you're suggesting looks reasonable. Just one comment: > My plan was to have the Snowflake dialect parser produce a TableAlias expression when it parses a FLATTEN function populated with with the columns produces by the expression. Right now a TableAlias is produced, but it has no columns, so lineage fails raising a ValueError. I'm not sure if we want to touch Snowflake's parser for this, even though we could. My initial reaction was that this can be solved by adding extra logic to the `qualify_tables` rule in order to emit a `TableAlias` with additional info, i.e. the output columns specified in Snowflake's docs. The downside to this is that we pollute the rule with Snowflake-specific logic, because there's no other way easy way to parameterize how we do stuff per dialect in the optimizer currently. @tobymao what do you think? shouldn't this be done in qualify_columns? it already deals with table column aliases Not sure, what do we gain from doing it there? I figured that `qualify_tables` would allow it to just work for the rest of the optimizer rules. It also feels more natural because we're trying to add more info to a node associated with a table as opposed to, say, expanding stars etc which fits in `qualify_columns` better. Doing it in `qualify_tables` makes sense to me after a quick glance. I had looked at the parser since that seemed like the place to switch on dialect. @edpaget are you planning to work on this? -------------------- </issues>	ceb42fabad60312699e4b15936aeebac00e22e4d
pyvista__pyvista-5055	5,055	pyvista/pyvista	0.43	e574da02bb2c2d7aafb2e8e15f55024505087b56	2023-10-11T23:44:19Z	diff --git a/pyvista/plotting/text.py b/pyvista/plotting/text.py index b5e0292d364..492990d6ed0 100644 --- a/pyvista/plotting/text.py +++ b/pyvista/plotting/text.py @@ -250,6 +250,14 @@ class TextProperty(_vtk.vtkTextProperty): shadow : bool, optional If enable the shadow. + justification_horizontal : str, optional + Text's horizontal justification. + Should be either "left", "center" or "right". + + justification_vertical : str, optional + Text's vertical justification. + Should be either "bottom", "center" or "top". + Examples -------- Create a text's property. @@ -281,6 +289,8 @@ def __init__( font_size=None, font_file=None, shadow=False, + justification_horizontal=None, + justification_vertical=None, ): """Initialize text's property.""" super().__init__() @@ -300,6 +310,10 @@ def __init__( self.set_font_file(font_file) if shadow: self.enable_shadow() + if justification_horizontal is not None: + self.justification_horizontal = justification_horizontal + if justification_vertical is not None: + self.justification_vertical = justification_vertical @property def color(self) -> Color: @@ -486,3 +500,61 @@ def set_font_file(self, font_file: str): raise FileNotFoundError(f'Unable to locate {path}') self.SetFontFamily(_vtk.VTK_FONT_FILE) self.SetFontFile(str(path)) + + @property + def justification_horizontal(self) -> str: + """Text's justification horizontal. + + Returns + ------- + str + Text's horizontal justification. + Should be either "left", "center" or "right". + """ + justification = self.GetJustificationAsString().lower() + if justification == 'centered': + justification = 'center' + return justification + + @justification_horizontal.setter + def justification_horizontal(self, justification: str): # numpydoc ignore=GL08 + if justification.lower() == 'left': + self.SetJustificationToLeft() + elif justification.lower() == 'center': + self.SetJustificationToCentered() + elif justification.lower() == 'right': + self.SetJustificationToRight() + else: + raise ValueError( + f'Invalid {justification} for justification_horizontal. ' + 'Should be either "left", "center" or "right".' + ) + + @property + def justification_vertical(self) -> str: + """Text's vertical justification. + + Returns + ------- + str + Text's vertical justification. + Should be either "bottom", "center" or "top". + """ + justification = self.GetVerticalJustificationAsString().lower() + if justification == 'centered': + justification = 'center' + return justification + + @justification_vertical.setter + def justification_vertical(self, justification: str): # numpydoc ignore=GL08 + if justification.lower() == 'bottom': + self.SetVerticalJustificationToBottom() + elif justification.lower() == 'center': + self.SetVerticalJustificationToCentered() + elif justification.lower() == 'top': + self.SetVerticalJustificationToTop() + else: + raise ValueError( + f'Invalid {justification} for justification_vertical. ' + 'Should be either "bottom", "center" or "top".' + )	diff --git a/tests/plotting/test_text.py b/tests/plotting/test_text.py index 2a15cbb4d46..0046eec024c 100644 --- a/tests/plotting/test_text.py +++ b/tests/plotting/test_text.py @@ -129,3 +129,34 @@ def test_property_set_font_file(prop): prop.set_font_file(font_file) with pytest.raises(FileNotFoundError): prop.set_font_file("foo.ttf") + + +@pytest.mark.parametrize( + 'justification', [('left', 'left'), ('center', 'centered'), ('right', 'right')] +) +def test_property_justification_horizontal(prop, justification): + prop.justification_horizontal = justification[0] + assert prop.GetJustificationAsString().lower() == justification[1] + assert prop.justification_horizontal == justification[0] + prop = pv.TextProperty(justification_horizontal=justification[0]) + assert prop.GetJustificationAsString().lower() == justification[1] + assert prop.justification_horizontal == justification[0] + + +@pytest.mark.parametrize( + 'justification', [('bottom', 'bottom'), ('center', 'centered'), ('top', 'top')] +) +def test_property_justification_vertical(prop, justification): + prop.justification_vertical = justification[0] + assert prop.GetVerticalJustificationAsString().lower() == justification[1] + assert prop.justification_vertical == justification[0] + prop = pv.TextProperty(justification_vertical=justification[0]) + assert prop.GetVerticalJustificationAsString().lower() == justification[1] + assert prop.justification_vertical == justification[0] + + +def test_property_justification_invalid(prop): + with pytest.raises(ValueError): + prop.justification_horizontal = "invalid" + with pytest.raises(ValueError): + prop.justification_vertical = "invalid"		[ { "components": [ { "doc": "", "lines": [ 520, 529 ], "name": "TextProperty.justification_horizontal", "signature": "def justification_horizontal(self, justification: str):", "type": "function" }, { "doc": "", ...	[ "tests/plotting/test_text.py::test_property_justification_horizontal[justification0]", "tests/plotting/test_text.py::test_property_justification_horizontal[justification1]", "tests/plotting/test_text.py::test_property_justification_horizontal[justification2]", "tests/plotting/test_text.py::test_property_justi...	[ "tests/plotting/test_text.py::test_corner_annotation_text", "tests/plotting/test_text.py::test_corner_annotation_prop", "tests/plotting/test_text.py::test_text_input", "tests/plotting/test_text.py::test_text_prop", "tests/plotting/test_text.py::test_text_position", "tests/plotting/test_text.py::test_prope...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add `justification` property to `TextProperty` ### Overview <!-- Please insert a high-level description of this pull request here. --> Add `justify` property to `TextProperty`. ```python >>> import pyvista as pv >>> prop = pv.TextProperty() >>> prop.justification_horizontal = "right" >>> prop.justification_vertical = "center" ``` <!-- Be sure to link other PRs or issues that relate to this PR here. --> <!-- If this fully addresses an issue, please use the keyword `resolves` in front of that issue number. --> ### Details - Follow-up of #5044 . ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pyvista/plotting/text.py] (definition of TextProperty.justification_horizontal:) def justification_horizontal(self, justification: str): (definition of TextProperty.justification_vertical:) def justification_vertical(self, justification: str): [end of new definitions in pyvista/plotting/text.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		25921025e45cafe97b2e274de39c3076b3c84681
scikit-learn__scikit-learn-27566	27,566	scikit-learn/scikit-learn	1.5	77f87316a19130c894445f98e910c95a6ae59004	2023-10-11T09:57:28Z	diff --git a/doc/metadata_routing.rst b/doc/metadata_routing.rst index 30f75bcec950a..d319b311dddd7 100644 --- a/doc/metadata_routing.rst +++ b/doc/metadata_routing.rst @@ -276,6 +276,7 @@ Meta-estimators and functions supporting metadata routing: - :class:`sklearn.calibration.CalibratedClassifierCV` - :class:`sklearn.compose.ColumnTransformer` +- :class:`sklearn.covariance.GraphicalLassoCV` - :class:`sklearn.ensemble.VotingClassifier` - :class:`sklearn.ensemble.VotingRegressor` - :class:`sklearn.ensemble.BaggingClassifier` @@ -313,7 +314,6 @@ Meta-estimators and functions supporting metadata routing: Meta-estimators and tools not supporting metadata routing yet: - :class:`sklearn.compose.TransformedTargetRegressor` -- :class:`sklearn.covariance.GraphicalLassoCV` - :class:`sklearn.ensemble.AdaBoostClassifier` - :class:`sklearn.ensemble.AdaBoostRegressor` - :class:`sklearn.ensemble.StackingClassifier` diff --git a/doc/whats_new/v1.5.rst b/doc/whats_new/v1.5.rst index 7a9318780b5b3..7aba612262822 100644 --- a/doc/whats_new/v1.5.rst +++ b/doc/whats_new/v1.5.rst @@ -79,6 +79,10 @@ more details. :class:`model_selection.GridSearchCV` object or the underlying scorer. :pr:`27560` by :user:`Omar Salman <OmarManzoor>`. +- \|Feature\| :class:`GraphicalLassoCV` now supports metadata routing in it's + `fit` method and routes metadata to the CV splitter. + :pr:`27566` by :user:`Omar Salman <OmarManzoor>`. + - \|Feature\| :class:`linear_model.RANSACRegressor` now supports metadata routing in its ``fit``, ``score`` and ``predict`` methods and route metadata to its underlying estimator's' ``fit``, ``score`` and ``predict`` methods. diff --git a/sklearn/covariance/_graph_lasso.py b/sklearn/covariance/_graph_lasso.py index fb40ffda162a4..75f79bf06ae91 100644 --- a/sklearn/covariance/_graph_lasso.py +++ b/sklearn/covariance/_graph_lasso.py @@ -21,8 +21,15 @@ from ..linear_model import _cd_fast as cd_fast # type: ignore from ..linear_model import lars_path_gram from ..model_selection import check_cv, cross_val_score +from ..utils import Bunch from ..utils._param_validation import Interval, StrOptions, validate_params -from ..utils.metadata_routing import _RoutingNotSupportedMixin +from ..utils.metadata_routing import ( + MetadataRouter, + MethodMapping, + _raise_for_params, + _routing_enabled, + process_routing, +) from ..utils.parallel import Parallel, delayed from ..utils.validation import ( _is_arraylike_not_scalar, @@ -721,7 +728,7 @@ def graphical_lasso_path( return covariances_, precisions_ -class GraphicalLassoCV(_RoutingNotSupportedMixin, BaseGraphicalLasso): +class GraphicalLassoCV(BaseGraphicalLasso): """Sparse inverse covariance w/ cross-validated choice of the l1 penalty. See glossary entry for :term:`cross-validation estimator`. @@ -942,7 +949,7 @@ def __init__( self.n_jobs = n_jobs @_fit_context(prefer_skip_nested_validation=True) - def fit(self, X, y=None): + def fit(self, X, y=None, params): """Fit the GraphicalLasso covariance model to X. Parameters @@ -953,12 +960,25 @@ def fit(self, X, y=None): y : Ignored Not used, present for API consistency by convention. + params : dict, default=None + Parameters to be passed to the CV splitter and the + cross_val_score function. + + .. versionadded:: 1.5 + Only available if `enable_metadata_routing=True`, + which can be set by using + ``sklearn.set_config(enable_metadata_routing=True)``. + See :ref:`Metadata Routing User Guide <metadata_routing>` for + more details. + Returns ------- self : object Returns the instance itself. """ # Covariance does not make sense for a single feature + _raise_for_params(params, self, "fit") + X = self._validate_data(X, ensure_min_features=2) if self.assume_centered: self.location_ = np.zeros(X.shape[1]) @@ -991,6 +1011,11 @@ def fit(self, X, y=None): alpha_0 = 1e-2 * alpha_1 alphas = np.logspace(np.log10(alpha_0), np.log10(alpha_1), n_alphas)[::-1] + if _routing_enabled(): + routed_params = process_routing(self, "fit", params) + else: + routed_params = Bunch(splitter=Bunch(split={})) + t0 = time.time() for i in range(n_refinements): with warnings.catch_warnings(): @@ -1015,7 +1040,7 @@ def fit(self, X, y=None): verbose=inner_verbose, eps=self.eps, ) - for train, test in cv.split(X, y) + for train, test in cv.split(X, y, routed_params.splitter.split) ) # Little danse to transform the list in what we need @@ -1081,6 +1106,7 @@ def fit(self, X, y=None): cv=cv, n_jobs=self.n_jobs, verbose=inner_verbose, + params=params, ) ) grid_scores = np.array(grid_scores) @@ -1108,3 +1134,23 @@ def fit(self, X, y=None): eps=self.eps, ) return self + + def get_metadata_routing(self): + """Get metadata routing of this object. + + Please check :ref:`User Guide <metadata_routing>` on how the routing + mechanism works. + + .. versionadded:: 1.5 + + Returns + ------- + routing : MetadataRouter + A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating + routing information. + """ + router = MetadataRouter(owner=self.__class__.__name__).add( + splitter=check_cv(self.cv), + method_mapping=MethodMapping().add(callee="split", caller="fit"), + ) + return router	diff --git a/sklearn/covariance/tests/test_graphical_lasso.py b/sklearn/covariance/tests/test_graphical_lasso.py index a7d251a5bbdfe..37ffd46290e22 100644 --- a/sklearn/covariance/tests/test_graphical_lasso.py +++ b/sklearn/covariance/tests/test_graphical_lasso.py @@ -16,6 +16,7 @@ graphical_lasso, ) from sklearn.datasets import make_sparse_spd_matrix +from sklearn.model_selection import GroupKFold from sklearn.utils import check_random_state from sklearn.utils._testing import ( _convert_container, @@ -254,12 +255,71 @@ def test_graphical_lasso_cv_scores(): X ) + _assert_graphical_lasso_cv_scores( + cov=cov, + n_splits=splits, + n_refinements=n_refinements, + n_alphas=n_alphas, + ) + + +# TODO(1.5): remove in 1.5 +def test_graphical_lasso_cov_init_deprecation(): + """Check that we raise a deprecation warning if providing `cov_init` in + `graphical_lasso`.""" + rng, dim, n_samples = np.random.RandomState(0), 20, 100 + prec = make_sparse_spd_matrix(dim, alpha=0.95, random_state=0) + cov = linalg.inv(prec) + X = rng.multivariate_normal(np.zeros(dim), cov, size=n_samples) + + emp_cov = empirical_covariance(X) + with pytest.warns(FutureWarning, match="cov_init parameter is deprecated"): + graphical_lasso(emp_cov, alpha=0.1, cov_init=emp_cov) + + +@pytest.mark.usefixtures("enable_slep006") +def test_graphical_lasso_cv_scores_with_routing(global_random_seed): + """Check that `GraphicalLassoCV` internally dispatches metadata to + the splitter. + """ + splits = 5 + n_alphas = 5 + n_refinements = 3 + true_cov = np.array( + [ + [0.8, 0.0, 0.2, 0.0], + [0.0, 0.4, 0.0, 0.0], + [0.2, 0.0, 0.3, 0.1], + [0.0, 0.0, 0.1, 0.7], + ] + ) + rng = np.random.RandomState(global_random_seed) + X = rng.multivariate_normal(mean=[0, 0, 0, 0], cov=true_cov, size=300) + n_samples = X.shape[0] + groups = rng.randint(0, 5, n_samples) + params = {"groups": groups} + cv = GroupKFold(n_splits=splits) + cv.set_split_request(groups=True) + + cov = GraphicalLassoCV(cv=cv, alphas=n_alphas, n_refinements=n_refinements).fit( + X, *params + ) + + _assert_graphical_lasso_cv_scores( + cov=cov, + n_splits=splits, + n_refinements=n_refinements, + n_alphas=n_alphas, + ) + + +def _assert_graphical_lasso_cv_scores(cov, n_splits, n_refinements, n_alphas): cv_results = cov.cv_results_ # alpha and one for each split total_alphas = n_refinements n_alphas + 1 keys = ["alphas"] - split_keys = [f"split{i}_test_score" for i in range(splits)] + split_keys = [f"split{i}_test_score" for i in range(n_splits)] for key in keys + split_keys: assert key in cv_results assert len(cv_results[key]) == total_alphas @@ -270,17 +330,3 @@ def test_graphical_lasso_cv_scores(): assert_allclose(cov.cv_results_["mean_test_score"], expected_mean) assert_allclose(cov.cv_results_["std_test_score"], expected_std) - - -# TODO(1.5): remove in 1.5 -def test_graphical_lasso_cov_init_deprecation(): - """Check that we raise a deprecation warning if providing `cov_init` in - `graphical_lasso`.""" - rng, dim, n_samples = np.random.RandomState(0), 20, 100 - prec = make_sparse_spd_matrix(dim, alpha=0.95, random_state=0) - cov = linalg.inv(prec) - X = rng.multivariate_normal(np.zeros(dim), cov, size=n_samples) - - emp_cov = empirical_covariance(X) - with pytest.warns(FutureWarning, match="cov_init parameter is deprecated"): - graphical_lasso(emp_cov, alpha=0.1, cov_init=emp_cov) diff --git a/sklearn/tests/test_metaestimators_metadata_routing.py b/sklearn/tests/test_metaestimators_metadata_routing.py index 1e8a5e4d38acb..aa6af5bd09aac 100644 --- a/sklearn/tests/test_metaestimators_metadata_routing.py +++ b/sklearn/tests/test_metaestimators_metadata_routing.py @@ -356,6 +356,13 @@ def enable_slep006(): "cv_name": "cv", "cv_routing_methods": ["fit"], }, + { + "metaestimator": GraphicalLassoCV, + "X": X, + "y": y, + "cv_name": "cv", + "cv_routing_methods": ["fit"], + }, ] """List containing all metaestimators to be tested and their settings @@ -397,7 +404,6 @@ def enable_slep006(): UNSUPPORTED_ESTIMATORS = [ AdaBoostClassifier(), AdaBoostRegressor(), - GraphicalLassoCV(), RFE(ConsumingClassifier()), RFECV(ConsumingClassifier()), SelfTrainingClassifier(ConsumingClassifier()),	diff --git a/doc/metadata_routing.rst b/doc/metadata_routing.rst index 30f75bcec950a..d319b311dddd7 100644 --- a/doc/metadata_routing.rst +++ b/doc/metadata_routing.rst @@ -276,6 +276,7 @@ Meta-estimators and functions supporting metadata routing: - :class:`sklearn.calibration.CalibratedClassifierCV` - :class:`sklearn.compose.ColumnTransformer` +- :class:`sklearn.covariance.GraphicalLassoCV` - :class:`sklearn.ensemble.VotingClassifier` - :class:`sklearn.ensemble.VotingRegressor` - :class:`sklearn.ensemble.BaggingClassifier` @@ -313,7 +314,6 @@ Meta-estimators and functions supporting metadata routing: Meta-estimators and tools not supporting metadata routing yet: - :class:`sklearn.compose.TransformedTargetRegressor` -- :class:`sklearn.covariance.GraphicalLassoCV` - :class:`sklearn.ensemble.AdaBoostClassifier` - :class:`sklearn.ensemble.AdaBoostRegressor` - :class:`sklearn.ensemble.StackingClassifier` diff --git a/doc/whats_new/v1.5.rst b/doc/whats_new/v1.5.rst index 7a9318780b5b3..7aba612262822 100644 --- a/doc/whats_new/v1.5.rst +++ b/doc/whats_new/v1.5.rst @@ -79,6 +79,10 @@ more details. :class:`model_selection.GridSearchCV` object or the underlying scorer. :pr:`27560` by :user:`Omar Salman <OmarManzoor>`. +- \|Feature\| :class:`GraphicalLassoCV` now supports metadata routing in it's + `fit` method and routes metadata to the CV splitter. + :pr:`27566` by :user:`Omar Salman <OmarManzoor>`. + - \|Feature\| :class:`linear_model.RANSACRegressor` now supports metadata routing in its ``fit``, ``score`` and ``predict`` methods and route metadata to its underlying estimator's' ``fit``, ``score`` and ``predict`` methods.	[ { "components": [ { "doc": "Get metadata routing of this object.\n\nPlease check :ref:`User Guide <metadata_routing>` on how the routing\nmechanism works.\n\n.. versionadded:: 1.5\n\nReturns\n-------\nrouting : MetadataRouter\n A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsula...	[ "sklearn/covariance/tests/test_graphical_lasso.py::test_graphical_lasso_cv_scores_with_routing[42]", "sklearn/tests/test_metaestimators_metadata_routing.py::test_default_request[GraphicalLassoCV]", "sklearn/tests/test_metaestimators_metadata_routing.py::test_metadata_is_routed_correctly_to_splitter[GraphicalLas...	[ "sklearn/covariance/tests/test_graphical_lasso.py::test_graphical_lassos", "sklearn/covariance/tests/test_graphical_lasso.py::test_graphical_lasso_when_alpha_equals_0", "sklearn/covariance/tests/test_graphical_lasso.py::test_graphical_lasso_n_iter[cd]", "sklearn/covariance/tests/test_graphical_lasso.py::test_...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> FEA Add metadata routing to GraphicalLassoCV <!-- Thanks for contributing a pull request! Please ensure you have taken a look at the contribution guidelines: https://github.com/scikit-learn/scikit-learn/blob/main/CONTRIBUTING.md --> #### Reference Issues/PRs <!-- Example: Fixes #1234. See also #3456. Please use keywords (e.g., Fixes) to create link to the issues or pull requests you resolved, so that they will automatically be closed when your pull request is merged. See https://github.com/blog/1506-closing-issues-via-pull-requests --> Towards #22893 #### What does this implement/fix? Explain your changes. - Adds metadata routing to GraphicalLassoCV and routes the corresponding metadata to the underlying cv splitter and the cross_val_score function. #### Any other comments? CC: @adrinjalali @glemaitre <!-- Please be aware that we are a loose team of volunteers so patience is necessary; assistance handling other issues is very welcome. We value all user contributions, no matter how minor they are. If we are slow to review, either the pull request needs some benchmarking, tinkering, convincing, etc. or more likely the reviewers are simply busy. In either case, we ask for your understanding during the review process. For more information, see our FAQ on this topic: http://scikit-learn.org/dev/faq.html#why-is-my-pull-request-not-getting-any-attention. Thanks for contributing! --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/covariance/_graph_lasso.py] (definition of GraphicalLassoCV.get_metadata_routing:) def get_metadata_routing(self): """Get metadata routing of this object. Please check :ref:`User Guide <metadata_routing>` on how the routing mechanism works. .. versionadded:: 1.5 Returns ------- routing : MetadataRouter A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating routing information.""" [end of new definitions in sklearn/covariance/_graph_lasso.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c799133710d518f5fba2958bb0e0765ee280df12
tobymao__sqlglot-2381	2,381	tobymao/sqlglot	null	ae27e46cf60bbbcb456997afe942a6e8ab9d03c1	2023-10-06T09:26:55Z	diff --git a/sqlglot/schema.py b/sqlglot/schema.py index f0b279b004..9301b2a40b 100644 --- a/sqlglot/schema.py +++ b/sqlglot/schema.py @@ -71,7 +71,7 @@ def column_names( def get_column_type( self, table: exp.Table \| str, - column: exp.Column, + column: exp.Column \| str, dialect: DialectType = None, normalize: t.Optional[bool] = None, ) -> exp.DataType: @@ -88,6 +88,28 @@ def get_column_type( The resulting column type. """ + def has_column( + self, + table: exp.Table \| str, + column: exp.Column \| str, + dialect: DialectType = None, + normalize: t.Optional[bool] = None, + ) -> bool: + """ + Returns whether or not `column` appears in `table`'s schema. + + Args: + table: the source table. + column: the target column. + dialect: the SQL dialect that will be used to parse `table` if it's a string. + normalize: whether to normalize identifiers according to the dialect of interest. + + Returns: + True if the column appears in the schema, False otherwise. + """ + name = column if isinstance(column, str) else column.name + return name in self.column_names(table, dialect=dialect, normalize=normalize) + @property @abc.abstractmethod def supported_table_args(self) -> t.Tuple[str, ...]: @@ -287,7 +309,7 @@ def column_names( def get_column_type( self, table: exp.Table \| str, - column: exp.Column, + column: exp.Column \| str, dialect: DialectType = None, normalize: t.Optional[bool] = None, ) -> exp.DataType: @@ -308,6 +330,22 @@ def get_column_type( return exp.DataType.build("unknown") + def has_column( + self, + table: exp.Table \| str, + column: exp.Column \| str, + dialect: DialectType = None, + normalize: t.Optional[bool] = None, + ) -> bool: + normalized_table = self._normalize_table(table, dialect=dialect, normalize=normalize) + + normalized_column_name = self._normalize_name( + column if isinstance(column, str) else column.this, dialect=dialect, normalize=normalize + ) + + table_schema = self.find(normalized_table, raise_on_missing=False) + return normalized_column_name in table_schema if table_schema else False + def _normalize(self, schema: t.Dict) -> t.Dict: """ Normalizes all identifiers in the schema.	diff --git a/tests/test_schema.py b/tests/test_schema.py index 626fa11e2a..34c507df46 100644 --- a/tests/test_schema.py +++ b/tests/test_schema.py @@ -272,3 +272,8 @@ def test_same_number_of_qualifiers(self): str(ctx.exception), "Table z must match the schema's nesting level: 2.", ) + + def test_has_column(self): + schema = MappingSchema({"x": {"c": "int"}}) + self.assertTrue(schema.has_column("x", exp.column("c"))) + self.assertFalse(schema.has_column("x", exp.column("k")))		[]	[ "tests/test_schema.py::TestSchema::test_has_column" ]	[ "tests/test_schema.py::TestSchema::test_same_number_of_qualifiers", "tests/test_schema.py::TestSchema::test_schema", "tests/test_schema.py::TestSchema::test_schema_add_table_with_and_without_mapping", "tests/test_schema.py::TestSchema::test_schema_catalog", "tests/test_schema.py::TestSchema::test_schema_db"...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat(schema): add method to check if column exists Thought something like this might be an improvement to the API ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		ceb42fabad60312699e4b15936aeebac00e22e4d
huggingface__accelerate-2034	2,034	huggingface/accelerate	null	956114ac92cfbdfe0874ca73aa37ac815326f040	2023-10-05T12:06:08Z	diff --git a/docs/source/package_reference/tracking.md b/docs/source/package_reference/tracking.md index 36719db683a..6845ca4bc05 100644 --- a/docs/source/package_reference/tracking.md +++ b/docs/source/package_reference/tracking.md @@ -31,3 +31,5 @@ rendered properly in your Markdown viewer. - __init__ [[autodoc]] tracking.MLflowTracker - __init__ +[[autodoc]] tracking.ClearMLTracker + - __init__ diff --git a/docs/source/usage_guides/tracking.md b/docs/source/usage_guides/tracking.md index fa123cde699..141fea6924b 100644 --- a/docs/source/usage_guides/tracking.md +++ b/docs/source/usage_guides/tracking.md @@ -20,12 +20,14 @@ There are a large number of experiment tracking API's available, however getting ## Integrated Trackers -Currently `Accelerate` supports four trackers out-of-the-box: +Currently `Accelerate` supports six trackers out-of-the-box: - TensorBoard - WandB - CometML +- Aim - MLFlow +- ClearML To use any of them, pass in the selected type(s) to the `log_with` parameter in [`Accelerate`]: ```python diff --git a/src/accelerate/tracking.py b/src/accelerate/tracking.py index aa2eb08b742..4f536d57812 100644 --- a/src/accelerate/tracking.py +++ b/src/accelerate/tracking.py @@ -28,6 +28,7 @@ from .utils import ( LoggerType, is_aim_available, + is_clearml_available, is_comet_ml_available, is_mlflow_available, is_tensorboard_available, @@ -53,6 +54,9 @@ if is_mlflow_available(): _available_trackers.append(LoggerType.MLFLOW) +if is_clearml_available(): + _available_trackers.append(LoggerType.CLEARML) + logger = get_logger(__name__) @@ -365,11 +369,11 @@ def log_table( Args: table_name (`str`): The name to give to the logged table on the wandb workspace - columns (List of `str`'s optional): + columns (list of `str`, optional): The name of the columns on the table - data (List of List of Any data type optional): + data (List of List of Any data type, optional): The data to be logged in the table - dataframe (Any data type optional): + dataframe (Any data type, optional): The data to be logged in the table step (`int`, optional): The run step. If included, the log will be affiliated with this step. @@ -681,12 +685,165 @@ def finish(self): mlflow.end_run() +class ClearMLTracker(GeneralTracker): + """ + A `Tracker` class that supports `clearml`. Should be initialized at the start of your script. + + Args: + run_name (`str`, optional): + Name of the experiment. Environment variables `CLEARML_PROJECT` and `CLEARML_TASK` have priority over this + argument. + kwargs: + Kwargs passed along to the `Task.__init__` method. + """ + + name = "clearml" + requires_logging_directory = False + + @on_main_process + def __init__(self, run_name: str = None, kwargs): + from clearml import Task + + current_task = Task.current_task() + self._initialized_externally = False + if current_task: + self._initialized_externally = True + self.task = current_task + return + + kwargs.setdefault("project_name", os.environ.get("CLEARML_PROJECT", run_name)) + kwargs.setdefault("task_name", os.environ.get("CLEARML_TASK", run_name)) + self.task = Task.init(kwargs) + + @property + def tracker(self): + return self.task + + @on_main_process + def store_init_configuration(self, values: dict): + """ + Connect configuration dictionary to the Task object. Should be run at the beginning of your experiment. + + Args: + values (`dict`): + Values to be stored as initial hyperparameters as key-value pairs. + """ + return self.task.connect_configuration(values) + + @on_main_process + def log(self, values: Dict[str, Union[int, float]], step: Optional[int] = None, *kwargs): + """ + Logs `values` dictionary to the current run. The dictionary keys must be strings. The dictionary values must be + ints or floats + + Args: + values (`Dict[str, Union[int, float]]`): + Values to be logged as key-value pairs. If the key starts with 'eval_'/'test_'/'train_', the value will + be reported under the 'eval'/'test'/'train' series and the respective prefix will be removed. + Otherwise, the value will be reported under the 'train' series, and no prefix will be removed. + step (`int`, optional): + If specified, the values will be reported as scalars, with the iteration number equal to `step`. + Otherwise they will be reported as single values. + kwargs: + Additional key word arguments passed along to the `clearml.Logger.report_single_value` or + `clearml.Logger.report_scalar` methods. + """ + clearml_logger = self.task.get_logger() + for k, v in values.items(): + if not isinstance(v, (int, float)): + logger.warning( + "Accelerator is attempting to log a value of " + f'"{v}" of type {type(v)} for key "{k}" as a scalar. ' + "This invocation of ClearML logger's report_scalar() " + "is incorrect so we dropped this attribute." + ) + continue + if step is None: + clearml_logger.report_single_value(name=k, value=v, kwargs) + continue + title, series = ClearMLTracker._get_title_series(k) + clearml_logger.report_scalar(title=title, series=series, value=v, iteration=step, kwargs) + + @on_main_process + def log_images(self, values: dict, step: Optional[int] = None, kwargs): + """ + Logs `images` to the current run. + + Args: + values (`Dict[str, List[Union[np.ndarray, PIL.Image]]`): + Values to be logged as key-value pairs. The values need to have type `List` of `np.ndarray` or + step (`int`, optional): + The run step. If included, the log will be affiliated with this step. + kwargs: + Additional key word arguments passed along to the `clearml.Logger.report_image` method. + """ + clearml_logger = self.task.get_logger() + for k, v in values.items(): + title, series = ClearMLTracker._get_title_series(k) + clearml_logger.report_image(title=title, series=series, iteration=step, image=v, kwargs) + + @on_main_process + def log_table( + self, + table_name: str, + columns: List[str] = None, + data: List[List[Any]] = None, + dataframe: Any = None, + step: Optional[int] = None, + kwargs, + ): + """ + Log a Table to the task. Can be defined eitherwith `columns` and `data` or with `dataframe`. + + Args: + table_name (`str`): + The name of the table + columns (list of `str`, optional): + The name of the columns on the table + data (List of List of Any data type, optional): + The data to be logged in the table. If `columns` is not specified, then the first entry in data will be + the name of the columns of the table + dataframe (Any data type, optional): + The data to be logged in the table + step (`int`, optional): + The run step. If included, the log will be affiliated with this step. + kwargs: + Additional key word arguments passed along to the `clearml.Logger.report_table` method. + """ + to_report = dataframe + if dataframe is None: + if data is None: + raise ValueError( + "`ClearMLTracker.log_table` requires that `data` to be supplied if `dataframe` is `None`" + ) + to_report = [columns] + data if columns else data + title, series = ClearMLTracker._get_title_series(table_name) + self.task.get_logger().report_table(title=title, series=series, table_plot=to_report, iteration=step, *kwargs) + + @on_main_process + def finish(self): + """ + Close the ClearML task. If the task was initialized externally (e.g. by manually calling `Task.init`), this + function is a noop + """ + if self.task and not self._initialized_externally: + self.task.close() + + @staticmethod + def _get_title_series(name): + for prefix in ["eval", "test", "train"]: + if name.startswith(prefix + "_"): + return name[len(prefix) + 1 :], prefix + return name, "train" + + LOGGER_TYPE_TO_CLASS = { "aim": AimTracker, "comet_ml": CometMLTracker, "mlflow": MLflowTracker, "tensorboard": TensorBoardTracker, "wandb": WandBTracker, + "clearml": ClearMLTracker, } diff --git a/src/accelerate/utils/__init__.py b/src/accelerate/utils/__init__.py index 09a5ef42a7a..fc4aaff74f8 100644 --- a/src/accelerate/utils/__init__.py +++ b/src/accelerate/utils/__init__.py @@ -45,6 +45,7 @@ is_bnb_available, is_boto3_available, is_ccl_available, + is_clearml_available, is_comet_ml_available, is_cuda_available, is_datasets_available, @@ -55,6 +56,7 @@ is_mlflow_available, is_mps_available, is_npu_available, + is_pandas_available, is_rich_available, is_safetensors_available, is_sagemaker_available, diff --git a/src/accelerate/utils/dataclasses.py b/src/accelerate/utils/dataclasses.py index 6533ca36b68..43cd75c7370 100644 --- a/src/accelerate/utils/dataclasses.py +++ b/src/accelerate/utils/dataclasses.py @@ -343,6 +343,7 @@ class LoggerType(BaseEnum): WANDB = "wandb" COMETML = "comet_ml" MLFLOW = "mlflow" + CLEARML = "clearml" class PrecisionType(BaseEnum): diff --git a/src/accelerate/utils/imports.py b/src/accelerate/utils/imports.py index 44d5459c5be..3ff167aecf6 100644 --- a/src/accelerate/utils/imports.py +++ b/src/accelerate/utils/imports.py @@ -210,6 +210,14 @@ def is_tqdm_available(): return _is_package_available("tqdm") +def is_clearml_available(): + return _is_package_available("clearml") + + +def is_pandas_available(): + return _is_package_available("pandas") + + def is_mlflow_available(): if _is_package_available("mlflow"): return True	diff --git a/src/accelerate/test_utils/testing.py b/src/accelerate/test_utils/testing.py index 40afdac4813..bb887285954 100644 --- a/src/accelerate/test_utils/testing.py +++ b/src/accelerate/test_utils/testing.py @@ -31,10 +31,12 @@ from ..utils import ( gather, is_bnb_available, + is_clearml_available, is_comet_ml_available, is_datasets_available, is_deepspeed_available, is_mps_available, + is_pandas_available, is_safetensors_available, is_tensorboard_available, is_timm_available, @@ -231,6 +233,20 @@ def require_comet_ml(test_case): return unittest.skipUnless(is_comet_ml_available(), "test requires comet_ml")(test_case) +def require_clearml(test_case): + """ + Decorator marking a test that requires clearml installed. These tests are skipped when clearml isn't installed + """ + return unittest.skipUnless(is_clearml_available(), "test requires clearml")(test_case) + + +def require_pandas(test_case): + """ + Decorator marking a test that requires pandas installed. These tests are skipped when pandas isn't installed + """ + return unittest.skipUnless(is_pandas_available(), "test requires pandas")(test_case) + + _atleast_one_tracker_available = ( any([is_wandb_available(), is_tensorboard_available()]) and not is_comet_ml_available() ) diff --git a/tests/test_tracking.py b/tests/test_tracking.py index 5a0288232e8..545b51fefd4 100644 --- a/tests/test_tracking.py +++ b/tests/test_tracking.py @@ -25,6 +25,7 @@ from typing import Optional from unittest import mock +import numpy as np import torch # We use TF to parse the logs @@ -32,7 +33,9 @@ from accelerate.test_utils.testing import ( MockingTestCase, TempDirTestCase, + require_clearml, require_comet_ml, + require_pandas, require_tensorboard, require_wandb, skip, @@ -250,6 +253,147 @@ def test_log(self): self.assertEqual(self.get_value_from_key(list_of_json, "my_text"), "some_value") +@require_clearml +class ClearMLTest(TempDirTestCase, MockingTestCase): + def setUp(self): + super().setUp() + # ClearML offline session location is stored in CLEARML_CACHE_DIR + self.add_mocks(mock.patch.dict(os.environ, {"CLEARML_CACHE_DIR": self.tmpdir})) + + @staticmethod + def _get_offline_dir(accelerator): + from clearml.config import get_offline_dir + + return get_offline_dir(task_id=accelerator.get_tracker("clearml", unwrap=True).id) + + @staticmethod + def _get_metrics(offline_dir): + metrics = [] + with open(os.path.join(offline_dir, "metrics.jsonl")) as f: + json_lines = f.readlines() + for json_line in json_lines: + metrics.extend(json.loads(json_line)) + return metrics + + def test_init_trackers(self): + from clearml import Task + from clearml.utilities.config import text_to_config_dict + + Task.set_offline(True) + accelerator = Accelerator(log_with="clearml") + config = {"num_iterations": 12, "learning_rate": 1e-2, "some_boolean": False, "some_string": "some_value"} + accelerator.init_trackers("test_project_with_config", config) + + offline_dir = ClearMLTest._get_offline_dir(accelerator) + accelerator.end_training() + + with open(os.path.join(offline_dir, "task.json")) as f: + offline_session = json.load(f) + clearml_offline_config = text_to_config_dict(offline_session["configuration"]["General"]["value"]) + self.assertDictEqual(config, clearml_offline_config) + + def test_log(self): + from clearml import Task + + Task.set_offline(True) + accelerator = Accelerator(log_with="clearml") + accelerator.init_trackers("test_project_with_log") + values_with_iteration = {"should_be_under_train": 1, "eval_value": 2, "test_value": 3.1, "train_value": 4.1} + accelerator.log(values_with_iteration, step=1) + single_values = {"single_value_1": 1.1, "single_value_2": 2.2} + accelerator.log(single_values) + + offline_dir = ClearMLTest._get_offline_dir(accelerator) + accelerator.end_training() + + metrics = ClearMLTest._get_metrics(offline_dir) + self.assertEqual(len(values_with_iteration) + len(single_values), len(metrics)) + for metric in metrics: + if metric["metric"] == "Summary": + self.assertIn(metric["variant"], single_values) + self.assertEqual(metric["value"], single_values[metric["variant"]]) + elif metric["metric"] == "should_be_under_train": + self.assertEqual(metric["variant"], "train") + self.assertEqual(metric["iter"], 1) + self.assertEqual(metric["value"], values_with_iteration["should_be_under_train"]) + else: + values_with_iteration_key = metric["variant"] + "_" + metric["metric"] + self.assertIn(values_with_iteration_key, values_with_iteration) + self.assertEqual(metric["iter"], 1) + self.assertEqual(metric["value"], values_with_iteration[values_with_iteration_key]) + + def test_log_images(self): + from clearml import Task + + Task.set_offline(True) + accelerator = Accelerator(log_with="clearml") + accelerator.init_trackers("test_project_with_log_images") + + base_image = np.eye(256, 256, dtype=np.uint8) * 255 + base_image_3d = np.concatenate((np.atleast_3d(base_image), np.zeros((256, 256, 2), dtype=np.uint8)), axis=2) + images = { + "base_image": base_image, + "base_image_3d": base_image_3d, + } + accelerator.get_tracker("clearml").log_images(images, step=1) + + offline_dir = ClearMLTest._get_offline_dir(accelerator) + accelerator.end_training() + + images_saved = Path(os.path.join(offline_dir, "data")).rglob("*.jpeg") + self.assertEqual(len(list(images_saved)), len(images)) + + def test_log_table(self): + from clearml import Task + + Task.set_offline(True) + accelerator = Accelerator(log_with="clearml") + accelerator.init_trackers("test_project_with_log_table") + + accelerator.get_tracker("clearml").log_table( + "from lists with columns", columns=["A", "B", "C"], data=[[1, 3, 5], [2, 4, 6]] + ) + accelerator.get_tracker("clearml").log_table("from lists", data=[["A2", "B2", "C2"], [7, 9, 11], [8, 10, 12]]) + offline_dir = ClearMLTest._get_offline_dir(accelerator) + accelerator.end_training() + + metrics = ClearMLTest._get_metrics(offline_dir) + self.assertEqual(len(metrics), 2) + for metric in metrics: + self.assertIn(metric["metric"], ["from lists", "from lists with columns"]) + plot = json.loads(metric["plot_str"]) + if metric["metric"] == "from lists with columns": + print(plot["data"][0]) + self.assertCountEqual(plot["data"][0]["header"]["values"], ["A", "B", "C"]) + self.assertCountEqual(plot["data"][0]["cells"]["values"], [[1, 2], [3, 4], [5, 6]]) + else: + self.assertCountEqual(plot["data"][0]["header"]["values"], ["A2", "B2", "C2"]) + self.assertCountEqual(plot["data"][0]["cells"]["values"], [[7, 8], [9, 10], [11, 12]]) + + @require_pandas + def test_log_table_pandas(self): + import pandas as pd + from clearml import Task + + Task.set_offline(True) + accelerator = Accelerator(log_with="clearml") + accelerator.init_trackers("test_project_with_log_table_pandas") + + accelerator.get_tracker("clearml").log_table( + "from df", dataframe=pd.DataFrame({"A": [1, 2], "B": [3, 4], "C": [5, 6]}), step=1 + ) + + offline_dir = ClearMLTest._get_offline_dir(accelerator) + accelerator.end_training() + + metrics = ClearMLTest._get_metrics(offline_dir) + self.assertEqual(len(metrics), 1) + self.assertEqual(metrics[0]["metric"], "from df") + plot = json.loads(metrics[0]["plot_str"]) + self.assertCountEqual(plot["data"][0]["header"]["values"], [["A"], ["B"], ["C"]]) + self.assertCountEqual(plot["data"][0]["cells"]["values"], [[1, 2], [3, 4], [5, 6]]) + + class MyCustomTracker(GeneralTracker): "Basic tracker that writes to a csv for testing" _col_names = [	diff --git a/docs/source/package_reference/tracking.md b/docs/source/package_reference/tracking.md index 36719db683a..6845ca4bc05 100644 --- a/docs/source/package_reference/tracking.md +++ b/docs/source/package_reference/tracking.md @@ -31,3 +31,5 @@ rendered properly in your Markdown viewer. - __init__ [[autodoc]] tracking.MLflowTracker - __init__ +[[autodoc]] tracking.ClearMLTracker + - __init__ diff --git a/docs/source/usage_guides/tracking.md b/docs/source/usage_guides/tracking.md index fa123cde699..141fea6924b 100644 --- a/docs/source/usage_guides/tracking.md +++ b/docs/source/usage_guides/tracking.md @@ -20,12 +20,14 @@ There are a large number of experiment tracking API's available, however getting ## Integrated Trackers -Currently `Accelerate` supports four trackers out-of-the-box: +Currently `Accelerate` supports six trackers out-of-the-box: - TensorBoard - WandB - CometML +- Aim - MLFlow +- ClearML To use any of them, pass in the selected type(s) to the `log_with` parameter in [`Accelerate`]: ```python	[ { "components": [ { "doc": "A `Tracker` class that supports `clearml`. Should be initialized at the start of your script.\n\nArgs:\n run_name (`str`, optional):\n Name of the experiment. Environment variables `CLEARML_PROJECT` and `CLEARML_TASK` have priority over this\n argumen...	[ "tests/test_tracking.py::CustomTrackerTestCase::test_init_trackers", "tests/test_tracking.py::CustomTrackerTestCase::test_log" ]	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add ClearML tracker Adds ClearML to the supported trackers. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/accelerate/tracking.py] (definition of ClearMLTracker:) class ClearMLTracker(GeneralTracker): """A `Tracker` class that supports `clearml`. Should be initialized at the start of your script. Args: run_name (`str`, optional): Name of the experiment. Environment variables `CLEARML_PROJECT` and `CLEARML_TASK` have priority over this argument. kwargs: Kwargs passed along to the `Task.__init__` method.""" (definition of ClearMLTracker.__init__:) def __init__(self, run_name: str = None, kwargs): (definition of ClearMLTracker.tracker:) def tracker(self): (definition of ClearMLTracker.store_init_configuration:) def store_init_configuration(self, values: dict): """Connect configuration dictionary to the Task object. Should be run at the beginning of your experiment. Args: values (`dict`): Values to be stored as initial hyperparameters as key-value pairs.""" (definition of ClearMLTracker.log:) def log(self, values: Dict[str, Union[int, float]], step: Optional[int] = None, kwargs): """Logs `values` dictionary to the current run. The dictionary keys must be strings. The dictionary values must be ints or floats Args: values (`Dict[str, Union[int, float]]`): Values to be logged as key-value pairs. If the key starts with 'eval_'/'test_'/'train_', the value will be reported under the 'eval'/'test'/'train' series and the respective prefix will be removed. Otherwise, the value will be reported under the 'train' series, and no prefix will be removed. step (`int`, optional): If specified, the values will be reported as scalars, with the iteration number equal to `step`. Otherwise they will be reported as single values. kwargs: Additional key word arguments passed along to the `clearml.Logger.report_single_value` or `clearml.Logger.report_scalar` methods.""" (definition of ClearMLTracker.log_images:) def log_images(self, values: dict, step: Optional[int] = None, *kwargs): """Logs `images` to the current run. Args: values (`Dict[str, List[Union[np.ndarray, PIL.Image]]`): Values to be logged as key-value pairs. The values need to have type `List` of `np.ndarray` or step (`int`, optional): The run step. If included, the log will be affiliated with this step. kwargs: Additional key word arguments passed along to the `clearml.Logger.report_image` method.""" (definition of ClearMLTracker.log_table:) def log_table( self, table_name: str, columns: List[str] = None, data: List[List[Any]] = None, dataframe: Any = None, step: Optional[int] = None, kwargs, ): """Log a Table to the task. Can be defined eitherwith `columns` and `data` or with `dataframe`. Args: table_name (`str`): The name of the table columns (list of `str`, optional): The name of the columns on the table data (List of List of Any data type, optional): The data to be logged in the table. If `columns` is not specified, then the first entry in data will be the name of the columns of the table dataframe (Any data type, optional): The data to be logged in the table step (`int`, optional*): The run step. If included, the log will be affiliated with this step. kwargs: Additional key word arguments passed along to the `clearml.Logger.report_table` method.""" (definition of ClearMLTracker.finish:) def finish(self): """Close the ClearML task. If the task was initialized externally (e.g. by manually calling `Task.init`), this function is a noop""" (definition of ClearMLTracker._get_title_series:) def _get_title_series(name): [end of new definitions in src/accelerate/tracking.py] [start of new definitions in src/accelerate/utils/imports.py] (definition of is_clearml_available:) def is_clearml_available(): (definition of is_pandas_available:) def is_pandas_available(): [end of new definitions in src/accelerate/utils/imports.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		08101b9dde2b1a9658c2e363e3e9f5663ba06073
tobymao__sqlglot-2375	2,375	tobymao/sqlglot	null	347ac51da6a553a7904739f0f3ad6b4bb4db01c6	2023-10-04T22:12:33Z	diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index 1dd73f5e26..5edf785c0d 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -4778,6 +4778,11 @@ class Posexplode(Func): pass +# https://cloud.google.com/bigquery/docs/reference/standard-sql/bigqueryml-syntax-predict#mlpredict_function +class Predict(Func): + arg_types = {"this": True, "expression": True, "params_struct": False} + + class Pow(Binary, Func): _sql_names = ["POWER", "POW"] diff --git a/sqlglot/generator.py b/sqlglot/generator.py index 3cf4a7bd04..216e9c088e 100644 --- a/sqlglot/generator.py +++ b/sqlglot/generator.py @@ -2887,6 +2887,14 @@ def columnprefix_sql(self, expression: exp.ColumnPrefix) -> str: def opclass_sql(self, expression: exp.Opclass) -> str: return f"{self.sql(expression, 'this')} {self.sql(expression, 'expression')}" + def predict_sql(self, expression: exp.Predict) -> str: + model = self.sql(expression, "this") + model = f"MODEL {model}" + table = self.sql(expression, "expression") + table = f"TABLE {table}" if not isinstance(expression.expression, exp.Subquery) else table + parameters = self.sql(expression, "params_struct") + return self.func("PREDICT", model, table, parameters or None) + def cached_generator( cache: t.Optional[t.Dict[int, str]] = None diff --git a/sqlglot/parser.py b/sqlglot/parser.py index ddaa9d6ebe..76b6ee51e1 100644 --- a/sqlglot/parser.py +++ b/sqlglot/parser.py @@ -789,6 +789,7 @@ class Parser(metaclass=_Parser): "MATCH": lambda self: self._parse_match_against(), "OPENJSON": lambda self: self._parse_open_json(), "POSITION": lambda self: self._parse_position(), + "PREDICT": lambda self: self._parse_predict(), "SAFE_CAST": lambda self: self._parse_cast(False), "STRING_AGG": lambda self: self._parse_string_agg(), "SUBSTRING": lambda self: self._parse_substring(), @@ -4407,6 +4408,20 @@ def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition: exp.StrPosition, this=haystack, substr=needle, position=seq_get(args, 2) ) + def _parse_predict(self) -> exp.Predict: + self._match_text_seq("MODEL") + this = self._parse_table() + + self._match(TokenType.COMMA) + self._match_text_seq("TABLE") + + return self.expression( + exp.Predict, + this=this, + expression=self._parse_table(), + params_struct=self._match(TokenType.COMMA) and self._parse_bitwise(), + ) + def _parse_join_hint(self, func_name: str) -> exp.JoinHint: args = self._parse_csv(self._parse_table) return exp.JoinHint(this=func_name.upper(), expressions=args)	diff --git a/tests/dialects/test_bigquery.py b/tests/dialects/test_bigquery.py index 8d172eaec8..5d17cc90a5 100644 --- a/tests/dialects/test_bigquery.py +++ b/tests/dialects/test_bigquery.py @@ -85,6 +85,24 @@ def test_bigquery(self): self.validate_identity("ROLLBACK TRANSACTION") self.validate_identity("CAST(x AS BIGNUMERIC)") self.validate_identity("SELECT y + 1 FROM x GROUP BY y + 1 ORDER BY 1") + self.validate_identity( + "SELECT * FROM ML.PREDICT(MODEL mydataset.mymodel, (SELECT label, column1, column2 FROM mydataset.mytable))" + ) + self.validate_identity( + "SELECT label, predicted_label1, predicted_label AS predicted_label2 FROM ML.PREDICT(MODEL mydataset.mymodel2, (SELECT * EXCEPT (predicted_label), predicted_label AS predicted_label1 FROM ML.PREDICT(MODEL mydataset.mymodel1, TABLE mydataset.mytable)))" + ) + self.validate_identity( + "SELECT * FROM ML.PREDICT(MODEL mydataset.mymodel, (SELECT custom_label, column1, column2 FROM mydataset.mytable), STRUCT(0.55 AS threshold))" + ) + self.validate_identity( + "SELECT * FROM ML.PREDICT(MODEL `my_project`.my_dataset.my_model, (SELECT * FROM input_data))" + ) + self.validate_identity( + "SELECT * FROM ML.PREDICT(MODEL my_dataset.vision_model, (SELECT uri, ML.RESIZE_IMAGE(ML.DECODE_IMAGE(data), 480, 480, FALSE) AS input FROM my_dataset.object_table))" + ) + self.validate_identity( + "SELECT * FROM ML.PREDICT(MODEL my_dataset.vision_model, (SELECT uri, ML.CONVERT_COLOR_SPACE(ML.RESIZE_IMAGE(ML.DECODE_IMAGE(data), 224, 280, TRUE), 'YIQ') AS input FROM my_dataset.object_table WHERE content_type = 'image/jpeg'))" + ) self.validate_identity( "DATE(CAST('2016-12-25 05:30:00+07' AS DATETIME), 'America/Los_Angeles')" )		[]	[ "tests/dialects/test_bigquery.py::TestBigQuery::test_bigquery" ]	[ "tests/dialects/test_bigquery.py::TestBigQuery::test_group_concat", "tests/dialects/test_bigquery.py::TestBigQuery::test_json_object", "tests/dialects/test_bigquery.py::TestBigQuery::test_merge", "tests/dialects/test_bigquery.py::TestBigQuery::test_pushdown_cte_column_names", "tests/dialects/test_bigquery.p...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat(bigquery): add support for ML.PREDICT function Reference: https://cloud.google.com/bigquery/docs/reference/standard-sql/bigqueryml-syntax-predict#mlpredict_function ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		ceb42fabad60312699e4b15936aeebac00e22e4d
slackapi__python-slack-sdk-1406	1,406	slackapi/python-slack-sdk	null	398923a417525ed5014bb0695a5a21ad0420815a	2023-10-03T04:53:03Z	diff --git a/slack_sdk/models/blocks/__init__.py b/slack_sdk/models/blocks/__init__.py index 3dfd87d3f..87febae70 100644 --- a/slack_sdk/models/blocks/__init__.py +++ b/slack_sdk/models/blocks/__init__.py @@ -32,6 +32,7 @@ from .block_elements import InteractiveElement from .block_elements import LinkButtonElement from .block_elements import OverflowMenuElement +from .block_elements import RichTextInputElement from .block_elements import PlainTextInputElement from .block_elements import EmailInputElement from .block_elements import UrlInputElement @@ -81,6 +82,7 @@ "InteractiveElement", "LinkButtonElement", "OverflowMenuElement", + "RichTextInputElement", "PlainTextInputElement", "EmailInputElement", "UrlInputElement", diff --git a/slack_sdk/models/blocks/block_elements.py b/slack_sdk/models/blocks/block_elements.py index 4cf1519c2..c65bd7f8a 100644 --- a/slack_sdk/models/blocks/block_elements.py +++ b/slack_sdk/models/blocks/block_elements.py @@ -3,7 +3,7 @@ import re import warnings from abc import ABCMeta -from typing import Iterator, List, Optional, Set, Type, Union, Sequence +from typing import Iterator, List, Optional, Set, Type, Union, Sequence, Dict, Any from slack_sdk.models import show_unknown_key_warning from slack_sdk.models.basic_objects import ( @@ -1331,6 +1331,45 @@ def __init__( self.max_selected_items = max_selected_items +# ------------------------------------------------- +# Rich Text Input Element +# ------------------------------------------------- + + +class RichTextInputElement(InputInteractiveElement): + type = "rich_text_input" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union( + { + "initial_value", + "dispatch_action_config", + } + ) + + def __init__( + self, + , + action_id: Optional[str] = None, + placeholder: Optional[Union[str, dict, TextObject]] = None, + initial_value: Optional[Dict[str, Any]] = None, # TODO: Add rich_text block class and its element classes + dispatch_action_config: Optional[Union[dict, DispatchActionConfig]] = None, + focus_on_load: Optional[bool] = None, + *others: dict, + ): + super().__init__( + type=self.type, + action_id=action_id, + placeholder=TextObject.parse(placeholder, PlainTextObject.type), + focus_on_load=focus_on_load, + ) + show_unknown_key_warning(self, others) + + self.initial_value = initial_value + self.dispatch_action_config = dispatch_action_config + + # ------------------------------------------------- # Plain Text Input Element # -------------------------------------------------	diff --git a/tests/slack_sdk/models/test_elements.py b/tests/slack_sdk/models/test_elements.py index 1b246b0a6..fe63d5fc0 100644 --- a/tests/slack_sdk/models/test_elements.py +++ b/tests/slack_sdk/models/test_elements.py @@ -34,6 +34,7 @@ NumberInputElement, UrlInputElement, WorkflowButtonElement, + RichTextInputElement, ) from . import STRING_3001_CHARS, STRING_301_CHARS @@ -1013,6 +1014,26 @@ def test_document(self): # ------------------------------------------------- +class RichTextInputElementTests(unittest.TestCase): + def test_simple(self): + input = { + "type": "rich_text_input", + "action_id": "rich_input", + "placeholder": {"type": "plain_text", "text": "Enter some plain text"}, + } + self.assertDictEqual(input, RichTextInputElement(input).to_dict()) + + def test_document(self): + input = { + "type": "rich_text_input", + "action_id": "rich_text_input-action", + "dispatch_action_config": {"trigger_actions_on": ["on_character_entered"]}, + "focus_on_load": True, + "placeholder": {"type": "plain_text", "text": "Enter text"}, + } + self.assertDictEqual(input, RichTextInputElement(input).to_dict()) + + class PlainTextInputElementTests(unittest.TestCase): def test_document_1(self): input = {		[ { "components": [ { "doc": "", "lines": [ 1339, 1370 ], "name": "RichTextInputElement", "signature": "class RichTextInputElement(InputInteractiveElement):", "type": "class" }, { "doc": "", "lines": [ ...	[ "tests/slack_sdk/models/test_elements.py::BlockElementTests::test_eq", "tests/slack_sdk/models/test_elements.py::BlockElementTests::test_parse_timepicker", "tests/slack_sdk/models/test_elements.py::InteractiveElementTests::test_with_input_interactive_element", "tests/slack_sdk/models/test_elements.py::Interac...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add RichTextInputElement to slack_sdk.models ## Summary This pull request adds RichTextInputElement to slack_sdk.models utilities. references: * https://api.slack.com/reference/block-kit/block-elements#rich_text_input ### Category (place an `x` in each of the `[ ]`) - [ ] slack_sdk.web.WebClient (sync/async) (Web API client) - [ ] slack_sdk.webhook.WebhookClient (sync/async) (Incoming Webhook, response_url sender) - [ ] slack_sdk.socket_mode (Socket Mode client) - [ ] slack_sdk.signature (Request Signature Verifier) - [ ] slack_sdk.oauth (OAuth Flow Utilities) - [x] slack_sdk.models (UI component builders) - [ ] slack_sdk.scim (SCIM API client) - [ ] slack_sdk.audit_logs (Audit Logs API client) - [ ] slack_sdk.rtm_v2 (RTM client) - [ ] `/docs-src` (Documents, have you run `./scripts/docs.sh`?) - [ ] `/docs-src-v2` (Documents, have you run `./scripts/docs-v2.sh`?) - [ ] `/tutorial` (PythOnBoardingBot tutorial) - [ ] `tests`/`integration_tests` (Automated tests for this library) ## Requirements (place an `x` in each `[ ]`) - [x] I've read and understood the [Contributing Guidelines](https://github.com/slackapi/python-slack-sdk/blob/main/.github/contributing.md) and have done my best effort to follow them. - [x] I've read and agree to the [Code of Conduct](https://slackhq.github.io/code-of-conduct). - [x] I've run `python3 -m venv .venv && source .venv/bin/activate && ./scripts/run_validation.sh` after making the changes. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in slack_sdk/models/blocks/block_elements.py] (definition of RichTextInputElement:) class RichTextInputElement(InputInteractiveElement): (definition of RichTextInputElement.attributes:) def attributes(self) -> Set[str]: (definition of RichTextInputElement.__init__:) def __init__( self, *, action_id: Optional[str] = None, placeholder: Optional[Union[str, dict, TextObject]] = None, initial_value: Optional[Dict[str, Any]] = None, [end of new definitions in slack_sdk/models/blocks/block_elements.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		2997a1786c4fd969b00ce69af888ebae8e8ebed0
Textualize__textual-3410	3,410	Textualize/textual	null	3b170b074802fab825a698ca66be2196871700cf	2023-09-27T08:55:29Z	diff --git a/CHANGELOG.md b/CHANGELOG.md index 995286f9bd..9f4411e2f0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/). - Fixed `DataTable` not scrolling to rows that were just added https://github.com/Textualize/textual/pull/3552 - Fixed cache bug with `DataTable.update_cell` https://github.com/Textualize/textual/pull/3551 +### Added + +- Add Document `get_index_from_location` / `get_location_from_index` https://github.com/Textualize/textual/pull/3410 + ### Changed - Buttons will now display multiple lines, and have auto height https://github.com/Textualize/textual/pull/3539 diff --git a/src/textual/document/_document.py b/src/textual/document/_document.py index 5e8e37d8d0..6fa2341911 100644 --- a/src/textual/document/_document.py +++ b/src/textual/document/_document.py @@ -320,6 +320,42 @@ def line_count(self) -> int: """Returns the number of lines in the document.""" return len(self._lines) + def get_index_from_location(self, location: Location) -> int: + """Given a location, returns the index from the document's text. + + Args: + location: The location in the document. + + Returns: + The index in the document's text. + """ + row, column = location + index = row * len(self.newline) + column + for line_index in range(row): + index += len(self.get_line(line_index)) + return index + + def get_location_from_index(self, index: int) -> Location: + """Given an index in the document's text, returns the corresponding location. + + Args: + index: The index in the document's text. + + Returns: + The corresponding location. + """ + column_index = 0 + newline_length = len(self.newline) + for line_index in range(self.line_count): + next_column_index = ( + column_index + len(self.get_line(line_index)) + newline_length + ) + if index < next_column_index: + return (line_index, index - column_index) + elif index == next_column_index: + return (line_index + 1, 0) + column_index = next_column_index + def get_line(self, index: int) -> str: """Returns the line with the given index from the document.	diff --git a/tests/document/test_document.py b/tests/document/test_document.py index b6e9952782..ad1c82b834 100644 --- a/tests/document/test_document.py +++ b/tests/document/test_document.py @@ -98,3 +98,42 @@ def test_get_selected_text_no_newline_at_end_of_file_windows(): document = Document(TEXT_WINDOWS) selection = document.get_text_range((0, 0), (2, 0)) assert selection == TEXT_WINDOWS + + +@pytest.mark.parametrize( + "text", [TEXT, TEXT_NEWLINE, TEXT_WINDOWS, TEXT_WINDOWS_NEWLINE] +) +def test_index_from_location(text): + document = Document(text) + lines = text.split(document.newline) + assert document.get_index_from_location((0, 0)) == 0 + assert document.get_index_from_location((0, len(lines[0]))) == len(lines[0]) + assert document.get_index_from_location((1, 0)) == len(lines[0]) + len( + document.newline + ) + assert document.get_index_from_location((len(lines) - 1, len(lines[-1]))) == len( + text + ) + + +@pytest.mark.parametrize( + "text", [TEXT, TEXT_NEWLINE, TEXT_WINDOWS, TEXT_WINDOWS_NEWLINE] +) +def test_location_from_index(text): + document = Document(text) + lines = text.split(document.newline) + assert document.get_location_from_index(0) == (0, 0) + assert document.get_location_from_index(len(lines[0])) == (0, len(lines[0])) + if len(document.newline) > 1: + assert document.get_location_from_index(len(lines[0]) + 1) == ( + 0, + len(lines[0]) + 1, + ) + assert document.get_location_from_index(len(lines[0]) + len(document.newline)) == ( + 1, + 0, + ) + assert document.get_location_from_index(len(text)) == ( + len(lines) - 1, + len(lines[-1]), + )	diff --git a/CHANGELOG.md b/CHANGELOG.md index 995286f9bd..9f4411e2f0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/). - Fixed `DataTable` not scrolling to rows that were just added https://github.com/Textualize/textual/pull/3552 - Fixed cache bug with `DataTable.update_cell` https://github.com/Textualize/textual/pull/3551 +### Added + +- Add Document `get_index_from_location` / `get_location_from_index` https://github.com/Textualize/textual/pull/3410 + ### Changed - Buttons will now display multiple lines, and have auto height https://github.com/Textualize/textual/pull/3539	[ { "components": [ { "doc": "Given a location, returns the index from the document's text.\n\nArgs:\n location: The location in the document.\n\nReturns:\n The index in the document's text.", "lines": [ 323, 336 ], "name": "Document.get_index_from_l...	[ "tests/document/test_document.py::test_index_from_location[I", "tests/document/test_document.py::test_location_from_index[I" ]	[ "tests/document/test_document.py::test_text[I", "tests/document/test_document.py::test_lines_newline_eof", "tests/document/test_document.py::test_lines_no_newline_eof", "tests/document/test_document.py::test_lines_windows", "tests/document/test_document.py::test_lines_windows_newline", "tests/document/tes...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add Document get_index_from_location / get_location_from_index Please review the following checklist. - [x] Docstrings on all new or modified functions / classes - [ ] Updated documentation - [x] Updated CHANGELOG.md (where appropriate) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/textual/document/_document.py] (definition of Document.get_index_from_location:) def get_index_from_location(self, location: Location) -> int: """Given a location, returns the index from the document's text. Args: location: The location in the document. Returns: The index in the document's text.""" (definition of Document.get_location_from_index:) def get_location_from_index(self, index: int) -> Location: """Given an index in the document's text, returns the corresponding location. Args: index: The index in the document's text. Returns: The corresponding location.""" [end of new definitions in src/textual/document/_document.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		86e93536b991014e0ea4bf993068202b446bb698
pvlib__pvlib-python-1876	1,876	pvlib/pvlib-python	0.9	46851d91bb70e9b5521feb7ec119b057ec3d7f70	2023-09-26T18:06:02Z	diff --git a/docs/sphinx/source/reference/irradiance/transposition.rst b/docs/sphinx/source/reference/irradiance/transposition.rst index 4749b5d5b9..7b3624e692 100644 --- a/docs/sphinx/source/reference/irradiance/transposition.rst +++ b/docs/sphinx/source/reference/irradiance/transposition.rst @@ -10,6 +10,7 @@ Transposition models irradiance.get_sky_diffuse irradiance.isotropic irradiance.perez + irradiance.perez_driesse irradiance.haydavies irradiance.klucher irradiance.reindl diff --git a/docs/sphinx/source/whatsnew/v0.10.3.rst b/docs/sphinx/source/whatsnew/v0.10.3.rst index 30b9f576b0..0853254983 100644 --- a/docs/sphinx/source/whatsnew/v0.10.3.rst +++ b/docs/sphinx/source/whatsnew/v0.10.3.rst @@ -7,6 +7,8 @@ v0.10.3 (Anticipated December, 2023) Enhancements ~~~~~~~~~~~~ +* Added the continuous Perez-Driesse transposition model. + :py:func:`pvlib.irradiance.perez_driesse` (:issue:`1841`, :pull:`1876`) * :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance` and :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance_poa` now include shaded fraction in returned variables. (:pull:`1871`) @@ -28,4 +30,5 @@ Contributors ~~~~~~~~~~~~ * Arjan Keeman (:ghuser:`akeeman`) * Miguel Sánchez de León Peque (:ghuser:`Peque`) -* Will Hobbs (:ghuser:`williamhobbs`) \ No newline at end of file +* Will Hobbs (:ghuser:`williamhobbs`) +* Anton Driesse (:ghuser:`adriesse`) diff --git a/pvlib/irradiance.py b/pvlib/irradiance.py index 7e66281974..efae7f6236 100644 --- a/pvlib/irradiance.py +++ b/pvlib/irradiance.py @@ -10,6 +10,7 @@ import numpy as np import pandas as pd +from scipy.interpolate import splev from pvlib import atmosphere, solarposition, tools import pvlib # used to avoid dni name collision in complete_irradiance @@ -323,6 +324,7 @@ def get_total_irradiance(surface_tilt, surface_azimuth, * reindl * king * perez + * perez-driesse Parameters ---------- @@ -351,7 +353,8 @@ def get_total_irradiance(surface_tilt, surface_azimuth, the list of accepted values. model : str, default 'isotropic' Irradiance model. Can be one of ``'isotropic'``, ``'klucher'``, - ``'haydavies'``, ``'reindl'``, ``'king'``, ``'perez'``. + ``'haydavies'``, ``'reindl'``, ``'king'``, ``'perez'``, + ``'perez-driesse'``. model_perez : str, default 'allsitescomposite1990' Used only if ``model='perez'``. See :py:func:`~pvlib.irradiance.perez`. @@ -363,13 +366,13 @@ def get_total_irradiance(surface_tilt, surface_azimuth, Notes ----- - Models ``'haydavies'``, ``'reindl'``, or ``'perez'`` require - ``'dni_extra'``. Values can be calculated using + Models ``'haydavies'``, ``'reindl'``, ``'perez'`` and ``'perez-driesse'`` + require ``'dni_extra'``. Values can be calculated using :py:func:`~pvlib.irradiance.get_extra_radiation`. - The ``'perez'`` model requires relative airmass (``airmass``) as input. If - ``airmass`` is not provided, it is calculated using the defaults in - :py:func:`~pvlib.atmosphere.get_relative_airmass`. + The ``'perez'`` and ``'perez-driesse'`` models require relative airmass + (``airmass``) as input. If ``airmass`` is not provided, it is calculated + using the defaults in :py:func:`~pvlib.atmosphere.get_relative_airmass`. """ poa_sky_diffuse = get_sky_diffuse( @@ -400,6 +403,7 @@ def get_sky_diffuse(surface_tilt, surface_azimuth, * reindl * king * perez + * perez-driesse Parameters ---------- @@ -423,7 +427,8 @@ def get_sky_diffuse(surface_tilt, surface_azimuth, Relative airmass (not adjusted for pressure). [unitless] model : str, default 'isotropic' Irradiance model. Can be one of ``'isotropic'``, ``'klucher'``, - ``'haydavies'``, ``'reindl'``, ``'king'``, ``'perez'``. + ``'haydavies'``, ``'reindl'``, ``'king'``, ``'perez'``, + ``'perez-driesse'``. model_perez : str, default 'allsitescomposite1990' Used only if ``model='perez'``. See :py:func:`~pvlib.irradiance.perez`. @@ -440,18 +445,19 @@ def get_sky_diffuse(surface_tilt, surface_azimuth, Notes ----- - Models ``'haydavies'``, ``'reindl'``, and ``'perez``` require 'dni_extra'. - Values can be calculated using + Models ``'haydavies'``, ``'reindl'``, ``'perez'`` and ``'perez-driesse'`` + require ``'dni_extra'``. Values can be calculated using :py:func:`~pvlib.irradiance.get_extra_radiation`. - The ``'perez'`` model requires relative airmass (``airmass``) as input. If - ``airmass`` is not provided, it is calculated using the defaults in - :py:func:`~pvlib.atmosphere.get_relative_airmass`. + The ``'perez'`` and ``'perez-driesse'`` models require relative airmass + (``airmass``) as input. If ``airmass`` is not provided, it is calculated + using the defaults in :py:func:`~pvlib.atmosphere.get_relative_airmass`. """ model = model.lower() - if (model in {'haydavies', 'reindl', 'perez'}) and (dni_extra is None): + if dni_extra is None and model in {'haydavies', 'reindl', + 'perez', 'perez-driesse'}: raise ValueError(f'dni_extra is required for model {model}') if model == 'isotropic': @@ -473,6 +479,10 @@ def get_sky_diffuse(surface_tilt, surface_azimuth, sky = perez(surface_tilt, surface_azimuth, dhi, dni, dni_extra, solar_zenith, solar_azimuth, airmass, model=model_perez) + elif model == 'perez-driesse': + # perez_driesse will calculate its own airmass if needed + sky = perez_driesse(surface_tilt, surface_azimuth, dhi, dni, dni_extra, + solar_zenith, solar_azimuth, airmass) else: raise ValueError(f'invalid model selection {model}') @@ -1212,6 +1222,228 @@ def perez(surface_tilt, surface_azimuth, dhi, dni, dni_extra, return sky_diffuse +def _calc_delta(dhi, dni_extra, solar_zenith, airmass=None): + ''' + Compute the delta parameter, which represents sky dome "brightness" + in the Perez and Perez-Driesse models. + + Helper function for perez_driesse transposition. + ''' + if airmass is None: + # use the same airmass model as in the original perez work + airmass = atmosphere.get_relative_airmass(solar_zenith, + 'kastenyoung1989') + + max_airmass = atmosphere.get_relative_airmass(90, 'kastenyoung1989') + airmass = np.where(solar_zenith >= 90, max_airmass, airmass) + + return dhi / (dni_extra / airmass) + + +def _calc_zeta(dhi, dni, zenith): + ''' + Compute the zeta parameter, which represents sky dome "clearness" + in the Perez-Driesse model. + + Helper function for perez_driesse transposition. + ''' + dhi = np.asarray(dhi) + dni = np.asarray(dni) + + # first calculate what zeta would be without the kappa correction + # using eq. 5 and eq. 13 + with np.errstate(invalid='ignore'): + zeta = dni / (dhi + dni) + + zeta = np.where(dhi == 0, 0.0, zeta) + + # then apply the kappa correction in a manner analogous to eq. 7 + kappa = 1.041 + kterm = kappa * np.radians(zenith) ** 3 + zeta = zeta / (1 - kterm * (zeta - 1)) + + return zeta + + +def _f(i, j, zeta): + ''' + Evaluate the quadratic splines corresponding to the + allsitescomposite1990 Perez model look-up table. + + Helper function for perez_driesse transposition. + ''' + knots = np.array( + [0.000, 0.000, 0.000, + 0.061, 0.187, 0.333, 0.487, 0.643, 0.778, 0.839, + 1.000, 1.000, 1.000]) + + coefs = np.array( + [[-0.053, +0.529, -0.028, -0.071, +0.061, -0.019], + [-0.008, +0.588, -0.062, -0.060, +0.072, -0.022], + [+0.131, +0.770, -0.167, -0.026, +0.106, -0.032], + [+0.328, +0.471, -0.216, +0.069, -0.105, -0.028], + [+0.557, +0.241, -0.300, +0.086, -0.085, -0.012], + [+0.861, -0.323, -0.355, +0.240, -0.467, -0.008], + [ 1.212, -1.239, -0.444, +0.305, -0.797, +0.047], + [ 1.099, -1.847, -0.365, +0.275, -1.132, +0.124], + [+0.544, +0.157, -0.213, +0.118, -1.455, +0.292], + [+0.544, +0.157, -0.213, +0.118, -1.455, +0.292], + [+0.000, +0.000, +0.000, +0.000, +0.000, +0.000], + [+0.000, +0.000, +0.000, +0.000, +0.000, +0.000], + [+0.000, +0.000, +0.000, +0.000, +0.000, +0.000]]) + + coefs = coefs.T.reshape((2, 3, 13)) + + tck = (knots, coefs[i-1, j-1], 2) + + return splev(zeta, tck) + + +def perez_driesse(surface_tilt, surface_azimuth, dhi, dni, dni_extra, + solar_zenith, solar_azimuth, airmass=None, + return_components=False): + ''' + Determine diffuse irradiance from the sky on a tilted surface using + the continuous Perez-Driesse model. + + The Perez-Driesse model [1]_ is a reformulation of the 1990 Perez + model [2]_ that provides continuity of the function and of its first + derivatives. This is achieved by replacing the look-up table of + coefficients with quadratic splines. + + Parameters + ---------- + surface_tilt : numeric + Surface tilt angles in decimal degrees. surface_tilt must be >=0 + and <=180. The tilt angle is defined as degrees from horizontal + (e.g. surface facing up = 0, surface facing horizon = 90) + + surface_azimuth : numeric + Surface azimuth angles in decimal degrees. surface_azimuth must + be >=0 and <=360. The azimuth convention is defined as degrees + east of north (e.g. North = 0, South=180 East = 90, West = 270). + + dhi : numeric + Diffuse horizontal irradiance in W/m^2. dhi must be >=0. + + dni : numeric + Direct normal irradiance in W/m^2. dni must be >=0. + + dni_extra : numeric + Extraterrestrial normal irradiance in W/m^2. + + solar_zenith : numeric + apparent (refraction-corrected) zenith angles in decimal + degrees. solar_zenith must be >=0 and <=180. + + solar_azimuth : numeric + Sun azimuth angles in decimal degrees. solar_azimuth must be >=0 + and <=360. The azimuth convention is defined as degrees east of + north (e.g. North = 0, East = 90, West = 270). + + airmass : numeric (optional, default None) + Relative (not pressure-corrected) airmass values. If airmass is a + DataFrame it must be of the same size as all other DataFrame + inputs. The kastenyoung1989 airmass calculation is used internally + and is also recommended when pre-calculating airmass because + it was used in the original model development. + + return_components: bool (optional, default=False) + Flag used to decide whether to return the calculated diffuse components + or not. + + Returns + -------- + numeric, OrderedDict, or DataFrame + Return type controlled by `return_components` argument. + If ``return_components=False``, `sky_diffuse` is returned. + If ``return_components=True``, `diffuse_components` is returned. + + sky_diffuse : numeric + The sky diffuse component of the solar radiation on a tilted + surface. + + diffuse_components : OrderedDict (array input) or DataFrame (Series input) + Keys/columns are: + * sky_diffuse: Total sky diffuse + * isotropic + * circumsolar + * horizon + + Notes + ----- + The Perez-Driesse model can be considered a plug-in replacement for the + 1990 Perez model using the ``'allsitescomposite1990'`` coefficient set. + Deviations between the two are very small, as demonstrated in [1]_. + Other coefficient sets are not supported because the 1990 set is + based on the largest and most diverse set of empirical data. + + References + ---------- + .. [1] A. Driesse, A. Jensen, R. Perez, A Continuous Form of the Perez + Diffuse Sky Model for Forward and Reverse Transposition, accepted + for publication in the Solar Energy Journal. + + .. [2] Perez, R., Ineichen, P., Seals, R., Michalsky, J., Stewart, R., + 1990. Modeling daylight availability and irradiance components from + direct and global irradiance. Solar Energy 44 (5), 271-289. + + See also + -------- + perez + isotropic + haydavies + klucher + reindl + king + ''' + # Contributed by Anton Driesse (@adriesse), PV Performance Labs. Oct., 2023 + + delta = _calc_delta(dhi, dni_extra, solar_zenith, airmass) + zeta = _calc_zeta(dhi, dni, solar_zenith) + + z = np.radians(solar_zenith) + + F1 = _f(1, 1, zeta) + _f(1, 2, zeta) * delta + _f(1, 3, zeta) * z + F2 = _f(2, 1, zeta) + _f(2, 2, zeta) * delta + _f(2, 3, zeta) * z + + # note the newly recommended upper limit on F1 + F1 = np.clip(F1, 0, 0.9) + + # lines after this point are identical to the original perez function + # with some checks removed + + A = aoi_projection(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth) + A = np.maximum(A, 0) + + B = tools.cosd(solar_zenith) + B = np.maximum(B, tools.cosd(85)) + + # Calculate Diffuse POA from sky dome + term1 = 0.5 * (1 - F1) * (1 + tools.cosd(surface_tilt)) + term2 = F1 * A / B + term3 = F2 * tools.sind(surface_tilt) + + sky_diffuse = np.maximum(dhi * (term1 + term2 + term3), 0) + + if return_components: + diffuse_components = OrderedDict() + diffuse_components['sky_diffuse'] = sky_diffuse + + # Calculate the different components + diffuse_components['isotropic'] = dhi * term1 + diffuse_components['circumsolar'] = dhi * term2 + diffuse_components['horizon'] = dhi * term3 + + if isinstance(sky_diffuse, pd.Series): + diffuse_components = pd.DataFrame(diffuse_components) + + return diffuse_components + else: + return sky_diffuse + + def clearsky_index(ghi, clearsky_ghi, max_clearsky_index=2.0): """ Calculate the clearsky index. @@ -2350,6 +2582,8 @@ def erbs_driesse(ghi, zenith, datetime_or_doy=None, dni_extra=None, orgill_hollands boland """ + # Contributed by Anton Driesse (@adriesse), PV Performance Labs. Aug., 2023 + # central polynomial coefficients with float64 precision p = [+12.26911439571261000, -16.47050842469730700,	diff --git a/pvlib/tests/test_irradiance.py b/pvlib/tests/test_irradiance.py index 2f660d5c97..8f24e7a605 100644 --- a/pvlib/tests/test_irradiance.py +++ b/pvlib/tests/test_irradiance.py @@ -273,6 +273,31 @@ def test_perez(irrad_data, ephem_data, dni_et, relative_airmass): assert_series_equal(out, expected, check_less_precise=2) +def test_perez_driesse(irrad_data, ephem_data, dni_et, relative_airmass): + dni = irrad_data['dni'].copy() + dni.iloc[2] = np.nan + out = irradiance.perez_driesse(40, 180, irrad_data['dhi'], dni, + dni_et, ephem_data['apparent_zenith'], + ephem_data['azimuth'], relative_airmass) + expected = pd.Series(np.array( + [0., 29.991, np.nan, 47.397]), + index=irrad_data.index) + assert_series_equal(out, expected, check_less_precise=2) + + +def test_perez_driesse_airmass(irrad_data, ephem_data, dni_et): + dni = irrad_data['dni'].copy() + dni.iloc[2] = np.nan + out = irradiance.perez_driesse(40, 180, irrad_data['dhi'], dni, + dni_et, ephem_data['apparent_zenith'], + ephem_data['azimuth'], airmass=None) + print(out) + expected = pd.Series(np.array( + [0., 29.991, np.nan, 47.397]), + index=irrad_data.index) + assert_series_equal(out, expected, check_less_precise=2) + + def test_perez_components(irrad_data, ephem_data, dni_et, relative_airmass): dni = irrad_data['dni'].copy() dni.iloc[2] = np.nan @@ -297,6 +322,32 @@ def test_perez_components(irrad_data, ephem_data, dni_et, relative_airmass): assert_series_equal(sum_components, expected_for_sum, check_less_precise=2) +def test_perez_driesse_components(irrad_data, ephem_data, dni_et, + relative_airmass): + dni = irrad_data['dni'].copy() + dni.iloc[2] = np.nan + out = irradiance.perez_driesse(40, 180, irrad_data['dhi'], dni, + dni_et, ephem_data['apparent_zenith'], + ephem_data['azimuth'], relative_airmass, + return_components=True) + + expected = pd.DataFrame(np.array( + [[0., 29.991, np.nan, 47.397], + [0., 25.806, np.nan, 33.181], + [0., 0.000, np.nan, 4.197], + [0., 4.184, np.nan, 10.018]]).T, + columns=['sky_diffuse', 'isotropic', 'circumsolar', 'horizon'], + index=irrad_data.index + ) + expected_for_sum = expected['sky_diffuse'].copy() + expected_for_sum.iloc[2] = 0 + sum_components = out.iloc[:, 1:].sum(axis=1) + sum_components.name = 'sky_diffuse' + + assert_frame_equal(out, expected, check_less_precise=2) + assert_series_equal(sum_components, expected_for_sum, check_less_precise=2) + + def test_perez_negative_horizon(): times = pd.date_range(start='20190101 11:30:00', freq='1H', periods=5, tz='US/Central') @@ -356,6 +407,21 @@ def test_perez_arrays(irrad_data, ephem_data, dni_et, relative_airmass): assert isinstance(out, np.ndarray) +def test_perez_driesse_arrays(irrad_data, ephem_data, dni_et, + relative_airmass): + dni = irrad_data['dni'].copy() + dni.iloc[2] = np.nan + out = irradiance.perez_driesse(40, 180, irrad_data['dhi'].values, + dni.values, dni_et, + ephem_data['apparent_zenith'].values, + ephem_data['azimuth'].values, + relative_airmass.values) + expected = np.array( + [0., 29.990, np.nan, 47.396]) + assert_allclose(out, expected, atol=1e-2) + assert isinstance(out, np.ndarray) + + def test_perez_scalar(): # copied values from fixtures out = irradiance.perez(40, 180, 118.45831879, 939.95469881, @@ -366,8 +432,17 @@ def test_perez_scalar(): assert_allclose(out, 109.084332) +def test_perez_driesse_scalar(): + # copied values from fixtures + out = irradiance.perez_driesse(40, 180, 118.458, 939.954, + 1321.165, 10.564, 144.765, 1.016) + # this will fail. out is ndarry with ndim == 0. fix in future version. + # assert np.isscalar(out) + assert_allclose(out, 110.341, atol=1e-2) + + @pytest.mark.parametrize('model', ['isotropic', 'klucher', 'haydavies', - 'reindl', 'king', 'perez']) + 'reindl', 'king', 'perez', 'perez-driesse']) def test_sky_diffuse_zenith_close_to_90(model): # GH 432 sky_diffuse = irradiance.get_sky_diffuse( @@ -419,7 +494,7 @@ def test_campbell_norman(): def test_get_total_irradiance(irrad_data, ephem_data, dni_et, relative_airmass): models = ['isotropic', 'klucher', - 'haydavies', 'reindl', 'king', 'perez'] + 'haydavies', 'reindl', 'king', 'perez', 'perez-driesse'] for model in models: total = irradiance.get_total_irradiance( @@ -437,7 +512,8 @@ def test_get_total_irradiance(irrad_data, ephem_data, dni_et, @pytest.mark.parametrize('model', ['isotropic', 'klucher', - 'haydavies', 'reindl', 'king', 'perez']) + 'haydavies', 'reindl', 'king', + 'perez', 'perez-driesse']) def test_get_total_irradiance_albedo( irrad_data, ephem_data, dni_et, relative_airmass, model): albedo = pd.Series(0.2, index=ephem_data.index) @@ -456,7 +532,8 @@ def test_get_total_irradiance_albedo( @pytest.mark.parametrize('model', ['isotropic', 'klucher', - 'haydavies', 'reindl', 'king', 'perez']) + 'haydavies', 'reindl', 'king', + 'perez', 'perez-driesse']) def test_get_total_irradiance_scalars(model): total = irradiance.get_total_irradiance( 32, 180,	diff --git a/docs/sphinx/source/reference/irradiance/transposition.rst b/docs/sphinx/source/reference/irradiance/transposition.rst index 4749b5d5b9..7b3624e692 100644 --- a/docs/sphinx/source/reference/irradiance/transposition.rst +++ b/docs/sphinx/source/reference/irradiance/transposition.rst @@ -10,6 +10,7 @@ Transposition models irradiance.get_sky_diffuse irradiance.isotropic irradiance.perez + irradiance.perez_driesse irradiance.haydavies irradiance.klucher irradiance.reindl diff --git a/docs/sphinx/source/whatsnew/v0.10.3.rst b/docs/sphinx/source/whatsnew/v0.10.3.rst index 30b9f576b0..0853254983 100644 --- a/docs/sphinx/source/whatsnew/v0.10.3.rst +++ b/docs/sphinx/source/whatsnew/v0.10.3.rst @@ -7,6 +7,8 @@ v0.10.3 (Anticipated December, 2023) Enhancements ~~~~~~~~~~~~ +* Added the continuous Perez-Driesse transposition model. + :py:func:`pvlib.irradiance.perez_driesse` (:issue:`1841`, :pull:`1876`) * :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance` and :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance_poa` now include shaded fraction in returned variables. (:pull:`1871`) @@ -28,4 +30,5 @@ Contributors ~~~~~~~~~~~~ * Arjan Keeman (:ghuser:`akeeman`) * Miguel Sánchez de León Peque (:ghuser:`Peque`) -* Will Hobbs (:ghuser:`williamhobbs`) \ No newline at end of file +* Will Hobbs (:ghuser:`williamhobbs`) +* Anton Driesse (:ghuser:`adriesse`)	[ { "components": [ { "doc": "Compute the delta parameter, which represents sky dome \"brightness\"\nin the Perez and Perez-Driesse models.\n\nHelper function for perez_driesse transposition.", "lines": [ 1225, 1240 ], "name": "_calc_delta", "signa...	[ "pvlib/tests/test_irradiance.py::test_perez_driesse", "pvlib/tests/test_irradiance.py::test_perez_driesse_airmass", "pvlib/tests/test_irradiance.py::test_perez_driesse_components", "pvlib/tests/test_irradiance.py::test_perez_driesse_arrays", "pvlib/tests/test_irradiance.py::test_perez_driesse_scalar", "pv...	[ "pvlib/tests/test_irradiance.py::test_get_extra_radiation[asce-300-1383.636203]", "pvlib/tests/test_irradiance.py::test_get_extra_radiation[asce-300.0-1383.636203]", "pvlib/tests/test_irradiance.py::test_get_extra_radiation[asce-testval2-1383.636203]", "pvlib/tests/test_irradiance.py::test_get_extra_radiation...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Continuous version of the Perez transposition model implementation <!-- Thank you for your contribution! The following items must be addressed before the code can be merged. Please don't hesitate to ask for help if you're unsure of how to accomplish any of the items. Feel free to remove checklist items that are not relevant to your change. --> - [x] Closes #1841 - [x] I am familiar with the [contributing guidelines](https://pvlib-python.readthedocs.io/en/latest/contributing.html) - [x] Tests added - [x] Updates entries in [`docs/sphinx/source/reference`](https://github.com/pvlib/pvlib-python/blob/main/docs/sphinx/source/reference) for API changes. - [x] Adds description and name entries in the appropriate "what's new" file in [`docs/sphinx/source/whatsnew`](https://github.com/pvlib/pvlib-python/tree/main/docs/sphinx/source/whatsnew) for all changes. Includes link to the GitHub Issue with `` :issue:`num` `` or this Pull Request with `` :pull:`num` ``. Includes contributor name and/or GitHub username (link with `` :ghuser:`user` ``). - [x] New code is fully documented. Includes [numpydoc](https://numpydoc.readthedocs.io/en/latest/format.html) compliant docstrings, examples, and comments where necessary. - [x] Pull request is nearly complete and ready for detailed review. - [x] Maintainer: Appropriate GitHub Labels (including `remote-data`) and Milestone are assigned to the Pull Request and linked Issue. Create a new version of the Perez model having smooth transitions, but without changing the overall performance w.r.t. the original. The solution uses quadratic splines as described in recent presentations and posters, and documented in a paper just accepted for publication in the Solar Energy Journal. (Link will be provided later; the pre-print is available to PR reviewers on request.) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pvlib/irradiance.py] (definition of _calc_delta:) def _calc_delta(dhi, dni_extra, solar_zenith, airmass=None): """Compute the delta parameter, which represents sky dome "brightness" in the Perez and Perez-Driesse models. Helper function for perez_driesse transposition.""" (definition of _calc_zeta:) def _calc_zeta(dhi, dni, zenith): """Compute the zeta parameter, which represents sky dome "clearness" in the Perez-Driesse model. Helper function for perez_driesse transposition.""" (definition of _f:) def _f(i, j, zeta): """Evaluate the quadratic splines corresponding to the allsitescomposite1990 Perez model look-up table. Helper function for perez_driesse transposition.""" (definition of perez_driesse:) def perez_driesse(surface_tilt, surface_azimuth, dhi, dni, dni_extra, solar_zenith, solar_azimuth, airmass=None, return_components=False): """Determine diffuse irradiance from the sky on a tilted surface using the continuous Perez-Driesse model. The Perez-Driesse model [1]_ is a reformulation of the 1990 Perez model [2]_ that provides continuity of the function and of its first derivatives. This is achieved by replacing the look-up table of coefficients with quadratic splines. Parameters ---------- surface_tilt : numeric Surface tilt angles in decimal degrees. surface_tilt must be >=0 and <=180. The tilt angle is defined as degrees from horizontal (e.g. surface facing up = 0, surface facing horizon = 90) surface_azimuth : numeric Surface azimuth angles in decimal degrees. surface_azimuth must be >=0 and <=360. The azimuth convention is defined as degrees east of north (e.g. North = 0, South=180 East = 90, West = 270). dhi : numeric Diffuse horizontal irradiance in W/m^2. dhi must be >=0. dni : numeric Direct normal irradiance in W/m^2. dni must be >=0. dni_extra : numeric Extraterrestrial normal irradiance in W/m^2. solar_zenith : numeric apparent (refraction-corrected) zenith angles in decimal degrees. solar_zenith must be >=0 and <=180. solar_azimuth : numeric Sun azimuth angles in decimal degrees. solar_azimuth must be >=0 and <=360. The azimuth convention is defined as degrees east of north (e.g. North = 0, East = 90, West = 270). airmass : numeric (optional, default None) Relative (not pressure-corrected) airmass values. If airmass is a DataFrame it must be of the same size as all other DataFrame inputs. The kastenyoung1989 airmass calculation is used internally and is also recommended when pre-calculating airmass because it was used in the original model development. return_components: bool (optional, default=False) Flag used to decide whether to return the calculated diffuse components or not. Returns -------- numeric, OrderedDict, or DataFrame Return type controlled by `return_components` argument. If ``return_components=False``, `sky_diffuse` is returned. If ``return_components=True``, `diffuse_components` is returned. sky_diffuse : numeric The sky diffuse component of the solar radiation on a tilted surface. diffuse_components : OrderedDict (array input) or DataFrame (Series input) Keys/columns are: * sky_diffuse: Total sky diffuse * isotropic * circumsolar * horizon Notes ----- The Perez-Driesse model can be considered a plug-in replacement for the 1990 Perez model using the ``'allsitescomposite1990'`` coefficient set. Deviations between the two are very small, as demonstrated in [1]_. Other coefficient sets are not supported because the 1990 set is based on the largest and most diverse set of empirical data. References ---------- .. [1] A. Driesse, A. Jensen, R. Perez, A Continuous Form of the Perez Diffuse Sky Model for Forward and Reverse Transposition, accepted for publication in the Solar Energy Journal. .. [2] Perez, R., Ineichen, P., Seals, R., Michalsky, J., Stewart, R., 1990. Modeling daylight availability and irradiance components from direct and global irradiance. Solar Energy 44 (5), 271-289. See also -------- perez isotropic haydavies klucher reindl king""" [end of new definitions in pvlib/irradiance.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Continuous version of the Perez transposition model Is your feature request related to a problem? Please describe. Due to the empirical look-up tables, the Perez transposition model produces small jumps in tilted irradiance under gradually evolving sky conditions, and creates a difficult challenge for reverse transposition algorithms. Describe the solution you'd like Create a new version of the model having smooth transitions, but without changing the overall performance w.r.t. the original. Additional context A publication describing a solution has been accepted for publication in the Solar Energy Journal, and this solution will be implemented here. ---------- -------------------- </issues>	d53f97e984bfdd268aa92f8bf482ced0edda0110
sqlfluff__sqlfluff-5234	5,234	sqlfluff/sqlfluff	2.2	5ea25f5681fafa04ac45117ee8db9af1fa3941bb	2023-09-25T11:53:56Z	diff --git a/src/sqlfluff/dialects/dialect_ansi.py b/src/sqlfluff/dialects/dialect_ansi.py index b81b91b91b9..4fd91847490 100644 --- a/src/sqlfluff/dialects/dialect_ansi.py +++ b/src/sqlfluff/dialects/dialect_ansi.py @@ -120,6 +120,18 @@ class CompositeComparisonOperatorSegment(BaseSegment): type = "comparison_operator" +class WordSegment(CodeSegment): + """A generic (likely letters only) segment. + + Defined here for type inheritance. + + This is the base segment for things like keywords and + naked identifiers. + """ + + type = "word" + + ansi_dialect = Dialect("ansi", root_segment_name="FileSegment") ansi_dialect.set_lexer_matchers( @@ -206,14 +218,7 @@ class CompositeComparisonOperatorSegment(BaseSegment): StringLexer("colon", ":", CodeSegment), StringLexer("semicolon", ";", CodeSegment), # This is the "fallback" lexer for anything else which looks like SQL. - RegexLexer( - # NOTE: CodeSegment doesn't automatically add the `type` "code". - # This will be resolved soon, but until then we need to specify it here. - "code", - r"[0-9a-zA-Z_]+", - CodeSegment, - segment_kwargs={"type": "code"}, - ), + RegexLexer("word", r"[0-9a-zA-Z_]+", WordSegment), ] ) @@ -339,7 +344,7 @@ class CompositeComparisonOperatorSegment(BaseSegment): r"\"?[A-Z][A-Z0-9_]\"?", CodeSegment, type="parameter" ), FunctionNameIdentifierSegment=TypedParser( - "code", CodeSegment, type="function_name_identifier" + "word", WordSegment, type="function_name_identifier" ), # Maybe data types should be more restrictive? DatatypeIdentifierSegment=SegmentGenerator( @@ -4244,7 +4249,7 @@ class PathSegment(BaseSegment): Sequence( Ref("SlashSegment"), Delimited( - TypedParser("code", CodeSegment, type="path_segment"), + TypedParser("word", WordSegment, type="path_segment"), delimiter=Ref("SlashSegment"), allow_gaps=False, ), diff --git a/src/sqlfluff/dialects/dialect_db2.py b/src/sqlfluff/dialects/dialect_db2.py index 80f2e0572a0..6b2350ff287 100644 --- a/src/sqlfluff/dialects/dialect_db2.py +++ b/src/sqlfluff/dialects/dialect_db2.py @@ -78,9 +78,7 @@ CodeSegment, ), # In Db2, a field could have a # pound/hash sign - RegexLexer( - "code", r"[0-9a-zA-Z_#]+", CodeSegment, segment_kwargs={"type": "code"} - ), + RegexLexer("word", r"[0-9a-zA-Z_#]+", ansi.WordSegment), ] ) diff --git a/src/sqlfluff/dialects/dialect_mysql.py b/src/sqlfluff/dialects/dialect_mysql.py index 4de2289703b..688e8a00c99 100644 --- a/src/sqlfluff/dialects/dialect_mysql.py +++ b/src/sqlfluff/dialects/dialect_mysql.py @@ -935,7 +935,7 @@ class IntervalExpressionSegment(BaseSegment): segment_kwargs={"type": "at_sign_literal", "trim_chars": ("@",)}, ), ], - before="code", + before="word", ) diff --git a/src/sqlfluff/dialects/dialect_oracle.py b/src/sqlfluff/dialects/dialect_oracle.py index 3824c56a662..307a18faa3a 100644 --- a/src/sqlfluff/dialects/dialect_oracle.py +++ b/src/sqlfluff/dialects/dialect_oracle.py @@ -73,12 +73,7 @@ oracle_dialect.patch_lexer_matchers( [ - RegexLexer( - "code", - r"[a-zA-Z][0-9a-zA-Z_$#]", - CodeSegment, - segment_kwargs={"type": "code"}, - ), + RegexLexer("word", r"[a-zA-Z][0-9a-zA-Z_$#]", ansi.WordSegment), ] ) @@ -91,7 +86,7 @@ ), StringLexer("at_sign", "@", CodeSegment), ], - before="code", + before="word", ) oracle_dialect.insert_lexer_matchers( diff --git a/src/sqlfluff/dialects/dialect_postgres.py b/src/sqlfluff/dialects/dialect_postgres.py index 0243ca005fa..1b467c6ee75 100644 --- a/src/sqlfluff/dialects/dialect_postgres.py +++ b/src/sqlfluff/dialects/dialect_postgres.py @@ -151,7 +151,7 @@ ansi.LiteralSegment, ), ], - before="code", # Final thing to search for - as psql specific + before="word", # Final thing to search for - as psql specific ) postgres_dialect.patch_lexer_matchers( @@ -175,12 +175,7 @@ r'(?s)".+?"', CodeSegment, ), - RegexLexer( - "code", - r"[a-zA-Z_][0-9a-zA-Z_$]", - CodeSegment, - segment_kwargs={"type": "code"}, - ), + RegexLexer("word", r"[a-zA-Z_][0-9a-zA-Z_$]", ansi.WordSegment), ] ) @@ -249,12 +244,12 @@ ), # Add a Full equivalent which also allow keywords NakedIdentifierFullSegment=TypedParser( - "code", + "word", ansi.IdentifierSegment, type="naked_identifier_all", ), PropertiesNakedIdentifierSegment=TypedParser( # allows reserved keywords - "code", + "word", CodeSegment, type="properties_naked_identifier", ), diff --git a/src/sqlfluff/dialects/dialect_redshift.py b/src/sqlfluff/dialects/dialect_redshift.py index fad246ec8ff..bb840b536f0 100644 --- a/src/sqlfluff/dialects/dialect_redshift.py +++ b/src/sqlfluff/dialects/dialect_redshift.py @@ -10,7 +10,6 @@ Anything, BaseSegment, Bracketed, - CodeSegment, Dedent, Delimited, Indent, @@ -194,12 +193,11 @@ redshift_dialect.patch_lexer_matchers( [ - # add optional leading # to code for temporary tables + # add optional leading # to word for temporary tables RegexLexer( - "code", + "word", r"#?[0-9a-zA-Z_]+[0-9a-zA-Z_$]", - CodeSegment, - segment_kwargs={"type": "code"}, + ansi.WordSegment, ), ] ) diff --git a/src/sqlfluff/dialects/dialect_sparksql.py b/src/sqlfluff/dialects/dialect_sparksql.py index a368676fe9f..2a7b25665ee 100644 --- a/src/sqlfluff/dialects/dialect_sparksql.py +++ b/src/sqlfluff/dialects/dialect_sparksql.py @@ -145,7 +145,7 @@ CodeSegment, ), ], - before="code", + before="word", ) sparksql_dialect.insert_lexer_matchers( [ diff --git a/src/sqlfluff/dialects/dialect_tsql.py b/src/sqlfluff/dialects/dialect_tsql.py index 22055837256..d6c721c9176 100644 --- a/src/sqlfluff/dialects/dialect_tsql.py +++ b/src/sqlfluff/dialects/dialect_tsql.py @@ -221,7 +221,7 @@ ), ), RegexLexer( - "code", r"[0-9a-zA-Z_#@]+", CodeSegment + "word", r"[0-9a-zA-Z_#@]+", ansi.WordSegment ), # overriding to allow hash mark and at-sign in code ] )	diff --git a/test/core/parser/lexer_test.py b/test/core/parser/lexer_test.py index 2762e3305a8..7685cb36b0d 100644 --- a/test/core/parser/lexer_test.py +++ b/test/core/parser/lexer_test.py @@ -223,7 +223,7 @@ def _load_result(args, kwargs): "placeholder", ), ("\n", None, None, "newline"), - ("select", None, None, "raw"), + ("select", None, None, "word"), (" ", None, None, "whitespace"), ("2", None, None, "literal"), ("\n", None, None, "newline"), @@ -252,18 +252,18 @@ def _load_result(args, *kwargs): ("", None, None, "dedent"), ("", "{% endmacro %}", "block_end", "placeholder"), ("\n", None, None, "newline"), - ("SELECT", None, None, "raw"), + ("SELECT", None, None, "word"), ("\n", None, None, "newline"), (" ", None, None, "whitespace"), ("\n", None, None, "newline"), (" ", None, None, "whitespace"), ("'Sir. foo'", None, None, "raw"), (" ", None, None, "whitespace"), - ("as", None, None, "raw"), + ("as", None, None, "word"), (" ", None, None, "whitespace"), ("\n", None, None, "newline"), (" ", None, None, "whitespace"), - ("bar", None, None, "raw"), + ("bar", None, None, "word"), ("\n", None, None, "newline"), (" ", None, None, "whitespace"), ("\n", None, None, "newline"), @@ -271,9 +271,9 @@ def _load_result(args, **kwargs): ("", None, None, "dedent"), ("", "{% endcall %}", "block_end", "placeholder"), ("\n", None, None, "newline"), - ("FROM", None, None, "raw"), + ("FROM", None, None, "word"), (" ", None, None, "whitespace"), - ("baz", None, None, "raw"), + ("baz", None, None, "word"), ("\n", None, None, "newline"), ("", None, None, "end_of_file"), ], @@ -352,7 +352,7 @@ class _LexerSlicingTemplateFileCase(NamedTuple): ], ), expected_segments=[ - ("SELECT", None, None, "raw"), + ("SELECT", None, None, "word"), (" ", None, None, "whitespace"), ("", "{# comment #}", "comment", "placeholder"), ("1", None, None, "literal"), @@ -380,7 +380,7 @@ class _LexerSlicingTemplateFileCase(NamedTuple): ], ), expected_segments=[ - ("SELECT", None, None, "raw"), + ("SELECT", None, None, "word"), (" ", None, None, "whitespace"), ("", "", "special_type", "placeholder"), ("1", None, None, "literal"),		[ { "components": [ { "doc": "A generic (likely letters only) segment.\n\nDefined here for type inheritance.\n\nThis is the base segment for things like keywords and\nnaked identifiers.", "lines": [ 123, 132 ], "name": "WordSegment", "signature": "...	[ "test/core/parser/lexer_test.py::test__parser__lexer_slicing_calls[call", "test/core/parser/lexer_test.py::test__parser__lexer_slicing_from_template_file[very", "test/core/parser/lexer_test.py::test__parser__lexer_slicing_from_template_file[special" ]	[ "test/core/parser/lexer_test.py::test__parser__lexer_obj[a", "test/core/parser/lexer_test.py::test__parser__lexer_obj[b.c-res1]", "test/core/parser/lexer_test.py::test__parser__lexer_obj[abc", "test/core/parser/lexer_test.py::test__parser__lexer_obj[abc'\\n", "test/core/parser/lexer_test.py::test__parser__l...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Introduce "word" segment This is a follow-on from #5232. We've got a bit of a rats nest around the `CodeSegment` currently. It doesn't define a `type` but some segments look for it in the `TypedParser`. This raises some really gnarly bugs when trying to enable reparsing of segments cleanly (which have arisen as part of #5230). This resolves that by introducing a `WordSegment` which _inherits from_ `CodeSegment` but allows us to distinguish better between things that look like words (such as keywords etc...) and things that don't (like symbols or quotes). NOTE: There are some dependency changes we should make, in particular that `KeywordSegment` should inherit from `WordSegment` - but that's not supported by the current layout of `KeywordSegment` being part of `sqlfluff.core.parser` and `WordSegment` (and others) being withing `sqlfluff.dialects.ansi`. I'll address that as another PR because it makes it very hard to see the changes already in this PR. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/sqlfluff/dialects/dialect_ansi.py] (definition of WordSegment:) class WordSegment(CodeSegment): """A generic (likely letters only) segment. Defined here for type inheritance. This is the base segment for things like keywords and naked identifiers.""" [end of new definitions in src/sqlfluff/dialects/dialect_ansi.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		65328e6b701f46ebb25b758c10b7572111f130ab
pvlib__pvlib-python-1875	1,875	pvlib/pvlib-python	0.9	12ba8ee00dbe1cae3d4b4b4d8c0098f9144156e3	2023-09-25T04:23:07Z	diff --git a/docs/sphinx/source/reference/iotools.rst b/docs/sphinx/source/reference/iotools.rst index b41a30b203..05100e9d17 100644 --- a/docs/sphinx/source/reference/iotools.rst +++ b/docs/sphinx/source/reference/iotools.rst @@ -46,6 +46,10 @@ of sources and file formats relevant to solar energy modeling. iotools.get_acis_station_data iotools.get_acis_available_stations iotools.read_panond + iotools.get_solcast_tmy + iotools.get_solcast_historic + iotools.get_solcast_forecast + iotools.get_solcast_live A :py:class:`~pvlib.location.Location` object may be created from metadata diff --git a/docs/sphinx/source/whatsnew/v0.10.3.rst b/docs/sphinx/source/whatsnew/v0.10.3.rst index 30fd46648f..29aa59a543 100644 --- a/docs/sphinx/source/whatsnew/v0.10.3.rst +++ b/docs/sphinx/source/whatsnew/v0.10.3.rst @@ -15,6 +15,9 @@ Enhancements * :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance` and :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance_poa` now include shaded fraction in returned variables. (:pull:`1871`) +* Added :py:func:`~pvlib.iotools.get_solcast_tmy`, :py:func:`~pvlib.iotools.get_solcast_historic`, + :py:func:`~pvlib.iotools.get_solcast_forecast` and :py:func:`~pvlib.iotools.get_solcast_live` to + read data from the Solcast API. (:issue:`1313`, :pull:`1875`) * Added :py:func:`~pvlib.iam.convert` and :py:func:`~pvlib.iam.fit` that convert between IAM models, and that fit an IAM model to data. (:issue:`1824`, :pull:`1827`) @@ -59,4 +62,5 @@ Contributors * :ghuser:`matsuobasho` * Harry Jack (:ghuser:`harry-solcast`) * Kevin Anderson (:ghuser:`kandersolar`) +* Lorenzo Riches (:ghuser:`lorenzo-solcast`) * Cliff Hansen (:ghuser:`cwhanse`) diff --git a/pvlib/iotools/__init__.py b/pvlib/iotools/__init__.py index 9935719b29..6a4991ee7b 100644 --- a/pvlib/iotools/__init__.py +++ b/pvlib/iotools/__init__.py @@ -27,3 +27,7 @@ from pvlib.iotools.acis import get_acis_mpe # noqa: F401 from pvlib.iotools.acis import get_acis_station_data # noqa: F401 from pvlib.iotools.acis import get_acis_available_stations # noqa: F401 +from pvlib.iotools.solcast import get_solcast_forecast # noqa: F401 +from pvlib.iotools.solcast import get_solcast_live # noqa: F401 +from pvlib.iotools.solcast import get_solcast_historic # noqa: F401 +from pvlib.iotools.solcast import get_solcast_tmy # noqa: F401 diff --git a/pvlib/iotools/solcast.py b/pvlib/iotools/solcast.py new file mode 100644 index 0000000000..4fcee40050 --- /dev/null +++ b/pvlib/iotools/solcast.py @@ -0,0 +1,488 @@ +""" Functions to access data from the Solcast API. +""" + +import requests +import pandas as pd +from dataclasses import dataclass + + +BASE_URL = "https://api.solcast.com.au/data" + + +@dataclass +class ParameterMap: + solcast_name: str + pvlib_name: str + conversion: callable = lambda x: x + + +# define the conventions between Solcast and pvlib nomenclature and units +VARIABLE_MAP = [ + # air_temp -> temp_air (deg C) + ParameterMap("air_temp", "temp_air"), + # surface_pressure (hPa) -> pressure (Pa) + ParameterMap("surface_pressure", "pressure", lambda x: x100), + # dewpoint_temp -> temp_dew (deg C) + ParameterMap("dewpoint_temp", "temp_dew"), + # gti (W/m^2) -> poa_global (W/m^2) + ParameterMap("gti", "poa_global"), + # wind_speed_10m (m/s) -> wind_speed (m/s) + ParameterMap("wind_speed_10m", "wind_speed"), + # wind_direction_10m (deg) -> wind_direction (deg) + ParameterMap("wind_direction_10m", "wind_direction"), + # azimuth -> solar_azimuth (degrees) (different convention) + ParameterMap( + "azimuth", "solar_azimuth", lambda x: -x % 360 + ), + # precipitable_water (kg/m2) -> precipitable_water (cm) + ParameterMap("precipitable_water", "precipitable_water", lambda x: x10), + # zenith -> solar_zenith + ParameterMap("zenith", "solar_zenith"), + # clearsky + ParameterMap("clearsky_dhi", "dhi_clear"), + ParameterMap("clearsky_dni", "dni_clear"), + ParameterMap("clearsky_ghi", "ghi_clear"), + ParameterMap("clearsky_gti", "poa_global_clear") +] + + +def get_solcast_tmy( + latitude, longitude, api_key, map_variables=True, kwargs +): + """Get irradiance and weather for a + Typical Meteorological Year (TMY) at a requested location. + + Data is derived from a multi-year time series selected to present the + unique weather phenomena with annual averages that are consistent with + long term averages. See [1]_ for details on the calculation. + + Parameters + ---------- + latitude : float + in decimal degrees, between -90 and 90, north is positive + longitude : float + in decimal degrees, between -180 and 180, east is positive + api_key : str + To access Solcast data you will need an API key [2]_. + map_variables: bool, default: True + When true, renames columns of the DataFrame to pvlib variable names + where applicable. See variable :const:`VARIABLE_MAP`. + Time is the index shifted to the midpoint of each interval + from Solcast's "period end" convention. + kwargs: + Optional parameters passed to the API. + See [3]_ for full list of parameters. + + Returns + ------- + data : pandas.DataFrame + containing the values for the parameters requested. The times + in the DataFrame index indicate the midpoint of each interval. + metadata: dict + latitude and longitude of the request. + + Examples + -------- + >>> df, meta = pvlib.iotools.solcast.get_solcast_tmy( + >>> latitude=-33.856784, + >>> longitude=151.215297, + >>> api_key="your-key" + >>> ) + + you can pass any of the parameters listed in the API docs, + like ``time_zone``. Here we set the value of 10 for + "10 hours ahead of UTC": + + >>> df, meta = pvlib.iotools.solcast.get_solcast_tmy( + >>> latitude=-33.856784, + >>> longitude=151.215297, + >>> time_zone=10, + >>> api_key="your-key" + >>> ) + + References + ---------- + .. [1] `Solcast TMY Docs <https://solcast.com/tmy>`_ + .. [2] `Get an API Key <https://toolkit.solcast.com.au/register>`_ + .. [3] `Solcast API Docs <https://docs.solcast.com.au/>`_ + + See Also + -------- + pvlib.iotools.get_solcast_historic, pvlib.iotools.get_solcast_forecast, + pvlib.iotools.get_solcast_live + """ + + params = dict( + latitude=latitude, + longitude=longitude, + format="json", + kwargs + ) + + data = _get_solcast( + endpoint="tmy/radiation_and_weather", + params=params, + api_key=api_key, + map_variables=map_variables + ) + + return data, {"latitude": latitude, "longitude": longitude} + + +def get_solcast_historic( + latitude, + longitude, + start, + api_key, + end=None, + duration=None, + map_variables=True, + kwargs +): + """Get historical irradiance and weather estimates. + + for up to 31 days of data at a time for a requested location, + derived from satellite (clouds and irradiance + over non-polar continental areas) and + numerical weather models (other data). + Data is available from 2007-01-01T00:00Z up to real time estimated actuals. + + Parameters + ---------- + latitude : float + in decimal degrees, between -90 and 90, north is positive + longitude : float + in decimal degrees, between -180 and 180, east is positive + start : datetime-like + First day of the requested period + end : optional, datetime-like + Last day of the requested period. + Must include one of ``end`` or ``duration``. + duration : optional, ISO 8601 compliant duration + Must include either ``end`` or ``duration``. + ISO 8601 compliant duration for the historic data, + like "P1D" for one day of data. + Must be within 31 days of ``start``. + map_variables: bool, default: True + When true, renames columns of the DataFrame to pvlib variable names + where applicable. See variable :const:`VARIABLE_MAP`. + Time is the index shifted to the midpoint of each interval + from Solcast's "period end" convention. + api_key : str + To access Solcast data you will need an API key [1]_. + kwargs: + Optional parameters passed to the API. + See [2]_ for full list of parameters. + + Returns + ------- + data : pandas.DataFrame + containing the values for the parameters requested. The times + in the DataFrame index indicate the midpoint of each interval. + metadata: dict + latitude and longitude of the request. + + Examples + -------- + >>> df, meta = pvlib.iotools.solcast.get_solcast_historic( + >>> latitude=-33.856784, + >>> longitude=151.215297, + >>> start='2007-01-01T00:00Z', + >>> duration='P1D', + >>> api_key="your-key" + >>> ) + + you can pass any of the parameters listed in the API docs, + for example using the ``end`` parameter instead + + >>> df, meta = pvlib.iotools.solcast.get_solcast_historic( + >>> latitude=-33.856784, + >>> longitude=151.215297, + >>> start='2007-01-01T00:00Z', + >>> end='2007-01-02T00:00Z', + >>> api_key="your-key" + >>> ) + + References + ---------- + .. [1] `Get an API Key <https://toolkit.solcast.com.au/register>`_ + .. [2] `Solcast API Docs <https://docs.solcast.com.au/>`_ + + See Also + -------- + pvlib.iotools.get_solcast_tmy, pvlib.iotools.get_solcast_forecast, + pvlib.iotools.get_solcast_live + """ + + params = dict( + latitude=latitude, + longitude=longitude, + start=start, + end=end, + duration=duration, + api_key=api_key, + format="json", + kwargs + ) + + data = _get_solcast( + endpoint="historic/radiation_and_weather", + params=params, + api_key=api_key, + map_variables=map_variables + ) + + return data, {"latitude": latitude, "longitude": longitude} + + +def get_solcast_forecast( + latitude, longitude, api_key, map_variables=True, kwargs +): + """Get irradiance and weather forecasts from the present time + up to 14 days ahead. + + Parameters + ---------- + latitude : float + in decimal degrees, between -90 and 90, north is positive + longitude : float + in decimal degrees, between -180 and 180, east is positive + api_key : str + To access Solcast data you will need an API key [1]_. + map_variables: bool, default: True + When true, renames columns of the DataFrame to pvlib variable names + where applicable. See variable :const:`VARIABLE_MAP`. + Time is the index shifted to the midpoint of each interval + from Solcast's "period end" convention. + kwargs: + Optional parameters passed to the API. + See [2]_ for full list of parameters. + + Returns + ------- + data : pandas.DataFrame + Contains the values for the parameters requested. The times + in the DataFrame index indicate the midpoint of each interval. + metadata: dict + latitude and longitude of the request. + + Examples + -------- + >>> df, meta = pvlib.iotools.solcast.get_solcast_forecast( + >>> latitude=-33.856784, + >>> longitude=151.215297, + >>> api_key="your-key" + >>> ) + + you can pass any of the parameters listed in the API docs, + like asking for specific variables for a specific time horizon: + + >>> df, meta = pvlib.iotools.solcast.get_solcast_forecast( + >>> latitude=-33.856784, + >>> longitude=151.215297, + >>> output_parameters=['dni', 'clearsky_dni', 'snow_soiling_rooftop'], + >>> hours=24, + >>> api_key="your-key" + >>> ) + + References + ---------- + .. [1] `Get an API Key <https://toolkit.solcast.com.au/register>`_ + .. [2] `Solcast API Docs <https://docs.solcast.com.au/>`_ + + See Also + -------- + pvlib.iotools.get_solcast_tmy, pvlib.iotools.get_solcast_historic, + pvlib.iotools.get_solcast_live + """ + + params = dict( + latitude=latitude, + longitude=longitude, + format="json", + kwargs + ) + + data = _get_solcast( + endpoint="forecast/radiation_and_weather", + params=params, + api_key=api_key, + map_variables=map_variables + ) + + return data, {"latitude": latitude, "longitude": longitude} + + +def get_solcast_live( + latitude, longitude, api_key, map_variables=True, kwargs +): + """Get irradiance and weather estimated actuals for near real-time + and past 7 days. + + Parameters + ---------- + latitude : float + in decimal degrees, between -90 and 90, north is positive + longitude : float + in decimal degrees, between -180 and 180, east is positive + api_key : str + To access Solcast data you will need an API key [1]_. + map_variables: bool, default: True + When true, renames columns of the DataFrame to pvlib variable names + where applicable. See variable :const:`VARIABLE_MAP`. + Time is the index shifted to the midpoint of each interval + from Solcast's "period end" convention. + kwargs: + Optional parameters passed to the API. + See [2]_ for full list of parameters. + + Returns + ------- + data : pandas.DataFrame + containing the values for the parameters requested. The times + in the DataFrame index indicate the midpoint of each interval. + metadata: dict + latitude and longitude of the request. + + Examples + -------- + >>> df, meta = pvlib.iotools.solcast.get_solcast_live( + >>> latitude=-33.856784, + >>> longitude=151.215297, + >>> api_key="your-key" + >>> ) + + you can pass any of the parameters listed in the API docs, like + + >>> df, meta = pvlib.iotools.solcast.get_solcast_live( + >>> latitude=-33.856784, + >>> longitude=151.215297, + >>> terrain_shading=True, + >>> output_parameters=['ghi', 'clearsky_ghi', 'snow_soiling_rooftop'], + >>> api_key="your-key" + >>> ) + + use ``map_variables=False`` to avoid converting the data + to PVLib's conventions. + + >>> df, meta = pvlib.iotools.solcast.get_solcast_live( + >>> latitude=-33.856784, + >>> longitude=151.215297, + >>> map_variables=False, + >>> api_key="your-key" + >>> ) + + References + ---------- + .. [1] `Get an API Key <https://toolkit.solcast.com.au/register>`_ + .. [2] `Solcast API Docs <https://docs.solcast.com.au/>`_ + + See Also + -------- + pvlib.iotools.get_solcast_tmy, pvlib.iotools.get_solcast_historic, + pvlib.iotools.get_solcast_forecast + """ + + params = dict( + latitude=latitude, + longitude=longitude, + format="json", + kwargs + ) + + data = _get_solcast( + endpoint="live/radiation_and_weather", + params=params, + api_key=api_key, + map_variables=map_variables + ) + + return data, {"latitude": latitude, "longitude": longitude} + + +def _solcast2pvlib(data): + """Format the data from Solcast to pvlib's conventions. + + Parameters + ---------- + data : pandas.DataFrame + contains the data returned from the Solcast API + + Returns + ------- + a pandas.DataFrame with the data cast to pvlib's conventions + """ + # move from period_end to period_middle as per pvlib convention + # to support Pandas 0.25 we cast PTXX to XX as ISO8601 + # durations without days aren't supported: + # https://github.com/pandas-dev/pandas/pull/37159\ + # Can remove once minimum supported Pandas version is >=1.2 + periods = data.period.str.replace("PT", "").str.replace("M", "m") + + data["period_mid"] = pd.to_datetime( + data.period_end) - pd.to_timedelta(periods) / 2 + data = data.set_index("period_mid").drop(columns=["period_end", "period"]) + + # rename and convert variables + for variable in VARIABLE_MAP: + if variable.solcast_name in data.columns: + data.rename( + columns={variable.solcast_name: variable.pvlib_name}, + inplace=True + ) + data[variable.pvlib_name] = data[ + variable.pvlib_name].apply(variable.conversion) + return data + + +def _get_solcast( + endpoint, + params, + api_key, + map_variables +): + """Retrieve weather, irradiance and power data from the Solcast API. + + Parameters + ---------- + endpoint : str + one of Solcast API endpoint: + - live/radiation_and_weather + - forecast/radiation_and_weather + - historic/radiation_and_weather + - tmy/radiation_and_weather + params : dict + parameters to be passed to the API + api_key : str + To access Solcast data you will need an API key [1]_. + map_variables: bool, default: True + When true, renames columns of the DataFrame to pvlib's variable names + where applicable. See variable :const:`VARIABLE_MAP`. + Time is the index shifted to the midpoint of each interval + from Solcast's "period end" convention. + + Returns + ------- + A pandas.DataFrame with the data if the request is successful, + an error message otherwise + + References + ---------- + .. [1] `register <https://toolkit.solcast.com.au/register>` + """ + + response = requests.get( + url='/'.join([BASE_URL, endpoint]), + params=params, + headers={"Authorization": f"Bearer {api_key}"} + ) + + if response.status_code == 200: + j = response.json() + df = pd.DataFrame.from_dict(j[list(j.keys())[0]]) + if map_variables: + return _solcast2pvlib(df) + else: + return df + else: + raise Exception(response.json())	diff --git a/pvlib/tests/iotools/test_solcast.py b/pvlib/tests/iotools/test_solcast.py new file mode 100644 index 0000000000..19b00b8611 --- /dev/null +++ b/pvlib/tests/iotools/test_solcast.py @@ -0,0 +1,324 @@ +from unittest.mock import patch +import pandas as pd +import pvlib +import pytest + + +@pytest.mark.parametrize("endpoint,params,api_key,json_response", [ + ( + "live/radiation_and_weather", + dict( + latitude=-33.856784, + longitude=151.215297, + output_parameters='dni,ghi' + ), + "1234", + {'estimated_actuals': + [{'dni': 836, 'ghi': 561, + 'period_end': '2023-09-18T05:00:00.0000000Z', 'period': 'PT30M'}, + {'dni': 866, 'ghi': 643, + 'period_end': '2023-09-18T04:30:00.0000000Z', 'period': 'PT30M'}, + {'dni': 890, 'ghi': 713, + 'period_end': '2023-09-18T04:00:00.0000000Z', 'period': 'PT30M'}, + {'dni': 909, 'ghi': 768, + 'period_end': '2023-09-18T03:30:00.0000000Z', 'period': 'PT30M'}] + } + ), +]) +def test__get_solcast(requests_mock, endpoint, params, api_key, json_response): + mock_url = f"https://api.solcast.com.au/data/{endpoint}?" \ + f"latitude={params['latitude']}&" \ + f"longitude={params['longitude']}&" \ + f"output_parameters={params['output_parameters']}" + + requests_mock.get(mock_url, json=json_response) + + # with variables remapping + pd.testing.assert_frame_equal( + pvlib.iotools.solcast._get_solcast( + endpoint, params, api_key, True + ), + pvlib.iotools.solcast._solcast2pvlib( + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]]) + ) + ) + + # no remapping of variables + pd.testing.assert_frame_equal( + pvlib.iotools.solcast._get_solcast( + endpoint, params, api_key, False + ), + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]]) + ) + + +@pytest.mark.parametrize("map_variables", [True, False]) +@pytest.mark.parametrize("endpoint,function,params,json_response", [ + ( + "live/radiation_and_weather", + pvlib.iotools.get_solcast_live, + dict( + api_key="1234", + latitude=-33.856784, + longitude=151.215297, + output_parameters='dni,ghi' + ), + {'estimated_actuals': + [{'dni': 836, 'ghi': 561, + 'period_end': '2023-09-18T05:00:00.0000000Z', 'period': 'PT30M'}, + {'dni': 866, 'ghi': 643, + 'period_end': '2023-09-18T04:30:00.0000000Z', 'period': 'PT30M'}, + {'dni': 890, 'ghi': 713, + 'period_end': '2023-09-18T04:00:00.0000000Z', 'period': 'PT30M'}, + {'dni': 909, 'ghi': 768, + 'period_end': '2023-09-18T03:30:00.0000000Z', 'period': 'PT30M'}] + } + ), +]) +def test_get_solcast_live( + requests_mock, endpoint, function, params, json_response, map_variables +): + mock_url = ( + f"https://api.solcast.com.au/data/{endpoint}?" + f"&latitude={params['latitude']}&" + f"longitude={params['longitude']}&" + f"output_parameters={params['output_parameters']}&format=json" + ) + + requests_mock.get(mock_url, json=json_response) + + if map_variables: + pd.testing.assert_frame_equal( + function(params, map_variables=map_variables)[0], + pvlib.iotools.solcast._solcast2pvlib( + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]] + ) + ), + ) + else: + pd.testing.assert_frame_equal( + function(params, map_variables=map_variables)[0], + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]] + ), + ) + + +@pytest.mark.parametrize("map_variables", [True, False]) +@pytest.mark.parametrize("endpoint,function,params,json_response", [ + ( + "tmy/radiation_and_weather", + pvlib.iotools.get_solcast_tmy, + dict( + api_key="1234", + latitude=-33.856784, + longitude=51.215297 + ), + {'estimated_actuals': [ + {'dni': 151, 'ghi': 609, + 'period_end': '2059-01-01T01:00:00.0000000Z', 'period': 'PT60M'}, + {'dni': 0, 'ghi': 404, + 'period_end': '2059-01-01T02:00:00.0000000Z', 'period': 'PT60M'}, + {'dni': 0, 'ghi': 304, + 'period_end': '2059-01-01T03:00:00.0000000Z', 'period': 'PT60M'}, + {'dni': 0, 'ghi': 174, + 'period_end': '2059-01-01T04:00:00.0000000Z', 'period': 'PT60M'}, + {'dni': 0, 'ghi': 111, + 'period_end': '2059-01-01T05:00:00.0000000Z', 'period': 'PT60M'}] + } + ), +]) +def test_get_solcast_tmy( + requests_mock, endpoint, function, params, json_response, map_variables +): + + mock_url = f"https://api.solcast.com.au/data/{endpoint}?" \ + f"&latitude={params['latitude']}&" \ + f"longitude={params['longitude']}&format=json" + + requests_mock.get(mock_url, json=json_response) + + if map_variables: + pd.testing.assert_frame_equal( + function(params, map_variables=map_variables)[0], + pvlib.iotools.solcast._solcast2pvlib( + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]] + ) + ), + ) + else: + pd.testing.assert_frame_equal( + function(params, map_variables=map_variables)[0], + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]] + ), + ) + + +@pytest.mark.parametrize("in_df,out_df", [ + ( + pd.DataFrame( + [[942, 843, 1017.4, 30, 7.8, 316, 1010, -2, 4.6, 16.4, + '2023-09-20T02:00:00.0000000Z', 'PT30M', 90], + [936, 832, 1017.9, 30, 7.9, 316, 996, -14, 4.5, 16.3, + '2023-09-20T01:30:00.0000000Z', 'PT30M', 0]], + columns=[ + 'dni', 'ghi', 'surface_pressure', 'air_temp', 'wind_speed_10m', + 'wind_direction_10m', 'gti', 'azimuth', 'dewpoint_temp', + 'precipitable_water', 'period_end', 'period', 'zenith'], + index=pd.RangeIndex(start=0, stop=2, step=1) + ), + pd.DataFrame( + [[9.4200e+02, 8.4300e+02, 1.0174e+05, 3.0000e+01, 7.8000e+00, + 3.1600e+02, 1.0100e+03, 2.0000e+00, 4.6000e+00, 1.6400e+02, 90], + [9.3600e+02, 8.3200e+02, 1.0179e+05, 3.0000e+01, 7.9000e+00, + 3.1600e+02, 9.9600e+02, 1.4000e+01, 4.5000e+00, 1.6300e+02, 0]], + columns=[ + 'dni', 'ghi', 'pressure', 'temp_air', 'wind_speed', + 'wind_direction', 'poa_global', 'solar_azimuth', + 'temp_dew', 'precipitable_water', 'solar_zenith'], + index=pd.DatetimeIndex( + ['2023-09-20 01:45:00+00:00', '2023-09-20 01:15:00+00:00'], + dtype='datetime64[ns, UTC]', name='period_mid', freq=None) + ) + ) +]) +def test_solcast2pvlib(in_df, out_df): + df = pvlib.iotools.solcast._solcast2pvlib(in_df) + pd.testing.assert_frame_equal(df.astype(float), out_df.astype(float)) + + +@pytest.mark.parametrize("map_variables", [True, False]) +@pytest.mark.parametrize("endpoint,function,params,json_response", [ + ( + "historic/radiation_and_weather", + pvlib.iotools.get_solcast_historic, + dict( + api_key="1234", + latitude=-33.856784, + longitude=51.215297, + start="2023-01-01T08:00", + duration="P1D", + period="PT1H", + output_parameters='dni' + ), {'estimated_actuals': [ + {'dni': 822, 'period_end': '2023-01-01T09:00:00.0000000Z', + 'period': 'PT60M'}, + {'dni': 918, 'period_end': '2023-01-01T10:00:00.0000000Z', + 'period': 'PT60M'}, + {'dni': 772, 'period_end': '2023-01-01T11:00:00.0000000Z', + 'period': 'PT60M'}, + {'dni': 574, 'period_end': '2023-01-01T12:00:00.0000000Z', + 'period': 'PT60M'}, + {'dni': 494, 'period_end': '2023-01-01T13:00:00.0000000Z', + 'period': 'PT60M'} + ]} + ), +]) +def test_get_solcast_historic( + requests_mock, endpoint, function, params, json_response, map_variables +): + mock_url = f"https://api.solcast.com.au/data/{endpoint}?" \ + f"&latitude={params['latitude']}&" \ + f"longitude={params['longitude']}&format=json" + + requests_mock.get(mock_url, json=json_response) + + if map_variables: + pd.testing.assert_frame_equal( + function(params, map_variables=map_variables)[0], + pvlib.iotools.solcast._solcast2pvlib( + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]] + ) + ), + ) + else: + pd.testing.assert_frame_equal( + function(params, map_variables=map_variables)[0], + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]] + ), + ) + + +@pytest.mark.parametrize("map_variables", [True, False]) +@pytest.mark.parametrize("endpoint,function,params,json_response", [ + ( + "forecast/radiation_and_weather", + pvlib.iotools.get_solcast_forecast, + dict( + api_key="1234", + latitude=-33.856784, + longitude=51.215297, + hours="5", + period="PT1H", + output_parameters='dni' + ), { + 'forecast': [ + {'dni': 0, 'period_end': '2023-12-13T01:00:00.0000000Z', + 'period': 'PT1H'}, + {'dni': 1, 'period_end': '2023-12-13T02:00:00.0000000Z', + 'period': 'PT1H'}, + {'dni': 2, 'period_end': '2023-12-13T03:00:00.0000000Z', + 'period': 'PT1H'}, + {'dni': 3, 'period_end': '2023-12-13T04:00:00.0000000Z', + 'period': 'PT1H'}, + {'dni': 4, 'period_end': '2023-12-13T05:00:00.0000000Z', + 'period': 'PT1H'}, + {'dni': 5, 'period_end': '2023-12-13T06:00:00.0000000Z', + 'period': 'PT1H'} + ]} + ), +]) +def test_get_solcast_forecast( + requests_mock, endpoint, function, params, json_response, map_variables +): + mock_url = f"https://api.solcast.com.au/data/{endpoint}?" \ + f"&latitude={params['latitude']}&" \ + f"longitude={params['longitude']}&format=json" + + requests_mock.get(mock_url, json=json_response) + + if map_variables: + pd.testing.assert_frame_equal( + function(params, map_variables=map_variables)[0], + pvlib.iotools.solcast._solcast2pvlib( + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]] + ) + ), + ) + else: + pd.testing.assert_frame_equal( + function(params, map_variables=map_variables)[0], + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]] + ), + ) + + +@pytest.mark.parametrize( + "function", + [ + pvlib.iotools.get_solcast_forecast, + pvlib.iotools.get_solcast_live, + pvlib.iotools.get_solcast_tmy, + pvlib.iotools.get_solcast_historic, + ], +) +@patch("requests.api.request") +def test_raises_exception(mock_response, function): + dummy_args = { + "latitude": 0, + "longitude": 0, + "api_key": "", + } + with patch.object(mock_response, "status_code", return_value=404): + with pytest.raises(Exception): + function(**dummy_args) + mock_response.json.assert_called_once()	diff --git a/docs/sphinx/source/reference/iotools.rst b/docs/sphinx/source/reference/iotools.rst index b41a30b203..05100e9d17 100644 --- a/docs/sphinx/source/reference/iotools.rst +++ b/docs/sphinx/source/reference/iotools.rst @@ -46,6 +46,10 @@ of sources and file formats relevant to solar energy modeling. iotools.get_acis_station_data iotools.get_acis_available_stations iotools.read_panond + iotools.get_solcast_tmy + iotools.get_solcast_historic + iotools.get_solcast_forecast + iotools.get_solcast_live A :py:class:`~pvlib.location.Location` object may be created from metadata diff --git a/docs/sphinx/source/whatsnew/v0.10.3.rst b/docs/sphinx/source/whatsnew/v0.10.3.rst index 30fd46648f..29aa59a543 100644 --- a/docs/sphinx/source/whatsnew/v0.10.3.rst +++ b/docs/sphinx/source/whatsnew/v0.10.3.rst @@ -15,6 +15,9 @@ Enhancements * :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance` and :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance_poa` now include shaded fraction in returned variables. (:pull:`1871`) +* Added :py:func:`~pvlib.iotools.get_solcast_tmy`, :py:func:`~pvlib.iotools.get_solcast_historic`, + :py:func:`~pvlib.iotools.get_solcast_forecast` and :py:func:`~pvlib.iotools.get_solcast_live` to + read data from the Solcast API. (:issue:`1313`, :pull:`1875`) * Added :py:func:`~pvlib.iam.convert` and :py:func:`~pvlib.iam.fit` that convert between IAM models, and that fit an IAM model to data. (:issue:`1824`, :pull:`1827`) @@ -59,4 +62,5 @@ Contributors * :ghuser:`matsuobasho` * Harry Jack (:ghuser:`harry-solcast`) * Kevin Anderson (:ghuser:`kandersolar`) +* Lorenzo Riches (:ghuser:`lorenzo-solcast`) * Cliff Hansen (:ghuser:`cwhanse`)	[ { "components": [ { "doc": "", "lines": [ 13, 16 ], "name": "ParameterMap", "signature": "class ParameterMap:", "type": "class" }, { "doc": "Get irradiance and weather for a\nTypical Meteorological Year (TMY) at a requ...	[ "pvlib/tests/iotools/test_solcast.py::test__get_solcast[live/radiation_and_weather-params0-1234-json_response0]", "pvlib/tests/iotools/test_solcast.py::test_get_solcast_live[live/radiation_and_weather-get_solcast_live-params0-json_response0-True]", "pvlib/tests/iotools/test_solcast.py::test_get_solcast_live[liv...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> add functionality to load Solcast API data to `iotools` - [x] Closes #1313 - [x] I am familiar with the [contributing guidelines](https://pvlib-python.readthedocs.io/en/latest/contributing.html) - [x] Tests added - [x] Updates entries in [`docs/sphinx/source/reference`](https://github.com/pvlib/pvlib-python/blob/main/docs/sphinx/source/reference) for API changes. - [x] Adds description and name entries in the appropriate "what's new" file in [`docs/sphinx/source/whatsnew`](https://github.com/pvlib/pvlib-python/tree/main/docs/sphinx/source/whatsnew) for all changes. Includes link to the GitHub Issue with `` :issue:`num` `` or this Pull Request with `` :pull:`num` ``. Includes contributor name and/or GitHub username (link with `` :ghuser:`user` ``). - [x] New code is fully documented. Includes [numpydoc](https://numpydoc.readthedocs.io/en/latest/format.html) compliant docstrings, examples, and comments where necessary. - [x] Pull request is nearly complete and ready for detailed review. - [x] Maintainer: Appropriate GitHub Labels (including `remote-data`) and Milestone are assigned to the Pull Request and linked Issue. With this PR we are proposing to add a module `iotools.solcast` with functions to get irradiation and weather data for live, forecast, historic and tmy from the Solcast API. We noticed the demand for such functionality and many of our users use PVLib with Solcast data. Note that Solcast has a free tier for radiation and weather data which you can access immediately by using a company email address when [signing up](https://toolkit.solcast.com.au/register). We also have unlimited requests at [unmetered locations](https://docs.solcast.com.au/#unmetered-locations) and additional free data is also [available](https://solcast.com/data-for-researchers) for researchers and students. This is a first iteration and are looking for feedback, in particular about the following design decisions: 1. following the pattern in the other `iotools` modules, we have created a mapping to translate variables form Solcast's definition to PVLibs that is applied when `map_variables` is `True`. This is a 1-way translation so the user would still query the Solcast API with Solcast's definitions and get the variables in a `pd.DataFrame` with the variables converted to PVLib's. We could make the interface only using PVLib's definitions but that may cause confusion with the API documentation. 2. testing is currently using `mocks`. If you prefer we can provide an API key to test directly against the API. 3. the function signatures have only the required parameters declared with all optional as `kwargs`. The intention is to avoid docstrings that are too verbose. Some tests have been added but we'll add more after a first review. Thanks! ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pvlib/iotools/solcast.py] (definition of ParameterMap:) class ParameterMap: (definition of get_solcast_tmy:) def get_solcast_tmy( latitude, longitude, api_key, map_variables=True, kwargs ): """Get irradiance and weather for a Typical Meteorological Year (TMY) at a requested location. Data is derived from a multi-year time series selected to present the unique weather phenomena with annual averages that are consistent with long term averages. See [1]_ for details on the calculation. Parameters ---------- latitude : float in decimal degrees, between -90 and 90, north is positive longitude : float in decimal degrees, between -180 and 180, east is positive api_key : str To access Solcast data you will need an API key [2]_. map_variables: bool, default: True When true, renames columns of the DataFrame to pvlib variable names where applicable. See variable :const:`VARIABLE_MAP`. Time is the index shifted to the midpoint of each interval from Solcast's "period end" convention. kwargs: Optional parameters passed to the API. See [3]_ for full list of parameters. Returns ------- data : pandas.DataFrame containing the values for the parameters requested. The times in the DataFrame index indicate the midpoint of each interval. metadata: dict latitude and longitude of the request. Examples -------- >>> df, meta = pvlib.iotools.solcast.get_solcast_tmy( >>> latitude=-33.856784, >>> longitude=151.215297, >>> api_key="your-key" >>> ) you can pass any of the parameters listed in the API docs, like ``time_zone``. Here we set the value of 10 for "10 hours ahead of UTC": >>> df, meta = pvlib.iotools.solcast.get_solcast_tmy( >>> latitude=-33.856784, >>> longitude=151.215297, >>> time_zone=10, >>> api_key="your-key" >>> ) References ---------- .. [1] `Solcast TMY Docs <https://solcast.com/tmy>`_ .. [2] `Get an API Key <https://toolkit.solcast.com.au/register>`_ .. [3] `Solcast API Docs <https://docs.solcast.com.au/>`_ See Also -------- pvlib.iotools.get_solcast_historic, pvlib.iotools.get_solcast_forecast, pvlib.iotools.get_solcast_live""" (definition of get_solcast_historic:) def get_solcast_historic( latitude, longitude, start, api_key, end=None, duration=None, map_variables=True, kwargs ): """Get historical irradiance and weather estimates. for up to 31 days of data at a time for a requested location, derived from satellite (clouds and irradiance over non-polar continental areas) and numerical weather models (other data). Data is available from 2007-01-01T00:00Z up to real time estimated actuals. Parameters ---------- latitude : float in decimal degrees, between -90 and 90, north is positive longitude : float in decimal degrees, between -180 and 180, east is positive start : datetime-like First day of the requested period end : optional, datetime-like Last day of the requested period. Must include one of ``end`` or ``duration``. duration : optional, ISO 8601 compliant duration Must include either ``end`` or ``duration``. ISO 8601 compliant duration for the historic data, like "P1D" for one day of data. Must be within 31 days of ``start``. map_variables: bool, default: True When true, renames columns of the DataFrame to pvlib variable names where applicable. See variable :const:`VARIABLE_MAP`. Time is the index shifted to the midpoint of each interval from Solcast's "period end" convention. api_key : str To access Solcast data you will need an API key [1]_. kwargs: Optional parameters passed to the API. See [2]_ for full list of parameters. Returns ------- data : pandas.DataFrame containing the values for the parameters requested. The times in the DataFrame index indicate the midpoint of each interval. metadata: dict latitude and longitude of the request. Examples -------- >>> df, meta = pvlib.iotools.solcast.get_solcast_historic( >>> latitude=-33.856784, >>> longitude=151.215297, >>> start='2007-01-01T00:00Z', >>> duration='P1D', >>> api_key="your-key" >>> ) you can pass any of the parameters listed in the API docs, for example using the ``end`` parameter instead >>> df, meta = pvlib.iotools.solcast.get_solcast_historic( >>> latitude=-33.856784, >>> longitude=151.215297, >>> start='2007-01-01T00:00Z', >>> end='2007-01-02T00:00Z', >>> api_key="your-key" >>> ) References ---------- .. [1] `Get an API Key <https://toolkit.solcast.com.au/register>`_ .. [2] `Solcast API Docs <https://docs.solcast.com.au/>`_ See Also -------- pvlib.iotools.get_solcast_tmy, pvlib.iotools.get_solcast_forecast, pvlib.iotools.get_solcast_live""" (definition of get_solcast_forecast:) def get_solcast_forecast( latitude, longitude, api_key, map_variables=True, kwargs ): """Get irradiance and weather forecasts from the present time up to 14 days ahead. Parameters ---------- latitude : float in decimal degrees, between -90 and 90, north is positive longitude : float in decimal degrees, between -180 and 180, east is positive api_key : str To access Solcast data you will need an API key [1]_. map_variables: bool, default: True When true, renames columns of the DataFrame to pvlib variable names where applicable. See variable :const:`VARIABLE_MAP`. Time is the index shifted to the midpoint of each interval from Solcast's "period end" convention. kwargs: Optional parameters passed to the API. See [2]_ for full list of parameters. Returns ------- data : pandas.DataFrame Contains the values for the parameters requested. The times in the DataFrame index indicate the midpoint of each interval. metadata: dict latitude and longitude of the request. Examples -------- >>> df, meta = pvlib.iotools.solcast.get_solcast_forecast( >>> latitude=-33.856784, >>> longitude=151.215297, >>> api_key="your-key" >>> ) you can pass any of the parameters listed in the API docs, like asking for specific variables for a specific time horizon: >>> df, meta = pvlib.iotools.solcast.get_solcast_forecast( >>> latitude=-33.856784, >>> longitude=151.215297, >>> output_parameters=['dni', 'clearsky_dni', 'snow_soiling_rooftop'], >>> hours=24, >>> api_key="your-key" >>> ) References ---------- .. [1] `Get an API Key <https://toolkit.solcast.com.au/register>`_ .. [2] `Solcast API Docs <https://docs.solcast.com.au/>`_ See Also -------- pvlib.iotools.get_solcast_tmy, pvlib.iotools.get_solcast_historic, pvlib.iotools.get_solcast_live""" (definition of get_solcast_live:) def get_solcast_live( latitude, longitude, api_key, map_variables=True, kwargs ): """Get irradiance and weather estimated actuals for near real-time and past 7 days. Parameters ---------- latitude : float in decimal degrees, between -90 and 90, north is positive longitude : float in decimal degrees, between -180 and 180, east is positive api_key : str To access Solcast data you will need an API key [1]_. map_variables: bool, default: True When true, renames columns of the DataFrame to pvlib variable names where applicable. See variable :const:`VARIABLE_MAP`. Time is the index shifted to the midpoint of each interval from Solcast's "period end" convention. kwargs: Optional parameters passed to the API. See [2]_ for full list of parameters. Returns ------- data : pandas.DataFrame containing the values for the parameters requested. The times in the DataFrame index indicate the midpoint of each interval. metadata: dict latitude and longitude of the request. Examples -------- >>> df, meta = pvlib.iotools.solcast.get_solcast_live( >>> latitude=-33.856784, >>> longitude=151.215297, >>> api_key="your-key" >>> ) you can pass any of the parameters listed in the API docs, like >>> df, meta = pvlib.iotools.solcast.get_solcast_live( >>> latitude=-33.856784, >>> longitude=151.215297, >>> terrain_shading=True, >>> output_parameters=['ghi', 'clearsky_ghi', 'snow_soiling_rooftop'], >>> api_key="your-key" >>> ) use ``map_variables=False`` to avoid converting the data to PVLib's conventions. >>> df, meta = pvlib.iotools.solcast.get_solcast_live( >>> latitude=-33.856784, >>> longitude=151.215297, >>> map_variables=False, >>> api_key="your-key" >>> ) References ---------- .. [1] `Get an API Key <https://toolkit.solcast.com.au/register>`_ .. [2] `Solcast API Docs <https://docs.solcast.com.au/>`_ See Also -------- pvlib.iotools.get_solcast_tmy, pvlib.iotools.get_solcast_historic, pvlib.iotools.get_solcast_forecast""" (definition of _solcast2pvlib:) def _solcast2pvlib(data): """Format the data from Solcast to pvlib's conventions. Parameters ---------- data : pandas.DataFrame contains the data returned from the Solcast API Returns ------- a pandas.DataFrame with the data cast to pvlib's conventions""" (definition of _get_solcast:) def _get_solcast( endpoint, params, api_key, map_variables ): """Retrieve weather, irradiance and power data from the Solcast API. Parameters ---------- endpoint : str one of Solcast API endpoint: - live/radiation_and_weather - forecast/radiation_and_weather - historic/radiation_and_weather - tmy/radiation_and_weather params : dict parameters to be passed to the API api_key : str To access Solcast data you will need an API key [1]_. map_variables: bool, default: True When true, renames columns of the DataFrame to pvlib's variable names where applicable. See variable :const:`VARIABLE_MAP`. Time is the index shifted to the midpoint of each interval from Solcast's "period end" convention. Returns ------- A pandas.DataFrame with the data if the request is successful, an error message otherwise References ---------- .. [1] `register <https://toolkit.solcast.com.au/register>`""" [end of new definitions in pvlib/iotools/solcast.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Integrate Solcast API into iotools Is your feature request related to a problem? Please describe. Get irradiance via Solcast API https://solcast.com/solar-data-api/api/ Describe the solution you'd like Use iotools to get irradiance data from Solcast Describe alternatives you've considered Solcast already has an API toolkit. Is irons redundant? Additional context * https://docs.solcast.com.au/#introduction * https://solcast.com/solar-data-api/api-toolkit/ * icymi @AdamRJensen ---------- This could be expanded to include other APIs, such as Solargis (https://solargis.com/products/api/data-delivery-web-service/overview) and SolarAnywhere (https://developers.cleanpower.com/irradiance-and-weather-data/). A bit of relevant discussion here: https://github.com/pvlib/pvlib-python/discussions/1310 Hi @kanderso-nrel is this issue superceded by the Engerer PR #1366 ? @mikofski Solcast and Engerer don't seem related to me, what's the connection? Or maybe you meant another issue? [Nick Engerer is the CTO and a co-founders of Solcast](https://www.linkedin.com/in/dr-nick-engerer/), so I thought maybe their software uses his methods? But TBH that's just an assumption. Ha, of course! I think #1366 does not supercede this one: decomposition function in `pvlib.irradiance` vs data fetching function in `pvlib.iotools`. -------------------- </issues>	d53f97e984bfdd268aa92f8bf482ced0edda0110
gradio-app__gradio-5668	5,668	gradio-app/gradio	null	09ac63e818dd2a2fc569f4338f77986c5d3c92df	2023-09-24T01:14:53Z	diff --git a/.changeset/some-forks-raise.md b/.changeset/some-forks-raise.md new file mode 100644 index 0000000000..5d3a64aa6e --- /dev/null +++ b/.changeset/some-forks-raise.md @@ -0,0 +1,5 @@ +--- +"gradio": patch +--- + +fix:Fully resolve generated filepaths when running on Hugging Face Spaces with multiple replicas diff --git a/gradio/route_utils.py b/gradio/route_utils.py index b79058820d..1b3d846edc 100644 --- a/gradio/route_utils.py +++ b/gradio/route_utils.py @@ -1,9 +1,11 @@ from __future__ import annotations +import copy import json from typing import TYPE_CHECKING, Optional, Union import fastapi +import httpx from gradio_client.documentation import document, set_documentation_group from gradio import utils @@ -244,3 +246,25 @@ async def call_process_api( output["data"] = output["data"][0] return output + + +def set_replica_url_in_config(config: dict, replica_url: str) -> dict: + """ + If the Gradio app is running on Hugging Face Spaces and the machine has multiple replicas, + we pass in the direct URL to the replica so that we have the fully resolved path to any files + on that machine. This direct URL can be shared with other users and the path will still work. + """ + parsed_url = httpx.URL(replica_url) + stripped_url = parsed_url.copy_with(query=None) + stripped_url = str(stripped_url) + if not stripped_url.endswith("/"): + stripped_url += "/" + + config_ = copy.deepcopy(config) + for component in config_["components"]: + if ( + component.get("props") is not None + and component["props"].get("root_url") is None + ): + component["props"]["root_url"] = stripped_url + return config_ diff --git a/gradio/routes.py b/gradio/routes.py index ff6886a4e8..1035c3fe4a 100644 --- a/gradio/routes.py +++ b/gradio/routes.py @@ -53,7 +53,7 @@ from gradio.exceptions import Error from gradio.oauth import attach_oauth from gradio.queueing import Estimation, Event -from gradio.route_utils import Request # noqa: F401 +from gradio.route_utils import Request, set_replica_url_in_config # noqa: F401 from gradio.state_holder import StateHolder from gradio.utils import ( cancel_tasks, @@ -124,6 +124,9 @@ def __init__(self, **kwargs): self.uploaded_file_dir = os.environ.get("GRADIO_TEMP_DIR") or str( Path(tempfile.gettempdir()) / "gradio" ) + self.replica_urls = ( + set() + ) # these are the full paths to the replicas if running on a Hugging Face Space with multiple replicas self.change_event: None \| threading.Event = None # Allow user to manually set `docs_url` and `redoc_url` # when instantiating an App; when they're not set, disable docs and redoc. @@ -158,9 +161,10 @@ def build_proxy_request(self, url_path): assert self.blocks # Don't proxy a URL unless it's a URL specifically loaded by the user using # gr.load() to prevent SSRF or harvesting of HF tokens by malicious Spaces. - is_safe_url = any( - url.host == httpx.URL(root).host for root in self.blocks.root_urls - ) + safe_urls = {httpx.URL(root).host for root in self.blocks.root_urls} \| { + httpx.URL(root).host for root in self.replica_urls + } + is_safe_url = url.host in safe_urls if not is_safe_url: raise PermissionError("This URL cannot be proxied.") is_hf_url = url.host.endswith(".hf.space") @@ -307,6 +311,13 @@ def main(request: fastapi.Request, user: str = Depends(get_current_user)): if app.auth is None or user is not None: config = app.get_blocks().config config["root"] = root_path + + # Handles the case where the app is running on Hugging Face Spaces with + # multiple replicas. See `set_replica_url_in_config` for more details. + replica_url = request.headers.get("X-Direct-Url") + if utils.get_space() and replica_url: + app.replica_urls.add(replica_url) + config = set_replica_url_in_config(config, replica_url) else: config = { "auth_required": True, @@ -344,8 +355,16 @@ def api_info(serialize: bool = True): @app.get("/config/", dependencies=[Depends(login_check)]) @app.get("/config", dependencies=[Depends(login_check)]) def get_config(request: fastapi.Request): - root_path = request.scope.get("root_path", "") config = app.get_blocks().config + + # Handles the case where the app is running on Hugging Face Spaces with + # multiple replicas. See `set_replica_url_in_config` for more details. + replica_url = request.headers.get("X-Direct-Url") + if utils.get_space() and replica_url: + app.replica_urls.add(replica_url) + config = set_replica_url_in_config(config, replica_url) + + root_path = request.scope.get("root_path", "") config["root"] = root_path return config	diff --git a/test/test_route_utils.py b/test/test_route_utils.py new file mode 100644 index 0000000000..66ebd751ba --- /dev/null +++ b/test/test_route_utils.py @@ -0,0 +1,27 @@ +from gradio.route_utils import set_replica_url_in_config + + +def test_set_replica_url(): + config = { + "components": [{"props": {}}, {"props": {"root_url": "existing_url/"}}, {}] + } + replica_url = "https://abidlabs-test-client-replica--fttzk.hf.space?__theme=light" + + config = set_replica_url_in_config(config, replica_url) + assert ( + config["components"][0]["props"]["root_url"] + == "https://abidlabs-test-client-replica--fttzk.hf.space/" + ) + assert config["components"][1]["props"]["root_url"] == "existing_url/" + assert "props" not in config["components"][2] + + +def test_url_without_trailing_slash(): + config = {"components": [{"props": {}}]} + replica_url = "https://abidlabs-test-client-replica--fttzk.hf.space" + + config = set_replica_url_in_config(config, replica_url) + assert ( + config["components"][0]["props"]["root_url"] + == "https://abidlabs-test-client-replica--fttzk.hf.space/" + )	diff --git a/.changeset/some-forks-raise.md b/.changeset/some-forks-raise.md new file mode 100644 index 0000000000..5d3a64aa6e --- /dev/null +++ b/.changeset/some-forks-raise.md @@ -0,0 +1,5 @@ +--- +"gradio": patch +--- + +fix:Fully resolve generated filepaths when running on Hugging Face Spaces with multiple replicas	[ { "components": [ { "doc": "If the Gradio app is running on Hugging Face Spaces and the machine has multiple replicas,\nwe pass in the direct URL to the replica so that we have the fully resolved path to any files\non that machine. This direct URL can be shared with other users and the path will s...	[ "test/test_route_utils.py::test_set_replica_url", "test/test_route_utils.py::test_url_without_trailing_slash" ]	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Fully resolve generated filepaths when running on Hugging Face Spaces with multiple replicas This PR makes a change to how we serve filepaths when running on Hugging Face Spaces with multiple replicas. When a Gradio app is running on a Space with $N$ replicas (e.g. https://huggingface.co/spaces/abidlabs/test-client-replica), then the "real URL" of the Gradio app can be one of $N$ different URL strings. A user is directed to a particular URL string based on a hash of their IP address. This means that when a file is generated on that Space (e.g. `https://huggingface.co/spaces/abidlabs/test-client-replica/file=cheetah.jpg`, it is actually only generated on one specific machine. This is fine for that user, because they will still be directed to that machine. However, if they try sharing this file with another user, the other user may get a 404 since the Spaces machine they are redirected to may be different than the original user's, and so the file may not actually exist for them. This PR leverages our existing `root_url` and `/proxy` routes to fully resolve any generated files. Meaning that instead of generated files having this filepath: ``` https://huggingface.co/spaces/abidlabs/test-client-replica/file=cheetah.jpg ``` they'll have: ``` https://abidlabs-test-client-replica.hf.space/proxy=https://abidlabs-test-client-replica--fttzk.hf.space/file=/tmp/gradio/4884a6ee81331aa870d691096911b279c8808bc9/cheetah.jpg ``` Notice the hash at the end of this: `https://abidlabs-test-client-replica--fttzk.hf.space` This means that this URL should always work for all users. I've installed this PR on this Space: https://huggingface.co/spaces/abidlabs/test-client-replica for testing purposes. cc @XciD @freddyaboulton ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in gradio/route_utils.py] (definition of set_replica_url_in_config:) def set_replica_url_in_config(config: dict, replica_url: str) -> dict: """If the Gradio app is running on Hugging Face Spaces and the machine has multiple replicas, we pass in the direct URL to the replica so that we have the fully resolved path to any files on that machine. This direct URL can be shared with other users and the path will still work.""" [end of new definitions in gradio/route_utils.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		9c6d83d12e4b67c5638ba67281c6f018052c5b3e
pyvista__pyvista-4954	4,954	pyvista/pyvista	0.43	b7737bd1ec44ae6ff86ca59642da29ea71d62900	2023-09-24T00:47:31Z	diff --git a/doc/source/api/utilities/geometric.rst b/doc/source/api/utilities/geometric.rst index af2d82c85c7..d753930731d 100644 --- a/doc/source/api/utilities/geometric.rst +++ b/doc/source/api/utilities/geometric.rst @@ -84,3 +84,4 @@ Geometric sources are closer to the actual VTK pipeline. They serve as the ConeSource CylinderSource + MultipleLinesSource diff --git a/pyvista/core/utilities/__init__.py b/pyvista/core/utilities/__init__.py index 7f9aacfd472..4bdc8addec2 100644 --- a/pyvista/core/utilities/__init__.py +++ b/pyvista/core/utilities/__init__.py @@ -81,7 +81,7 @@ Wavelet, translate, ) -from .geometric_sources import ConeSource, CylinderSource +from .geometric_sources import ConeSource, CylinderSource, MultipleLinesSource from .helpers import axis_rotation, generate_plane, is_inside_bounds, is_pyvista_dataset, wrap from .misc import ( AnnotatedIntEnum, diff --git a/pyvista/core/utilities/geometric_objects.py b/pyvista/core/utilities/geometric_objects.py index cedbcc3bb1a..7181bea4a74 100644 --- a/pyvista/core/utilities/geometric_objects.py +++ b/pyvista/core/utilities/geometric_objects.py @@ -26,7 +26,7 @@ from pyvista.core.errors import PyVistaDeprecationWarning from .arrays import _coerce_pointslike_arg -from .geometric_sources import ConeSource, CylinderSource, translate +from .geometric_sources import ConeSource, CylinderSource, MultipleLinesSource, translate from .helpers import wrap from .misc import check_valid_vector @@ -495,14 +495,7 @@ def MultipleLines(points=[[-0.5, 0.0, 0.0], [0.5, 0.0, 0.0]]): >>> plotter.camera.zoom(0.8) >>> plotter.show() """ - points, _ = _coerce_pointslike_arg(points) - src = _vtk.vtkLineSource() - if not (len(points) >= 2): - raise ValueError('>=2 points need to define multiple lines.') - src.SetPoints(pyvista.vtk_points(points)) - src.Update() - multiple_lines = wrap(src.GetOutput()) - return multiple_lines + return MultipleLinesSource(points=points).output def Tube(pointa=(-0.5, 0.0, 0.0), pointb=(0.5, 0.0, 0.0), resolution=1, radius=1.0, n_sides=15): diff --git a/pyvista/core/utilities/geometric_sources.py b/pyvista/core/utilities/geometric_sources.py index 55d77db56e8..e4260a370f4 100644 --- a/pyvista/core/utilities/geometric_sources.py +++ b/pyvista/core/utilities/geometric_sources.py @@ -7,9 +7,11 @@ import numpy as np +import pyvista from pyvista.core import _vtk_core as _vtk from pyvista.core.utilities.misc import no_new_attr +from .arrays import _coerce_pointslike_arg from .helpers import wrap @@ -500,3 +502,58 @@ def output(self): output.rotate_z(-90, inplace=True) translate(output, self.center, self.direction) return output + + +@no_new_attr +class MultipleLinesSource(_vtk.vtkLineSource): + """Multiple lines source algorithm class. + + Parameters + ---------- + points : array_like[float], default: [[-0.5, 0.0, 0.0], [0.5, 0.0, 0.0]] + List of points defining a broken line. + """ + + _new_attr_exceptions = ['points'] + + def __init__(self, points=[[-0.5, 0.0, 0.0], [0.5, 0.0, 0.0]]): + """Initialize the multiple lines source class.""" + super().__init__() + self.points = points + + @property + def points(self) -> np.ndarray: + """Get the list of points defining a broken line. + + Returns + ------- + np.ndarray + List of points defining a broken line. + """ + return _vtk.vtk_to_numpy(self.GetPoints().GetData()) + + @points.setter + def points(self, points: Sequence[Sequence[float]]): + """Set the list of points defining a broken line. + + Parameters + ---------- + points : array_like[float] + List of points defining a broken line. + """ + points, _ = _coerce_pointslike_arg(points) + if not (len(points) >= 2): + raise ValueError('>=2 points need to define multiple lines.') + self.SetPoints(pyvista.vtk_points(points)) + + @property + def output(self): + """Get the output data object for a port on this algorithm. + + Returns + ------- + pyvista.PolyData + Line mesh. + """ + self.Update() + return wrap(self.GetOutput())	diff --git a/tests/core/test_geometric_sources.py b/tests/core/test_geometric_sources.py index 4b3c64dbb2a..7dcb303397f 100644 --- a/tests/core/test_geometric_sources.py +++ b/tests/core/test_geometric_sources.py @@ -32,3 +32,16 @@ def test_cylinder_source(): algo.direction = direction assert np.array_equal(algo.center, center) assert np.array_equal(algo.direction, direction) + + +def test_multiple_lines_source(): + algo = pv.MultipleLinesSource() + points = np.array([[-0.5, 0.0, 0.0], [0.5, 0.0, 0.0]]) + assert np.array_equal(algo.points, points) + points = np.array([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0], [0.0, 0.0, 1.0]]) + algo = pv.MultipleLinesSource(points=points) + assert np.array_equal(algo.points, points) + with pytest.raises(ValueError, match='Array of points must have three values per point'): + algo.points = points[:, :1] + with pytest.raises(ValueError, match='>=2 points need to define multiple lines.'): + algo.points = points[0, :]	diff --git a/doc/source/api/utilities/geometric.rst b/doc/source/api/utilities/geometric.rst index af2d82c85c7..d753930731d 100644 --- a/doc/source/api/utilities/geometric.rst +++ b/doc/source/api/utilities/geometric.rst @@ -84,3 +84,4 @@ Geometric sources are closer to the actual VTK pipeline. They serve as the ConeSource CylinderSource + MultipleLinesSource	[ { "components": [ { "doc": "Multiple lines source algorithm class.\n\nParameters\n----------\npoints : array_like[float], default: [[-0.5, 0.0, 0.0], [0.5, 0.0, 0.0]]\n List of points defining a broken line.", "lines": [ 508, 559 ], "name": "MultipleL...	[ "tests/core/test_geometric_sources.py::test_multiple_lines_source" ]	[ "tests/core/test_geometric_sources.py::test_cone_source", "tests/core/test_geometric_sources.py::test_cylinder_source" ]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add `MultipleLinesSource` class ### Overview <!-- Please insert a high-level description of this pull request here. --> - Follow-up PR of #4860 . Add `CylinderSource` class. - ~~Inspired by https://github.com/pyvista/pyvista/discussions/4945 .~~ <!-- Be sure to link other PRs or issues that relate to this PR here. --> <!-- If this fully addresses an issue, please use the keyword `resolves` in front of that issue number. --> ### Details - [x] ~~Add sin wave line animation example.~~ (In the next PR.) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pyvista/core/utilities/geometric_sources.py] (definition of MultipleLinesSource:) class MultipleLinesSource(_vtk.vtkLineSource): """Multiple lines source algorithm class. Parameters ---------- points : array_like[float], default: [[-0.5, 0.0, 0.0], [0.5, 0.0, 0.0]] List of points defining a broken line.""" (definition of MultipleLinesSource.__init__:) def __init__(self, points=[[-0.5, 0.0, 0.0], [0.5, 0.0, 0.0]]): """Initialize the multiple lines source class.""" (definition of MultipleLinesSource.points:) def points(self, points: Sequence[Sequence[float]]): """Set the list of points defining a broken line. Parameters ---------- points : array_like[float] List of points defining a broken line.""" (definition of MultipleLinesSource.output:) def output(self): """Get the output data object for a port on this algorithm. Returns ------- pyvista.PolyData Line mesh.""" [end of new definitions in pyvista/core/utilities/geometric_sources.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		25921025e45cafe97b2e274de39c3076b3c84681
pyvista__pyvista-4890	4,890	pyvista/pyvista	0.43	bc912e9f40462204aa8f0c3c2e9eec7068dd40d7	2023-09-16T08:59:59Z	diff --git a/doc/source/api/utilities/geometric.rst b/doc/source/api/utilities/geometric.rst index 9e6bbc65f1b..af2d82c85c7 100644 --- a/doc/source/api/utilities/geometric.rst +++ b/doc/source/api/utilities/geometric.rst @@ -83,3 +83,4 @@ Geometric sources are closer to the actual VTK pipeline. They serve as the :toctree: _autosummary ConeSource + CylinderSource diff --git a/pyvista/core/utilities/__init__.py b/pyvista/core/utilities/__init__.py index 48e469edba5..7f9aacfd472 100644 --- a/pyvista/core/utilities/__init__.py +++ b/pyvista/core/utilities/__init__.py @@ -81,7 +81,7 @@ Wavelet, translate, ) -from .geometric_sources import ConeSource +from .geometric_sources import ConeSource, CylinderSource from .helpers import axis_rotation, generate_plane, is_inside_bounds, is_pyvista_dataset, wrap from .misc import ( AnnotatedIntEnum, diff --git a/pyvista/core/utilities/geometric_objects.py b/pyvista/core/utilities/geometric_objects.py index c15ffcb2fb0..cedbcc3bb1a 100644 --- a/pyvista/core/utilities/geometric_objects.py +++ b/pyvista/core/utilities/geometric_objects.py @@ -2,7 +2,7 @@ CONTAINS vtkArrowSource -vtkCylinderSource +CylinderSource vtkSphereSource vtkPlaneSource vtkLineSource @@ -26,7 +26,7 @@ from pyvista.core.errors import PyVistaDeprecationWarning from .arrays import _coerce_pointslike_arg -from .geometric_sources import ConeSource +from .geometric_sources import ConeSource, CylinderSource, translate from .helpers import wrap from .misc import check_valid_vector @@ -40,47 +40,6 @@ } -def translate(surf, center=(0.0, 0.0, 0.0), direction=(1.0, 0.0, 0.0)): - """Translate and orient a mesh to a new center and direction. - - By default, the input mesh is considered centered at the origin - and facing in the x direction. - - Parameters - ---------- - surf : pyvista.core.pointset.PolyData - Mesh to be translated and oriented. - center : tuple, optional, default: (0.0, 0.0, 0.0) - Center point to which the mesh should be translated. - direction : tuple, optional, default: (1.0, 0.0, 0.0) - Direction vector along which the mesh should be oriented. - - """ - normx = np.array(direction) / np.linalg.norm(direction) - normy_temp = [0.0, 1.0, 0.0] - - # Adjust normy if collinear with normx since cross-product will - # be zero otherwise - if np.allclose(normx, [0, 1, 0]): - normy_temp = [-1.0, 0.0, 0.0] - elif np.allclose(normx, [0, -1, 0]): - normy_temp = [1.0, 0.0, 0.0] - - normz = np.cross(normx, normy_temp) - normz /= np.linalg.norm(normz) - normy = np.cross(normz, normx) - - trans = np.zeros((4, 4)) - trans[:3, 0] = normx - trans[:3, 1] = normy - trans[:3, 2] = normz - trans[3, 3] = 1 - - surf.transform(trans) - if not np.allclose(center, [0.0, 0.0, 0.0]): - surf.points += np.array(center) - - def Cylinder( center=(0.0, 0.0, 0.0), direction=(1.0, 0.0, 0.0), @@ -127,16 +86,15 @@ def Cylinder( ... ) >>> cylinder.plot(show_edges=True, line_width=5, cpos='xy') """ - cylinderSource = _vtk.vtkCylinderSource() - cylinderSource.SetRadius(radius) - cylinderSource.SetHeight(height) - cylinderSource.SetCapping(capping) - cylinderSource.SetResolution(resolution) - cylinderSource.Update() - surf = wrap(cylinderSource.GetOutput()) - surf.rotate_z(-90, inplace=True) - translate(surf, center, direction) - return surf + algo = CylinderSource( + center=center, + direction=direction, + radius=radius, + height=height, + capping=capping, + resolution=resolution, + ) + return algo.output def CylinderStructured( diff --git a/pyvista/core/utilities/geometric_sources.py b/pyvista/core/utilities/geometric_sources.py index 6226dbf97f6..55d77db56e8 100644 --- a/pyvista/core/utilities/geometric_sources.py +++ b/pyvista/core/utilities/geometric_sources.py @@ -5,12 +5,55 @@ """ from typing import Sequence +import numpy as np + from pyvista.core import _vtk_core as _vtk from pyvista.core.utilities.misc import no_new_attr from .helpers import wrap +def translate(surf, center=(0.0, 0.0, 0.0), direction=(1.0, 0.0, 0.0)): + """Translate and orient a mesh to a new center and direction. + + By default, the input mesh is considered centered at the origin + and facing in the x direction. + + Parameters + ---------- + surf : pyvista.core.pointset.PolyData + Mesh to be translated and oriented. + center : tuple, optional, default: (0.0, 0.0, 0.0) + Center point to which the mesh should be translated. + direction : tuple, optional, default: (1.0, 0.0, 0.0) + Direction vector along which the mesh should be oriented. + + """ + normx = np.array(direction) / np.linalg.norm(direction) + normy_temp = [0.0, 1.0, 0.0] + + # Adjust normy if collinear with normx since cross-product will + # be zero otherwise + if np.allclose(normx, [0, 1, 0]): + normy_temp = [-1.0, 0.0, 0.0] + elif np.allclose(normx, [0, -1, 0]): + normy_temp = [1.0, 0.0, 0.0] + + normz = np.cross(normx, normy_temp) + normz /= np.linalg.norm(normz) + normy = np.cross(normz, normx) + + trans = np.zeros((4, 4)) + trans[:3, 0] = normx + trans[:3, 1] = normy + trans[:3, 2] = normz + trans[3, 3] = 1 + + surf.transform(trans) + if not np.allclose(center, [0.0, 0.0, 0.0]): + surf.points += np.array(center) + + @no_new_attr class ConeSource(_vtk.vtkConeSource): """Cone source algorithm class. @@ -252,3 +295,208 @@ def output(self): """ self.Update() return wrap(self.GetOutput()) + + +@no_new_attr +class CylinderSource(_vtk.vtkCylinderSource): + """Cylinder source algorithm class. + + Parameters + ---------- + center : sequence[float], default: (0.0, 0.0, 0.0) + Location of the centroid in ``[x, y, z]``. + + direction : sequence[float], default: (1.0, 0.0, 0.0) + Direction cylinder points to in ``[x, y, z]``. + + radius : float, default: 0.5 + Radius of the cylinder. + + height : float, default: 1.0 + Height of the cylinder. + + capping : bool, default: True + Cap cylinder ends with polygons. + + resolution : int, default: 100 + Number of points on the circular face of the cylinder. + + Examples + -------- + Create a default CylinderSource. + + >>> import pyvista + >>> source = pyvista.CylinderSource() + >>> source.output.plot(show_edges=True, line_width=5) + """ + + _new_attr_exceptions = ['_center', '_direction'] + + def __init__( + self, + center=(0.0, 0.0, 0.0), + direction=(1.0, 0.0, 0.0), + radius=0.5, + height=1.0, + capping=True, + resolution=100, + ): + """Initialize the cylinder source class.""" + super().__init__() + self._center = center + self._direction = direction + self.radius = radius + self.height = height + self.resolution = resolution + self.capping = capping + + @property + def center(self) -> Sequence[float]: + """Get location of the centroid in ``[x, y, z]``. + + Returns + ------- + sequence[float] + Center in ``[x, y, z]``. Axis of the cylinder passes through this + point. + """ + return self._center + + @center.setter + def center(self, center: Sequence[float]): + """Set location of the centroid in ``[x, y, z]``. + + Parameters + ---------- + center : sequence[float] + Center in ``[x, y, z]``. Axis of the cylinder passes through this + point. + """ + self._center = center + + @property + def direction(self) -> Sequence[float]: + """Get the direction vector in ``[x, y, z]``. Orientation vector of the cylinder. + + Returns + ------- + sequence[float] + Direction vector in ``[x, y, z]``. Orientation vector of the + cylinder. + """ + return self._direction + + @direction.setter + def direction(self, direction: Sequence[float]): + """Set the direction in ``[x, y, z]``. Axis of the cylinder passes through this point. + + Parameters + ---------- + direction : sequence[float] + Direction vector in ``[x, y, z]``. Orientation vector of the + cylinder. + """ + self._direction = direction + + @property + def radius(self) -> bool: + """Get radius of the cylinder. + + Returns + ------- + float + Radius of the cylinder. + """ + return self.GetRadius() + + @radius.setter + def radius(self, radius: float): + """Set radius of the cylinder. + + Parameters + ---------- + radius : float + Radius of the cylinder. + """ + self.SetRadius(radius) + + @property + def height(self) -> float: + """Get the height of the cylinder. + + Returns + ------- + float + Height of the cylinder. + """ + return self.GetHeight() + + @height.setter + def height(self, height: float): + """Set the height of the cylinder. + + Parameters + ---------- + height : float + Height of the cylinder. + """ + self.SetHeight(height) + + @property + def resolution(self) -> int: + """Get number of points on the circular face of the cylinder. + + Returns + ------- + int + Number of points on the circular face of the cone. + """ + return self.GetResolution() + + @resolution.setter + def resolution(self, resolution: int): + """Set number of points on the circular face of the cone. + + Parameters + ---------- + resolution : int + Number of points on the circular face of the cone. + """ + self.SetResolution(resolution) + + @property + def capping(self) -> bool: + """Get cap cylinder ends with polygons. + + Returns + ------- + bool + Cap cylinder ends with polygons. + """ + return self.GetCapping() + + @capping.setter + def capping(self, capping: bool): + """Set cap cylinder ends with polygons. + + Parameters + ---------- + capping : bool, optional + Cap cylinder ends with polygons. + """ + self.SetCapping(capping) + + @property + def output(self): + """Get the output data object for a port on this algorithm. + + Returns + ------- + pyvista.PolyData + Cylinder surface. + """ + self.Update() + output = wrap(self.GetOutput()) + output.rotate_z(-90, inplace=True) + translate(output, self.center, self.direction) + return output	diff --git a/tests/core/test_geometric_sources.py b/tests/core/test_geometric_sources.py index 9562ade64cc..4b3c64dbb2a 100644 --- a/tests/core/test_geometric_sources.py +++ b/tests/core/test_geometric_sources.py @@ -18,3 +18,17 @@ def test_cone_source(): assert algo.angle == 0.0 algo = pv.ConeSource(radius=0.0) assert algo.radius == 0.0 + + +def test_cylinder_source(): + algo = pv.CylinderSource() + assert algo.radius == 0.5 + assert algo.height == 1.0 + assert algo.capping + assert algo.resolution == 100 + center = np.random.rand(3) + direction = np.random.rand(3) + algo.center = center + algo.direction = direction + assert np.array_equal(algo.center, center) + assert np.array_equal(algo.direction, direction)	diff --git a/doc/source/api/utilities/geometric.rst b/doc/source/api/utilities/geometric.rst index 9e6bbc65f1b..af2d82c85c7 100644 --- a/doc/source/api/utilities/geometric.rst +++ b/doc/source/api/utilities/geometric.rst @@ -83,3 +83,4 @@ Geometric sources are closer to the actual VTK pipeline. They serve as the :toctree: _autosummary ConeSource + CylinderSource	[ { "components": [ { "doc": "Translate and orient a mesh to a new center and direction.\n\nBy default, the input mesh is considered centered at the origin\nand facing in the x direction.\n\nParameters\n----------\nsurf : pyvista.core.pointset.PolyData\n Mesh to be translated and oriented.\ncente...	[ "tests/core/test_geometric_sources.py::test_cylinder_source" ]	[ "tests/core/test_geometric_sources.py::test_cone_source" ]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add `CylinderSource` class ### Overview <!-- Please insert a high-level description of this pull request here. --> - Follow-up PR of #4860 . Add `CylinderSource` class. - Move `translate` function from `geometric_objects.py` to `geometric_sources.py` . <!-- Be sure to link other PRs or issues that relate to this PR here. --> <!-- If this fully addresses an issue, please use the keyword `resolves` in front of that issue number. --> ### Details - None ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pyvista/core/utilities/geometric_sources.py] (definition of translate:) def translate(surf, center=(0.0, 0.0, 0.0), direction=(1.0, 0.0, 0.0)): """Translate and orient a mesh to a new center and direction. By default, the input mesh is considered centered at the origin and facing in the x direction. Parameters ---------- surf : pyvista.core.pointset.PolyData Mesh to be translated and oriented. center : tuple, optional, default: (0.0, 0.0, 0.0) Center point to which the mesh should be translated. direction : tuple, optional, default: (1.0, 0.0, 0.0) Direction vector along which the mesh should be oriented.""" (definition of CylinderSource:) class CylinderSource(_vtk.vtkCylinderSource): """Cylinder source algorithm class. Parameters ---------- center : sequence[float], default: (0.0, 0.0, 0.0) Location of the centroid in ``[x, y, z]``. direction : sequence[float], default: (1.0, 0.0, 0.0) Direction cylinder points to in ``[x, y, z]``. radius : float, default: 0.5 Radius of the cylinder. height : float, default: 1.0 Height of the cylinder. capping : bool, default: True Cap cylinder ends with polygons. resolution : int, default: 100 Number of points on the circular face of the cylinder. Examples -------- Create a default CylinderSource. >>> import pyvista >>> source = pyvista.CylinderSource() >>> source.output.plot(show_edges=True, line_width=5)""" (definition of CylinderSource.__init__:) def __init__( self, center=(0.0, 0.0, 0.0), direction=(1.0, 0.0, 0.0), radius=0.5, height=1.0, capping=True, resolution=100, ): """Initialize the cylinder source class.""" (definition of CylinderSource.center:) def center(self, center: Sequence[float]): """Set location of the centroid in ``[x, y, z]``. Parameters ---------- center : sequence[float] Center in ``[x, y, z]``. Axis of the cylinder passes through this point.""" (definition of CylinderSource.direction:) def direction(self, direction: Sequence[float]): """Set the direction in ``[x, y, z]``. Axis of the cylinder passes through this point. Parameters ---------- direction : sequence[float] Direction vector in ``[x, y, z]``. Orientation vector of the cylinder.""" (definition of CylinderSource.radius:) def radius(self, radius: float): """Set radius of the cylinder. Parameters ---------- radius : float Radius of the cylinder.""" (definition of CylinderSource.height:) def height(self, height: float): """Set the height of the cylinder. Parameters ---------- height : float Height of the cylinder.""" (definition of CylinderSource.resolution:) def resolution(self, resolution: int): """Set number of points on the circular face of the cone. Parameters ---------- resolution : int Number of points on the circular face of the cone.""" (definition of CylinderSource.capping:) def capping(self, capping: bool): """Set cap cylinder ends with polygons. Parameters ---------- capping : bool, optional Cap cylinder ends with polygons.""" (definition of CylinderSource.output:) def output(self): """Get the output data object for a port on this algorithm. Returns ------- pyvista.PolyData Cylinder surface.""" [end of new definitions in pyvista/core/utilities/geometric_sources.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		25921025e45cafe97b2e274de39c3076b3c84681
conan-io__conan-14743	14,743	conan-io/conan	null	e9b13cff49fa0e991f179343ebf3c807e89938f5	2023-09-14T23:10:36Z	diff --git a/conan/cli/commands/profile.py b/conan/cli/commands/profile.py index bb3254fe523..27abff00d1f 100644 --- a/conan/cli/commands/profile.py +++ b/conan/cli/commands/profile.py @@ -1,3 +1,4 @@ +import json import os from conan.api.output import ConanOutput, cli_out_write @@ -22,7 +23,14 @@ def profiles_list_cli_output(profiles): cli_out_write(p) -@conan_subcommand(formatters={"text": print_profiles}) +def json_profiles(profiles): + host, build = profiles + result = {"host": host.serialize(), + "build": build.serialize()} + cli_out_write(json.dumps(result)) + + +@conan_subcommand(formatters={"text": print_profiles, "json": json_profiles}) def profile_show(conan_api, parser, subparser, *args): """ Show aggregated profiles from the passed arguments.	diff --git a/conans/test/integration/command/test_profile.py b/conans/test/integration/command/test_profile.py index 2cc252e3ce2..86207bb4678 100644 --- a/conans/test/integration/command/test_profile.py +++ b/conans/test/integration/command/test_profile.py @@ -1,3 +1,4 @@ +import json import os from conans.test.utils.tools import TestClient @@ -28,3 +29,13 @@ def test_ignore_paths_when_listing_profiles(): c.run("profile list") assert ignore_path not in c.out + + +def test_profile_show_json(): + c = TestClient() + c.save({"myprofilewin": "[settings]\nos=Windows", + "myprofilelinux": "[settings]\nos=Linux"}) + c.run("profile show -pr:b=myprofilewin -pr:h=myprofilelinux --format=json") + profile = json.loads(c.stdout) + assert profile["build"]["settings"] == {"os": "Windows"} + assert profile["host"]["settings"] == {"os": "Linux"}		[ { "components": [ { "doc": "", "lines": [ 26, 30 ], "name": "json_profiles", "signature": "def json_profiles(profiles):", "type": "function" } ], "file": "conan/cli/commands/profile.py" } ]	[ "conans/test/integration/command/test_profile.py::test_profile_show_json" ]	[ "conans/test/integration/command/test_profile.py::test_profile_path", "conans/test/integration/command/test_profile.py::test_profile_path_missing", "conans/test/integration/command/test_profile.py::test_ignore_paths_when_listing_profiles" ]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> profile show --format=json Changelog: Feature: Add ``--format=json`` formatter to ``conan profile show`` command Docs: https://github.com/conan-io/docs/pull/3388 Implement https://github.com/conan-io/conan/issues/14742 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conan/cli/commands/profile.py] (definition of json_profiles:) def json_profiles(profiles): [end of new definitions in conan/cli/commands/profile.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		4a5b19a75db9225316c8cb022a2dfb9705a2af34
conan-io__conan-14731	14,731	conan-io/conan	null	98b5c6acda0bdde4fb9a1a99496265b10dc827f5	2023-09-13T22:48:27Z	diff --git a/conan/tools/cmake/toolchain/blocks.py b/conan/tools/cmake/toolchain/blocks.py index 07a0f8efa89..c42c6186b89 100644 --- a/conan/tools/cmake/toolchain/blocks.py +++ b/conan/tools/cmake/toolchain/blocks.py @@ -840,8 +840,23 @@ def __init__(self, conanfile, toolchain, items=None): for name, block in items: self._blocks[name] = block(conanfile, toolchain) - def remove(self, name): + def keys(self): + return self._blocks.keys() + + def items(self): + return self._blocks.items() + + def remove(self, name, args): del self._blocks[name] + for arg in args: + del self._blocks[arg] + + def select(self, name, args): + """ + keep the blocks provided as arguments, remove the others + """ + to_keep = [name] + list(args) + self._blocks = OrderedDict((k, v) for k, v in self._blocks.items() if k in to_keep) def __setitem__(self, name, block_type): # Create a new class inheriting Block with the elements of the provided one	diff --git a/conans/test/unittests/tools/cmake/test_cmaketoolchain.py b/conans/test/unittests/tools/cmake/test_cmaketoolchain.py index a5e2bec1a9f..3c6e42458f6 100644 --- a/conans/test/unittests/tools/cmake/test_cmaketoolchain.py +++ b/conans/test/unittests/tools/cmake/test_cmaketoolchain.py @@ -49,6 +49,40 @@ def test_remove(conanfile): toolchain.blocks.remove("generic_system") content = toolchain.content assert 'CMAKE_SYSTEM_NAME' not in content + assert "CMAKE_CXX_FLAGS_INIT" in content + assert "_CMAKE_IN_TRY_COMPILE" in content + + # remove multiple + toolchain = CMakeToolchain(conanfile) + toolchain.blocks.remove("generic_system", "cmake_flags_init") + content = toolchain.content + assert 'CMAKE_SYSTEM_NAME' not in content + assert "CMAKE_CXX_FLAGS_INIT" not in content + assert "_CMAKE_IN_TRY_COMPILE" in content + + +def test_filter(conanfile): + toolchain = CMakeToolchain(conanfile) + toolchain.blocks.select("generic_system") + content = toolchain.content + assert 'CMAKE_SYSTEM_NAME' in content + assert "CMAKE_CXX_FLAGS_INIT" not in content + assert "_CMAKE_IN_TRY_COMPILE" not in content + + # remove multiple + toolchain = CMakeToolchain(conanfile) + toolchain.blocks.select("generic_system", "cmake_flags_init") + content = toolchain.content + assert 'CMAKE_SYSTEM_NAME' in content + assert "CMAKE_CXX_FLAGS_INIT" in content + assert "_CMAKE_IN_TRY_COMPILE" not in content + + +def test_dict_keys(conanfile): + toolchain = CMakeToolchain(conanfile) + assert "generic_system" in toolchain.blocks.keys() + items = dict(toolchain.blocks.items()) + assert "generic_system" in items def test_template_remove(conanfile):		[ { "components": [ { "doc": "", "lines": [ 843, 844 ], "name": "ToolchainBlocks.keys", "signature": "def keys(self):", "type": "function" }, { "doc": "", "lines": [ 846, 847 ], ...	[ "conans/test/unittests/tools/cmake/test_cmaketoolchain.py::test_remove", "conans/test/unittests/tools/cmake/test_cmaketoolchain.py::test_filter", "conans/test/unittests/tools/cmake/test_cmaketoolchain.py::test_dict_keys" ]	[ "conans/test/unittests/tools/cmake/test_cmaketoolchain.py::test_cmake_toolchain", "conans/test/unittests/tools/cmake/test_cmaketoolchain.py::test_template_remove", "conans/test/unittests/tools/cmake/test_cmaketoolchain.py::test_template_change", "conans/test/unittests/tools/cmake/test_cmaketoolchain.py::test_...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> better CMakeToolchain blocks filter Changelog: Feature: Better ``CMakeToolchain`` blocks interface. Added new ``.blocks.select()``, ``.blocks.keys()``. Docs: https://github.com/conan-io/docs/pull/3384 Close https://github.com/conan-io/conan/issues/14640 Close https://github.com/conan-io/conan/issues/14641 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conan/tools/cmake/toolchain/blocks.py] (definition of ToolchainBlocks.keys:) def keys(self): (definition of ToolchainBlocks.items:) def items(self): (definition of ToolchainBlocks.select:) def select(self, name, *args): """keep the blocks provided as arguments, remove the others""" [end of new definitions in conan/tools/cmake/toolchain/blocks.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		4a5b19a75db9225316c8cb022a2dfb9705a2af34
conan-io__conan-14727	14,727	conan-io/conan	null	48656d8556dd71736f0f07f5c73170d6dd17b742	2023-09-13T13:24:58Z	diff --git a/conan/api/subapi/profiles.py b/conan/api/subapi/profiles.py index b2a2c54269d..2c3b9bbd54c 100644 --- a/conan/api/subapi/profiles.py +++ b/conan/api/subapi/profiles.py @@ -57,8 +57,8 @@ def get_default_build(self): return default_profile def get_profiles_from_args(self, args): - build = [self.get_default_build()] if not args.profile_build else args.profile_build - host = [self.get_default_host()] if not args.profile_host else args.profile_host + build_profiles = args.profile_build or [self.get_default_build()] + host_profiles = args.profile_host or [self.get_default_host()] cache = ClientCache(self._conan_api.cache_folder) global_conf = cache.new_config @@ -66,12 +66,11 @@ def get_profiles_from_args(self, args): cache_settings = self._settings() profile_plugin = self._load_profile_plugin() cwd = os.getcwd() - profile_build = self._get_profile(build, args.settings_build, args.options_build, + profile_build = self._get_profile(build_profiles, args.settings_build, args.options_build, args.conf_build, cwd, cache_settings, profile_plugin, global_conf) - profile_host = self._get_profile(host, args.settings_host, args.options_host, args.conf_host, + profile_host = self._get_profile(host_profiles, args.settings_host, args.options_host, args.conf_host, cwd, cache_settings, profile_plugin, global_conf) - return profile_host, profile_build def get_profile(self, profiles, settings=None, options=None, conf=None, cwd=None): diff --git a/conan/cli/args.py b/conan/cli/args.py index 6c9eb9b9d16..2b65c498506 100644 --- a/conan/cli/args.py +++ b/conan/cli/args.py @@ -1,3 +1,5 @@ +import argparse + from conan.cli.command import OnceArgument from conan.errors import ConanException @@ -56,45 +58,47 @@ def add_common_install_arguments(parser): def add_profiles_args(parser): - def profile_args(machine, short_suffix="", long_suffix=""): - parser.add_argument("-pr{}".format(short_suffix), - "--profile{}".format(long_suffix), - default=None, action="append", - dest='profile_{}'.format(machine), - help='Apply the specified profile to the {} machine'.format(machine)) - - def settings_args(machine, short_suffix="", long_suffix=""): - parser.add_argument("-s{}".format(short_suffix), - "--settings{}".format(long_suffix), - action="append", - dest='settings_{}'.format(machine), - help='Settings to build the package, overwriting the defaults' - ' ({} machine). e.g.: -s{} compiler=gcc'.format(machine, - short_suffix)) - - def options_args(machine, short_suffix="", long_suffix=""): - parser.add_argument("-o{}".format(short_suffix), - "--options{}".format(long_suffix), - action="append", - dest="options_{}".format(machine), - help='Define options values ({} machine), e.g.:' - ' -o{} Pkg:with_qt=true'.format(machine, short_suffix)) + contexts = ["build", "host"] + + # This comes from the _AppendAction code but modified to add to the contexts + class ContextAllAction(argparse.Action): + + def __call__(self, action_parser, namespace, values, option_string=None): + for context in contexts: + items = getattr(namespace, self.dest + "_" + context, None) + items = items[:] if items else [] + items.append(values) + setattr(namespace, self.dest + "_" + context, items) - def conf_args(machine, short_suffix="", long_suffix=""): - parser.add_argument("-c{}".format(short_suffix), - "--conf{}".format(long_suffix), + def create_config(short, long, example=None): + parser.add_argument(f"-{short}", f"--{long}", + default=None, action="append", - dest='conf_{}'.format(machine), - help='Configuration to build the package, overwriting the defaults' - ' ({} machine). e.g.: -c{} ' - 'tools.cmake.cmaketoolchain:generator=Xcode'.format(machine, - short_suffix)) - - for item_fn in [options_args, profile_args, settings_args, conf_args]: - item_fn("host", "", - "") # By default it is the HOST, the one we are building binaries for - item_fn("build", ":b", ":build") - item_fn("host", ":h", ":host") + dest=f"{long}_host", + metavar=long.upper(), + help='Apply the specified profile. ' + f'By default, or if specifying -{short}:h (--{long}:host), it applies to the host context. ' + f'Use -{short}:b (--{long}:build) to specify the build context, ' + f'or -{short}:a (--{long}:all) to specify both contexts at once' + + ('' if not example else f". Example: {example}")) + for context in contexts: + parser.add_argument(f"-{short}:{context[0]}", f"--{long}:{context}", + default=None, + action="append", + dest=f"{long}_{context}", + help="") + + parser.add_argument(f"-{short}:a", f"--{long}:all", + default=None, + action=ContextAllAction, + dest=long, + metavar=f"{long.upper()}_ALL", + help="") + + create_config("pr", "profile") + create_config("o", "options", "-o pkg:with_qt=true") + create_config("s", "settings", "-s compiler=gcc") + create_config("c", "conf", "-c tools.cmake.cmaketoolchain:generator=Xcode") def add_reference_args(parser):	diff --git a/conans/test/integration/command/test_profile.py b/conans/test/integration/command/test_profile.py index 86207bb4678..8490f435c43 100644 --- a/conans/test/integration/command/test_profile.py +++ b/conans/test/integration/command/test_profile.py @@ -1,5 +1,6 @@ import json import os +import textwrap from conans.test.utils.tools import TestClient @@ -31,11 +32,110 @@ def test_ignore_paths_when_listing_profiles(): assert ignore_path not in c.out +def test_shorthand_syntax(): + tc = TestClient() + tc.save({"profile": "[conf]\nuser.profile=True"}) + tc.run("profile show -h") + assert "[-pr:b" in tc.out + assert "[-pr:h" in tc.out + assert "[-pr:a" in tc.out + + tc.run( + "profile show -o:a=both_options=True -pr:a=profile -s:a=os=WindowsCE -s:a=os.platform=conan -c:a=user.conf.cli=True -f=json") + + out = json.loads(tc.out) + assert out == {'build': {'build_env': '', + 'conf': {'user.conf.cli': True, 'user.profile': True}, + 'options': {'both_options': 'True'}, + 'package_settings': {}, + 'settings': {'os': 'WindowsCE', 'os.platform': 'conan'}, + 'tool_requires': {}}, + 'host': {'build_env': '', + 'conf': {'user.conf.cli': True, 'user.profile': True}, + 'options': {'both_options': 'True'}, + 'package_settings': {}, + 'settings': {'os': 'WindowsCE', 'os.platform': 'conan'}, + 'tool_requires': {}}} + + tc.save({"pre": textwrap.dedent(""" + [settings] + os=Linux + compiler=gcc + compiler.version=11 + """), + "mid": textwrap.dedent(""" + [settings] + compiler=clang + compiler.version=14 + """), + "post": textwrap.dedent(""" + [settings] + compiler.version=13 + """)}) + + tc.run("profile show -pr:a=pre -pr:a=mid -pr:a=post -f=json") + out = json.loads(tc.out) + assert out == {'build': {'build_env': '', + 'conf': {}, + 'options': {}, + 'package_settings': {}, + 'settings': {'compiler': 'clang', + 'compiler.version': '13', + 'os': 'Linux'}, + 'tool_requires': {}}, + 'host': {'build_env': '', + 'conf': {}, + 'options': {}, + 'package_settings': {}, + 'settings': {'compiler': 'clang', + 'compiler.version': '13', + 'os': 'Linux'}, + 'tool_requires': {}}} + + tc.run("profile show -pr:a=pre -pr:h=post -f=json") + out = json.loads(tc.out) + assert out == {'build': {'build_env': '', + 'conf': {}, + 'options': {}, + 'package_settings': {}, + 'settings': {'compiler': 'gcc', + 'compiler.version': '11', + 'os': 'Linux'}, + 'tool_requires': {}}, + 'host': {'build_env': '', + 'conf': {}, + 'options': {}, + 'package_settings': {}, + 'settings': {'compiler': 'gcc', + 'compiler.version': '13', + 'os': 'Linux'}, + 'tool_requires': {}}} + + tc.run("profile show -pr:a=pre -o:b foo=False -o:a foo=True -o:h foo=False -f=json") + out = json.loads(tc.out) + assert out == {'build': {'build_env': '', + 'conf': {}, + 'options': {'foo': 'True'}, + 'package_settings': {}, + 'settings': {'compiler': 'gcc', + 'compiler.version': '11', + 'os': 'Linux'}, + 'tool_requires': {}}, + 'host': {'build_env': '', + 'conf': {}, + 'options': {'foo': 'False'}, + 'package_settings': {}, + 'settings': {'compiler': 'gcc', + 'compiler.version': '11', + 'os': 'Linux'}, + 'tool_requires': {}}} + + def test_profile_show_json(): c = TestClient() c.save({"myprofilewin": "[settings]\nos=Windows", "myprofilelinux": "[settings]\nos=Linux"}) c.run("profile show -pr:b=myprofilewin -pr:h=myprofilelinux --format=json") profile = json.loads(c.stdout) - assert profile["build"]["settings"] == {"os": "Windows"} + assert profile["build"]["settings"] == {"os": "Windows"} assert profile["host"]["settings"] == {"os": "Linux"} diff --git a/conans/test/unittests/cli/common_test.py b/conans/test/unittests/cli/common_test.py index 9353ba5599a..79b30e70f19 100644 --- a/conans/test/unittests/cli/common_test.py +++ b/conans/test/unittests/cli/common_test.py @@ -23,12 +23,16 @@ def argparse_args(): return MagicMock( profile_build=None, profile_host=None, + profile_all=None, settings_build=None, settings_host=None, + settings_all=None, options_build=None, options_host=None, + options_all=None, conf_build=None, - conf_host=None + conf_host=None, + conf_all=None, )		[ { "components": [ { "doc": "", "lines": [ 64, 71 ], "name": "add_profiles_args.ContextAllAction", "signature": "class ContextAllAction(argparse.Action):", "type": "class" }, { "doc": "", "lines": [ 66...	[ "conans/test/integration/command/test_profile.py::test_shorthand_syntax" ]	[ "conans/test/integration/command/test_profile.py::test_profile_path", "conans/test/integration/command/test_profile.py::test_profile_path_missing", "conans/test/integration/command/test_profile.py::test_ignore_paths_when_listing_profiles", "conans/test/integration/command/test_profile.py::test_profile_show_js...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add shorthand syntax in cli to specify host and build in 1 argument Changelog: Feature: Add shorthand syntax in cli to specify host and build in 1 argument Docs: https://github.com/conan-io/docs/pull/3439 There's some split preferences between possible names. This pr implements (for `-pr`, `-s`, `-o`, `-c`) `-s:a` (`--settings:all`), but other possible names we discussed are: * `-s:hb` (`settings:hostbuild`): Makes it more clear that this affects the host and build profiles * `-s:h,b` (`settings:host,build`): Separates both names with a comma (Which is not a special char in any terminal as far as I can see), maybe easier to read? I'm open to change it to whatever everyone feels like a better one The new profile args read like this: ``` $ conan build -h usage: conan build [-h] [-v [V]] [--name NAME] [--version VERSION] [--user USER] [--channel CHANNEL] [-g GENERATOR] [-of OUTPUT_FOLDER] [-d DEPLOYER] [--deployer-folder DEPLOYER_FOLDER] [--build-require] [-b BUILD] [-r REMOTE \| -nr] [-u] [-pr PROFILE] [-pr:b PROFILE_BUILD] [-pr:h PROFILE_HOST] [-pr:a PROFILE_ALL] [-o OPTIONS] [-o:b OPTIONS_BUILD] [-o:h OPTIONS_HOST] [-o:a OPTIONS_ALL] [-s SETTINGS] [-s:b SETTINGS_BUILD] [-s:h SETTINGS_HOST] [-s:a SETTINGS_ALL] [-c CONF] [-c:b CONF_BUILD] [-c:h CONF_HOST] [-c:a CONF_ALL] [-l LOCKFILE] [--lockfile-partial] [--lockfile-out LOCKFILE_OUT] [--lockfile-packages] [--lockfile-clean] [--lockfile-overrides LOCKFILE_OVERRIDES] [path] Install dependencies and call the build() method. positional arguments: path Path to a python-based recipe file or a folder containing a conanfile.py recipe. conanfile.txt cannot be used with conan build. options: -h, --help show this help message and exit -v [V] Level of detail of the output. Valid options from less verbose to more verbose: -vquiet, -verror, -vwarning, -vnotice, -vstatus, -v or -vverbose, -vv or -vdebug, -vvv or -vtrace --name NAME Provide a package name if not specified in conanfile --version VERSION Provide a package version if not specified in conanfile --user USER Provide a user if not specified in conanfile --channel CHANNEL Provide a channel if not specified in conanfile -g GENERATOR, --generator GENERATOR Generators to use -of OUTPUT_FOLDER, --output-folder OUTPUT_FOLDER The root output folder for generated and build files -d DEPLOYER, --deployer DEPLOYER Deploy using the provided deployer to the output folder --deployer-folder DEPLOYER_FOLDER Deployer output folder, base build folder by default if not set --build-require Whether the provided path is a build-require -b BUILD, --build BUILD Optional, specify which packages to build from source. Combining multiple '--build' options on one command line is allowed. Possible values: --build="*" Force build from source for all packages. --build=never Disallow build for all packages, use binary packages or fail if a binary package is not found, it cannot be combined with other '--build' options. --build=missing Build packages from source whose binary package is not found. --build=cascade Build packages from source that have at least one dependency being built from source. --build=[pattern] Build packages from source whose package reference matches the pattern. The pattern uses 'fnmatch' style wildcards. --build=~[pattern] Excluded packages, which will not be built from the source, whose package reference matches the pattern. The pattern uses 'fnmatch' style wildcards. --build=missing:[pattern] Build from source if a compatible binary does not exist, only for packages matching pattern. -r REMOTE, --remote REMOTE Look in the specified remote or remotes server -nr, --no-remote Do not use remote, resolve exclusively in the cache -u, --update Will check the remote and in case a newer version and/or revision of the dependencies exists there, it will install those in the local cache. When using version ranges, it will install the latest version that satisfies the range. Also, if using revisions, it will update to the latest revision for the resolved version range. -pr PROFILE, --profile PROFILE Apply the specified profile. By default, or if specifying -pr:h (--profile:host), it applies to the host context. Use -pr:b (--profile:build) to specify the build context, or -pr:a (--profile:all) to specify both contexts at once -pr:b PROFILE_BUILD, --pr:build PROFILE_BUILD -pr:h PROFILE_HOST, --pr:host PROFILE_HOST -pr:a PROFILE_ALL, --profile:all PROFILE_ALL -o OPTIONS, --options OPTIONS Apply the specified profile. By default, or if specifying -o:h (--options:host), it applies to the host context. Use -o:b (--options:build) to specify the build context, or -o:a (--options:all) to specify both contexts at once. Example: -o pkg:with_qt=true -o:b OPTIONS_BUILD, --o:build OPTIONS_BUILD -o:h OPTIONS_HOST, --o:host OPTIONS_HOST -o:a OPTIONS_ALL, --options:all OPTIONS_ALL -s SETTINGS, --settings SETTINGS Apply the specified profile. By default, or if specifying -s:h (--settings:host), it applies to the host context. Use -s:b (--settings:build) to specify the build context, or -s:a (--settings:all) to specify both contexts at once. Example: -s compiler=gcc -s:b SETTINGS_BUILD, --s:build SETTINGS_BUILD -s:h SETTINGS_HOST, --s:host SETTINGS_HOST -s:a SETTINGS_ALL, --settings:all SETTINGS_ALL -c CONF, --conf CONF Apply the specified profile. By default, or if specifying -c:h (--conf:host), it applies to the host context. Use -c:b (--conf:build) to specify the build context, or -c:a (--conf:all) to specify both contexts at once. Example: -c tools.cmake.cmaketoolchain:generator=Xcode -c:b CONF_BUILD, --c:build CONF_BUILD -c:h CONF_HOST, --c:host CONF_HOST -c:a CONF_ALL, --conf:all CONF_ALL -l LOCKFILE, --lockfile LOCKFILE Path to a lockfile. Use --lockfile="" to avoid automatic use of existing 'conan.lock' file --lockfile-partial Do not raise an error if some dependency is not found in lockfile --lockfile-out LOCKFILE_OUT Filename of the updated lockfile --lockfile-packages Lock package-id and package-revision information --lockfile-clean Remove unused entries from the lockfile --lockfile-overrides LOCKFILE_OVERRIDES Overwrite lockfile overrides ``` Closes #14696 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conan/cli/args.py] (definition of add_profiles_args.ContextAllAction:) class ContextAllAction(argparse.Action): (definition of add_profiles_args.ContextAllAction.__call__:) def __call__(self, action_parser, namespace, values, option_string=None): (definition of add_profiles_args.create_config:) def create_config(short, long, example=None): [end of new definitions in conan/cli/args.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> [feature] Same host and build profile option? ### What is your suggestion? In "developer mode sitting at my desk" mode, i.e. when building and running code on the same machine and manually typing `conan install ....` often, I'd find it useful to save some typing by adding a command line option to set both profiles the same easily. So far I've not had a problem with only using `--profile`, but that merging of profiles makes me a bit nervous depending on what might be in `default` vs. what I really want (not specifying any profiles and just relying on `default` for both is not what I'm after, as I have multiple differing profiles). Not sure if I'm missing something obvious or it's a really bad idea for some reason I'm not aware of, but in case it's a reasonable idea I hacked something up at: https://github.com/lukester1975/conan/commit/d554a6ad84015007e0005d8aa027d7877b64bef2 Thanks! ### Have you read the CONTRIBUTING guide? - [X] I've read the CONTRIBUTING guide ---------- Hi @lukester1975 Thanks for your comments > I'd find it useful to save some typing by adding a command line option to set both profiles the same easily. This is generally not intended as a normal development flow. Because changing your "host" profile doesn't really mean wanting to change the "build" profile. For example, changing the host build_type to ``Debug``, almost always doesn't mean that you want to run your "build" tools like ``cmake`` in Debug mode. Same happens for practically all settings, like wanting to compile your code with ``gcc`` (mingw in Windows) doesn't really mean that you want to build your tools with mingw, maybe those tools does not even work with mingw. So the "build" profile is understood as something very static, and in theory it should be possible to use the "default" most of the time. And that happens for normal "native" builds, for every cross-build, it is directly impossible to use same profiles, of course. What are your use cases? what ``tool_requires`` are you managing that you want to change the way they are compiled so often? What profiles are you using? OK not to worry, I wouldn't want to waste your time trying to help me understand better! Could take a while 😀 I do have some further wacky suggestions but I'll separate issues for them then. Thanks No prob, happy to help! Don't hesitate to ask as much as you want, and open new tickets for any further question 🙂 I have seen some duplicated command lines, that could benefit from this syntax, and at the end of the day is almost cero risk, ux seems clear, so why not. I am re-opening this, to give it a second chance and propose it to the team to see what they think. I guess I should open a separate issue for this, but it's somewhat related... Has consideration been given for specifying profiles on that command line that don't mean the default is not used? E.g. something like `conan install . -pr +my_libcxx_profile` being the same as `conan install . -pr default -pr my_libcxx_profile`. (Can't see anything in issues but a difficult thing to search for, so sorry if I missed something.) `my_libcxx_profile` here is (mostly) orthogonal to any compiler selection type profile, so `include()`ing isn't really the right thing to do without getting combinatorially onerous and ending up with too many profiles... Thanks Not sure if I understood, but multiple profiles can be defined for both host and build, and they are dynamically composed on the fly, with precedence from left to right (right is the highest priority), so you can compose profiles without using ``include()``, but adding them in the command line. By default profiles in Conan 2.0 no longer compose with the ``default`` one, which is no longer needed if you specify your own profile, so a special syntax for it wouldn't be needed if I understood it correctly. Yeah I think you misunderstood a bit. What I was after is to be able to compose with the default profile without specifying it, but it sounds like you're saying that was the v1 behaviour :) I.e. it would be nice not to have to add `-pr=default` before `-pr=my_libcxx_profile` in the example above, somehow... but not possible IIUC. Although "by default" ... so it's maybe possible? I can step through and see if I can find how to do that, I don't want to take up your time. What can I say, I get through a lot of keyboards. Had a look, I guess not possible to change the default behaviour and somehow compose with the default: ```py build = [self.get_default_build()] if not args.profile_build else args.profile_build host = [self.get_default_host()] if not args.profile_host else args.profile_host ``` As a quick POC of a `+` ugly syntax hack: ```py def get_profiles_from_args(self, args): def _get_profiles(get_default, profiles): if not profiles: return [get_default()] elif (profiles[0].startswith("+")): return [get_default(), profiles[0].removeprefix("+"), *profiles[1:]] else: return profiles build = _get_profiles(self.get_default_build, args.profile_build) host = _get_profiles(self.get_default_host, args.profile_host) profile_build = self.get_profile(profiles=build, settings=args.settings_build, options=args.options_build, conf=args.conf_build) profile_host = self.get_profile(profiles=host, settings=args.settings_host, options=args.options_host, conf=args.conf_host) return profile_host, profile_build ``` Doesn't appear to break any existing tests... > I.e. it would be nice not to have to add -pr=default before -pr=my_libcxx_profile in the example above, somehow... but not possible IIUC. Yes, this is not possible, this is exactly what we had in Conan 1.X, and it was explicitly requested, and we had a lot of cases where the implicit use of the ``default`` was being problematic. So as similar to other cases, we opted for the "better explicit than implicit", and now it is necessary to do the ``include(default)`` or pass ``-pr=default -pr=myprofile`` Makes sense, though not exactly the same as 1.x presumably? What I was suggesting is still explicit just with a more terse syntax :) I.e `-pr=+my_profile`. Best of both worlds? Anyway no big deal if it's a hard no. Thanks -------------------- </issues>	4a5b19a75db9225316c8cb022a2dfb9705a2af34
sqlfluff__sqlfluff-5187	5,187	sqlfluff/sqlfluff	2.2	48ab0cac22e27352a1e3b94b35525db6eb814053	2023-09-11T10:42:11Z	diff --git a/src/sqlfluff/core/parser/grammar/anyof.py b/src/sqlfluff/core/parser/grammar/anyof.py index b57a00a97d0..8294b0e2aba 100644 --- a/src/sqlfluff/core/parser/grammar/anyof.py +++ b/src/sqlfluff/core/parser/grammar/anyof.py @@ -11,15 +11,59 @@ ) from sqlfluff.core.parser.grammar.sequence import Bracketed, Sequence from sqlfluff.core.parser.helpers import trim_non_code_segments +from sqlfluff.core.parser.match_algorithms import greedy_match from sqlfluff.core.parser.match_result import MatchResult from sqlfluff.core.parser.match_wrapper import match_wrapper -from sqlfluff.core.parser.segments import BaseSegment -from sqlfluff.core.parser.types import MatchableType, SimpleHintType +from sqlfluff.core.parser.segments import BaseSegment, UnparsableSegment +from sqlfluff.core.parser.types import MatchableType, ParseMode, SimpleHintType + + +def _parse_mode_match_result( + matched_segments: Tuple[BaseSegment, ...], + unmatched_segments: Tuple[BaseSegment, ...], + tail: Tuple[BaseSegment, ...], + parse_mode: ParseMode, +) -> MatchResult: + """A helper function for the return values of AnyNumberOf. + + This method creates UnparsableSegments as appropriate + depending on the parse mode and return values. + """ + # If we're being strict, just return. + if parse_mode == ParseMode.STRICT: + return MatchResult(matched_segments, unmatched_segments + tail) + + # Nothing in unmatched anyway? + if not unmatched_segments or all(not s.is_code for s in unmatched_segments): + return MatchResult(matched_segments, unmatched_segments + tail) + + _trim_idx = 0 + for _trim_idx in range(len(unmatched_segments)): + if unmatched_segments[_trim_idx].is_code: + break + + # Create an unmatched segment + _expected = "Nothing else" + if tail: + _expected += f" before {tail[0].raw!r}" + + unmatched_seg = UnparsableSegment( + unmatched_segments[_trim_idx:], expected=_expected + ) + return MatchResult( + matched_segments + unmatched_segments[:_trim_idx] + (unmatched_seg,), + tail, + ) class AnyNumberOf(BaseGrammar): """A more configurable version of OneOf.""" + supported_parse_modes = { + ParseMode.STRICT, + ParseMode.GREEDY, + } + def __init__( self, args: Union[MatchableType, str], @@ -31,6 +75,7 @@ def __init__( reset_terminators: bool = False, allow_gaps: bool = True, optional: bool = False, + parse_mode: ParseMode = ParseMode.STRICT, ) -> None: self.max_times = max_times self.min_times = min_times @@ -43,6 +88,7 @@ def __init__( optional=optional, terminators=terminators, reset_terminators=reset_terminators, + parse_mode=parse_mode, ) @cached_method_for_parse_context @@ -117,31 +163,51 @@ def match( if self.exclude.match(segments, ctx): return MatchResult.from_unmatched(segments) - # Match on each of the options matched_segments: MatchResult = MatchResult.from_empty() unmatched_segments: Tuple[BaseSegment, ...] = segments - n_matches = 0 + tail: Tuple[BaseSegment, ...] = () + + # Secondly, if we're in a greedy mode, handle that first. + if self.parse_mode == ParseMode.GREEDY: + _terminators = [self.terminators, parse_context.terminators] + _term_match = greedy_match( + segments, + parse_context, + matchers=_terminators, + ) + if _term_match: + # If we found a terminator, trim off the tail of the available + # segments to match on. + unmatched_segments = _term_match.matched_segments + tail = _term_match.unmatched_segments # Keep track of the number of times each option has been matched. + n_matches = 0 option_counter = {elem.cache_key(): 0 for elem in self._elements} while True: if self.max_times and n_matches >= self.max_times: # We've matched as many times as we can - return MatchResult( - matched_segments.matched_segments, unmatched_segments + return _parse_mode_match_result( + matched_segments.matched_segments, + unmatched_segments, + tail, + self.parse_mode, ) # Is there anything left to match? if len(unmatched_segments) == 0: # No... if n_matches >= self.min_times: - return MatchResult( - matched_segments.matched_segments, unmatched_segments + return _parse_mode_match_result( + matched_segments.matched_segments, + unmatched_segments, + tail, + self.parse_mode, ) else: # pragma: no cover TODO? # We didn't meet the hurdle - return MatchResult.from_unmatched(unmatched_segments) + return MatchResult.from_unmatched(segments) # If we've already matched once... if n_matches > 0 and self.allow_gaps: @@ -165,8 +231,11 @@ def match( self.max_times_per_element and option_counter[matched_key] > self.max_times_per_element ): - return MatchResult( - matched_segments.matched_segments, unmatched_segments + return _parse_mode_match_result( + matched_segments.matched_segments, + pre_seg + unmatched_segments, + tail, + self.parse_mode, ) if match: @@ -178,12 +247,22 @@ def match( # unmatched segments are meaningful, i.e. they're not what we're # looking for. if n_matches >= self.min_times: - return MatchResult( - matched_segments.matched_segments, pre_seg + unmatched_segments + return _parse_mode_match_result( + matched_segments.matched_segments, + pre_seg + unmatched_segments, + tail, + self.parse_mode, ) else: # We didn't meet the hurdle - return MatchResult.from_unmatched(unmatched_segments) + return _parse_mode_match_result( + (), + matched_segments.matched_segments + + pre_seg + + unmatched_segments, + tail, + self.parse_mode, + ) class OneOf(AnyNumberOf): @@ -201,6 +280,7 @@ def __init__( reset_terminators: bool = False, allow_gaps: bool = True, optional: bool = False, + parse_mode: ParseMode = ParseMode.STRICT, ) -> None: super().__init__( args, @@ -211,6 +291,7 @@ def __init__( reset_terminators=reset_terminators, allow_gaps=allow_gaps, optional=optional, + parse_mode=parse_mode, ) @@ -228,6 +309,7 @@ def __init__( terminators: SequenceType[Union[MatchableType, str]] = (), reset_terminators: bool = False, optional: bool = False, + parse_mode: ParseMode = ParseMode.STRICT, ) -> None: super().__init__( Bracketed(args), @@ -237,6 +319,7 @@ def __init__( terminators=terminators, reset_terminators=reset_terminators, optional=optional, + parse_mode=parse_mode, ) @@ -253,6 +336,7 @@ def __init__( reset_terminators: bool = False, allow_gaps: bool = True, optional: bool = False, + parse_mode: ParseMode = ParseMode.STRICT, ) -> None: super().__init__( args, @@ -264,4 +348,5 @@ def __init__( reset_terminators=reset_terminators, allow_gaps=allow_gaps, optional=optional, + parse_mode=parse_mode, ) diff --git a/src/sqlfluff/core/parser/grammar/base.py b/src/sqlfluff/core/parser/grammar/base.py index bcac5d9b6cf..3ca3f5e28ca 100644 --- a/src/sqlfluff/core/parser/grammar/base.py +++ b/src/sqlfluff/core/parser/grammar/base.py @@ -255,8 +255,11 @@ def _longest_trimmed_match( return MatchResult.from_unmatched(segments), None # Prune available options, based on their simple representation for efficiency. + # NOTE: We're also passing in terminators as options. available_options = prune_options( - matchers, segments, parse_context=parse_context + matchers, + segments, + parse_context=parse_context, ) # If we've pruned all the options, return no match @@ -271,9 +274,6 @@ def _longest_trimmed_match( # than only being used in a per-grammar basis. if parse_context.terminators: parse_context.increment("ltm_calls_w_ctx_terms") - terminators = parse_context.terminators - else: - terminators = () # If gaps are allowed, trim the ends. if trim_noncode: @@ -315,6 +315,10 @@ def _longest_trimmed_match( # Cache it for later to for performance. parse_context.put_parse_cache(loc_key, matcher_key, res_match) + # No match. Skip this one. + if not res_match: + continue + if res_match.is_complete(): # Just return it! (WITH THE RIGHT OTHER STUFF) parse_context.increment("complete_match") @@ -342,11 +346,11 @@ def _longest_trimmed_match( # We're going to end anyway, so we can skip that step. terminated = True break - elif terminators: + elif parse_context.terminators: _, segs, _ = trim_non_code_segments( best_match[0].unmatched_segments ) - for terminator in terminators: + for terminator in parse_context.terminators: terminator_match: MatchResult = terminator.match( segs, parse_context ) diff --git a/src/sqlfluff/dialects/dialect_bigquery.py b/src/sqlfluff/dialects/dialect_bigquery.py index 9e4c9122448..7e82b06705c 100644 --- a/src/sqlfluff/dialects/dialect_bigquery.py +++ b/src/sqlfluff/dialects/dialect_bigquery.py @@ -17,7 +17,6 @@ CodeSegment, Dedent, Delimited, - GreedyUntil, Indent, Matchable, MultiStringParser, @@ -488,8 +487,7 @@ class ForInStatementsSegment(BaseSegment): """ type = "for_in_statements" - match_grammar = GreedyUntil(Sequence("END", "FOR")) - parse_grammar = AnyNumberOf( + match_grammar = AnyNumberOf( Sequence( OneOf( Ref("StatementSegment"), @@ -497,6 +495,8 @@ class ForInStatementsSegment(BaseSegment): ), Ref("DelimiterGrammar"), ), + terminators=[Sequence("END", "FOR")], + parse_mode=ParseMode.GREEDY, ) @@ -530,8 +530,7 @@ class RepeatStatementsSegment(BaseSegment): """ type = "repeat_statements" - match_grammar = GreedyUntil(Ref.keyword("UNTIL")) - parse_grammar = AnyNumberOf( + match_grammar = AnyNumberOf( Sequence( OneOf( Ref("StatementSegment"), @@ -539,6 +538,8 @@ class RepeatStatementsSegment(BaseSegment): ), Ref("DelimiterGrammar"), ), + terminators=["UNTIL"], + parse_mode=ParseMode.GREEDY, ) @@ -568,8 +569,7 @@ class IfStatementsSegment(BaseSegment): """ type = "if_statements" - match_grammar = GreedyUntil(OneOf("ELSE", "ELSEIF", Sequence("END", "IF"))) - parse_grammar = AnyNumberOf( + match_grammar = AnyNumberOf( Sequence( OneOf( Ref("StatementSegment"), @@ -577,6 +577,12 @@ class IfStatementsSegment(BaseSegment): ), Ref("DelimiterGrammar"), ), + terminators=[ + "ELSE", + "ELSEIF", + Sequence("END", "IF"), + ], + parse_mode=ParseMode.GREEDY, ) @@ -623,8 +629,7 @@ class LoopStatementsSegment(BaseSegment): """ type = "loop_statements" - match_grammar = GreedyUntil(Sequence("END", "LOOP")) - parse_grammar = AnyNumberOf( + match_grammar = AnyNumberOf( Sequence( OneOf( Ref("StatementSegment"), @@ -632,6 +637,8 @@ class LoopStatementsSegment(BaseSegment): ), Ref("DelimiterGrammar"), ), + terminators=[Sequence("END", "LOOP")], + parse_mode=ParseMode.GREEDY, ) @@ -659,12 +666,13 @@ class WhileStatementsSegment(BaseSegment): """ type = "while_statements" - match_grammar = GreedyUntil(Sequence("END", "WHILE")) - parse_grammar = AnyNumberOf( + match_grammar = AnyNumberOf( Sequence( Ref("StatementSegment"), Ref("DelimiterGrammar"), ), + terminators=[Sequence("END", "WHILE")], + parse_mode=ParseMode.GREEDY, ) @@ -1735,8 +1743,11 @@ class PivotForClauseSegment(BaseSegment): """ type = "pivot_for_clause" - match_grammar = GreedyUntil("IN") - parse_grammar = Ref("BaseExpressionElementGrammar") + match_grammar = Sequence( + Ref("BaseExpressionElementGrammar"), + terminators=["IN"], + parse_mode=ParseMode.GREEDY, + ) class FromPivotExpressionSegment(BaseSegment): @@ -2084,12 +2095,13 @@ class ProcedureStatements(BaseSegment): """ type = "procedure_statements" - match_grammar = GreedyUntil("END") - parse_grammar = AnyNumberOf( + match_grammar = AnyNumberOf( Sequence( Ref("StatementSegment"), Ref("DelimiterGrammar"), ), + terminators=["END"], + parse_mode=ParseMode.GREEDY, )	diff --git a/test/core/parser/grammar/grammar_anyof_test.py b/test/core/parser/grammar/grammar_anyof_test.py index 602511a4534..ec9af082aef 100644 --- a/test/core/parser/grammar/grammar_anyof_test.py +++ b/test/core/parser/grammar/grammar_anyof_test.py @@ -7,13 +7,14 @@ from sqlfluff.core.parser import ( KeywordSegment, + ParseMode, RegexParser, StringParser, WhitespaceSegment, ) from sqlfluff.core.parser.context import ParseContext from sqlfluff.core.parser.grammar import OneOf, Sequence -from sqlfluff.core.parser.grammar.anyof import AnySetOf +from sqlfluff.core.parser.grammar.anyof import AnyNumberOf, AnySetOf def test__parser__grammar__oneof__copy(): @@ -140,3 +141,106 @@ def test__parser__grammar_anysetof(generate_test_segments): ) # Check with a bit of whitespace assert not g.match(seg_list[1:], parse_context=ctx) + + +@pytest.mark.parametrize( + "mode,sequence,terminators,input_slice,kwargs,output_tuple", + [ + # ##### + # Strict matches + # ##### + # 1. Match once + (ParseMode.STRICT, ["a"], [], slice(None, None), {}, (("keyword", "a"),)), + # 2. Match none + (ParseMode.STRICT, ["b"], [], slice(None, None), {}, ()), + # 3. Match twice + ( + ParseMode.STRICT, + ["b", "a"], + [], + slice(None, None), + {}, + ( + ("keyword", "a"), + ("whitespace", " "), + ("keyword", "b"), + ), + ), + # 4. Limited match + ( + ParseMode.STRICT, + ["b", "a"], + [], + slice(None, None), + {"max_times": 1}, + (("keyword", "a"),), + ), + # ##### + # Greedy matches + # ##### + # 1. Terminated match + ( + ParseMode.GREEDY, + ["b", "a"], + ["b"], + slice(None, None), + {}, + (("keyword", "a"),), + ), + # 2. Terminated, but not matching the first element. + ( + ParseMode.GREEDY, + ["b"], + ["b"], + slice(None, None), + {}, + (("unparsable", (("raw", "a"),)),), + ), + # 3. Terminated, but only a partial match. + ( + ParseMode.GREEDY, + ["a"], + ["c"], + slice(None, None), + {}, + ( + ("keyword", "a"), + ("whitespace", " "), + ("unparsable", (("raw", "b"),)), + ), + ), + ], +) +def test__parser__grammar_anyof_modes( + mode, + sequence, + terminators, + input_slice, + kwargs, + output_tuple, + generate_test_segments, + fresh_ansi_dialect, +): + """Test the Sequence grammar with various parse modes. + + In particular here we're testing the treatment of unparsable + sections. + """ + segments = generate_test_segments(["a", " ", "b", " ", "c", "d", " ", "d"]) + # Dialect is required here only to have access to bracket segments. + ctx = ParseContext(dialect=fresh_ansi_dialect) + + _seq = AnyNumberOf( + (StringParser(e, KeywordSegment) for e in sequence), + parse_mode=mode, + terminators=[StringParser(e, KeywordSegment) for e in terminators], + *kwargs, + ) + _match = _seq.match(segments[input_slice], ctx) + # If we're expecting an output tuple, assert the match is truthy. + if output_tuple: + assert _match + _result = tuple( + e.to_tuple(show_raw=True, code_only=False) for e in _match.matched_segments + ) + assert _result == output_tuple		[ { "components": [ { "doc": "A helper function for the return values of AnyNumberOf.\n\nThis method creates UnparsableSegments as appropriate\ndepending on the parse mode and return values.", "lines": [ 21, 55 ], "name": "_parse_mode_match_result", ...	[ "test/core/parser/grammar/grammar_anyof_test.py::test__parser__grammar_anyof_modes[ParseMode.STRICT-sequence0-terminators0-input_slice0-kwargs0-output_tuple0]", "test/core/parser/grammar/grammar_anyof_test.py::test__parser__grammar_anyof_modes[ParseMode.STRICT-sequence1-terminators1-input_slice1-kwargs1-output_tu...	[ "test/core/parser/grammar/grammar_anyof_test.py::test__parser__grammar__oneof__copy", "test/core/parser/grammar/grammar_anyof_test.py::test__parser__grammar_oneof[True]", "test/core/parser/grammar/grammar_anyof_test.py::test__parser__grammar_oneof[False]", "test/core/parser/grammar/grammar_anyof_test.py::test...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Parse modes for `AnyNumberOf` Another step on #5124 . Combined with #5186 , this removes the last parts of `parse_grammar` (apart from the `FileSegment` which is the final puzzle piece and will come last). We do this by adding greedy support to `AnyNumberOf` (and therefore to `OneOf` and all the other similar grammars). Interestingly, most of the effects of this are in the `bigquery` dialect. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/sqlfluff/core/parser/grammar/anyof.py] (definition of _parse_mode_match_result:) def _parse_mode_match_result( matched_segments: Tuple[BaseSegment, ...], unmatched_segments: Tuple[BaseSegment, ...], tail: Tuple[BaseSegment, ...], parse_mode: ParseMode, ) -> MatchResult: """A helper function for the return values of AnyNumberOf. This method creates UnparsableSegments as appropriate depending on the parse mode and return values.""" [end of new definitions in src/sqlfluff/core/parser/grammar/anyof.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		65328e6b701f46ebb25b758c10b7572111f130ab
slackapi__python-slack-sdk-1399	1,399	slackapi/python-slack-sdk	null	d468b354ca8d37702198c1c26ee6fd77133dfb71	2023-09-08T06:20:01Z	diff --git a/slack_sdk/models/blocks/basic_components.py b/slack_sdk/models/blocks/basic_components.py index 1e708ffa6..3999b9119 100644 --- a/slack_sdk/models/blocks/basic_components.py +++ b/slack_sdk/models/blocks/basic_components.py @@ -524,3 +524,38 @@ def to_dict(self) -> Dict[str, Any]: # skipcq: PYL-W0221 if self._trigger_actions_on: json["trigger_actions_on"] = self._trigger_actions_on return json + + +class WorkflowTrigger(JsonObject): + attributes = {"trigger"} + + def __init__(self, , url: str, customizable_input_parameters: Optional[List[Dict[str, str]]] = None): + self._url = url + self._customizable_input_parameters = customizable_input_parameters + + def to_dict(self) -> Dict[str, Any]: # skipcq: PYL-W0221 + self.validate_json() + json = {"url": self._url} + if self._customizable_input_parameters is not None: + json.update({"customizable_input_parameters": self._customizable_input_parameters}) + return json + + +class Workflow(JsonObject): + attributes = {"trigger"} + + def __init__( + self, + , + trigger: Union[WorkflowTrigger, dict], + ): + self._trigger = trigger + + def to_dict(self) -> Dict[str, Any]: # skipcq: PYL-W0221 + self.validate_json() + json = {} + if isinstance(self._trigger, WorkflowTrigger): + json["trigger"] = self._trigger.to_dict() + else: + json["trigger"] = self._trigger + return json diff --git a/slack_sdk/models/blocks/block_elements.py b/slack_sdk/models/blocks/block_elements.py index 65157e1ec..4cf1519c2 100644 --- a/slack_sdk/models/blocks/block_elements.py +++ b/slack_sdk/models/blocks/block_elements.py @@ -11,7 +11,7 @@ JsonValidator, EnumValidator, ) -from .basic_components import ButtonStyles +from .basic_components import ButtonStyles, Workflow from .basic_components import ConfirmObject from .basic_components import DispatchActionConfig from .basic_components import MarkdownTextObject @@ -1689,3 +1689,60 @@ def __init__( @JsonValidator(f"options attribute must have between {options_min_length} " f"and {options_max_length} items") def _validate_options_length(self) -> bool: return self.options_min_length <= len(self.options) <= self.options_max_length + + +# ------------------------------------------------- +# Workflow Button +# ------------------------------------------------- + + +class WorkflowButtonElement(InteractiveElement): + type = "workflow_button" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"text", "workflow", "style", "accessibility_label"}) + + def __init__( + self, + , + text: Union[str, dict, TextObject], + action_id: Optional[str] = None, + workflow: Optional[Union[dict, Workflow]] = None, + style: Optional[str] = None, # primary, danger + accessibility_label: Optional[str] = None, + *others: dict, + ): + """Allows users to run a link trigger with customizable inputs + Interactive component - but interactions with workflow button elements will not send block_actions events, + since these are used to start new workflow runs. + https://api.slack.com/reference/block-kit/block-elements#workflow_button + + Args: + text (required): A text object that defines the button's text. + Can only be of type: plain_text. text may truncate with ~30 characters. + Maximum length for the text in this field is 75 characters. + action_id (required): An identifier for this action. + You can use this when you receive an interaction payload to identify the source of the action. + Should be unique among all other action_ids in the containing block. + Maximum length for this field is 255 characters. + workflow: A workflow object that contains details about the workflow + that will run when the button is clicked. + style: Decorates buttons with alternative visual color schemes. Use this option with restraint. + "primary" gives buttons a green outline and text, ideal for affirmation or confirmation actions. + "primary" should only be used for one button within a set. + "danger" gives buttons a red outline and text, and should be used when the action is destructive. + Use "danger" even more sparingly than "primary". + If you don't include this field, the default button style will be used. + accessibility_label: A label for longer descriptive text about a button element. + This label will be read out by screen readers instead of the button text object. + Maximum length for this field is 75 characters. + """ + super().__init__(action_id=action_id, type=self.type) + show_unknown_key_warning(self, others) + + # NOTE: default_type=PlainTextObject.type here is only for backward-compatibility with version 2.5.0 + self.text = TextObject.parse(text, default_type=PlainTextObject.type) + self.workflow = workflow + self.style = style + self.accessibility_label = accessibility_label	diff --git a/tests/slack_sdk/models/test_elements.py b/tests/slack_sdk/models/test_elements.py index 906147c1c..1b246b0a6 100644 --- a/tests/slack_sdk/models/test_elements.py +++ b/tests/slack_sdk/models/test_elements.py @@ -33,6 +33,7 @@ EmailInputElement, NumberInputElement, UrlInputElement, + WorkflowButtonElement, ) from . import STRING_3001_CHARS, STRING_301_CHARS @@ -1213,3 +1214,26 @@ def test_focus_on_load(self): "focus_on_load": True, } self.assertDictEqual(input, RadioButtonsElement(input).to_dict()) + + +# ------------------------------------------------- +# Workflow Button +# ------------------------------------------------- + + +class WorkflowButtonElementTests(unittest.TestCase): + def test_load(self): + input = { + "type": "workflow_button", + "text": {"type": "plain_text", "text": "Run Workflow"}, + "workflow": { + "trigger": { + "url": "https://slack.com/shortcuts/Ft0123ABC456/xyz...zyx", + "customizable_input_parameters": [ + {"name": "input_parameter_a", "value": "Value for input param A"}, + {"name": "input_parameter_b", "value": "Value for input param B"}, + ], + } + }, + } + self.assertDictEqual(input, WorkflowButtonElement(input).to_dict()) diff --git a/tests/slack_sdk/models/test_objects.py b/tests/slack_sdk/models/test_objects.py index 532cddd6b..383abee7c 100644 --- a/tests/slack_sdk/models/test_objects.py +++ b/tests/slack_sdk/models/test_objects.py @@ -11,6 +11,7 @@ OptionGroup, PlainTextObject, ) +from slack_sdk.models.blocks.basic_components import Workflow, WorkflowTrigger from slack_sdk.models.messages import ( ChannelLink, DateLink, @@ -566,3 +567,28 @@ def test_confirm_style_validation(self): "style": "something-wrong", } ).validate_json() + + +class WorkflowTests(unittest.TestCase): + def test_creation(self): + workflow = Workflow( + trigger=WorkflowTrigger( + url="https://slack.com/shortcuts/Ft0123ABC456/xyz...zyx", + customizable_input_parameters=[ + {"name": "input_parameter_a", "value": "Value for input param A"}, + {"name": "input_parameter_b", "value": "Value for input param B"}, + ], + ) + ) + self.assertDictEqual( + workflow.to_dict(), + { + "trigger": { + "url": "https://slack.com/shortcuts/Ft0123ABC456/xyz...zyx", + "customizable_input_parameters": [ + {"name": "input_parameter_a", "value": "Value for input param A"}, + {"name": "input_parameter_b", "value": "Value for input param B"}, + ], + } + }, + )		[ { "components": [ { "doc": "", "lines": [ 529, 541 ], "name": "WorkflowTrigger", "signature": "class WorkflowTrigger(JsonObject):", "type": "class" }, { "doc": "", "lines": [ 532, 534 ...	[ "tests/slack_sdk/models/test_elements.py::BlockElementTests::test_eq", "tests/slack_sdk/models/test_elements.py::BlockElementTests::test_parse_timepicker", "tests/slack_sdk/models/test_elements.py::InteractiveElementTests::test_with_input_interactive_element", "tests/slack_sdk/models/test_elements.py::Interac...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add workflow_button block element ## Summary This pull request adds a new block element (https://api.slack.com/reference/block-kit/block-elements#workflow_button) to slack_sdk.models package. ### Category (place an `x` in each of the `[ ]`) - [ ] slack_sdk.web.WebClient (sync/async) (Web API client) - [ ] slack_sdk.webhook.WebhookClient (sync/async) (Incoming Webhook, response_url sender) - [ ] slack_sdk.socket_mode (Socket Mode client) - [ ] slack_sdk.signature (Request Signature Verifier) - [ ] slack_sdk.oauth (OAuth Flow Utilities) - [x] slack_sdk.models (UI component builders) - [ ] slack_sdk.scim (SCIM API client) - [ ] slack_sdk.audit_logs (Audit Logs API client) - [ ] slack_sdk.rtm_v2 (RTM client) - [ ] `/docs-src` (Documents, have you run `./scripts/docs.sh`?) - [ ] `/docs-src-v2` (Documents, have you run `./scripts/docs-v2.sh`?) - [ ] `/tutorial` (PythOnBoardingBot tutorial) - [x] `tests`/`integration_tests` (Automated tests for this library) ## Requirements (place an `x` in each `[ ]`) - [x] I've read and understood the [Contributing Guidelines](https://github.com/slackapi/python-slack-sdk/blob/main/.github/contributing.md) and have done my best effort to follow them. - [x] I've read and agree to the [Code of Conduct](https://slackhq.github.io/code-of-conduct). - [x] I've run `python3 -m venv .venv && source .venv/bin/activate && ./scripts/run_validation.sh` after making the changes. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in slack_sdk/models/blocks/basic_components.py] (definition of WorkflowTrigger:) class WorkflowTrigger(JsonObject): (definition of WorkflowTrigger.__init__:) def __init__(self, , url: str, customizable_input_parameters: Optional[List[Dict[str, str]]] = None): (definition of WorkflowTrigger.to_dict:) def to_dict(self) -> Dict[str, Any]: (definition of Workflow:) class Workflow(JsonObject): (definition of Workflow.__init__:) def __init__( self, , trigger: Union[WorkflowTrigger, dict], ): (definition of Workflow.to_dict:) def to_dict(self) -> Dict[str, Any]: [end of new definitions in slack_sdk/models/blocks/basic_components.py] [start of new definitions in slack_sdk/models/blocks/block_elements.py] (definition of WorkflowButtonElement:) class WorkflowButtonElement(InteractiveElement): (definition of WorkflowButtonElement.attributes:) def attributes(self) -> Set[str]: (definition of WorkflowButtonElement.__init__:) def __init__( self, *, text: Union[str, dict, TextObject], action_id: Optional[str] = None, workflow: Optional[Union[dict, Workflow]] = None, style: Optional[str] = None, """Allows users to run a link trigger with customizable inputs Interactive component - but interactions with workflow button elements will not send block_actions events, since these are used to start new workflow runs. https://api.slack.com/reference/block-kit/block-elements#workflow_button Args: text (required): A text object that defines the button's text. Can only be of type: plain_text. text may truncate with ~30 characters. Maximum length for the text in this field is 75 characters. action_id (required): An identifier for this action. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. workflow: A workflow object that contains details about the workflow that will run when the button is clicked. style: Decorates buttons with alternative visual color schemes. Use this option with restraint. "primary" gives buttons a green outline and text, ideal for affirmation or confirmation actions. "primary" should only be used for one button within a set. "danger" gives buttons a red outline and text, and should be used when the action is destructive. Use "danger" even more sparingly than "primary". If you don't include this field, the default button style will be used. accessibility_label: A label for longer descriptive text about a button element. This label will be read out by screen readers instead of the button text object. Maximum length for this field is 75 characters.""" [end of new definitions in slack_sdk/models/blocks/block_elements.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		2997a1786c4fd969b00ce69af888ebae8e8ebed0
scikit-learn__scikit-learn-27308	27,308	scikit-learn/scikit-learn	1.4	93e22cdd8dff96fa3870475f40e435083bce8ad0	2023-09-06T20:11:59Z	diff --git a/doc/metadata_routing.rst b/doc/metadata_routing.rst index 61fc7a8f72b65..12d64eab8217c 100644 --- a/doc/metadata_routing.rst +++ b/doc/metadata_routing.rst @@ -260,6 +260,9 @@ Meta-estimators and functions supporting metadata routing: - :func:`sklearn.model_selection.cross_validate` - :func:`sklearn.model_selection.cross_val_score` - :func:`sklearn.model_selection.cross_val_predict` +- :class:`sklearn.multiclass.OneVsOneClassifier` +- :class:`sklearn.multiclass.OneVsRestClassifier` +- :class:`sklearn.multiclass.OutputCodeClassifier` - :class:`sklearn.multioutput.ClassifierChain` - :class:`sklearn.multioutput.MultiOutputClassifier` - :class:`sklearn.multioutput.MultiOutputRegressor` @@ -296,8 +299,5 @@ Meta-estimators and tools not supporting metadata routing yet: - :class:`sklearn.model_selection.learning_curve` - :class:`sklearn.model_selection.permutation_test_score` - :class:`sklearn.model_selection.validation_curve` -- :class:`sklearn.multiclass.OneVsOneClassifier` -- :class:`sklearn.multiclass.OneVsRestClassifier` -- :class:`sklearn.multiclass.OutputCodeClassifier` - :class:`sklearn.pipeline.FeatureUnion` - :class:`sklearn.semi_supervised.SelfTrainingClassifier` diff --git a/doc/whats_new/v1.4.rst b/doc/whats_new/v1.4.rst index 6afc5011ded30..250496182752f 100644 --- a/doc/whats_new/v1.4.rst +++ b/doc/whats_new/v1.4.rst @@ -40,6 +40,13 @@ The following models now support metadata routing in one or more or their methods. Refer to the :ref:`Metadata Routing User Guide <metadata_routing>` for more details. +- \|Feature\| :class:`multiclass.OneVsRestClassifier`, + :class:`multiclass.OneVsOneClassifier` and + :class:`multiclass.OutputCodeClassifier` now support metadata routing in + their ``fit`` and ``partial_fit``, and route metadata to the underlying + estimator's ``fit`` and ``partial_fit``. :pr:`27308` by :user:`Stefanie + Senger <StefanieSenger>`. + - \|Feature\| :class:`pipeline.Pipeline` now supports metadata routing according to :ref:`metadata routing user guide <metadata_routing>`. :pr:`26789` by `Adrin Jalali`_. diff --git a/sklearn/multiclass.py b/sklearn/multiclass.py index f73802f0c701c..07b19115f0912 100644 --- a/sklearn/multiclass.py +++ b/sklearn/multiclass.py @@ -56,7 +56,12 @@ from .utils import check_random_state from .utils._param_validation import HasMethods, Interval from .utils._tags import _safe_tags -from .utils.metadata_routing import _RoutingNotSupportedMixin +from .utils.metadata_routing import ( + MetadataRouter, + MethodMapping, + _raise_for_params, + process_routing, +) from .utils.metaestimators import _safe_split, available_if from .utils.multiclass import ( _check_partial_fit_first_call, @@ -64,7 +69,7 @@ check_classification_targets, ) from .utils.parallel import Parallel, delayed -from .utils.validation import _num_samples, check_is_fitted +from .utils.validation import _check_method_params, _num_samples, check_is_fitted __all__ = [ "OneVsRestClassifier", @@ -73,7 +78,7 @@ ] -def _fit_binary(estimator, X, y, classes=None): +def _fit_binary(estimator, X, y, fit_params, classes=None): """Fit a single binary estimator.""" unique_y = np.unique(y) if len(unique_y) == 1: @@ -88,13 +93,13 @@ def _fit_binary(estimator, X, y, classes=None): estimator = _ConstantPredictor().fit(X, unique_y) else: estimator = clone(estimator) - estimator.fit(X, y) + estimator.fit(X, y, fit_params) return estimator -def _partial_fit_binary(estimator, X, y): +def _partial_fit_binary(estimator, X, y, partial_fit_params): """Partially fit a single binary estimator.""" - estimator.partial_fit(X, y, np.array((0, 1))) + estimator.partial_fit(X, y, classes=np.array((0, 1)), partial_fit_params) return estimator @@ -120,6 +125,8 @@ def _threshold_for_binary_predict(estimator): class _ConstantPredictor(BaseEstimator): + """Helper predictor to be used when only one class is present.""" + def fit(self, X, y): check_params = dict( force_all_finite=False, dtype=None, ensure_2d=False, accept_sparse=True @@ -183,7 +190,6 @@ def _estimators_has(attr): class OneVsRestClassifier( - _RoutingNotSupportedMixin, MultiOutputMixin, ClassifierMixin, MetaEstimatorMixin, @@ -312,7 +318,7 @@ def __init__(self, estimator, , n_jobs=None, verbose=0): # OneVsRestClassifier.estimator is not validated yet prefer_skip_nested_validation=False ) - def fit(self, X, y): + def fit(self, X, y, fit_params): """Fit underlying estimators. Parameters @@ -324,11 +330,27 @@ def fit(self, X, y): Multi-class targets. An indicator matrix turns on multilabel classification. + fit_params : dict + Parameters passed to the ``estimator.fit`` method of each + sub-estimator. + + .. versionadded:: 1.4 + Only available if `enable_metadata_routing=True`. See + :ref:`Metadata Routing User Guide <metadata_routing>` for more + details. + Returns ------- self : object Instance of fitted estimator. """ + _raise_for_params(fit_params, self, "fit") + + routed_params = process_routing( + self, + "fit", + fit_params, + ) # A sparse LabelBinarizer, with sparse_output=True, has been shown to # outperform or match a dense label binarizer in all cases and has also # resulted in less or equal memory consumption in the fit_ovr function @@ -346,6 +368,7 @@ def fit(self, X, y): self.estimator, X, column, + fit_params=routed_params.estimator.fit, classes=[ "not %s" % self.label_binarizer_.classes_[i], self.label_binarizer_.classes_[i], @@ -366,11 +389,11 @@ def fit(self, X, y): # OneVsRestClassifier.estimator is not validated yet prefer_skip_nested_validation=False ) - def partial_fit(self, X, y, classes=None): + def partial_fit(self, X, y, classes=None, partial_fit_params): """Partially fit underlying estimators. Should be used when memory is inefficient to train all data. - Chunks of data can be passed in several iteration. + Chunks of data can be passed in several iterations. Parameters ---------- @@ -388,11 +411,28 @@ def partial_fit(self, X, y, classes=None): This argument is only required in the first call of partial_fit and can be omitted in the subsequent calls. + partial_fit_params : dict + Parameters passed to the ``estimator.partial_fit`` method of each + sub-estimator. + + .. versionadded:: 1.4 + Only available if `enable_metadata_routing=True`. See + :ref:`Metadata Routing User Guide <metadata_routing>` for more + details. + Returns ------- self : object Instance of partially fitted estimator. """ + _raise_for_params(partial_fit_params, self, "partial_fit") + + routed_params = process_routing( + self, + "partial_fit", + partial_fit_params, + ) + if _check_partial_fit_first_call(self, classes): if not hasattr(self.estimator, "partial_fit"): raise ValueError( @@ -421,7 +461,12 @@ def partial_fit(self, X, y, classes=None): columns = (col.toarray().ravel() for col in Y.T) self.estimators_ = Parallel(n_jobs=self.n_jobs)( - delayed(_partial_fit_binary)(estimator, X, column) + delayed(_partial_fit_binary)( + estimator, + X, + column, + partial_fit_params=routed_params.estimator.partial_fit, + ) for estimator, column in zip(self.estimators_, columns) ) @@ -552,8 +597,35 @@ def _more_tags(self): """Indicate if wrapped estimator is using a precomputed Gram matrix""" return {"pairwise": _safe_tags(self.estimator, key="pairwise")} + def get_metadata_routing(self): + """Get metadata routing of this object. + + Please check :ref:`User Guide <metadata_routing>` on how the routing + mechanism works. -def _fit_ovo_binary(estimator, X, y, i, j): + .. versionadded:: 1.4 + + Returns + ------- + routing : MetadataRouter + A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating + routing information. + """ + + router = ( + MetadataRouter(owner=self.__class__.__name__) + .add_self_request(self) + .add( + estimator=self.estimator, + method_mapping=MethodMapping() + .add(callee="fit", caller="fit") + .add(callee="partial_fit", caller="partial_fit"), + ) + ) + return router + + +def _fit_ovo_binary(estimator, X, y, i, j, fit_params): """Fit a single binary estimator (one-vs-one).""" cond = np.logical_or(y == i, y == j) y = y[cond] @@ -561,18 +633,21 @@ def _fit_ovo_binary(estimator, X, y, i, j): y_binary[y == i] = 0 y_binary[y == j] = 1 indcond = np.arange(_num_samples(X))[cond] + + fit_params_subset = _check_method_params(X, params=fit_params, indices=indcond) return ( _fit_binary( estimator, _safe_split(estimator, X, None, indices=indcond)[0], y_binary, + fit_params=fit_params_subset, classes=[i, j], ), indcond, ) -def _partial_fit_ovo_binary(estimator, X, y, i, j): +def _partial_fit_ovo_binary(estimator, X, y, i, j, partial_fit_params): """Partially fit a single binary estimator(one-vs-one).""" cond = np.logical_or(y == i, y == j) @@ -580,13 +655,16 @@ def _partial_fit_ovo_binary(estimator, X, y, i, j): if len(y) != 0: y_binary = np.zeros_like(y) y_binary[y == j] = 1 - return _partial_fit_binary(estimator, X[cond], y_binary) + partial_fit_params_subset = _check_method_params( + X, params=partial_fit_params, indices=cond + ) + return _partial_fit_binary( + estimator, X[cond], y_binary, partial_fit_params=partial_fit_params_subset + ) return estimator -class OneVsOneClassifier( - _RoutingNotSupportedMixin, MetaEstimatorMixin, ClassifierMixin, BaseEstimator -): +class OneVsOneClassifier(MetaEstimatorMixin, ClassifierMixin, BaseEstimator): """One-vs-one multiclass strategy. This strategy consists in fitting one classifier per class pair. @@ -677,7 +755,7 @@ def __init__(self, estimator, , n_jobs=None): # OneVsOneClassifier.estimator is not validated yet prefer_skip_nested_validation=False ) - def fit(self, X, y): + def fit(self, X, y, fit_params): """Fit underlying estimators. Parameters @@ -688,11 +766,28 @@ def fit(self, X, y): y : array-like of shape (n_samples,) Multi-class targets. + fit_params : dict + Parameters passed to the ``estimator.fit`` method of each + sub-estimator. + + .. versionadded:: 1.4 + Only available if `enable_metadata_routing=True`. See + :ref:`Metadata Routing User Guide <metadata_routing>` for more + details. + Returns ------- self : object The fitted underlying estimator. """ + _raise_for_params(fit_params, self, "fit") + + routed_params = process_routing( + self, + "fit", + *fit_params, + ) + # We need to validate the data because we do a safe_indexing later. X, y = self._validate_data( X, y, accept_sparse=["csr", "csc"], force_all_finite=False @@ -710,7 +805,12 @@ def fit(self, X, y): ( Parallel(n_jobs=self.n_jobs)( delayed(_fit_ovo_binary)( - self.estimator, X, y, self.classes_[i], self.classes_[j] + self.estimator, + X, + y, + self.classes_[i], + self.classes_[j], + fit_params=routed_params.estimator.fit, ) for i in range(n_classes) for j in range(i + 1, n_classes) @@ -731,7 +831,7 @@ def fit(self, X, y): # OneVsOneClassifier.estimator is not validated yet prefer_skip_nested_validation=False ) - def partial_fit(self, X, y, classes=None): + def partial_fit(self, X, y, classes=None, partial_fit_params): """Partially fit underlying estimators. Should be used when memory is inefficient to train all data. Chunks @@ -753,11 +853,28 @@ def partial_fit(self, X, y, classes=None): This argument is only required in the first call of partial_fit and can be omitted in the subsequent calls. + partial_fit_params : dict + Parameters passed to the ``estimator.partial_fit`` method of each + sub-estimator. + + .. versionadded:: 1.4 + Only available if `enable_metadata_routing=True`. See + :ref:`Metadata Routing User Guide <metadata_routing>` for more + details. + Returns ------- self : object The partially fitted underlying estimator. """ + _raise_for_params(partial_fit_params, self, "partial_fit") + + routed_params = process_routing( + self, + "partial_fit", + *partial_fit_params, + ) + first_call = _check_partial_fit_first_call(self, classes) if first_call: self.estimators_ = [ @@ -783,7 +900,12 @@ def partial_fit(self, X, y, classes=None): combinations = itertools.combinations(range(self.n_classes_), 2) self.estimators_ = Parallel(n_jobs=self.n_jobs)( delayed(_partial_fit_ovo_binary)( - estimator, X, y, self.classes_[i], self.classes_[j] + estimator, + X, + y, + self.classes_[i], + self.classes_[j], + partial_fit_params=routed_params.estimator.partial_fit, ) for estimator, (i, j) in zip(self.estimators_, (combinations)) ) @@ -874,10 +996,35 @@ def _more_tags(self): """Indicate if wrapped estimator is using a precomputed Gram matrix""" return {"pairwise": _safe_tags(self.estimator, key="pairwise")} + def get_metadata_routing(self): + """Get metadata routing of this object. -class OutputCodeClassifier( - _RoutingNotSupportedMixin, MetaEstimatorMixin, ClassifierMixin, BaseEstimator -): + Please check :ref:`User Guide <metadata_routing>` on how the routing + mechanism works. + + .. versionadded:: 1.4 + + Returns + ------- + routing : MetadataRouter + A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating + routing information. + """ + + router = ( + MetadataRouter(owner=self.__class__.__name__) + .add_self_request(self) + .add( + estimator=self.estimator, + method_mapping=MethodMapping() + .add(callee="fit", caller="fit") + .add(callee="partial_fit", caller="partial_fit"), + ) + ) + return router + + +class OutputCodeClassifier(MetaEstimatorMixin, ClassifierMixin, BaseEstimator): """(Error-Correcting) Output-Code multiclass strategy. Output-code based strategies consist in representing each class with a @@ -924,7 +1071,7 @@ class OutputCodeClassifier( classes_ : ndarray of shape (n_classes,) Array containing labels. - code_book_ : ndarray of shape (n_classes, code_size) + code_book_ : ndarray of shape (n_classes, `len(estimators_)`) Binary array containing the code of each class. n_features_in_ : int @@ -997,7 +1144,7 @@ def __init__(self, estimator, , code_size=1.5, random_state=None, n_jobs=None): # OutputCodeClassifier.estimator is not validated yet prefer_skip_nested_validation=False ) - def fit(self, X, y): + def fit(self, X, y, fit_params): """Fit underlying estimators. Parameters @@ -1008,11 +1155,28 @@ def fit(self, X, y): y : array-like of shape (n_samples,) Multi-class targets. + fit_params : dict + Parameters passed to the ``estimator.fit`` method of each + sub-estimator. + + .. versionadded:: 1.4 + Only available if `enable_metadata_routing=True`. See + :ref:`Metadata Routing User Guide <metadata_routing>` for more + details. + Returns ------- self : object Returns a fitted instance of self. """ + _raise_for_params(fit_params, self, "fit") + + routed_params = process_routing( + self, + "fit", + *fit_params, + ) + y = self._validate_data(X="no_validation", y=y) random_state = check_random_state(self.random_state) @@ -1024,11 +1188,11 @@ def fit(self, X, y): raise ValueError( "OutputCodeClassifier can not be fit when no class is present." ) - code_size_ = int(n_classes self.code_size) + n_estimators = int(n_classes * self.code_size) # FIXME: there are more elaborate methods than generating the codebook # randomly. - self.code_book_ = random_state.uniform(size=(n_classes, code_size_)) + self.code_book_ = random_state.uniform(size=(n_classes, n_estimators)) self.code_book_[self.code_book_ > 0.5] = 1.0 if hasattr(self.estimator, "decision_function"): @@ -1044,7 +1208,10 @@ def fit(self, X, y): ) self.estimators_ = Parallel(n_jobs=self.n_jobs)( - delayed(_fit_binary)(self.estimator, X, Y[:, i]) for i in range(Y.shape[1]) + delayed(_fit_binary)( + self.estimator, X, Y[:, i], fit_params=routed_params.estimator.fit + ) + for i in range(Y.shape[1]) ) if hasattr(self.estimators_[0], "n_features_in_"): @@ -1078,3 +1245,24 @@ def predict(self, X): ).T pred = pairwise_distances_argmin(Y, self.code_book_, metric="euclidean") return self.classes_[pred] + + def get_metadata_routing(self): + """Get metadata routing of this object. + + Please check :ref:`User Guide <metadata_routing>` on how the routing + mechanism works. + + .. versionadded:: 1.4 + + Returns + ------- + routing : MetadataRouter + A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating + routing information. + """ + + router = MetadataRouter(owner=self.__class__.__name__).add( + estimator=self.estimator, + method_mapping=MethodMapping().add(callee="fit", caller="fit"), + ) + return router	diff --git a/sklearn/tests/metadata_routing_common.py b/sklearn/tests/metadata_routing_common.py index 2bc7a00aae585..14bf037ae9054 100644 --- a/sklearn/tests/metadata_routing_common.py +++ b/sklearn/tests/metadata_routing_common.py @@ -20,6 +20,7 @@ MetadataRouter, process_routing, ) +from sklearn.utils.multiclass import _check_partial_fit_first_call def record_metadata(obj, method, record_default=True, kwargs): @@ -46,6 +47,10 @@ def check_recorded_metadata(obj, method, split_params=tuple(), kwargs): Parameters ---------- + obj : estimator object + sub-estimator to check routed params for + method : str + sub-estimator's method where metadata is routed to split_params : tuple, default=empty specifies any parameters which are to be checked as being a subset of the original values. @@ -170,7 +175,7 @@ def fit(self, X, y): if self.registry is not None: self.registry.append(self) - self.classes_ = [0, 1] + self.classes_ = np.unique(y) return self def predict(self, X): @@ -197,14 +202,16 @@ def __init__(self, registry=None, alpha=0.0): self.alpha = alpha self.registry = registry - def partial_fit(self, X, y, sample_weight="default", metadata="default"): + def partial_fit( + self, X, y, classes=None, sample_weight="default", metadata="default" + ): if self.registry is not None: self.registry.append(self) record_metadata_not_default( self, "partial_fit", sample_weight=sample_weight, metadata=metadata ) - self.classes_ = [0, 1] + _check_partial_fit_first_call(self, classes) return self def fit(self, X, y, sample_weight="default", metadata="default"): @@ -214,7 +221,7 @@ def fit(self, X, y, sample_weight="default", metadata="default"): record_metadata_not_default( self, "fit", sample_weight=sample_weight, metadata=metadata ) - self.classes_ = [0, 1] + self.classes_ = np.unique(y) return self def predict(self, X, sample_weight="default", metadata="default"): diff --git a/sklearn/tests/test_metaestimators_metadata_routing.py b/sklearn/tests/test_metaestimators_metadata_routing.py index 7956ed5f3726e..dfe57d7682da6 100644 --- a/sklearn/tests/test_metaestimators_metadata_routing.py +++ b/sklearn/tests/test_metaestimators_metadata_routing.py @@ -76,8 +76,10 @@ rng = np.random.RandomState(42) N, M = 100, 4 X = rng.rand(N, M) -y = rng.randint(0, 2, size=N) -y_multi = rng.randint(0, 2, size=(N, 3)) +y = rng.randint(0, 3, size=N) +classes = np.unique(y) +y_multi = rng.randint(0, 3, size=(N, 3)) +classes_multi = [np.unique(y_multi[:, i]) for i in range(y_multi.shape[1])] metadata = rng.randint(0, 10, size=N) sample_weight = rng.rand(N) groups = np.array([0, 1] * (len(y) // 2)) @@ -106,6 +108,7 @@ def enable_slep006(): "X": X, "y": y_multi, "estimator_routing_methods": ["fit", "partial_fit"], + "method_args": {"partial_fit": {"classes": classes_multi}}, }, { "metaestimator": CalibratedClassifierCV, @@ -197,6 +200,34 @@ def enable_slep006(): "cv_name": "cv", "cv_routing_methods": ["fit"], }, + { + "metaestimator": OneVsRestClassifier, + "estimator_name": "estimator", + "estimator": ConsumingClassifier, + "X": X, + "y": y, + "estimator_routing_methods": ["fit", "partial_fit"], + "method_args": {"partial_fit": {"classes": classes}}, + }, + { + "metaestimator": OneVsOneClassifier, + "estimator_name": "estimator", + "estimator": ConsumingClassifier, + "X": X, + "y": y, + "estimator_routing_methods": ["fit", "partial_fit"], + "preserves_metadata": "subset", + "method_args": {"partial_fit": {"classes": classes}}, + }, + { + "metaestimator": OutputCodeClassifier, + "estimator_name": "estimator", + "estimator": ConsumingClassifier, + "init_args": {"random_state": 42}, + "X": X, + "y": y, + "estimator_routing_methods": ["fit"], + }, ] """List containing all metaestimators to be tested and their settings @@ -225,6 +256,8 @@ def enable_slep006(): - cv_name: The name of the argument for the CV splitter - cv_routing_methods: list of all methods to check for routing metadata to the splitter +- method_args: a dict of dicts, defining extra arguments needed to be passed to + methods, such as passing `classes` to `partial_fit`. """ # IDs used by pytest to get meaningful verbose messages when running the tests @@ -244,10 +277,7 @@ def enable_slep006(): LassoLarsCV(), MultiTaskElasticNetCV(), MultiTaskLassoCV(), - OneVsOneClassifier(ConsumingClassifier()), - OneVsRestClassifier(ConsumingClassifier()), OrthogonalMatchingPursuitCV(), - OutputCodeClassifier(ConsumingClassifier()), RANSACRegressor(), RFE(ConsumingClassifier()), RFECV(ConsumingClassifier()), @@ -366,7 +396,7 @@ def test_error_on_missing_requests_for_sub_estimator(metaestimator): # requests are not set if "estimator" not in metaestimator: # This test only makes sense for metaestimators which have a - # sub-estimator + # sub-estimator, e.g. MyMetaEstimator(estimator=MySubEstimator()) return cls = metaestimator["metaestimator"] @@ -398,7 +428,7 @@ def test_setting_request_on_sub_estimator_removes_error(metaestimator): # should be no errors. if "estimator" not in metaestimator: # This test only makes sense for metaestimators which have a - # sub-estimator + # sub-estimator, e.g. MyMetaEstimator(estimator=MySubEstimator()) return def set_request(estimator, method_name): @@ -427,8 +457,10 @@ def set_request(estimator, method_name): set_request(estimator, method_name) instance = cls(kwargs) method = getattr(instance, method_name) - method(X, y, method_kwargs) - + extra_method_args = metaestimator.get("method_args", {}).get( + method_name, {} + ) + method(X, y, method_kwargs, extra_method_args) # sanity check that registry is not empty, or else the test passes # trivially assert registry	diff --git a/doc/metadata_routing.rst b/doc/metadata_routing.rst index 61fc7a8f72b65..12d64eab8217c 100644 --- a/doc/metadata_routing.rst +++ b/doc/metadata_routing.rst @@ -260,6 +260,9 @@ Meta-estimators and functions supporting metadata routing: - :func:`sklearn.model_selection.cross_validate` - :func:`sklearn.model_selection.cross_val_score` - :func:`sklearn.model_selection.cross_val_predict` +- :class:`sklearn.multiclass.OneVsOneClassifier` +- :class:`sklearn.multiclass.OneVsRestClassifier` +- :class:`sklearn.multiclass.OutputCodeClassifier` - :class:`sklearn.multioutput.ClassifierChain` - :class:`sklearn.multioutput.MultiOutputClassifier` - :class:`sklearn.multioutput.MultiOutputRegressor` @@ -296,8 +299,5 @@ Meta-estimators and tools not supporting metadata routing yet: - :class:`sklearn.model_selection.learning_curve` - :class:`sklearn.model_selection.permutation_test_score` - :class:`sklearn.model_selection.validation_curve` -- :class:`sklearn.multiclass.OneVsOneClassifier` -- :class:`sklearn.multiclass.OneVsRestClassifier` -- :class:`sklearn.multiclass.OutputCodeClassifier` - :class:`sklearn.pipeline.FeatureUnion` - :class:`sklearn.semi_supervised.SelfTrainingClassifier` diff --git a/doc/whats_new/v1.4.rst b/doc/whats_new/v1.4.rst index 6afc5011ded30..250496182752f 100644 --- a/doc/whats_new/v1.4.rst +++ b/doc/whats_new/v1.4.rst @@ -40,6 +40,13 @@ The following models now support metadata routing in one or more or their methods. Refer to the :ref:`Metadata Routing User Guide <metadata_routing>` for more details. +- \|Feature\| :class:`multiclass.OneVsRestClassifier`, + :class:`multiclass.OneVsOneClassifier` and + :class:`multiclass.OutputCodeClassifier` now support metadata routing in + their ``fit`` and ``partial_fit``, and route metadata to the underlying + estimator's ``fit`` and ``partial_fit``. :pr:`27308` by :user:`Stefanie + Senger <StefanieSenger>`. + - \|Feature\| :class:`pipeline.Pipeline` now supports metadata routing according to :ref:`metadata routing user guide <metadata_routing>`. :pr:`26789` by `Adrin Jalali`_.	[ { "components": [ { "doc": "Get metadata routing of this object.\n\nPlease check :ref:`User Guide <metadata_routing>` on how the routing\nmechanism works.\n\n.. versionadded:: 1.4\n\nReturns\n-------\nrouting : MetadataRouter\n A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsula...	[ "sklearn/tests/test_metaestimators_metadata_routing.py::test_default_request[OneVsRestClassifier]", "sklearn/tests/test_metaestimators_metadata_routing.py::test_default_request[OneVsOneClassifier]", "sklearn/tests/test_metaestimators_metadata_routing.py::test_default_request[OutputCodeClassifier]", "sklearn/t...	[ "sklearn/tests/test_metaestimators_metadata_routing.py::test_unsupported_estimators_get_metadata_routing[estimator0]", "sklearn/tests/test_metaestimators_metadata_routing.py::test_unsupported_estimators_get_metadata_routing[estimator1]", "sklearn/tests/test_metaestimators_metadata_routing.py::test_unsupported_e...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> ENH Add metadata routing to OneVsRestClassifier, OneVsOneClassifier and OutputCodeClassifier #### Reference Issues/PRs Towards #22893 #### What does this implement/fix? Explain your changes. - Adds metadata routing to OneVsRestClassifier, OneVsOneClassifier and OutputCodeClassifier - The routing is added in the `fit` and `partial_fit` methods if they exist - A test is added for checking that the coefficients are different when different sample weights are passed. Another test asserts if the correct error message is shown if `enable_metadata_routing` is `False`, but metadata is passed. #### Comments I had do put those three together, because they share common functions. Thanks @glemaitre for your help! ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/multiclass.py] (definition of OneVsRestClassifier.get_metadata_routing:) def get_metadata_routing(self): """Get metadata routing of this object. Please check :ref:`User Guide <metadata_routing>` on how the routing mechanism works. .. versionadded:: 1.4 Returns ------- routing : MetadataRouter A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating routing information.""" (definition of OneVsOneClassifier.get_metadata_routing:) def get_metadata_routing(self): """Get metadata routing of this object. Please check :ref:`User Guide <metadata_routing>` on how the routing mechanism works. .. versionadded:: 1.4 Returns ------- routing : MetadataRouter A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating routing information.""" (definition of OutputCodeClassifier.get_metadata_routing:) def get_metadata_routing(self): """Get metadata routing of this object. Please check :ref:`User Guide <metadata_routing>` on how the routing mechanism works. .. versionadded:: 1.4 Returns ------- routing : MetadataRouter A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating routing information.""" [end of new definitions in sklearn/multiclass.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		ae2c80a21007d8295fb3ec3a927fce17b3d60ab8
Textualize__textual-3236	3,236	Textualize/textual	null	06b6426750a583ef9f7bc2fc458ccc72cbec9fd0	2023-09-05T12:28:31Z	diff --git a/src/textual/_slug.py b/src/textual/_slug.py new file mode 100644 index 0000000000..8d23ca4dab --- /dev/null +++ b/src/textual/_slug.py @@ -0,0 +1,116 @@ +"""Provides a utility function and class for creating Markdown-friendly slugs. + +The approach to creating slugs is designed to be as close to +GitHub-flavoured Markdown as possible. However, because there doesn't appear +to be any actual documentation for this 'standard', the code here involves +some guesswork and also some pragmatic shortcuts. + +Expect this to grow over time. + +The main rules used in here at the moment are: + +1. Strip all leading and trailing whitespace. +2. Remove all non-lingual characters (emoji, etc). +3. Remove all punctuation and whitespace apart from dash and underscore. +""" + +from __future__ import annotations + +from collections import defaultdict +from re import compile +from string import punctuation +from typing import Pattern +from urllib.parse import quote + +from typing_extensions import Final + +WHITESPACE_REPLACEMENT: Final[str] = "-" +"""The character to replace undesirable characters with.""" + +REMOVABLE: Final[str] = punctuation.replace(WHITESPACE_REPLACEMENT, "").replace("_", "") +"""The collection of characters that should be removed altogether.""" + +NONLINGUAL: Final[str] = ( + r"\U000024C2-\U0001F251" + r"\U00002702-\U000027B0" + r"\U0001F1E0-\U0001F1FF" + r"\U0001F300-\U0001F5FF" + r"\U0001F600-\U0001F64F" + r"\U0001F680-\U0001F6FF" + r"\U0001f926-\U0001f937" + r"\u200D" + r"\u2640-\u2642" +) +"""A string that can be used in a regular expression to remove most non-lingual characters.""" + +STRIP_RE: Final[Pattern] = compile(f"[{REMOVABLE}{NONLINGUAL}]+") +"""A regular expression for finding all the characters that should be removed.""" + +WHITESPACE_RE: Final[Pattern] = compile(r"\s") +"""A regular expression for finding all the whitespace and turning it into `REPLACEMENT`.""" + + +def slug(text: str) -> str: + """Create a Markdown-friendly slug from the given text. + + Args: + text: The text to generate a slug from. + + Returns: + A slug for the given text. + + The rules used in generating the slug are based on observations of how + GitHub-flavoured Markdown works. + """ + result = text.strip().lower() + for rule, replacement in ( + (STRIP_RE, ""), + (WHITESPACE_RE, WHITESPACE_REPLACEMENT), + ): + result = rule.sub(replacement, result) + return quote(result) + + +class TrackedSlugs: + """Provides a class for generating tracked slugs. + + While [`slug`][textual._slug.slug] will generate a slug for a given + string, it does not guarantee that it is unique for a given context. If + you want to ensure that the same string generates unique slugs (perhaps + heading slugs within a Markdown document, as an example), use an + instance of this class to generate them. + + Example: + ```python + >>> slug("hello world") + 'hello-world' + >>> slug("hello world") + 'hello-world' + >>> unique = TrackedSlugs() + >>> unique.slug("hello world") + 'hello-world' + >>> unique.slug("hello world") + 'hello-world-1' + ``` + """ + + def __init__(self) -> None: + """Initialise the tracked slug object.""" + self._used: defaultdict[str, int] = defaultdict(int) + """Keeps track of how many times a particular slug has been used.""" + + def slug(self, text: str) -> str: + """Create a Markdown-friendly unique slug from the given text. + + Args: + text: The text to generate a slug from. + + Returns: + A slug for the given text. + """ + slugged = slug(text) + used = self._used[slugged] + self._used[slugged] += 1 + if used: + slugged = f"{slugged}-{used}" + return slugged	diff --git a/tests/test_slug.py b/tests/test_slug.py new file mode 100644 index 0000000000..0486966e83 --- /dev/null +++ b/tests/test_slug.py @@ -0,0 +1,62 @@ +import pytest + +from textual._slug import TrackedSlugs, slug + + +@pytest.mark.parametrize( + "text, expected", + [ + ("test", "test"), + ("Test", "test"), + (" Test ", "test"), + ("-test-", "-test-"), + ("!test!", "test"), + ("test!!test", "testtest"), + ("test! !test", "test-test"), + ("test test", "test-test"), + ("test test", "test--test"), + ("test test", "test----------test"), + ("--test", "--test"), + ("test--", "test--"), + ("--test--test--", "--test--test--"), + ("test!\"#$%&'()+,-./:;<=>?@[]^_`{\|}~test", "test-_test"), + ("tëst", "t%C3%ABst"), + ("test🙂test", "testtest"), + ("test🤷test", "testtest"), + ("test🤷🏻‍♀️test", "testtest"), + ], +) +def test_simple_slug(text: str, expected: str) -> None: + """The simple slug function should produce the expected slug.""" + assert slug(text) == expected + + +@pytest.fixture(scope="module") +def tracker() -> TrackedSlugs: + return TrackedSlugs() + + +@pytest.mark.parametrize( + "text, expected", + [ + ("test", "test"), + ("test", "test-1"), + ("test", "test-2"), + ("-test-", "-test-"), + ("-test-", "-test--1"), + ("test!\"#$%&'()+,-./:;<=>?@[]^_`{\|}~test", "test-_test"), + ("test!\"#$%&'()*+,-./:;<=>?@[]^_`{\|}~test", "test-_test-1"), + ("tëst", "t%C3%ABst"), + ("tëst", "t%C3%ABst-1"), + ("tëst", "t%C3%ABst-2"), + ("test🙂test", "testtest"), + ("test🤷test", "testtest-1"), + ("test🤷🏻‍♀️test", "testtest-2"), + ("test", "test-3"), + ("test", "test-4"), + (" test ", "test-5"), + ], +) +def test_tracked_slugs(tracker: TrackedSlugs, text: str, expected: str) -> None: + """The tracked slugging class should produce the expected slugs.""" + assert tracker.slug(text) == expected		[ { "components": [ { "doc": "Create a Markdown-friendly slug from the given text.\n\nArgs:\n text: The text to generate a slug from.\n\nReturns:\n A slug for the given text.\n\nThe rules used in generating the slug are based on observations of how\nGitHub-flavoured Markdown works.", "...	[ "tests/test_slug.py::test_simple_slug[test-test]", "tests/test_slug.py::test_simple_slug[Test-test]", "tests/test_slug.py::test_simple_slug[", "tests/test_slug.py::test_simple_slug[-test---test-]", "tests/test_slug.py::test_simple_slug[!test!-test]", "tests/test_slug.py::test_simple_slug[test!!test-testte...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add utility code for generating Markdown-oriented slugs With #3094 in mind, and with the feedback on #2941 in mind, this PR seeks to implement some utility code for generating slugs that can be used as anchor links with Markdown documents. As per [Will's request that it be made to work like GitHub's approach](https://github.com/Textualize/textual/pull/2941#discussion_r1308516663), this code is a first pass at attempting to deliver that. Sadly, as best as I can tell, there's no specification for what GitHub does when it comes to slugging headers, so the rules have been worked out using some "common sense" and trial and error while editing and viewing a Markdown document on GitHub. The code in here, and the tests to go with it, aim to cover the vast majority of cases. There are some weird edge cases where it doesn't seem worth trying to handle them as they appear to be bugs. For example, in GutHub, this: ``` test🤷test ``` will slug to `testtest`. On the other hand this: ``` test🤷🏻‍♀️test ``` slugs to `test%EF%B8%8Ftest` That is, it seems like there are occasions where the last codepoint "leaks" into the slug (with the emoji itself being removed first). Without a specification or reference code to work from it's difficult to say if this intended or not, but I've taken the view that it's unintended and remote and unhelpful to try and replicate it -- the vast majority of headers are going to be pretty simple to slug. This code can be extended to be "bug compatible" if we find it's an issue. With this code merged into `main` I believe we'll be in a better position to rework #2941. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/textual/_slug.py] (definition of slug:) def slug(text: str) -> str: """Create a Markdown-friendly slug from the given text. Args: text: The text to generate a slug from. Returns: A slug for the given text. The rules used in generating the slug are based on observations of how GitHub-flavoured Markdown works.""" (definition of TrackedSlugs:) class TrackedSlugs: """Provides a class for generating tracked slugs. While [`slug`][textual._slug.slug] will generate a slug for a given string, it does not guarantee that it is unique for a given context. If you want to ensure that the same string generates unique slugs (perhaps heading slugs within a Markdown document, as an example), use an instance of this class to generate them. Example: ```python >>> slug("hello world") 'hello-world' >>> slug("hello world") 'hello-world' >>> unique = TrackedSlugs() >>> unique.slug("hello world") 'hello-world' >>> unique.slug("hello world") 'hello-world-1' ```""" (definition of TrackedSlugs.__init__:) def __init__(self) -> None: """Initialise the tracked slug object.""" (definition of TrackedSlugs.slug:) def slug(self, text: str) -> str: """Create a Markdown-friendly unique slug from the given text. Args: text: The text to generate a slug from. Returns: A slug for the given text.""" [end of new definitions in src/textual/_slug.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		86e93536b991014e0ea4bf993068202b446bb698
tobymao__sqlglot-2156	2,156	tobymao/sqlglot	null	585d0bfcbd40125492640480c890af328d8bc51f	2023-09-05T09:43:42Z	diff --git a/sqlglot/dialects/snowflake.py b/sqlglot/dialects/snowflake.py index 934e320adf..8d8183c3df 100644 --- a/sqlglot/dialects/snowflake.py +++ b/sqlglot/dialects/snowflake.py @@ -190,6 +190,13 @@ def _parse_regexp_replace(args: t.List) -> exp.RegexpReplace: return regexp_replace +def _show_parser(args: t.Any, kwargs: t.Any) -> t.Callable[[Snowflake.Parser], exp.Show]: + def _parse(self: Snowflake.Parser) -> exp.Show: + return self._parse_show_snowflake(args, kwargs) + + return _parse + + class Snowflake(Dialect): # https://docs.snowflake.com/en/sql-reference/identifiers-syntax RESOLVES_IDENTIFIERS_AS_UPPERCASE = True @@ -289,6 +296,16 @@ class Parser(parser.Parser): ), } + STATEMENT_PARSERS = { + parser.Parser.STATEMENT_PARSERS, + TokenType.SHOW: lambda self: self._parse_show(), + } + + SHOW_PARSERS = { + "PRIMARY KEYS": _show_parser("PRIMARY KEYS"), + "TERSE PRIMARY KEYS": _show_parser("PRIMARY KEYS"), + } + def _parse_id_var( self, any_token: bool = True, @@ -304,6 +321,23 @@ def _parse_id_var( return super()._parse_id_var(any_token=any_token, tokens=tokens) + def _parse_show_snowflake(self, this: str) -> exp.Show: + scope = None + scope_kind = None + + if self._match(TokenType.IN): + if self._match_text_seq("ACCOUNT"): + scope_kind = "ACCOUNT" + elif self._match_set(self.DB_CREATABLES): + scope_kind = self._prev.text + if self._curr: + scope = self._parse_table() + elif self._curr: + scope_kind = "TABLE" + scope = self._parse_table() + + return self.expression(exp.Show, this=this, scope=scope, scope_kind=scope_kind) + class Tokenizer(tokens.Tokenizer): STRING_ESCAPES = ["\\", "'"] HEX_STRINGS = [("x'", "'"), ("X'", "'")] @@ -338,6 +372,8 @@ class Tokenizer(tokens.Tokenizer): VAR_SINGLE_TOKENS = {"$"} + COMMANDS = tokens.Tokenizer.COMMANDS - {TokenType.SHOW} + class Generator(generator.Generator): PARAMETER_TOKEN = "$" MATCHED_BY_SOURCE = False @@ -413,6 +449,16 @@ class Generator(generator.Generator): exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED, } + def show_sql(self, expression: exp.Show) -> str: + scope = self.sql(expression, "scope") + scope = f" {scope}" if scope else "" + + scope_kind = self.sql(expression, "scope_kind") + if scope_kind: + scope_kind = f" IN {scope_kind}" + + return f"SHOW {expression.name}{scope_kind}{scope}" + def regexpextract_sql(self, expression: exp.RegexpExtract) -> str: # Other dialects don't support all of the following parameters, so we need to # generate default values as necessary to ensure the transpilation is correct diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index 7103b9c800..0479da09cb 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -1071,6 +1071,8 @@ class Show(Expression): "like": False, "where": False, "db": False, + "scope": False, + "scope_kind": False, "full": False, "mutex": False, "query": False, diff --git a/sqlglot/parser.py b/sqlglot/parser.py index 214998c74b..709122e04d 100644 --- a/sqlglot/parser.py +++ b/sqlglot/parser.py @@ -4852,8 +4852,7 @@ def _parse_show(self) -> t.Optional[exp.Expression]: parser = self._find_parser(self.SHOW_PARSERS, self.SHOW_TRIE) if parser: return parser(self) - self._advance() - return self.expression(exp.Show, this=self._prev.text.upper()) + return self._parse_as_command(self._prev) def _parse_set_item_assignment( self, kind: t.Optional[str] = None	diff --git a/tests/dialects/test_snowflake.py b/tests/dialects/test_snowflake.py index 05da654d8c..30a1f037bf 100644 --- a/tests/dialects/test_snowflake.py +++ b/tests/dialects/test_snowflake.py @@ -1034,3 +1034,33 @@ def test_match_recognize(self): )""", pretty=True, ) + + def test_show(self): + # Parsed as Command + self.validate_identity("SHOW COLUMNS IN TABLE dt_test") + self.validate_identity("SHOW TABLES LIKE 'line%' IN tpch.public") + + ast = parse_one("SHOW TABLES HISTORY IN tpch.public") + self.assertIsInstance(ast, exp.Command) + + # Parsed as Show + self.validate_identity("SHOW PRIMARY KEYS") + self.validate_identity("SHOW PRIMARY KEYS IN ACCOUNT") + self.validate_identity("SHOW PRIMARY KEYS IN DATABASE") + self.validate_identity("SHOW PRIMARY KEYS IN DATABASE foo") + self.validate_identity("SHOW PRIMARY KEYS IN TABLE") + self.validate_identity("SHOW PRIMARY KEYS IN TABLE foo") + self.validate_identity( + 'SHOW PRIMARY KEYS IN "TEST"."PUBLIC"."customers"', + 'SHOW PRIMARY KEYS IN TABLE "TEST"."PUBLIC"."customers"', + ) + self.validate_identity( + 'SHOW TERSE PRIMARY KEYS IN "TEST"."PUBLIC"."customers"', + 'SHOW PRIMARY KEYS IN TABLE "TEST"."PUBLIC"."customers"', + ) + + ast = parse_one('SHOW PRIMARY KEYS IN "TEST"."PUBLIC"."customers"', read="snowflake") + table = ast.find(exp.Table) + + self.assertIsNotNone(table) + self.assertEqual(table.sql(dialect="snowflake"), '"TEST"."PUBLIC"."customers"')		[]	[ "tests/dialects/test_snowflake.py::TestSnowflake::test_show" ]	[ "tests/dialects/test_snowflake.py::TestSnowflake::test_ddl", "tests/dialects/test_snowflake.py::TestSnowflake::test_describe_table", "tests/dialects/test_snowflake.py::TestSnowflake::test_flatten", "tests/dialects/test_snowflake.py::TestSnowflake::test_match_recognize", "tests/dialects/test_snowflake.py::Te...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat!(snowflake): improve parsing for SHOW statement Fixes #2148 cc @tobymao had already started working on this; it doesn't parse all `SHOW` variants, but it solves the original issue and falls back to parsing `SHOW ...` as a `Command` in all other cases. It also serves as a foundation for completing the parsing of `SHOW` statements if we ever need to extend it. Reference: https://docs.snowflake.com/en/sql-reference/sql/show-primary-keys ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Show doesn't yield any metadata ``` from sqlglot import parse_one, exp tables = parse_one('SHOW PRIMARY KEYS IN "TEST"."PUBLIC"."customers"', read="snowflake", dialect="snowflake").find_all(exp.Table) ``` Expected output: List of tables, in this case it should be `customers` Instead receiving an empty result Official documentation: https://docs.snowflake.com/en/sql-reference/sql/show-primary-keys ---------- Hey, thanks for the report, we'll look into this soon. closed by 585d0bfcbd40125492640480c890af328d8bc51f parsed as a command, explicit parsing is out of scope, but happy to accept a PR -------------------- </issues>	ceb42fabad60312699e4b15936aeebac00e22e4d
joke2k__faker-1904	1,904	joke2k/faker	null	33e36b1b6cc9c6f039fe387988853771bab60624	2023-09-04T14:06:36Z	diff --git a/faker/providers/color/__init__.py b/faker/providers/color/__init__.py index e2aa0dec16..358512b73f 100644 --- a/faker/providers/color/__init__.py +++ b/faker/providers/color/__init__.py @@ -1,5 +1,6 @@ from collections import OrderedDict -from typing import Dict, Optional +from functools import cached_property +from typing import Dict, Optional, Tuple from ...typing import HueType from .. import BaseProvider, ElementsType @@ -198,6 +199,10 @@ def rgb_css_color(self) -> str: """Generate a color formatted as a CSS rgb() function.""" return f"rgb({self.random_int(0, 255)},{self.random_int(0, 255)},{self.random_int(0, 255)})" + @cached_property + def _random_color(self): + return RandomColor(self.generator) + def color( self, hue: Optional[HueType] = None, @@ -238,8 +243,40 @@ def color( :sample: hue=135, luminosity='dark', color_format='hsv' :sample: hue=(300, 20), luminosity='random', color_format='hsl' """ - return RandomColor(self.generator).generate( + return self._random_color.generate( hue=hue, luminosity=luminosity, color_format=color_format, ) + + def color_rgb( + self, + hue: Optional[HueType] = None, + luminosity: Optional[str] = None, + ) -> Tuple[int, int, int]: + """Generate a RGB color tuple of integers in a human-friendly way.""" + return self._random_color.generate_rgb(hue=hue, luminosity=luminosity) + + def color_rgb_float( + self, + hue: Optional[HueType] = None, + luminosity: Optional[str] = None, + ) -> Tuple[float, float, float]: + """Generate a RGB color tuple of floats in a human-friendly way.""" + return self._random_color.generate_rgb_float(hue=hue, luminosity=luminosity) + + def color_hsl( + self, + hue: Optional[HueType] = None, + luminosity: Optional[str] = None, + ) -> Tuple[int, int, int]: + """Generate a HSL color tuple in a human-friendly way.""" + return self._random_color.generate_hsl(hue=hue, luminosity=luminosity) + + def color_hsv( + self, + hue: Optional[HueType] = None, + luminosity: Optional[str] = None, + ) -> Tuple[int, int, int]: + """Generate a HSV color tuple in a human-friendly way.""" + return self._random_color.generate_hsv(hue=hue, luminosity=luminosity) diff --git a/faker/providers/color/color.py b/faker/providers/color/color.py index 91132f5c60..379024f1fc 100644 --- a/faker/providers/color/color.py +++ b/faker/providers/color/color.py @@ -16,13 +16,16 @@ import random import sys -from typing import TYPE_CHECKING, Dict, Hashable, Optional, Sequence, Tuple +from typing import TYPE_CHECKING, Dict, Hashable, Literal, Optional, Sequence, Tuple if TYPE_CHECKING: from ...factory import Generator from ...typing import HueType +ColorFormat = Literal["hex", "hsl", "hsv", "rgb"] + + COLOR_MAP: Dict[str, Dict[str, Sequence[Tuple[int, int]]]] = { "monochrome": { "hue_range": [(0, 0)], @@ -144,37 +147,64 @@ def __init__(self, generator: Optional["Generator"] = None, seed: Optional[Hasha self.seed = seed if seed else random.randint(0, sys.maxsize) self.random = random.Random(self.seed) - for color_name, color_attrs in self.colormap.items(): - lower_bounds: Sequence[Tuple[int, int]] = color_attrs["lower_bounds"] - s_min, b_max = lower_bounds[0] - s_max, b_min = lower_bounds[-1] - - self.colormap[color_name]["saturation_range"] = [(s_min, s_max)] - self.colormap[color_name]["brightness_range"] = [(b_min, b_max)] - def generate( self, hue: Optional[HueType] = None, luminosity: Optional[str] = None, - color_format: str = "hex", + color_format: ColorFormat = "hex", ) -> str: - """Generate a color. + """Generate and format a color. Whenever :meth:`color() <faker.providers.color.Provider.color>` is called, the arguments used are simply passed into this method, and this method handles the rest. """ + # Generate HSV color tuple from picked hue and luminosity + hsv = self.generate_hsv(hue=hue, luminosity=luminosity) + + # Return the HSB/V color in the desired string format + return self.set_format(hsv, color_format) + + def generate_hsv( + self, + hue: Optional[HueType] = None, + luminosity: Optional[str] = None, + ) -> Tuple[int, int, int]: + """Generate a HSV color tuple.""" # First we pick a hue (H) h = self.pick_hue(hue) # Then use H to determine saturation (S) s = self.pick_saturation(h, hue, luminosity) - # Then use S and H to determine brightness (B). - b = self.pick_brightness(h, s, luminosity) + # Then use S and H to determine brightness/value (B/V). + v = self.pick_brightness(h, s, luminosity) - # Then we return the HSB color in the desired format - return self.set_format((h, s, b), color_format) + return h, s, v + + def generate_rgb( + self, + hue: Optional[HueType] = None, + luminosity: Optional[str] = None, + ) -> Tuple[int, int, int]: + """Generate a RGB color tuple of integers.""" + return self.hsv_to_rgb(self.generate_hsv(hue=hue, luminosity=luminosity)) + + def generate_rgb_float( + self, + hue: Optional[HueType] = None, + luminosity: Optional[str] = None, + ) -> Tuple[float, float, float]: + """Generate a RGB color tuple of floats.""" + return self.hsv_to_rgb_float(self.generate_hsv(hue=hue, luminosity=luminosity)) + + def generate_hsl( + self, + hue: Optional[HueType] = None, + luminosity: Optional[str] = None, + ) -> Tuple[int, int, int]: + """Generate a HSL color tuple.""" + return self.hsv_to_hsl(self.generate_hsv(hue=hue, luminosity=luminosity)) def pick_hue(self, hue: Optional[HueType]) -> int: """Return a numerical hue value.""" @@ -226,7 +256,7 @@ def pick_brightness(self, h: int, s: int, luminosity: Optional[str]) -> int: return self.random_within((b_min, b_max)) - def set_format(self, hsv: Tuple[int, int, int], color_format: str) -> str: + def set_format(self, hsv: Tuple[int, int, int], color_format: ColorFormat) -> str: """Handle conversion of HSV values into desired format.""" if color_format == "hsv": color = f"hsv({hsv[0]}, {hsv[1]}, {hsv[2]})" @@ -265,11 +295,11 @@ def get_hue_range(self, color_input: Optional[HueType]) -> Tuple[int, int]: """Return the hue range for a given ``color_input``.""" if isinstance(color_input, (int, float)) and 0 <= color_input <= 360: color_input = int(color_input) - return (color_input, color_input) + return color_input, color_input elif isinstance(color_input, str) and color_input in self.colormap: return self.colormap[color_input]["hue_range"][0] elif color_input is None: - return (0, 360) + return 0, 360 if isinstance(color_input, list): color_input = tuple(color_input) @@ -285,12 +315,13 @@ def get_hue_range(self, color_input: Optional[HueType]) -> Tuple[int, int]: v1, v2 = v2, v1 v1 = max(v1, 0) v2 = min(v2, 360) - return (v1, v2) + return v1, v2 raise TypeError("Hue must be a valid string, numeric type, or a tuple/list of 2 numeric types.") def get_saturation_range(self, hue: int) -> Tuple[int, int]: """Return the saturation range for a given numerical ``hue`` value.""" - return self.get_color_info(hue)["saturation_range"][0] + saturation_bounds = [s for s, v in self.get_color_info(hue)["lower_bounds"]] + return min(saturation_bounds), max(saturation_bounds) def get_color_info(self, hue: int) -> Dict[str, Sequence[Tuple[int, int]]]: """Return the color info for a given numerical ``hue`` value.""" @@ -310,18 +341,27 @@ def random_within(self, r: Sequence[int]) -> int: return self.random.randint(int(r[0]), int(r[1])) @classmethod - def hsv_to_rgb(cls, hsv: Tuple[int, int, int]) -> Tuple[int, int, int]: + def hsv_to_rgb_float(cls, hsv: Tuple[int, int, int]) -> Tuple[float, float, float]: """Convert HSV to RGB. This method expects ``hsv`` to be a 3-tuple of H, S, and V values, and - it will return a 3-tuple of the equivalent R, G, and B values. + it will return a 3-tuple of the equivalent R, G, and B float values. """ h, s, v = hsv h = max(h, 1) h = min(h, 359) - r, g, b = colorsys.hsv_to_rgb(h / 360, s / 100, v / 100) - return (int(r * 255), int(g * 255), int(b * 255)) + return colorsys.hsv_to_rgb(h / 360, s / 100, v / 100) + + @classmethod + def hsv_to_rgb(cls, hsv: Tuple[int, int, int]) -> Tuple[int, int, int]: + """Convert HSV to RGB. + + This method expects ``hsv`` to be a 3-tuple of H, S, and V values, and + it will return a 3-tuple of the equivalent R, G, and B integer values. + """ + r, g, b = cls.hsv_to_rgb_float(hsv) + return int(r * 255), int(g * 255), int(b * 255) @classmethod def hsv_to_hsl(cls, hsv: Tuple[int, int, int]) -> Tuple[int, int, int]: @@ -334,7 +374,7 @@ def hsv_to_hsl(cls, hsv: Tuple[int, int, int]) -> Tuple[int, int, int]: s_: float = s / 100.0 v_: float = v / 100.0 - l = 0.5 * (v_) * (2 - s_) # noqa: E741 + l = 0.5 * v_ * (2 - s_) # noqa: E741 s_ = 0.0 if l in [0, 1] else v_ * s_ / (1 - math.fabs(2 * l - 1)) - return (int(h), int(s_ * 100), int(l * 100)) + return int(h), int(s_ * 100), int(l * 100)	diff --git a/tests/providers/test_color.py b/tests/providers/test_color.py index 0770621463..608277eb8e 100644 --- a/tests/providers/test_color.py +++ b/tests/providers/test_color.py @@ -47,15 +47,42 @@ def test_rgb_css_color(self, faker, num_samples): assert 0 <= b <= 255 def test_color(self, faker, num_samples): - baseline_random_color = RandomColor(seed=4761) - expected = [baseline_random_color.generate() for _ in range(num_samples)] + random_color = self._seed_instances(faker, 4761) + expected = [random_color.generate() for _ in range(num_samples)] # The `color` provider method should behave like the `generate` # method of a standalone RandomColor instance for a given seed - faker.seed_instance(4761) colors = [faker.color() for _ in range(num_samples)] assert colors == expected + def _seed_instances(self, faker, seed): + faker.seed_instance(seed) + return RandomColor(seed=seed) + + def test_color_rgb(self, faker, num_samples): + random_color = self._seed_instances(faker, 4761) + expected = [random_color.generate_rgb() for _ in range(num_samples)] + colors = [faker.color_rgb() for _ in range(num_samples)] + assert colors == expected + + def test_color_rgb_float(self, faker, num_samples): + random_color = self._seed_instances(faker, 4761) + expected = [random_color.generate_rgb_float() for _ in range(num_samples)] + colors = [faker.color_rgb_float() for _ in range(num_samples)] + assert colors == expected + + def test_color_hsl(self, faker, num_samples): + random_color = self._seed_instances(faker, 4761) + expected = [random_color.generate_hsl() for _ in range(num_samples)] + colors = [faker.color_hsl() for _ in range(num_samples)] + assert colors == expected + + def test_color_hsv(self, faker, num_samples): + random_color = self._seed_instances(faker, 4761) + expected = [random_color.generate_hsv() for _ in range(num_samples)] + colors = [faker.color_hsv() for _ in range(num_samples)] + assert colors == expected + class TestRandomColor: """Test RandomColor class""" @@ -116,6 +143,42 @@ def test_color_format_unspecified(self, num_samples): color = self.random_color.generate() assert self.hex_color_pattern.fullmatch(color) + def test_rgb(self, num_samples): + for _ in range(num_samples): + value = self.random_color.generate_rgb() + assert len(value) == 3 + for i in range(3): + assert isinstance(value[i], int) + assert 0 <= value[i] <= 255 + + def test_rgb_float(self, num_samples): + for _ in range(num_samples): + value = self.random_color.generate_rgb_float() + assert len(value) == 3 + for i in range(3): + assert isinstance(value[i], float) + assert 0 <= value[i] <= 1 + + def test_hsl(self, num_samples): + for _ in range(num_samples): + value = self.random_color.generate_hsl() + assert len(value) == 3 + for i in range(3): + assert isinstance(value[i], int) + assert 0 <= value[0] <= 360 + assert 0 <= value[1] <= 100 + assert 0 <= value[2] <= 100 + + def test_hsv(self, num_samples): + for _ in range(num_samples): + value = self.random_color.generate_hsl() + assert len(value) == 3 + for i in range(3): + assert isinstance(value[i], int) + assert 0 <= value[0] <= 360 + assert 0 <= value[1] <= 100 + assert 0 <= value[2] <= 100 + def test_hue_integer(self): # HSV format is used, because whatever hue value supplied must be present in the output for hue in range(360):		[ { "components": [ { "doc": "", "lines": [ 203, 204 ], "name": "Provider._random_color", "signature": "def _random_color(self):", "type": "function" }, { "doc": "Generate a RGB color tuple of integers in a human-friendl...	[ "tests/providers/test_color.py::TestColorProvider::test_color_rgb", "tests/providers/test_color.py::TestColorProvider::test_color_rgb_float", "tests/providers/test_color.py::TestColorProvider::test_color_hsl", "tests/providers/test_color.py::TestColorProvider::test_color_hsv", "tests/providers/test_color.py...	[ "tests/providers/test_color.py::TestColorProvider::test_safe_hex_color", "tests/providers/test_color.py::TestColorProvider::test_hex_color", "tests/providers/test_color.py::TestColorProvider::test_rgb_color", "tests/providers/test_color.py::TestColorProvider::test_rgb_css_color", "tests/providers/test_color...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Additional pseudo-random color fakes ### What does this change Add `color_rgb`, `color_rgb_float`, `color_hsv` and `color_hsl` fakes ### What was wrong Pseudo-random colors were only available as strings. ### How this fixes it Additional fakes provide tuples of int/float. Fixes #1903 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in faker/providers/color/__init__.py] (definition of Provider._random_color:) def _random_color(self): (definition of Provider.color_rgb:) def color_rgb( self, hue: Optional[HueType] = None, luminosity: Optional[str] = None, ) -> Tuple[int, int, int]: """Generate a RGB color tuple of integers in a human-friendly way.""" (definition of Provider.color_rgb_float:) def color_rgb_float( self, hue: Optional[HueType] = None, luminosity: Optional[str] = None, ) -> Tuple[float, float, float]: """Generate a RGB color tuple of floats in a human-friendly way.""" (definition of Provider.color_hsl:) def color_hsl( self, hue: Optional[HueType] = None, luminosity: Optional[str] = None, ) -> Tuple[int, int, int]: """Generate a HSL color tuple in a human-friendly way.""" (definition of Provider.color_hsv:) def color_hsv( self, hue: Optional[HueType] = None, luminosity: Optional[str] = None, ) -> Tuple[int, int, int]: """Generate a HSV color tuple in a human-friendly way.""" [end of new definitions in faker/providers/color/__init__.py] [start of new definitions in faker/providers/color/color.py] (definition of RandomColor.generate_hsv:) def generate_hsv( self, hue: Optional[HueType] = None, luminosity: Optional[str] = None, ) -> Tuple[int, int, int]: """Generate a HSV color tuple.""" (definition of RandomColor.generate_rgb:) def generate_rgb( self, hue: Optional[HueType] = None, luminosity: Optional[str] = None, ) -> Tuple[int, int, int]: """Generate a RGB color tuple of integers.""" (definition of RandomColor.generate_rgb_float:) def generate_rgb_float( self, hue: Optional[HueType] = None, luminosity: Optional[str] = None, ) -> Tuple[float, float, float]: """Generate a RGB color tuple of floats.""" (definition of RandomColor.generate_hsl:) def generate_hsl( self, hue: Optional[HueType] = None, luminosity: Optional[str] = None, ) -> Tuple[int, int, int]: """Generate a HSL color tuple.""" (definition of RandomColor.hsv_to_rgb_float:) def hsv_to_rgb_float(cls, hsv: Tuple[int, int, int]) -> Tuple[float, float, float]: """Convert HSV to RGB. This method expects ``hsv`` to be a 3-tuple of H, S, and V values, and it will return a 3-tuple of the equivalent R, G, and B float values.""" [end of new definitions in faker/providers/color/color.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> RGB/HSV/HSL color tuples from `color` provider * Faker version: 19.3.1 * OS: any With #104/#1055 the `color` provider learned how to generate colors with certain characteristics like "dark" or from a given hue. As noted by @malefice in the previous PR, the faked values are only available as strings. Often a numeric format is more suitable as input for other data-generation or computation. I am personally looking for this functionality to generate placeholder-images with similar colors and [pycairo](https://pycairo.readthedocs.io/en/latest/reference/patterns.html#class-solidpattern-pattern) works with RGB as float. With a little refactoring it should be easy to reuse the logic already implemented in `RandomColor` to provide int/float tuples for pseudo-random colors. ### Expected behavior Instead of adding another `color_format` argument and `color()` having non-string return values, additional fakes could provide the color tuples using the same `hue` and `luminosity` kwargs as `color()`. ``` >>> from faker import Faker >>> fake = Faker() >>> fake.color(hue='red') '#931929' >>> fake.color_rgb(hue='red') (247, 127, 118) >>> fake.color_rgb_float(hue='red') (0.98, 0.68355, 0.6566) >>> fake.color_hsv(hue='red') (334, 91, 78) >>> fake.color_hsl(hue='red') (340, 57, 60) ``` ### Feature overlap and further changes... The current color provider only generates strings. There is however some overlap with `color()` and `rgb_css_color()`, that probably should be refactored/deprecated in a separate step, i.e.: ``` >>> fake.color(hue='blue', color_format='rgb') 'rgb(25, 211, 232)' >>> fake.rgb_css_color() 'rgb(117,96,199)' ``` ---------- -------------------- </issues>	6edfdbf6ae90b0153309e3bf066aa3b2d16494a7
tobymao__sqlglot-2149	2,149	tobymao/sqlglot	null	7b589ae2ce4071f004b0cd3eedab5fca4deb79bb	2023-09-04T13:29:22Z	diff --git a/sqlglot/dialects/bigquery.py b/sqlglot/dialects/bigquery.py index 7c4e051ec2..c0b3daf8b5 100644 --- a/sqlglot/dialects/bigquery.py +++ b/sqlglot/dialects/bigquery.py @@ -397,6 +397,27 @@ def _parse_table_parts(self, schema: bool = False) -> exp.Table: return table + def _parse_json_object(self) -> exp.JSONObject: + json_object = super()._parse_json_object() + array_kv_pair = seq_get(json_object.expressions, 0) + + # Converts BQ's "signature 2" of JSON_OBJECT into SQLGlot's canonical representation + # https://cloud.google.com/bigquery/docs/reference/standard-sql/json_functions#json_object_signature2 + if ( + array_kv_pair + and isinstance(array_kv_pair.this, exp.Array) + and isinstance(array_kv_pair.expression, exp.Array) + ): + keys = array_kv_pair.this.expressions + values = array_kv_pair.expression.expressions + + json_object.set( + "expressions", + [exp.JSONKeyValue(this=k, expression=v) for k, v in zip(keys, values)], + ) + + return json_object + class Generator(generator.Generator): EXPLICIT_UNION = True INTERVAL_ALLOWS_PLURAL_FORM = False @@ -619,6 +640,13 @@ def attimezone_sql(self, expression: exp.AtTimeZone) -> str: return super().attimezone_sql(expression) + def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str: + # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#json_literals + if expression.is_type("json"): + return f"JSON {self.sql(expression, 'this')}" + + return super().cast_sql(expression, safe_prefix=safe_prefix) + def trycast_sql(self, expression: exp.TryCast) -> str: return self.cast_sql(expression, safe_prefix="SAFE_") diff --git a/sqlglot/parser.py b/sqlglot/parser.py index 210a7b3e6c..8b3d0f7efa 100644 --- a/sqlglot/parser.py +++ b/sqlglot/parser.py @@ -4144,7 +4144,7 @@ def _parse_decode(self) -> t.Optional[exp.Decode \| exp.Case]: def _parse_json_key_value(self) -> t.Optional[exp.JSONKeyValue]: self._match_text_seq("KEY") - key = self._parse_field() + key = self._parse_column() self._match_set((TokenType.COLON, TokenType.COMMA)) self._match_text_seq("VALUE") value = self._parse_column()	diff --git a/tests/dialects/test_bigquery.py b/tests/dialects/test_bigquery.py index 8f6dc3f645..b776bdd3ce 100644 --- a/tests/dialects/test_bigquery.py +++ b/tests/dialects/test_bigquery.py @@ -9,6 +9,7 @@ class TestBigQuery(Validator): maxDiff = None def test_bigquery(self): + self.validate_identity("""SELECT JSON '"foo"' AS json_data""") self.validate_identity("SELECT * FROM tbl FOR SYSTEM_TIME AS OF z") self.validate_all( @@ -789,5 +790,22 @@ def test_json_object(self): self.validate_identity("SELECT JSON_OBJECT('foo', 10, 'bar', TRUE) AS json_data") self.validate_identity("SELECT JSON_OBJECT('foo', 10, 'bar', ['a', 'b']) AS json_data") self.validate_identity("SELECT JSON_OBJECT('a', 10, 'a', 'foo') AS json_data") + self.validate_identity( + "SELECT JSON_OBJECT(['a', 'b'], [10, NULL]) AS json_data", + "SELECT JSON_OBJECT('a', 10, 'b', NULL) AS json_data", + ) + self.validate_identity( + """SELECT JSON_OBJECT(['a', 'b'], [JSON '10', JSON '"foo"']) AS json_data""", + """SELECT JSON_OBJECT('a', JSON '10', 'b', JSON '"foo"') AS json_data""", + ) + self.validate_identity( + "SELECT JSON_OBJECT(['a', 'b'], [STRUCT(10 AS id, 'Red' AS color), STRUCT(20 AS id, 'Blue' AS color)]) AS json_data", + "SELECT JSON_OBJECT('a', STRUCT(10 AS id, 'Red' AS color), 'b', STRUCT(20 AS id, 'Blue' AS color)) AS json_data", + ) + self.validate_identity( + "SELECT JSON_OBJECT(['a', 'b'], [TO_JSON(10), TO_JSON(['foo', 'bar'])]) AS json_data", + "SELECT JSON_OBJECT('a', TO_JSON(10), 'b', TO_JSON(['foo', 'bar'])) AS json_data", + ) + with self.assertRaises(ParseError): transpile("SELECT JSON_OBJECT('a', 1, 'b') AS json_data", read="bigquery") diff --git a/tests/dialects/test_presto.py b/tests/dialects/test_presto.py index 0043ad0808..dbca5b3f26 100644 --- a/tests/dialects/test_presto.py +++ b/tests/dialects/test_presto.py @@ -824,7 +824,7 @@ def test_presto(self, logger): self.validate_all( """JSON_FORMAT(JSON '"x"')""", write={ - "bigquery": """TO_JSON_STRING(CAST('"x"' AS JSON))""", + "bigquery": """TO_JSON_STRING(JSON '"x"')""", "duckdb": """CAST(TO_JSON(CAST('"x"' AS JSON)) AS TEXT)""", "presto": """JSON_FORMAT(CAST('"x"' AS JSON))""", "spark": """REGEXP_EXTRACT(TO_JSON(FROM_JSON('["x"]', SCHEMA_OF_JSON('["x"]'))), '^.(.*).$', 1)""",		[]	[ "tests/dialects/test_bigquery.py::TestBigQuery::test_bigquery", "tests/dialects/test_bigquery.py::TestBigQuery::test_json_object", "tests/dialects/test_presto.py::TestPresto::test_presto" ]	[ "tests/dialects/test_bigquery.py::TestBigQuery::test_group_concat", "tests/dialects/test_bigquery.py::TestBigQuery::test_merge", "tests/dialects/test_bigquery.py::TestBigQuery::test_pushdown_cte_column_names", "tests/dialects/test_bigquery.py::TestBigQuery::test_remove_precision_parameterized_types", "tests...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat!(bigquery): improve handling of array JSON_OBJECT syntax This PR was motivated by https://github.com/tobymao/sqlglot/pull/2136. It seems like `CAST(... AS JSON)` is not valid in BQ, at least for the examples I tried: ```sql SELECT CAST(1 AS JSON) AS foo -- Invalid cast from INT64 to JSON at [1:13] SELECT CAST('"foo"' AS JSON) AS foo -- Invalid cast from STRING to JSON at [1:13] SELECT CAST('foo' AS JSON) AS foo -- Invalid cast from STRING to JSON at [1:13] ``` Reference: https://cloud.google.com/bigquery/docs/reference/standard-sql/json_functions#json_object cc: @middagj ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		ceb42fabad60312699e4b15936aeebac00e22e4d
astropy__astropy-15264	15,264	astropy/astropy	5.2	d64fc339429487631173fc5f81dd0130cc54fa3d	2023-09-01T12:20:49Z	diff --git a/astropy/time/core.py b/astropy/time/core.py index 32c0af62dc84..acfd4dcf25bc 100644 --- a/astropy/time/core.py +++ b/astropy/time/core.py @@ -11,7 +11,7 @@ import operator import os import threading -from datetime import date, datetime, timedelta, timezone +from datetime import date, datetime, timezone from time import strftime from warnings import warn @@ -33,6 +33,7 @@ TIME_FORMATS, TimeAstropyTime, TimeDatetime, + TimeDeltaNumeric, TimeFromEpoch, # noqa: F401 TimeJD, TimeUnique, @@ -499,8 +500,6 @@ def _init_from_vals( inputs. This handles coercion into the correct shapes and some basic input validation. """ - if precision is None: - precision = 3 if in_subfmt is None: in_subfmt = "" if out_subfmt is None: @@ -561,12 +560,14 @@ def _get_time_fmt(self, val, val2, format, scale, precision, in_subfmt, out_subf If format is `None` and the input is a string-type or object array then guess available formats and stop when one matches. """ - if format is None and ( - val.dtype.kind in ("S", "U", "O", "M") or val.dtype.names - ): - # Input is a string, object, datetime, or a table-like ndarray - # (structured array, recarray). These input types can be - # uniquely identified by the format classes. + if format is None: + # If val and val2 broadcasted shape is (0,) (i.e. empty array input) then we + # cannot guess format from the input values. Instead use the default + # format. + if val.size == 0 and (val2 is None or val2.size == 0): + raise ValueError( + "cannot guess format from input values with zero-size array" + ) formats = [ (name, cls) for name, cls in self.FORMATS.items() @@ -575,22 +576,20 @@ def _get_time_fmt(self, val, val2, format, scale, precision, in_subfmt, out_subf # AstropyTime is a pseudo-format that isn't in the TIME_FORMATS registry, # but try to guess it at the end. - formats.append(("astropy_time", TimeAstropyTime)) + if isinstance(self, Time): + formats.append(("astropy_time", TimeAstropyTime)) - elif not (isinstance(format, str) and format.lower() in self.FORMATS): - if format is None: - raise ValueError( - "No time format was given, and the input is not unique" - ) - else: - raise ValueError( - f"Format {format!r} is not one of the allowed formats " - f"{sorted(self.FORMATS)}" - ) + elif not isinstance(format, str): + raise TypeError("format must be a string") + + elif format.lower() not in self.FORMATS: + raise ValueError( + f"Format {format!r} is not one of the allowed formats " + f"{sorted(self.FORMATS)}" + ) else: formats = [(format, self.FORMATS[format])] - assert formats problems = {} for name, cls in formats: try: @@ -609,10 +608,12 @@ def _get_time_fmt(self, val, val2, format, scale, precision, in_subfmt, out_subf ) from err else: problems[name] = err - raise ValueError( + + message = ( "Input values did not match any of the formats where the format " - f"keyword is optional: {problems}" - ) from problems[formats[0][0]] + "keyword is optional:\n" + ) + "\n".join(f"- '{name}': {err}" for name, err in problems.items()) + raise ValueError(message) @property def writeable(self): @@ -1278,7 +1279,7 @@ def _apply(self, method, args, format=None, cls=None, *kwargs): jd1, jd2, self.scale, - precision=0, + precision=None, in_subfmt="", out_subfmt="", from_jd=True, @@ -2724,7 +2725,7 @@ class TimeDelta(TimeBase): The allowed values for ``format`` can be listed with:: >>> list(TimeDelta.FORMATS) - ['sec', 'jd', 'datetime'] + ['sec', 'jd', 'datetime', 'quantity_str'] Note that for time differences, the scale can be among three groups: geocentric ('tai', 'tt', 'tcg'), barycentric ('tcb', 'tdb'), and rotational @@ -2758,6 +2759,12 @@ class TimeDelta(TimeBase): ('tdb', 'tt', 'ut1', 'tcg', 'tcb', 'tai'). If not given (or ``None``), the scale is arbitrary; when added or subtracted from a ``Time`` instance, it will be used without conversion. + precision : int, optional + Digits of precision in string representation of time + in_subfmt : str, optional + Unix glob to select subformats for parsing input times + out_subfmt : str, optional + Unix glob to select subformat for outputting times copy : bool, optional Make a copy of the input values """ @@ -2789,31 +2796,49 @@ def __new__( return self - def __init__(self, val, val2=None, format=None, scale=None, copy=False): + def __init__( + self, + val, + val2=None, + format=None, + scale=None, + , + precision=None, + in_subfmt=None, + out_subfmt=None, + copy=False, + ): if isinstance(val, TimeDelta): if scale is not None: self._set_scale(scale) else: - format = format or self._get_format(val) - self._init_from_vals(val, val2, format, scale, copy) + self._init_from_vals( + val, + val2, + format, + scale, + copy, + precision=precision, + in_subfmt=in_subfmt, + out_subfmt=out_subfmt, + ) + self._check_numeric_no_unit(val, format) if scale is not None: self.SCALES = TIME_DELTA_TYPES[scale] - @staticmethod - def _get_format(val): - if isinstance(val, timedelta): - return "datetime" - - if getattr(val, "unit", None) is None: + def _check_numeric_no_unit(self, val, format): + if ( + isinstance(self._time, TimeDeltaNumeric) + and getattr(val, "unit", None) is None + and format is None + ): warn( "Numerical value without unit or explicit format passed to" " TimeDelta, assuming days", TimeDeltaMissingUnitWarning, ) - return "jd" - def replicate(self, args, kwargs): out = super().replicate(args, *kwargs) out.SCALES = self.SCALES @@ -3049,12 +3074,13 @@ def to_value(self, args, *kwargs): To convert to a unit with optional equivalencies, the options are:: tm.to_value('hr') # convert to u.hr (hours) - tm.to_value('hr', []) # specify equivalencies as a positional arg tm.to_value('hr', equivalencies=[]) tm.to_value(unit='hr', equivalencies=[]) - The built-in `~astropy.time.TimeDelta` options for ``format`` are: - {'jd', 'sec', 'datetime'}. + The built-in `~astropy.time.TimeDelta` options for ``format`` are shown below:: + + >>> list(TimeDelta.FORMATS) + ['sec', 'jd', 'datetime', 'quantity_str'] For the two numerical formats 'jd' and 'sec', the available ``subfmt`` options are: {'float', 'long', 'decimal', 'str', 'bytes'}. Here, 'long' @@ -3096,17 +3122,37 @@ def to_value(self, args, *kwargs): if not (args or kwargs): raise TypeError("to_value() missing required format or unit argument") - # TODO: maybe allow 'subfmt' also for units, keeping full precision - # (effectively, by doing the reverse of quantity_day_frac)? - # This way, only equivalencies could lead to possible precision loss. + # Validate keyword arguments. + if kwargs: + allowed_kwargs = {"format", "subfmt", "unit", "equivalencies"} + if not set(kwargs).issubset(allowed_kwargs): + bad = (set(kwargs) - allowed_kwargs).pop() + raise TypeError( + f"{self.to_value.__qualname__}() got an unexpected keyword argument" + f" '{bad}'" + ) + + # Handle a valid format as first positional argument or keyword. This will also + # accept a subfmt keyword if supplied. if "format" in kwargs or ( args != () and (args[0] is None or args[0] in self.FORMATS) ): # Super-class will error with duplicate arguments, etc. return super().to_value(args, kwargs) - # With positional arguments, we try parsing the first one as a unit, - # so that on failure we can give a more informative exception. + # Handle subfmt keyword with no format and no args. + if "subfmt" in kwargs: + if args: + raise ValueError( + "cannot specify 'subfmt' and positional argument that is not a " + "valid format" + ) + return super().to_value(self.format, kwargs) + + # At this point any positional argument must be a unit so try parsing as such. + # If it fails then give an informative exception. + # TODO: deprecate providing equivalencies as a positional argument. This is + # quite non-obvious in this context. if args: try: unit = u.Unit(args[0]) diff --git a/astropy/time/formats.py b/astropy/time/formats.py index 1d0187118b0c..a548351b2a05 100644 --- a/astropy/time/formats.py +++ b/astropy/time/formats.py @@ -42,6 +42,7 @@ "TimeDeltaFormat", "TimeDeltaSec", "TimeDeltaJD", + "TimeDeltaQuantityString", "TimeEpochDateString", "TimeBesselianEpochString", "TimeJulianEpochString", @@ -139,6 +140,10 @@ class TimeFormat: """ _default_scale = "utc" # As of astropy 0.4 + _default_precision = 3 + _min_precision = 0 + _max_precision = 9 + subfmts = () _registry = TIME_FORMATS @@ -276,9 +281,16 @@ def precision(self): @precision.setter def precision(self, val): + if val is None: + val = self._default_precision # Verify precision is 0-9 (inclusive) - if not isinstance(val, int) or val < 0 or val > 9: - raise ValueError("precision attribute must be an int between 0 and 9") + if not ( + isinstance(val, int) and self._min_precision <= val <= self._max_precision + ): + raise ValueError( + "precision attribute must be an int between " + f"{self._min_precision} and {self._max_precision}" + ) self._precision = val @lazyproperty @@ -2086,6 +2098,10 @@ class TimeDeltaFormat(TimeFormat): """Base class for time delta representations.""" _registry = TIME_DELTA_FORMATS + _default_precision = 3 + # Somewhat arbitrary values that are effectively no limit for precision. + _min_precision = -99 + _max_precision = 99 def _check_scale(self, scale): """ @@ -2122,7 +2138,7 @@ class TimeDeltaSec(TimeDeltaNumeric): unit = 1.0 / erfa.DAYSEC # for quantity input -class TimeDeltaJD(TimeDeltaNumeric): +class TimeDeltaJD(TimeDeltaNumeric, TimeUnique): """Time delta in Julian days (86400 SI seconds).""" name = "jd" @@ -2175,6 +2191,227 @@ def value(self): return self.mask_if_needed(iterator.operands[-1]) +class TimeDeltaQuantityString(TimeDeltaFormat, TimeUnique): + """Time delta as a string with one or more Quantity components. + + This format provides a human-readable multi-scale string representation of a time + delta. It is convenient for applications like a configuration file or a command line + option. + + The format is specified as follows: + + - The string is a sequence of one or more components. + - Each component is a number followed by an astropy unit of time. + - For input, whitespace within the string is allowed but optional. + - For output, there is a single space between components. + - The allowed components are listed below. + - The order (yr, d, hr, min, s) is fixed but individual components are optional. + + The allowed input component units are shown below: + + - "yr": years (365.25 days) + - "d": days (24 hours) + - "hr": hours (60 minutes) + - "min": minutes (60 seconds) + - "s": seconds + + .. Note:: These definitions correspond to physical units of time and are NOT + calendar date intervals. Thus adding "1yr" to "2000-01-01 00:00:00" will give + "2000-12-31 06:00:00" instead of "2001-01-01 00:00:00". + + The ``out_subfmt`` attribute specifies the components to be included in the string + output. The default is ``"multi"`` which represents the time delta as + ``"<days>d <hours>hr <minutes>min <seconds>s"``, where only non-zero components are + included. + + - "multi": multiple components, e.g. "2d 3hr 15min 5.6s" + - "yr": years + - "d": days + - "hr": hours + - "min": minutes + - "s": seconds + + Examples + -------- + >>> from astropy.time import Time, TimeDelta + >>> import astropy.units as u + + >>> print(TimeDelta("1yr")) + 365d 6hr + + >>> print(Time("2000-01-01") + TimeDelta("1yr")) + 2000-12-31 06:00:00.000 + >>> print(TimeDelta("+3.6d")) + 3d 14hr 24min + >>> print(TimeDelta("-3.6d")) + -3d 14hr 24min + >>> print(TimeDelta("1yr 3.6d", out_subfmt="d")) + 368.85d + + >>> td = TimeDelta(40 * u.hr) + >>> print(td.to_value(format="quantity_str")) + 1d 16hr + >>> print(td.to_value(format="quantity_str", subfmt="d")) + 1.667d + >>> td.precision = 9 + >>> print(td.to_value(format="quantity_str", subfmt="d")) + 1.666666667d + """ + + name = "quantity_str" + + subfmts = ( + ("multi", None, None), + ("yr", None, None), + ("d", None, None), + ("hr", None, None), + ("min", None, None), + ("s", None, None), + ) + + # Regex to parse "1.02yr 2.2d 3.12hr 4.322min 5.6s" where each element is optional + # but the order is fixed. Each element is a float with optional exponent. Each + # element is named. + re_float = r"(\d+(\.\d)?\|\.\d+)([eE][-+]?\d+)?" + re_ydhms = re.compile( + rf"""^ \s + (?P<sign>[-+])? \s* # Optional sign + (?=[^-+\s]) # At least one character which is not a sign or whitespace + ((?P<yr>{re_float}) \s* yr \s)? + ((?P<d>{re_float}) \s d \s)? + ((?P<hr>{re_float}) \s hr \s)? + ((?P<min>{re_float}) \s min \s)? + ((?P<s>{re_float}) \s s)? + \s* $ + """, + re.VERBOSE, + ) + + def _check_val_type(self, val1, val2): + if val1.dtype.kind not in ("S", "U") and val1.size: + raise TypeError(f"Input values for {self.name} class must be strings") + if val2 is not None: + raise ValueError( + f"{self.name} objects do not accept a val2 but you provided {val2}" + ) + return val1, None + + def parse_string(self, timestr): + """Read time from a single string""" + components = ("yr", "d", "hr", "min", "s") + + if (match := self.re_ydhms.match(timestr)) is None: + raise ValueError( + f"Time delta '{timestr}' does not match {self.name} format" + ) + + tm = match.groupdict() + vals = [float(tm[component] or 0.0) for component in components] + if tm["sign"] == "-": + vals = [-val for val in vals] + + return vals + + def set_jds(self, val1, val2): + """Parse the time strings contained in val1 and get jd1, jd2.""" + # Be liberal in what we accept: convert bytes to ascii. + # Here .item() is needed for arrays with entries of unequal length, + # to strip trailing 0 bytes. + to_string = ( + str if val1.dtype.kind == "U" else lambda x: str(x.item(), encoding="ascii") + ) + iterator = np.nditer( + [val1, None, None, None, None, None], + flags=["zerosize_ok"], + op_dtypes=[None] + 5 * [np.double], + ) + for val, yr, day, hr, min, sec in iterator: + val = to_string(val) + ( + yr[...], + day[...], + hr[...], + min[...], + sec[...], + ) = self.parse_string(val) + + yrs, days, hrs, mins, secs = iterator.operands[1:] + + jd1 = yrs * 365.25 + days # Exact in the case that yrs and days are integer + jd2 = hrs / 24.0 + mins / 1440.0 + secs / 86400.0 # Inexact + self.jd1, self.jd2 = day_frac(jd1, jd2) + + def to_value(self, parent=None, out_subfmt=None): + out_subfmt = out_subfmt or self.out_subfmt + subfmt = self._get_allowed_subfmt(out_subfmt) + + iterator = np.nditer( + [self.jd1, self.jd2, None], + flags=["refs_ok", "zerosize_ok"], + op_dtypes=[None, None, object], + ) + + for jd1, jd2, out in iterator: + jd = jd1 + jd2 + if jd < 0: + jd1, jd2, jd = -jd1, -jd2, -jd # Flip all signs + sign = "-" + else: + sign = "" + + if subfmt in ["", "multi"]: + comps = self.get_multi_comps(jd1, jd2) + + else: + value = (jd u.day).to_value(subfmt) + value = np.round(value, self.precision) + comps = [f"{value}{subfmt}"] + + out[...] = sign + " ".join(comps) + + return self.mask_if_needed(np.array(iterator.operands[-1], dtype="U")) + + def get_multi_comps(self, jd1, jd2): + jd, remainder = two_sum(jd1, jd2) + days = int(np.floor(jd)) + jd -= days + jd += remainder + + hours = int(np.floor(jd * 24.0)) + jd -= hours / 24.0 + mins = int(np.floor(jd * 1440.0)) + jd -= mins / 1440.0 + secs = np.round(jd * 86400.0, self.precision) + + comp_vals = [days, hours, mins, secs] + if secs >= 60.0: + self.fix_comp_vals_overflow(comp_vals) + + comps = [ + f"{comp_val}{name}" + for comp_val, name in zip(comp_vals, ("d", "hr", "min", "s")) + if comp_val != 0 + ] + if not comps: + comps = ["0.0s"] + + return comps + + @staticmethod + def fix_comp_vals_overflow(comp_vals): + comp_maxes = (None, 24, 60, 60.0) + for ii in [3, 2, 1]: + comp_val = comp_vals[ii] + comp_max = comp_maxes[ii] + if comp_val >= comp_max: + comp_vals[ii] -= comp_max + comp_vals[ii - 1] += 1 + + @property + def value(self): + return self.to_value() + + def _validate_jd_for_storage(jd): if isinstance(jd, (float, int)): return np.array(jd, dtype=float) diff --git a/docs/changes/time/15264.api.rst b/docs/changes/time/15264.api.rst new file mode 100644 index 000000000000..657ec69d2956 --- /dev/null +++ b/docs/changes/time/15264.api.rst @@ -0,0 +1,4 @@ +Changed the ``TimeDelta`` init signature to be consistent with that of ``Time``. +Previously the argument order was ``val, val2, format, scale, copy``. Now the order is +``val, val2, format, scale, , precision, in_subfmt, out_subfmt, copy``, where the +arguments after the ```` must be specified by keyword. diff --git a/docs/changes/time/15264.feature.rst b/docs/changes/time/15264.feature.rst new file mode 100644 index 000000000000..4f8b56fee977 --- /dev/null +++ b/docs/changes/time/15264.feature.rst @@ -0,0 +1,5 @@ +Added a ``TimeDelta`` format ``quantity_str`` that represents the time delta as a string +with one or more ``Quantity`` components. This format provides a human-readable +multi-scale string representation of a time delta. The default output sub-format is not +considered stable in this release, please see https://github.com/astropy/astropy/issues/15485 +for more information. diff --git a/docs/time/index.rst b/docs/time/index.rst index b2ba8cdb49ee..229592e8b8be 100644 --- a/docs/time/index.rst +++ b/docs/time/index.rst @@ -330,6 +330,7 @@ Format Subformats ================ ======================================== ``jd`` float, long, decimal, str, bytes ``sec`` float, long, decimal, str, bytes +``quantity_str`` multi, yr, d, hr, min, s ================ ======================================== Time from Epoch Formats @@ -1189,6 +1190,8 @@ To calculate sidereal time:: .. EXAMPLE END +.. _time-delta: + Time Deltas ----------- @@ -1212,13 +1215,14 @@ day is exactly 86400 seconds. Hence, the scale cannot be UTC. The available time formats are: -========= =================================================== -Format Class -========= =================================================== -sec :class:`~astropy.time.TimeDeltaSec` -jd :class:`~astropy.time.TimeDeltaJD` -datetime :class:`~astropy.time.TimeDeltaDatetime` -========= =================================================== +============ =================================================== +Format Class +============ =================================================== +sec :class:`~astropy.time.TimeDeltaSec` +jd :class:`~astropy.time.TimeDeltaJD` +datetime :class:`~astropy.time.TimeDeltaDatetime` +quantity_str :class:`~astropy.time.TimeDeltaQuantityString` +============ =================================================== Examples ^^^^^^^^ @@ -1257,11 +1261,25 @@ Use of the \|TimeDelta\| object is illustrated in the few examples below:: >>> t1 + 1 * u.hour <Time object: scale='utc' format='iso' value=2010-01-01 01:00:00.000> - # The now deprecated default assumes days for numeric inputs +A human-readable multi-scale format for string representation of a time delta is +available via the ``quantity_str`` format. See the +:class:`~astropy.time.TimeDeltaQuantityString` class docstring for more details:: + + >>> TimeDelta(40.1 * u.hr).quantity_str + '1d 16hr 6min' + >>> t4 = TimeDelta("-1yr 2d 23hr 10min 5.6s") + >>> print(t4) + -368d 5hr 10min 5.6s + >>> t4.to_value(subfmt="d") + '-368.215d' + +The now deprecated default assumes days for numeric inputs:: + >>> t1 + 5.0 # doctest: +SHOW_WARNINGS +ELLIPSIS <Time object: scale='utc' format='iso' value=2010-01-06 00:00:00.000> TimeDeltaMissingUnitWarning: Numerical value without unit or explicit format passed to TimeDelta, assuming days + The \|TimeDelta\| has a `~astropy.time.TimeDelta.to_value` method which supports controlling the type of the output representation by providing either a format name and optional `subformat`_ or a valid ``astropy`` unit:: diff --git a/docs/whatsnew/6.0.rst b/docs/whatsnew/6.0.rst index a0ef90e8e46d..10b5fec7537b 100644 --- a/docs/whatsnew/6.0.rst +++ b/docs/whatsnew/6.0.rst @@ -18,6 +18,7 @@ In particular, this release includes: * :ref:`whatsnew-6.0-cosmology-latex-export` * :ref:`whatsnew-6.0-iers-data` * :ref:`whatsnew-6.0-model-annotation-in-votable` +* :ref:`whatsnew-6.0-time-delta-quantity-str` * :ref:`whatsnew-6.0-votable-parquet-serialization` In addition to these major changes, Astropy v6.0 includes a large number of @@ -254,6 +255,43 @@ There is no function processing data models, they will be delegated to affiliate See :ref:`votable_mivot` for more details. +.. _whatsnew-6.0-time-delta-quantity-str: + +TimeDelta string format "quantity_str" +====================================== + +A new :ref:`TimeDelta<time-delta>` format ``"quantity_str"`` is now available that +represents the time delta as a string with one or more Quantity components. This format +provides a human-readable multi-scale string representation of a time delta. It is +convenient for applications like a configuration file or a command line option. + +.. Warning:: The default output format is not yet finalized and may change in version + 6.1 of astropy. The input format is stable. Please see + `issue 15485 <https://github.com/astropy/astropy/issues/15485>`_ for more details. + +The format is a string with one or more time Quantity components separated by optional +whitespace, for example ``"1yr 2d 3hr 4min 5.6s"``. In more detail: + +- The string is a sequence of one or more components. +- Each component is a number followed by an astropy unit of time. +- For input, whitespace within the string is allowed but optional. +- For output, there is a single space between components. +- The order (yr, d, hr, min, s) is fixed but individual components are optional. + +The allowed component units are shown below and correspond to scaling relations +defined by the astropy units: + +- "yr": years (365.25 days) +- "d": days (24 hours) +- "hr": hours (60 minutes) +- "min": minutes (60 seconds) +- "s": seconds + +.. Note:: These definitions correspond to physical units of time and are NOT + calendar date intervals. Thus adding "1yr" to "2000-01-01 00:00:00" will give + "2000-12-31 06:00:00" instead of "2001-01-01 00:00:00". + +See :class:`~astropy.time.formats.TimeDeltaQuantityString` for more details. .. _whatsnew-6.0-votable-parquet-serialization:	diff --git a/astropy/time/tests/test_basic.py b/astropy/time/tests/test_basic.py index 39edda889eda..b526aa3ed576 100644 --- a/astropy/time/tests/test_basic.py +++ b/astropy/time/tests/test_basic.py @@ -2361,9 +2361,10 @@ def test_hash_time_delta(): def test_get_time_fmt_exception_messages(): - with pytest.raises(ValueError) as err: + with pytest.raises( + ValueError, match=r"Input values did not match any of the formats" + ): Time(10) - assert "No time format was given, and the input is" in str(err.value) with pytest.raises(ValueError) as err: Time("2000:001", format="not-a-format") @@ -2788,3 +2789,8 @@ def test_to_string(): exp_repr = f"<Time object: scale='utc' format='iso' value={exp_str}>" assert out_repr == exp_repr + + +def test_format_typeerror(): + with pytest.raises(TypeError, match="format must be a string"): + Time("2020-01-01", format=1) diff --git a/astropy/time/tests/test_delta.py b/astropy/time/tests/test_delta.py index e4e85b47c448..2b9332426b18 100644 --- a/astropy/time/tests/test_delta.py +++ b/astropy/time/tests/test_delta.py @@ -685,3 +685,161 @@ def test_no_units_warning(): # table column with units table = Table({"t": [1, 2, 3] * u.s}) assert np.all(TimeDelta(table["t"]).to_value(u.s) == [1, 2, 3]) + + +quantity_str_basic_cases = [ + # Simple seconds (seconds always have a decimal point) + ("1s", "1.0s", 1.0), + # Simple minutes + ("1min", "1min", 60.0), + # Float hours + ("2.5hr", "2hr 30min", 2.5 * 3600), + # Variations on single input component with exponent to multiple output components + ("3.000001e7s", "347d 5hr 20min 10.0s", 30000010.0), + ("3.e7s", "347d 5hr 20min", 30000000.0), + ("3e7s", "347d 5hr 20min", 30000000.0), + # High precision seconds + ("1.0123456789012345s", "1.012s", 1.0123456789012345), + # High precision seconds, random/missing white space and a longer time interval + (" 100.0 d1.0123456789012345 s ", "100d 1.012s", 100 * 86400 + 1.0123456789012345), + # All possible components + ( + "2yr 3d 4hr 5min 6.789s", + "733d 16hr 5min 6.789s", + 2 * 365.25 * 86400 + 3 * 86400 + 4 * 3600 + 5 * 60 + 6.789, + ), + # Float values in components get normalized + ( + "2.5yr 3.5d 4.5hr 5.5min 6.789s", + "916d 19hr 35min 36.789s", + 2.5 * 365.25 * 86400 + 3.5 * 86400 + 4.5 * 3600 + 5.5 * 60 + 6.789, + ), +] + + +@pytest.mark.parametrize("sign", ["", "+", "-"]) +@pytest.mark.parametrize("in_str, out_val, dt_sec", quantity_str_basic_cases) +def test_quantity_str_basic(sign, in_str, out_val, dt_sec): + dt = TimeDelta(sign + in_str) + minus = sign == "-" + out_sign = "-" if minus else "" + out_mult = -1 if minus else 1 + assert dt.value == out_sign + out_val + assert allclose_sec(dt.sec, out_mult * dt_sec) + + +def test_quantity_str_precision(): + dt = TimeDelta("100.0d 1.0123456789012345s", precision=9) + assert dt.value == "100d 1.012345679s" + + dt = TimeDelta("21.123456789012345s") + assert dt.value == "21.123s" + + dt.precision = -1 + assert dt.value == "20.0s" + + dt.precision = 12 + assert dt.value == "21.123456789012s" + + with pytest.raises( + ValueError, match="precision attribute must be an int between -99 and 99" + ): + dt.precision = 100 + + +quantity_str_invalid_cases = [ + "", + " ", + "+", + " - ", + "1.0", + "1.0s 2.0s", + "1.0s 2.0", + "1.0s 2min", + "++1.0s", + "2min +1s", + "2d -1s", + "1sec", +] + + +@pytest.mark.parametrize("in_str", quantity_str_invalid_cases) +def test_quantity_str_invalid(in_str): + match = "Input values did not match the format class quantity_str" + with pytest.raises(ValueError, match=match): + TimeDelta(in_str, format="quantity_str") + + +quantity_str_subfmt_exps = { + "multi": "347d 5hr 20min 10.0s", + "yr": "0.951yr", + "d": "347.222d", + "hr": "8333.336hr", + "min": "500000.167min", + "s": "30000010.0s", +} + + +def test_quantity_str_out_subfmt(): + for subfmt, exp in quantity_str_subfmt_exps.items(): + dt = TimeDelta("30000010s", out_subfmt=subfmt) + assert dt.value == exp + + +def test_quantity_str_out_subfmt_precision(): + dt = TimeDelta("100.0d 1.0123456789012345s", precision=9, out_subfmt="d") + assert dt.value == "100.000011717d" + + +def test_quantity_str_out_subfmt_to_value_subfmt(): + dt = TimeDelta("30000010s") + for subfmt, exp in quantity_str_subfmt_exps.items(): + assert dt.to_value(subfmt=subfmt) == exp + + +def test_quantity_str_out_subfmt_from_non_quantity_str(): + dt = TimeDelta(30000010.0 * u.s) + for subfmt, exp in quantity_str_subfmt_exps.items(): + assert dt.to_value(format="quantity_str", subfmt=subfmt) == exp + + +def test_quantity_str_internal_precision(): + dt = TimeDelta("100000000d 1.0123456789012345s") + assert dt.jd1 == 100000000 + assert allclose_sec(dt.jd2 * 86400, 1.0123456789012345) + + +def test_time_delta_to_value_validation_error(): + with pytest.raises( + TypeError, + match=r"TimeDelta.to_value\(\) got an unexpected keyword argument 'junk'", + ): + TimeDelta(1, format="sec").to_value(junk=1) + + +def test_quantity_str_val_type_error(): + with pytest.raises(ValueError, match="quantity_str objects do not accept"): + TimeDelta("1s", "2s") + + +def test_quantity_str_zero_value(): + dt = TimeDelta("0d") + assert dt.value == "0.0s" + assert dt._time.value == "0.0s" # get coverage of _time.value property + + +def test_quantity_str_multi_comps_overflow(): + # Default precision=3 rounds seconds to 60.0s which triggers the overflow + dt = TimeDelta("1d 23hr 59min 59.9999s") + assert dt.value == "2d" + dt.precision = 9 + assert dt.value == "1d 23hr 59min 59.9999s" + + dt = TimeDelta("1d 23hr 58min 59.9999s") + assert dt.value == "1d 23hr 59min" + + # Not actually an overflow case, but good to check + dt = TimeDelta("1d 23hr 59min 60.0001s") + assert dt.value == "2d" + dt.precision = 9 + assert dt.value == "2d 0.0001s" diff --git a/astropy/time/tests/test_quantity_interaction.py b/astropy/time/tests/test_quantity_interaction.py index 52dda8cfa760..4e84898bf005 100644 --- a/astropy/time/tests/test_quantity_interaction.py +++ b/astropy/time/tests/test_quantity_interaction.py @@ -151,8 +151,10 @@ def test_quantity_output_errors(self): dt.to_value("parrot") with pytest.raises(TypeError): dt.to_value("sec", unit=u.s) - with pytest.raises(TypeError): - # TODO: would be nice to make this work! + with pytest.raises( + ValueError, + match=r"cannot specify 'subfmt' and positional arg.*not a valid format", + ): dt.to_value(u.s, subfmt="str") def test_valid_quantity_operations1(self):	diff --git a/docs/changes/time/15264.api.rst b/docs/changes/time/15264.api.rst new file mode 100644 index 000000000000..657ec69d2956 --- /dev/null +++ b/docs/changes/time/15264.api.rst @@ -0,0 +1,4 @@ +Changed the ``TimeDelta`` init signature to be consistent with that of ``Time``. +Previously the argument order was ``val, val2, format, scale, copy``. Now the order is +``val, val2, format, scale, , precision, in_subfmt, out_subfmt, copy``, where the +arguments after the ```` must be specified by keyword. diff --git a/docs/changes/time/15264.feature.rst b/docs/changes/time/15264.feature.rst new file mode 100644 index 000000000000..4f8b56fee977 --- /dev/null +++ b/docs/changes/time/15264.feature.rst @@ -0,0 +1,5 @@ +Added a ``TimeDelta`` format ``quantity_str`` that represents the time delta as a string +with one or more ``Quantity`` components. This format provides a human-readable +multi-scale string representation of a time delta. The default output sub-format is not +considered stable in this release, please see https://github.com/astropy/astropy/issues/15485 +for more information. diff --git a/docs/time/index.rst b/docs/time/index.rst index b2ba8cdb49ee..229592e8b8be 100644 --- a/docs/time/index.rst +++ b/docs/time/index.rst @@ -330,6 +330,7 @@ Format Subformats ================ ======================================== ``jd`` float, long, decimal, str, bytes ``sec`` float, long, decimal, str, bytes +``quantity_str`` multi, yr, d, hr, min, s ================ ======================================== Time from Epoch Formats @@ -1189,6 +1190,8 @@ To calculate sidereal time:: .. EXAMPLE END +.. _time-delta: + Time Deltas ----------- @@ -1212,13 +1215,14 @@ day is exactly 86400 seconds. Hence, the scale cannot be UTC. The available time formats are: -========= =================================================== -Format Class -========= =================================================== -sec :class:`~astropy.time.TimeDeltaSec` -jd :class:`~astropy.time.TimeDeltaJD` -datetime :class:`~astropy.time.TimeDeltaDatetime` -========= =================================================== +============ =================================================== +Format Class +============ =================================================== +sec :class:`~astropy.time.TimeDeltaSec` +jd :class:`~astropy.time.TimeDeltaJD` +datetime :class:`~astropy.time.TimeDeltaDatetime` +quantity_str :class:`~astropy.time.TimeDeltaQuantityString` +============ =================================================== Examples ^^^^^^^^ @@ -1257,11 +1261,25 @@ Use of the \|TimeDelta\| object is illustrated in the few examples below:: >>> t1 + 1 * u.hour <Time object: scale='utc' format='iso' value=2010-01-01 01:00:00.000> - # The now deprecated default assumes days for numeric inputs +A human-readable multi-scale format for string representation of a time delta is +available via the ``quantity_str`` format. See the +:class:`~astropy.time.TimeDeltaQuantityString` class docstring for more details:: + + >>> TimeDelta(40.1 * u.hr).quantity_str + '1d 16hr 6min' + >>> t4 = TimeDelta("-1yr 2d 23hr 10min 5.6s") + >>> print(t4) + -368d 5hr 10min 5.6s + >>> t4.to_value(subfmt="d") + '-368.215d' + +The now deprecated default assumes days for numeric inputs:: + >>> t1 + 5.0 # doctest: +SHOW_WARNINGS +ELLIPSIS <Time object: scale='utc' format='iso' value=2010-01-06 00:00:00.000> TimeDeltaMissingUnitWarning: Numerical value without unit or explicit format passed to TimeDelta, assuming days + The \|TimeDelta\| has a `~astropy.time.TimeDelta.to_value` method which supports controlling the type of the output representation by providing either a format name and optional `subformat`_ or a valid ``astropy`` unit:: diff --git a/docs/whatsnew/6.0.rst b/docs/whatsnew/6.0.rst index a0ef90e8e46d..10b5fec7537b 100644 --- a/docs/whatsnew/6.0.rst +++ b/docs/whatsnew/6.0.rst @@ -18,6 +18,7 @@ In particular, this release includes: * :ref:`whatsnew-6.0-cosmology-latex-export` * :ref:`whatsnew-6.0-iers-data` * :ref:`whatsnew-6.0-model-annotation-in-votable` +* :ref:`whatsnew-6.0-time-delta-quantity-str` * :ref:`whatsnew-6.0-votable-parquet-serialization` In addition to these major changes, Astropy v6.0 includes a large number of @@ -254,6 +255,43 @@ There is no function processing data models, they will be delegated to affiliate See :ref:`votable_mivot` for more details. +.. _whatsnew-6.0-time-delta-quantity-str: + +TimeDelta string format "quantity_str" +====================================== + +A new :ref:`TimeDelta<time-delta>` format ``"quantity_str"`` is now available that +represents the time delta as a string with one or more Quantity components. This format +provides a human-readable multi-scale string representation of a time delta. It is +convenient for applications like a configuration file or a command line option. + +.. Warning:: The default output format is not yet finalized and may change in version + 6.1 of astropy. The input format is stable. Please see + `issue 15485 <https://github.com/astropy/astropy/issues/15485>`_ for more details. + +The format is a string with one or more time Quantity components separated by optional +whitespace, for example ``"1yr 2d 3hr 4min 5.6s"``. In more detail: + +- The string is a sequence of one or more components. +- Each component is a number followed by an astropy unit of time. +- For input, whitespace within the string is allowed but optional. +- For output, there is a single space between components. +- The order (yr, d, hr, min, s) is fixed but individual components are optional. + +The allowed component units are shown below and correspond to scaling relations +defined by the astropy units: + +- "yr": years (365.25 days) +- "d": days (24 hours) +- "hr": hours (60 minutes) +- "min": minutes (60 seconds) +- "s": seconds + +.. Note:: These definitions correspond to physical units of time and are NOT + calendar date intervals. Thus adding "1yr" to "2000-01-01 00:00:00" will give + "2000-12-31 06:00:00" instead of "2001-01-01 00:00:00". + +See :class:`~astropy.time.formats.TimeDeltaQuantityString` for more details. .. _whatsnew-6.0-votable-parquet-serialization:	[ { "components": [ { "doc": "", "lines": [ 2830, 2839 ], "name": "TimeDelta._check_numeric_no_unit", "signature": "def _check_numeric_no_unit(self, val, format):", "type": "function" } ], "file": "astropy/time/core.py" }, ...	[ "astropy/time/tests/test_basic.py::test_get_time_fmt_exception_messages", "astropy/time/tests/test_basic.py::test_format_typeerror", "astropy/time/tests/test_delta.py::test_quantity_str_basic[1s-1.0s-1.0-]", "astropy/time/tests/test_delta.py::test_quantity_str_basic[1s-1.0s-1.0-+]", "astropy/time/tests/test...	[ "astropy/time/tests/test_basic.py::TestBasic::test_simple", "astropy/time/tests/test_basic.py::TestBasic::test_different_dimensions", "astropy/time/tests/test_basic.py::TestBasic::test_empty_value[jd]", "astropy/time/tests/test_basic.py::TestBasic::test_empty_value[mjd]", "astropy/time/tests/test_basic.py::...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add TimeDelta format `quantity_str` for Year Day Hour Minute Sec string <!-- This comments are hidden when you submit the pull request, so you do not need to remove them! --> <!-- Please be sure to check out our contributing guidelines, https://github.com/astropy/astropy/blob/main/CONTRIBUTING.md . Please be sure to check out our code of conduct, https://github.com/astropy/astropy/blob/main/CODE_OF_CONDUCT.md . --> <!-- If you are new or need to be re-acquainted with Astropy contributing workflow, please see http://docs.astropy.org/en/latest/development/workflow/development_workflow.html . There is even a practical example at https://docs.astropy.org/en/latest/development/workflow/git_edit_workflow_examples.html#astropy-fix-example . --> <!-- Please just have a quick search on GitHub to see if a similar pull request has already been posted. We have old closed pull requests that might provide useful code or ideas that directly tie in with your pull request. --> <!-- We have several automatic features that run when a pull request is open. They can appear daunting but do not worry because maintainers will help you navigate them, if necessary. --> ### Description <!-- Provide a general description of what your pull request does. Complete the following sentence and add relevant details as you see fit. --> <!-- In addition please ensure that the pull request title is descriptive and allows maintainers to infer the applicable subpackage(s). --> <!-- READ THIS FOR MANUAL BACKPORT FROM A MAINTAINER: Apply "skip-basebranch-check" label before you open the PR! --> This pull request adds a new string `TimeDelta` format `"quantity_str"` that represents the time delta as a string with one or more Quantity components. This format provides a human-readable multi-scale string representation of a time delta. It is convenient for applications like a configuration file or a command line option. It is NOT intended for high-precision applications since the internal calculations are done using 64-bit floating point numbers. The driver for this is that it can be convenient to have a human-readable string representing a time delta which has natural scales so that delta from seconds to years are manageable. A string representation is useful in configuration files and application command line inputs. This PR defines a new format which is like `"[-+]? 1yr 2d 3hr 4min 5.6s"`. The format is specified as follows: - The string is a sequence of one or more components. - Each component is a number (float or int) followed by an astropy unit of time. - For input, whitespace within the string is allowed but optional. - For output, there is a single space between components. - The allowed components are listed below. - The order (yr, d, hr, min, s) is fixed but individual components are optional. The allowed component units are shown below: - "yr": years (365.25 days) - "d": days (24 hours) - "hr": hours (60 minutes) - "min": minutes (60 seconds) - "s": seconds These definitions correspond to physical units of time and are NOT calendar date intervals. Thus adding "1yr" to "2000-01-01 00:00:00" will give "2000-12-31 06:00:00" instead of "2001-01-01 00:00:00". The format is defined internally as a single regular expression that could be used in other non-Python implementations for parsing. #### Output subformats The `quantity_str` format supports output sub-formats `"multi", "yr", "d", "hr", "min", "s"` to allow specifying the string output as a single unit or in the default multi-unit format. The `precision` attribute (default=3) applies to the specified subformat. For example `TimeDelta("100.0d 1.0123456789012345s", precision=9, out_subfmt="d").value` is `"100.000011717d"`. #### Why not re-use an existing standard? The only other existing standard that I am aware of for time intervals is defined in [ISO 8601 durations](https://en.wikipedia.org/wiki/ISO_8601#Durations) that represent the duration between two dates. The ISO 8601 duration format is: P(n)Y(n)M(n)DT(n)H(n)M(n)S. The fundamental problem with this format is that it explicitly depends on the reference start date as a calendar date in Year Month day hour min sec. So this is not suitable for physical time deltas that are independent of the reference date. <!-- If the pull request closes any open issues you can add this. If you replace <Issue Number> with a number, GitHub will automatically link it. If this pull request is unrelated to any issues, please remove the following line. --> <!-- Optional opt-out --> - [ ] By checking this box, the PR author has requested that maintainers do NOT use the "Squash and Merge" button. Maintainers should respect this when possible; however, the final decision is at the discretion of the maintainer that merges the PR. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in astropy/time/core.py] (definition of TimeDelta._check_numeric_no_unit:) def _check_numeric_no_unit(self, val, format): [end of new definitions in astropy/time/core.py] [start of new definitions in astropy/time/formats.py] (definition of TimeDeltaQuantityString:) class TimeDeltaQuantityString(TimeDeltaFormat, TimeUnique): """Time delta as a string with one or more Quantity components. This format provides a human-readable multi-scale string representation of a time delta. It is convenient for applications like a configuration file or a command line option. The format is specified as follows: - The string is a sequence of one or more components. - Each component is a number followed by an astropy unit of time. - For input, whitespace within the string is allowed but optional. - For output, there is a single space between components. - The allowed components are listed below. - The order (yr, d, hr, min, s) is fixed but individual components are optional. The allowed input component units are shown below: - "yr": years (365.25 days) - "d": days (24 hours) - "hr": hours (60 minutes) - "min": minutes (60 seconds) - "s": seconds .. Note:: These definitions correspond to physical units of time and are NOT calendar date intervals. Thus adding "1yr" to "2000-01-01 00:00:00" will give "2000-12-31 06:00:00" instead of "2001-01-01 00:00:00". The ``out_subfmt`` attribute specifies the components to be included in the string output. The default is ``"multi"`` which represents the time delta as ``"<days>d <hours>hr <minutes>min <seconds>s"``, where only non-zero components are included. - "multi": multiple components, e.g. "2d 3hr 15min 5.6s" - "yr": years - "d": days - "hr": hours - "min": minutes - "s": seconds Examples -------- >>> from astropy.time import Time, TimeDelta >>> import astropy.units as u >>> print(TimeDelta("1yr")) 365d 6hr >>> print(Time("2000-01-01") + TimeDelta("1yr")) 2000-12-31 06:00:00.000 >>> print(TimeDelta("+3.6d")) 3d 14hr 24min >>> print(TimeDelta("-3.6d")) -3d 14hr 24min >>> print(TimeDelta("1yr 3.6d", out_subfmt="d")) 368.85d >>> td = TimeDelta(40 * u.hr) >>> print(td.to_value(format="quantity_str")) 1d 16hr >>> print(td.to_value(format="quantity_str", subfmt="d")) 1.667d >>> td.precision = 9 >>> print(td.to_value(format="quantity_str", subfmt="d")) 1.666666667d""" (definition of TimeDeltaQuantityString._check_val_type:) def _check_val_type(self, val1, val2): (definition of TimeDeltaQuantityString.parse_string:) def parse_string(self, timestr): """Read time from a single string""" (definition of TimeDeltaQuantityString.set_jds:) def set_jds(self, val1, val2): """Parse the time strings contained in val1 and get jd1, jd2.""" (definition of TimeDeltaQuantityString.to_value:) def to_value(self, parent=None, out_subfmt=None): (definition of TimeDeltaQuantityString.get_multi_comps:) def get_multi_comps(self, jd1, jd2): (definition of TimeDeltaQuantityString.fix_comp_vals_overflow:) def fix_comp_vals_overflow(comp_vals): (definition of TimeDeltaQuantityString.value:) def value(self): [end of new definitions in astropy/time/formats.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		32bd0ffb6898c6a57b9ec1a55c13c7a0efe8d273
tobymao__sqlglot-2105	2,105	tobymao/sqlglot	null	bda94dfebc169c1a8bb07330d3d0c8997fabcf17	2023-08-23T00:38:05Z	diff --git a/sqlglot/dataframe/README.md b/sqlglot/dataframe/README.md index 86fdc4b045..adde9a1dfe 100644 --- a/sqlglot/dataframe/README.md +++ b/sqlglot/dataframe/README.md @@ -21,10 +21,12 @@ Currently many of the common operations are covered and more functionality will * Ex: `['cola', 'colb']` * The lack of types may limit functionality in future releases. * See [Registering Custom Schema](#registering-custom-schema-class) for information on how to skip this step if the information is stored externally. +* If your output SQL dialect is not Spark, then configure the SparkSession to use that dialect + * Ex: `SparkSession().builder.config("sqlframe.dialect", "bigquery").getOrCreate()` + * See [dialects](https://github.com/tobymao/sqlglot/tree/main/sqlglot/dialects) for a full list of dialects. * Add `.sql(pretty=True)` to your final DataFrame command to return a list of sql statements to run that command. - * In most cases a single SQL statement is returned. Currently the only exception is when caching DataFrames which isn't supported in other dialects. - * Spark is the default output dialect. See [dialects](https://github.com/tobymao/sqlglot/tree/main/sqlglot/dialects) for a full list of dialects. - * Ex: `.sql(pretty=True, dialect='bigquery')` + * In most cases a single SQL statement is returned. Currently the only exception is when caching DataFrames which isn't supported in other dialects. + * Ex: `.sql(pretty=True)` ## Examples @@ -33,6 +35,8 @@ import sqlglot from sqlglot.dataframe.sql.session import SparkSession from sqlglot.dataframe.sql import functions as F +dialect = "spark" + sqlglot.schema.add_table( 'employee', { @@ -41,10 +45,10 @@ sqlglot.schema.add_table( 'lname': 'STRING', 'age': 'INT', }, - dialect="spark", + dialect=dialect, ) # Register the table structure prior to reading from the table -spark = SparkSession() +spark = SparkSession.builder.config("sqlframe.dialect", dialect).getOrCreate() df = ( spark @@ -53,7 +57,7 @@ df = ( .agg(F.countDistinct(F.col("employee_id")).alias("num_employees")) ) -print(df.sql(pretty=True)) # Spark will be the dialect used by default +print(df.sql(pretty=True)) ``` ```sparksql @@ -81,7 +85,7 @@ class ExternalSchema(Schema): sqlglot.schema = ExternalSchema() -spark = SparkSession() +spark = SparkSession() # Spark will be used by default is not specific in SparkSession config df = ( spark @@ -119,11 +123,14 @@ schema = types.StructType([ ]) sql_statements = ( - SparkSession() + SparkSession + .builder + .config("sqlframe.dialect", "bigquery") + .getOrCreate() .createDataFrame(data, schema) .groupBy(F.col("age")) .agg(F.countDistinct(F.col("employee_id")).alias("num_employees")) - .sql(dialect="bigquery") + .sql() ) result = None @@ -166,11 +173,14 @@ schema = types.StructType([ ]) sql_statements = ( - SparkSession() + SparkSession + .builder + .config("sqlframe.dialect", "snowflake") + .getOrCreate() .createDataFrame(data, schema) .groupBy(F.col("age")) .agg(F.countDistinct(F.col("lname")).alias("num_employees")) - .sql(dialect="snowflake") + .sql() ) try: @@ -210,7 +220,7 @@ sql_statements = ( .createDataFrame(data, schema) .groupBy(F.col("age")) .agg(F.countDistinct(F.col("employee_id")).alias("num_employees")) - .sql(dialect="spark") + .sql() ) pyspark = PySparkSession.builder.master("local[]").getOrCreate() diff --git a/sqlglot/dataframe/sql/column.py b/sqlglot/dataframe/sql/column.py index fcfd71e9a0..3acf494c2a 100644 --- a/sqlglot/dataframe/sql/column.py +++ b/sqlglot/dataframe/sql/column.py @@ -5,7 +5,6 @@ import sqlglot from sqlglot import expressions as exp from sqlglot.dataframe.sql.types import DataType -from sqlglot.dialects import Spark from sqlglot.helper import flatten, is_iterable if t.TYPE_CHECKING: @@ -15,19 +14,20 @@ class Column: def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]): + from sqlglot.dataframe.sql.session import SparkSession + if isinstance(expression, Column): expression = expression.expression # type: ignore elif expression is None or not isinstance(expression, (str, exp.Expression)): expression = self._lit(expression).expression # type: ignore - - expression = sqlglot.maybe_parse(expression, dialect="spark") + elif not isinstance(expression, exp.Column): + expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform( + SparkSession().dialect.normalize_identifier, copy=False + ) if expression is None: raise ValueError(f"Could not parse {expression}") - if isinstance(expression, exp.Column): - expression.transform(Spark.normalize_identifier, copy=False) - - self.expression: exp.Expression = expression + self.expression: exp.Expression = expression # type: ignore def __repr__(self): return repr(self.expression) @@ -207,7 +207,9 @@ def set_table_name(self, table_name: str, copy=False) -> Column: return Column(expression) def sql(self, kwargs) -> str: - return self.expression.sql({"dialect": "spark", kwargs}) + from sqlglot.dataframe.sql.session import SparkSession + + return self.expression.sql({"dialect": SparkSession().dialect, kwargs}) def alias(self, name: str) -> Column: new_expression = exp.alias_(self.column_expression, name) @@ -264,9 +266,11 @@ def cast(self, dataType: t.Union[str, DataType]) -> Column: Functionality Difference: PySpark cast accepts a datatype instance of the datatype class Sqlglot doesn't currently replicate this class so it only accepts a string """ + from sqlglot.dataframe.sql.session import SparkSession + if isinstance(dataType, DataType): dataType = dataType.simpleString() - return Column(exp.cast(self.column_expression, dataType, dialect="spark")) + return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect)) def startswith(self, value: t.Union[str, Column]) -> Column: value = self._lit(value) if not isinstance(value, Column) else value diff --git a/sqlglot/dataframe/sql/dataframe.py b/sqlglot/dataframe/sql/dataframe.py index 64cceeac02..f51560820a 100644 --- a/sqlglot/dataframe/sql/dataframe.py +++ b/sqlglot/dataframe/sql/dataframe.py @@ -1,12 +1,13 @@ from __future__ import annotations import functools +import logging import typing as t import zlib from copy import copy import sqlglot -from sqlglot import expressions as exp +from sqlglot import Dialect, expressions as exp from sqlglot.dataframe.sql import functions as F from sqlglot.dataframe.sql.column import Column from sqlglot.dataframe.sql.group import GroupedData @@ -18,6 +19,7 @@ from sqlglot.dataframe.sql.window import Window from sqlglot.helper import ensure_list, object_to_dict, seq_get from sqlglot.optimizer import optimize as optimize_func +from sqlglot.optimizer.qualify_columns import quote_identifiers if t.TYPE_CHECKING: from sqlglot.dataframe.sql._typing import ( @@ -27,7 +29,9 @@ OutputExpressionContainer, ) from sqlglot.dataframe.sql.session import SparkSession + from sqlglot.dialects.dialect import DialectType +logger = logging.getLogger("sqlglot") JOIN_HINTS = { "BROADCAST", @@ -264,7 +268,9 @@ def _get_outer_select_columns(cls, item: t.Union[exp.Expression, DataFrame]) -> @classmethod def _create_hash_from_expression(cls, expression: exp.Expression) -> str: - value = expression.sql(dialect="spark").encode("utf-8") + from sqlglot.dataframe.sql.session import SparkSession + + value = expression.sql(dialect=SparkSession().dialect).encode("utf-8") return f"t{zlib.crc32(value)}"[:6] def _get_select_expressions( @@ -291,7 +297,15 @@ def _get_select_expressions( select_expressions.append(expression_select_pair) # type: ignore return select_expressions - def sql(self, dialect="spark", optimize=True, kwargs) -> t.List[str]: + def sql( + self, dialect: t.Optional[DialectType] = None, optimize: bool = True, kwargs + ) -> t.List[str]: + from sqlglot.dataframe.sql.session import SparkSession + + if dialect and Dialect.get_or_raise(dialect)() != SparkSession().dialect: + logger.warning( + f"The recommended way of defining a dialect is by doing `SparkSession.builder.config('sqlframe.dialect', '{dialect}').getOrCreate()`. It is no longer needed then when calling `sql`. If you run into issues try updating your query to use this pattern." + ) df = self._resolve_pending_hints() select_expressions = df._get_select_expressions() output_expressions: t.List[t.Union[exp.Select, exp.Cache, exp.Drop]] = [] @@ -299,7 +313,10 @@ def sql(self, dialect="spark", optimize=True, kwargs) -> t.List[str]: for expression_type, select_expression in select_expressions: select_expression = select_expression.transform(replace_id_value, replacement_mapping) if optimize: - select_expression = t.cast(exp.Select, optimize_func(select_expression)) + quote_identifiers(select_expression) + select_expression = t.cast( + exp.Select, optimize_func(select_expression, dialect=SparkSession().dialect) + ) select_expression = df._replace_cte_names_with_hashes(select_expression) expression: t.Union[exp.Select, exp.Cache, exp.Drop] if expression_type == exp.Cache: @@ -313,10 +330,12 @@ def sql(self, dialect="spark", optimize=True, kwargs) -> t.List[str]: sqlglot.schema.add_table( cache_table_name, { - expression.alias_or_name: expression.type.sql("spark") + expression.alias_or_name: expression.type.sql( + dialect=SparkSession().dialect + ) for expression in select_expression.expressions }, - dialect="spark", + dialect=SparkSession().dialect, ) cache_storage_level = select_expression.args["cache_storage_level"] options = [ @@ -345,7 +364,8 @@ def sql(self, dialect="spark", optimize=True, kwargs) -> t.List[str]: output_expressions.append(expression) return [ - expression.sql({"dialect": dialect, kwargs}) for expression in output_expressions + expression.sql({"dialect": SparkSession().dialect, kwargs}) + for expression in output_expressions ] def copy(self, kwargs) -> DataFrame: diff --git a/sqlglot/dataframe/sql/normalize.py b/sqlglot/dataframe/sql/normalize.py index 4eec782429..f68bacb2f6 100644 --- a/sqlglot/dataframe/sql/normalize.py +++ b/sqlglot/dataframe/sql/normalize.py @@ -5,7 +5,6 @@ from sqlglot import expressions as exp from sqlglot.dataframe.sql.column import Column from sqlglot.dataframe.sql.util import get_tables_from_expression_with_join -from sqlglot.dialects import Spark from sqlglot.helper import ensure_list NORMALIZE_INPUT = t.TypeVar("NORMALIZE_INPUT", bound=t.Union[str, exp.Expression, Column]) @@ -20,7 +19,7 @@ def normalize(spark: SparkSession, expression_context: exp.Select, expr: t.List[ for expression in expressions: identifiers = expression.find_all(exp.Identifier) for identifier in identifiers: - Spark.normalize_identifier(identifier) + identifier.transform(spark.dialect.normalize_identifier) replace_alias_name_with_cte_name(spark, expression_context, identifier) replace_branch_and_sequence_ids_with_cte_name(spark, expression_context, identifier) diff --git a/sqlglot/dataframe/sql/readwriter.py b/sqlglot/dataframe/sql/readwriter.py index 9d87d4a785..080448622b 100644 --- a/sqlglot/dataframe/sql/readwriter.py +++ b/sqlglot/dataframe/sql/readwriter.py @@ -4,7 +4,6 @@ import sqlglot from sqlglot import expressions as exp -from sqlglot.dialects import Spark from sqlglot.helper import object_to_dict if t.TYPE_CHECKING: @@ -18,15 +17,25 @@ def __init__(self, spark: SparkSession): def table(self, tableName: str) -> DataFrame: from sqlglot.dataframe.sql.dataframe import DataFrame + from sqlglot.dataframe.sql.session import SparkSession - sqlglot.schema.add_table(tableName, dialect="spark") + sqlglot.schema.add_table(tableName, dialect=SparkSession().dialect) return DataFrame( self.spark, exp.Select() - .from_(exp.to_table(tableName, dialect="spark").transform(Spark.normalize_identifier)) + .from_( + exp.to_table(tableName, dialect=SparkSession().dialect).transform( + SparkSession().dialect.normalize_identifier + ) + ) .select( - (column for column in sqlglot.schema.column_names(tableName, dialect="spark")) + ( + column + for column in sqlglot.schema.column_names( + tableName, dialect=SparkSession().dialect + ) + ) ), ) @@ -63,6 +72,8 @@ def byName(self): return self.copy(by_name=True) def insertInto(self, tableName: str, overwrite: t.Optional[bool] = None) -> DataFrameWriter: + from sqlglot.dataframe.sql.session import SparkSession + output_expression_container = exp.Insert( { "this": exp.to_table(tableName), @@ -71,7 +82,9 @@ def insertInto(self, tableName: str, overwrite: t.Optional[bool] = None) -> Data ) df = self._df.copy(output_expression_container=output_expression_container) if self._by_name: - columns = sqlglot.schema.column_names(tableName, only_visible=True, dialect="spark") + columns = sqlglot.schema.column_names( + tableName, only_visible=True, dialect=SparkSession().dialect + ) df = df._convert_leaf_to_cte().select(columns) return self.copy(_df=df) diff --git a/sqlglot/dataframe/sql/session.py b/sqlglot/dataframe/sql/session.py index b883359e49..531ee1728b 100644 --- a/sqlglot/dataframe/sql/session.py +++ b/sqlglot/dataframe/sql/session.py @@ -5,31 +5,35 @@ from collections import defaultdict import sqlglot -from sqlglot import expressions as exp +from sqlglot import Dialect, expressions as exp from sqlglot.dataframe.sql import functions as F from sqlglot.dataframe.sql.dataframe import DataFrame from sqlglot.dataframe.sql.readwriter import DataFrameReader from sqlglot.dataframe.sql.types import StructType from sqlglot.dataframe.sql.util import get_column_mapping_from_schema_input +from sqlglot.helper import classproperty if t.TYPE_CHECKING: from sqlglot.dataframe.sql._typing import ColumnLiterals, SchemaInput class SparkSession: - known_ids: t.ClassVar[t.Set[str]] = set() - known_branch_ids: t.ClassVar[t.Set[str]] = set() - known_sequence_ids: t.ClassVar[t.Set[str]] = set() - name_to_sequence_id_mapping: t.ClassVar[t.Dict[str, t.List[str]]] = defaultdict(list) + DEFAULT_DIALECT = "spark" + _instance = None def __init__(self): - self.incrementing_id = 1 - - def __getattr__(self, name: str) -> SparkSession: - return self - - def __call__(self, args, kwargs) -> SparkSession: - return self + if not hasattr(self, "known_ids"): + self.known_ids = set() + self.known_branch_ids = set() + self.known_sequence_ids = set() + self.name_to_sequence_id_mapping = defaultdict(list) + self.incrementing_id = 1 + self.dialect = Dialect.get_or_raise(self.DEFAULT_DIALECT)() + + def __new__(cls, args, *kwargs) -> SparkSession: + if cls._instance is None: + cls._instance = super().__new__(cls) + return cls._instance @property def read(self) -> DataFrameReader: @@ -101,7 +105,7 @@ def createDataFrame( return DataFrame(self, sel_expression) def sql(self, sqlQuery: str) -> DataFrame: - expression = sqlglot.parse_one(sqlQuery, read="spark") + expression = sqlglot.parse_one(sqlQuery, read=self.dialect) if isinstance(expression, exp.Select): df = DataFrame(self, expression) df = df._convert_leaf_to_cte() @@ -149,3 +153,38 @@ def _join_hint_names(self) -> t.Set[str]: def _add_alias_to_mapping(self, name: str, sequence_id: str): self.name_to_sequence_id_mapping[name].append(sequence_id) + + class Builder: + SQLFRAME_DIALECT_KEY = "sqlframe.dialect" + + def __init__(self): + self.dialect = "spark" + + def __getattr__(self, item) -> SparkSession.Builder: + return self + + def __call__(self, args, *kwargs): + return self + + def config( + self, + key: t.Optional[str] = None, + value: t.Optional[t.Any] = None, + , + map: t.Optional[t.Dict[str, t.Any]] = None, + kwargs: t.Any, + ) -> SparkSession.Builder: + if key == self.SQLFRAME_DIALECT_KEY: + self.dialect = value + elif map and self.SQLFRAME_DIALECT_KEY in map: + self.dialect = map[self.SQLFRAME_DIALECT_KEY] + return self + + def getOrCreate(self) -> SparkSession: + spark = SparkSession() + spark.dialect = Dialect.get_or_raise(self.dialect)() + return spark + + @classproperty + def builder(cls) -> Builder: + return cls.Builder() diff --git a/sqlglot/dataframe/sql/window.py b/sqlglot/dataframe/sql/window.py index c54c07e21c..c1d913fe01 100644 --- a/sqlglot/dataframe/sql/window.py +++ b/sqlglot/dataframe/sql/window.py @@ -48,7 +48,9 @@ def copy(self): return WindowSpec(self.expression.copy()) def sql(self, kwargs) -> str: - return self.expression.sql(dialect="spark", kwargs) + from sqlglot.dataframe.sql.session import SparkSession + + return self.expression.sql(dialect=SparkSession().dialect, kwargs) def partitionBy(self, *cols: t.Union[ColumnOrName, t.List[ColumnOrName]]) -> WindowSpec: from sqlglot.dataframe.sql.column import Column diff --git a/sqlglot/helper.py b/sqlglot/helper.py index 582fbf4dcd..7335d1e309 100644 --- a/sqlglot/helper.py +++ b/sqlglot/helper.py @@ -33,6 +33,15 @@ def _generate_next_value_(name, _start, _count, _last_values): return name +class classproperty(property): + """ + Similar to a normal property but works for class methods + """ + + def __get__(self, obj: t.Any, owner: t.Any = None) -> t.Any: + return classmethod(self.fget).__get__(None, owner)() # type: ignore + + def seq_get(seq: t.Sequence[T], index: int) -> t.Optional[T]: """Returns the value in `seq` at position `index`, or `None` if `index` is out of bounds.""" try:	diff --git a/tests/dataframe/unit/dataframe_sql_validator.py b/tests/dataframe/unit/dataframe_sql_validator.py index 2dcdb39f23..4363b0dfa1 100644 --- a/tests/dataframe/unit/dataframe_sql_validator.py +++ b/tests/dataframe/unit/dataframe_sql_validator.py @@ -1,14 +1,11 @@ -import typing as t -import unittest - from sqlglot.dataframe.sql import types -from sqlglot.dataframe.sql.dataframe import DataFrame from sqlglot.dataframe.sql.session import SparkSession -from sqlglot.helper import ensure_list +from tests.dataframe.unit.dataframe_test_base import DataFrameTestBase -class DataFrameSQLValidator(unittest.TestCase): +class DataFrameSQLValidator(DataFrameTestBase): def setUp(self) -> None: + super().setUp() self.spark = SparkSession() self.employee_schema = types.StructType( [ @@ -29,12 +26,3 @@ def setUp(self) -> None: self.df_employee = self.spark.createDataFrame( data=employee_data, schema=self.employee_schema ) - - def compare_sql( - self, df: DataFrame, expected_statements: t.Union[str, t.List[str]], pretty=False - ): - actual_sqls = df.sql(pretty=pretty) - expected_statements = ensure_list(expected_statements) - self.assertEqual(len(expected_statements), len(actual_sqls)) - for expected, actual in zip(expected_statements, actual_sqls): - self.assertEqual(expected, actual) diff --git a/tests/dataframe/unit/dataframe_test_base.py b/tests/dataframe/unit/dataframe_test_base.py new file mode 100644 index 0000000000..6b07df98bd --- /dev/null +++ b/tests/dataframe/unit/dataframe_test_base.py @@ -0,0 +1,23 @@ +import typing as t +import unittest + +import sqlglot +from sqlglot import MappingSchema +from sqlglot.dataframe.sql import SparkSession +from sqlglot.dataframe.sql.dataframe import DataFrame +from sqlglot.helper import ensure_list + + +class DataFrameTestBase(unittest.TestCase): + def setUp(self) -> None: + sqlglot.schema = MappingSchema() + SparkSession._instance = None + + def compare_sql( + self, df: DataFrame, expected_statements: t.Union[str, t.List[str]], pretty=False + ): + actual_sqls = df.sql(pretty=pretty) + expected_statements = ensure_list(expected_statements) + self.assertEqual(len(expected_statements), len(actual_sqls)) + for expected, actual in zip(expected_statements, actual_sqls): + self.assertEqual(expected, actual) diff --git a/tests/dataframe/unit/test_session.py b/tests/dataframe/unit/test_session.py index 4c275e9c0d..9758033fa6 100644 --- a/tests/dataframe/unit/test_session.py +++ b/tests/dataframe/unit/test_session.py @@ -1,9 +1,6 @@ -from unittest import mock - import sqlglot from sqlglot.dataframe.sql import functions as F, types from sqlglot.dataframe.sql.session import SparkSession -from sqlglot.schema import MappingSchema from tests.dataframe.unit.dataframe_sql_validator import DataFrameSQLValidator @@ -68,7 +65,6 @@ def test_typed_schema_nested(self): self.compare_sql(df, expected) - @mock.patch("sqlglot.schema", MappingSchema()) def test_sql_select_only(self): query = "SELECT cola, colb FROM table" sqlglot.schema.add_table("table", {"cola": "string", "colb": "string"}, dialect="spark") @@ -78,16 +74,6 @@ def test_sql_select_only(self): df.sql(pretty=False)[0], ) - @mock.patch("sqlglot.schema", MappingSchema()) - def test_select_quoted(self): - sqlglot.schema.add_table("`TEST`", {"name": "string"}, dialect="spark") - - self.assertEqual( - SparkSession().table("`TEST`").select(F.col("name")).sql(dialect="snowflake")[0], - '''SELECT "test"."name" AS "name" FROM "test" AS "test"''', - ) - - @mock.patch("sqlglot.schema", MappingSchema()) def test_sql_with_aggs(self): query = "SELECT cola, colb FROM table" sqlglot.schema.add_table("table", {"cola": "string", "colb": "string"}, dialect="spark") @@ -97,7 +83,6 @@ def test_sql_with_aggs(self): df.sql(pretty=False, optimize=False)[0], ) - @mock.patch("sqlglot.schema", MappingSchema()) def test_sql_create(self): query = "CREATE TABLE new_table AS WITH t1 AS (SELECT cola, colb FROM table) SELECT cola, colb, FROM t1" sqlglot.schema.add_table("table", {"cola": "string", "colb": "string"}, dialect="spark") @@ -105,7 +90,6 @@ def test_sql_create(self): expected = "CREATE TABLE new_table AS SELECT `table`.`cola` AS `cola`, `table`.`colb` AS `colb` FROM `table` AS `table`" self.compare_sql(df, expected) - @mock.patch("sqlglot.schema", MappingSchema()) def test_sql_insert(self): query = "WITH t1 AS (SELECT cola, colb FROM table) INSERT INTO new_table SELECT cola, colb FROM t1" sqlglot.schema.add_table("table", {"cola": "string", "colb": "string"}, dialect="spark") @@ -114,5 +98,4 @@ def test_sql_insert(self): self.compare_sql(df, expected) def test_session_create_builder_patterns(self): - spark = SparkSession() - self.assertEqual(spark.builder.appName("abc").getOrCreate(), spark) + self.assertEqual(SparkSession.builder.appName("abc").getOrCreate(), SparkSession()) diff --git a/tests/dataframe/unit/test_session_case_sensitivity.py b/tests/dataframe/unit/test_session_case_sensitivity.py new file mode 100644 index 0000000000..7e352895c1 --- /dev/null +++ b/tests/dataframe/unit/test_session_case_sensitivity.py @@ -0,0 +1,81 @@ +import sqlglot +from sqlglot.dataframe.sql import functions as F +from sqlglot.dataframe.sql.session import SparkSession +from sqlglot.errors import OptimizeError +from tests.dataframe.unit.dataframe_test_base import DataFrameTestBase + + +class TestSessionCaseSensitivity(DataFrameTestBase): + def setUp(self) -> None: + super().setUp() + self.spark = SparkSession.builder.config("sqlframe.dialect", "snowflake").getOrCreate() + + tests = [ + ( + "All lower no intention of CS", + "test", + "test", + {"name": "VARCHAR"}, + "name", + '''SELECT "TEST"."NAME" AS "NAME" FROM "TEST" AS "TEST"''', + ), + ( + "Table has CS while column does not", + '"Test"', + '"Test"', + {"name": "VARCHAR"}, + "name", + '''SELECT "TEST"."NAME" AS "NAME" FROM "Test" AS "TEST"''', + ), + ( + "Column has CS while table does not", + "test", + "test", + {'"Name"': "VARCHAR"}, + '"Name"', + '''SELECT "TEST"."Name" AS "Name" FROM "TEST" AS "TEST"''', + ), + ( + "Both Table and column have CS", + '"Test"', + '"Test"', + {'"Name"': "VARCHAR"}, + '"Name"', + '''SELECT "TEST"."Name" AS "Name" FROM "Test" AS "TEST"''', + ), + ( + "Lowercase CS table and column", + '"test"', + '"test"', + {'"name"': "VARCHAR"}, + '"name"', + '''SELECT "TEST"."name" AS "name" FROM "test" AS "TEST"''', + ), + ( + "CS table and column and query table but no CS in query column", + '"test"', + '"test"', + {'"name"': "VARCHAR"}, + "name", + OptimizeError(), + ), + ( + "CS table and column and query column but no CS in query table", + '"test"', + "test", + {'"name"': "VARCHAR"}, + '"name"', + OptimizeError(), + ), + ] + + def test_basic_case_sensitivity(self): + for test_name, table_name, spark_table, schema, spark_column, expected in self.tests: + with self.subTest(test_name): + sqlglot.schema.add_table(table_name, schema, dialect=self.spark.dialect) + df = self.spark.table(spark_table).select(F.col(spark_column)) + if isinstance(expected, OptimizeError): + with self.assertRaises(OptimizeError): + df.sql() + else: + self.compare_sql(df, expected) diff --git a/tests/dataframe/unit/test_window.py b/tests/dataframe/unit/test_window.py index 45d736f115..9c4c897586 100644 --- a/tests/dataframe/unit/test_window.py +++ b/tests/dataframe/unit/test_window.py @@ -1,10 +1,9 @@ -import unittest - from sqlglot.dataframe.sql import functions as F from sqlglot.dataframe.sql.window import Window, WindowSpec +from tests.dataframe.unit.dataframe_test_base import DataFrameTestBase -class TestDataframeWindow(unittest.TestCase): +class TestDataframeWindow(DataFrameTestBase): def test_window_spec_partition_by(self): partition_by = WindowSpec().partitionBy(F.col("cola"), F.col("colb")) self.assertEqual("OVER (PARTITION BY cola, colb)", partition_by.sql())	diff --git a/sqlglot/dataframe/README.md b/sqlglot/dataframe/README.md index 86fdc4b045..adde9a1dfe 100644 --- a/sqlglot/dataframe/README.md +++ b/sqlglot/dataframe/README.md @@ -21,10 +21,12 @@ Currently many of the common operations are covered and more functionality will * Ex: `['cola', 'colb']` * The lack of types may limit functionality in future releases. * See [Registering Custom Schema](#registering-custom-schema-class) for information on how to skip this step if the information is stored externally. +* If your output SQL dialect is not Spark, then configure the SparkSession to use that dialect + * Ex: `SparkSession().builder.config("sqlframe.dialect", "bigquery").getOrCreate()` + * See [dialects](https://github.com/tobymao/sqlglot/tree/main/sqlglot/dialects) for a full list of dialects. * Add `.sql(pretty=True)` to your final DataFrame command to return a list of sql statements to run that command. - * In most cases a single SQL statement is returned. Currently the only exception is when caching DataFrames which isn't supported in other dialects. - * Spark is the default output dialect. See [dialects](https://github.com/tobymao/sqlglot/tree/main/sqlglot/dialects) for a full list of dialects. - * Ex: `.sql(pretty=True, dialect='bigquery')` + * In most cases a single SQL statement is returned. Currently the only exception is when caching DataFrames which isn't supported in other dialects. + * Ex: `.sql(pretty=True)` ## Examples @@ -33,6 +35,8 @@ import sqlglot from sqlglot.dataframe.sql.session import SparkSession from sqlglot.dataframe.sql import functions as F +dialect = "spark" + sqlglot.schema.add_table( 'employee', { @@ -41,10 +45,10 @@ sqlglot.schema.add_table( 'lname': 'STRING', 'age': 'INT', }, - dialect="spark", + dialect=dialect, ) # Register the table structure prior to reading from the table -spark = SparkSession() +spark = SparkSession.builder.config("sqlframe.dialect", dialect).getOrCreate() df = ( spark @@ -53,7 +57,7 @@ df = ( .agg(F.countDistinct(F.col("employee_id")).alias("num_employees")) ) -print(df.sql(pretty=True)) # Spark will be the dialect used by default +print(df.sql(pretty=True)) ``` ```sparksql @@ -81,7 +85,7 @@ class ExternalSchema(Schema): sqlglot.schema = ExternalSchema() -spark = SparkSession() +spark = SparkSession() # Spark will be used by default is not specific in SparkSession config df = ( spark @@ -119,11 +123,14 @@ schema = types.StructType([ ]) sql_statements = ( - SparkSession() + SparkSession + .builder + .config("sqlframe.dialect", "bigquery") + .getOrCreate() .createDataFrame(data, schema) .groupBy(F.col("age")) .agg(F.countDistinct(F.col("employee_id")).alias("num_employees")) - .sql(dialect="bigquery") + .sql() ) result = None @@ -166,11 +173,14 @@ schema = types.StructType([ ]) sql_statements = ( - SparkSession() + SparkSession + .builder + .config("sqlframe.dialect", "snowflake") + .getOrCreate() .createDataFrame(data, schema) .groupBy(F.col("age")) .agg(F.countDistinct(F.col("lname")).alias("num_employees")) - .sql(dialect="snowflake") + .sql() ) try: @@ -210,7 +220,7 @@ sql_statements = ( .createDataFrame(data, schema) .groupBy(F.col("age")) .agg(F.countDistinct(F.col("employee_id")).alias("num_employees")) - .sql(dialect="spark") + .sql() ) pyspark = PySparkSession.builder.master("local[*]").getOrCreate()	[]	[ "tests/dataframe/unit/test_session.py::TestDataframeSession::test_session_create_builder_patterns", "tests/dataframe/unit/test_session_case_sensitivity.py::TestSessionCaseSensitivity::test_basic_case_sensitivity" ]	[ "tests/dataframe/unit/test_session.py::TestDataframeSession::test_cdf_dict_rows", "tests/dataframe/unit/test_session.py::TestDataframeSession::test_cdf_multiple_rows", "tests/dataframe/unit/test_session.py::TestDataframeSession::test_cdf_no_schema", "tests/dataframe/unit/test_session.py::TestDataframeSession:...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat: Support dialect across all Dataframe Operations Slack thread that prompted this change: https://tobiko-data.slack.com/archives/C0448SFS3PF/p1692679901587439?thread_ts=1692679773.389409&cid=C0448SFS3PF Prior to this change all input was assumed to be Spark and then you could transpile that final query to whatever dialect you wanted. One challenge with this approach is when the user wants to do something that isn't natively supported by Spark. This example was that the user wanted case-sensitive columns but all column input into the Dataframe was assumed to be Spark and therefore case-insensitive. This change makes it so that the SparkSession can be configured for a specific dialect and therefore that dialect would be used for parsing all user input. As shown by the tests, this then support case-sensitive input if the target engine is case-sensitive. The old behavior of allowing a dialect to be defined with the `sql` method is still supported for backwards compatibility. A warning is shown if their dialect doesn't match the configured dialect and shows them how to fix this going forward. The plan is to eventually drop `dialect` from `sql` in a future major release. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		ceb42fabad60312699e4b15936aeebac00e22e4d
Aider-AI__aider-207	207	Aider-AI/aider	null	43047c38358d7453c5778d4415475f152e4c562e	2023-08-18T17:17:40Z	diff --git a/HISTORY.md b/HISTORY.md index b033f264ac7..8f8750dc81e 100644 --- a/HISTORY.md +++ b/HISTORY.md @@ -2,6 +2,7 @@ ### main branch +- [Only git commit dirty files that GPT tries to edit](https://aider.chat/docs/faq.html#how-does-aider-use-git) - Send chat history as prompt/context for Whisper voice transcription - Added `--voice-language` switch to constrain `/voice` to transcribe to a specific language diff --git a/aider/coders/base_coder.py b/aider/coders/base_coder.py index fe1415f0289..06c1a518ec0 100755 --- a/aider/coders/base_coder.py +++ b/aider/coders/base_coder.py @@ -57,13 +57,7 @@ def create( io, kwargs, ): - from . import ( - EditBlockCoder, - EditBlockFunctionCoder, - SingleWholeFileFunctionCoder, - WholeFileCoder, - WholeFileFunctionCoder, - ) + from . import EditBlockCoder, WholeFileCoder if not main_model: main_model = models.GPT35_16k @@ -84,14 +78,6 @@ def create( return EditBlockCoder(main_model, io, kwargs) elif edit_format == "whole": return WholeFileCoder(main_model, io, kwargs) - elif edit_format == "whole-func": - return WholeFileFunctionCoder(main_model, io, kwargs) - elif edit_format == "single-whole-func": - return SingleWholeFileFunctionCoder(main_model, io, kwargs) - elif edit_format == "diff-func-list": - return EditBlockFunctionCoder("list", main_model, io, kwargs) - elif edit_format in ("diff-func", "diff-func-string"): - return EditBlockFunctionCoder("string", main_model, io, *kwargs) else: raise ValueError(f"Unknown edit format {edit_format}") @@ -119,6 +105,7 @@ def __init__( self.chat_completion_call_hashes = [] self.chat_completion_response_hashes = [] + self.need_commit_before_edits = set() self.verbose = verbose self.abs_fnames = set() @@ -203,9 +190,6 @@ def __init__( for fname in self.get_inchat_relative_files(): self.io.tool_output(f"Added {fname} to the chat.") - if self.repo: - self.repo.add_new_files(fname for fname in fnames if not Path(fname).is_dir()) - self.summarizer = ChatSummary() self.summarizer_thread = None self.summarized_done_messages = None @@ -408,11 +392,6 @@ def run_loop(self): self.commands, ) - if self.should_dirty_commit(inp) and self.dirty_commit(): - if inp.strip(): - self.io.tool_output("Use up-arrow to retry previous command:", inp) - return - if not inp: return @@ -500,7 +479,7 @@ def send_new_user_message(self, inp): if edited: if self.repo and self.auto_commits and not self.dry_run: - saved_message = self.auto_commit() + saved_message = self.auto_commit(edited) elif hasattr(self.gpt_prompts, "files_content_gpt_edits_no_repo"): saved_message = self.gpt_prompts.files_content_gpt_edits_no_repo else: @@ -728,42 +707,93 @@ def get_last_modified(self): def get_addable_relative_files(self): return set(self.get_all_relative_files()) - set(self.get_inchat_relative_files()) - def allowed_to_edit(self, path, write_content=None): + def check_for_dirty_commit(self, path): + if not self.repo: + return + if not self.dirty_commits: + return + if not self.repo.is_dirty(path): + return + + fullp = Path(self.abs_root_path(path)) + if not fullp.stat().st_size: + return + + self.io.tool_output(f"Committing {path} before applying edits.") + self.need_commit_before_edits.add(path) + return + + def allowed_to_edit(self, path): full_path = self.abs_root_path(path) + if self.repo: + need_to_add = not self.repo.path_in_repo(path) + else: + need_to_add = False if full_path in self.abs_fnames: - if write_content: - self.io.write_text(full_path, write_content) - return full_path + self.check_for_dirty_commit(path) + return True if not Path(full_path).exists(): - question = f"Allow creation of new file {path}?" # noqa: E501 - else: - question = f"Allow edits to {path} which was not previously provided?" # noqa: E501 - if not self.io.confirm_ask(question): - self.io.tool_error(f"Skipping edit to {path}") + if not self.io.confirm_ask(f"Allow creation of new file {path}?"): + self.io.tool_error(f"Skipping edits to {path}") + return + + if not self.dry_run: + Path(full_path).parent.mkdir(parents=True, exist_ok=True) + Path(full_path).touch() + + # Seems unlikely that we needed to create the file, but it was + # actually already part of the repo. + # But let's only add if we need to, just to be safe. + if need_to_add: + self.repo.repo.git.add(full_path) + + self.abs_fnames.add(full_path) + return True + + if not self.io.confirm_ask( + f"Allow edits to {path} which was not previously added to chat?" + ): + self.io.tool_error(f"Skipping edits to {path}") return - if not Path(full_path).exists() and not self.dry_run: - Path(full_path).parent.mkdir(parents=True, exist_ok=True) - Path(full_path).touch() + if need_to_add: + self.repo.repo.git.add(full_path) self.abs_fnames.add(full_path) + self.check_for_dirty_commit(path) + return True - # Check if the file is already in the repo - if self.repo: - tracked_files = set(self.repo.get_tracked_files()) - relative_fname = self.get_rel_fname(full_path) - if relative_fname not in tracked_files and self.io.confirm_ask(f"Add {path} to git?"): - if not self.dry_run: - self.repo.repo.git.add(full_path) + apply_update_errors = 0 - if write_content: - self.io.write_text(full_path, write_content) + def prepare_to_edit(self, edits): + res = [] + seen = dict() - return full_path + self.need_commit_before_edits = set() - apply_update_errors = 0 + for edit in edits: + path = edit[0] + if path in seen: + allowed = seen[path] + else: + allowed = self.allowed_to_edit(path) + seen[path] = allowed + + if allowed: + res.append(edit) + + self.dirty_commit() + self.need_commit_before_edits = set() + + return res + + def update_files(self): + edits = self.get_edits() + edits = self.prepare_to_edit(edits) + self.apply_edits(edits) + return set(edit[0] for edit in edits) def apply_updates(self): max_apply_update_errors = 3 @@ -795,12 +825,11 @@ def apply_updates(self): self.apply_update_errors = 0 - if edited: - for path in sorted(edited): - if self.dry_run: - self.io.tool_output(f"Did not apply edit to {path} (--dry-run)") - else: - self.io.tool_output(f"Applied edit to {path}") + for path in edited: + if self.dry_run: + self.io.tool_output(f"Did not apply edit to {path} (--dry-run)") + else: + self.io.tool_output(f"Applied edit to {path}") return edited, None @@ -840,9 +869,9 @@ def get_context_from_history(self, history): context += "\n" + msg["role"].upper() + ": " + msg["content"] + "\n" return context - def auto_commit(self): + def auto_commit(self, edited): context = self.get_context_from_history(self.cur_messages) - res = self.repo.commit(context=context, prefix="aider: ") + res = self.repo.commit(fnames=edited, context=context, prefix="aider: ") if res: commit_hash, commit_message = res self.last_aider_commit_hash = commit_hash @@ -855,43 +884,14 @@ def auto_commit(self): self.io.tool_output("No changes made to git tracked files.") return self.gpt_prompts.files_content_gpt_no_edits - def should_dirty_commit(self, inp): - cmds = self.commands.matching_commands(inp) - if cmds: - matching_commands, _, _ = cmds - if len(matching_commands) == 1: - cmd = matching_commands[0][1:] - if cmd in "add clear commit diff drop exit help ls tokens".split(): - return - - if self.last_asked_for_commit_time >= self.get_last_modified(): - return - return True - def dirty_commit(self): + if not self.need_commit_before_edits: + return if not self.dirty_commits: return if not self.repo: return - if not self.repo.is_dirty(): - return - - self.io.tool_output("Git repo has uncommitted changes.") - self.repo.show_diffs(self.pretty) - self.last_asked_for_commit_time = self.get_last_modified() - res = self.io.prompt_ask( - "Commit before the chat proceeds [y/n/commit message]?", - default="y", - ).strip() - if res.lower() in ["n", "no"]: - self.io.tool_error("Skipped commmit.") - return - if res.lower() in ["y", "yes"]: - message = None - else: - message = res.strip() - - self.repo.commit(message=message) + self.repo.commit(fnames=self.need_commit_before_edits) # files changed, move cur messages back behind the files messages self.move_back_cur_messages(self.gpt_prompts.files_content_local_edits) diff --git a/aider/coders/editblock_coder.py b/aider/coders/editblock_coder.py index 5388bbac70c..bcc36762721 100644 --- a/aider/coders/editblock_coder.py +++ b/aider/coders/editblock_coder.py @@ -13,22 +13,21 @@ def __init__(self, args, *kwargs): self.gpt_prompts = EditBlockPrompts() super().__init__(args, *kwargs) - def update_files(self): + def get_edits(self): content = self.partial_response_content # might raise ValueError for malformed ORIG/UPD blocks edits = list(find_original_update_blocks(content)) - edited = set() + return edits + + def apply_edits(self, edits): for path, original, updated in edits: - full_path = self.allowed_to_edit(path) - if not full_path: - continue + full_path = self.abs_root_path(path) content = self.io.read_text(full_path) content = do_replace(full_path, content, original, updated) if content: self.io.write_text(full_path, content) - edited.add(path) continue raise ValueError(f"""InvalidEditBlock: edit failed! @@ -42,8 +41,6 @@ def update_files(self): {original}``` """) - return edited - def prep(content): if content and not content.endswith("\n"): diff --git a/aider/coders/editblock_func_coder.py b/aider/coders/editblock_func_coder.py index 3f7acbaf52d..42bbb20f359 100644 --- a/aider/coders/editblock_func_coder.py +++ b/aider/coders/editblock_func_coder.py @@ -58,6 +58,7 @@ class EditBlockFunctionCoder(Coder): ] def __init__(self, code_format, args, *kwargs): + raise RuntimeError("Deprecated, needs to be refactored to support get_edits/apply_edits") self.code_format = code_format if code_format == "string": @@ -91,7 +92,7 @@ def render_incremental_response(self, final=False): res = json.dumps(args, indent=4) return res - def update_files(self): + def _update_files(self): name = self.partial_response_function_call.get("name") if name and name != "replace_lines": diff --git a/aider/coders/single_wholefile_func_coder.py b/aider/coders/single_wholefile_func_coder.py index 2d99c364580..ef1680e97eb 100644 --- a/aider/coders/single_wholefile_func_coder.py +++ b/aider/coders/single_wholefile_func_coder.py @@ -31,6 +31,7 @@ class SingleWholeFileFunctionCoder(Coder): ] def __init__(self, args, *kwargs): + raise RuntimeError("Deprecated, needs to be refactored to support get_edits/apply_edits") self.gpt_prompts = SingleWholeFileFunctionPrompts() super().__init__(args, *kwargs) @@ -94,7 +95,7 @@ def live_diffs(self, fname, content, final): return "\n".join(show_diff) - def update_files(self): + def _update_files(self): name = self.partial_response_function_call.get("name") if name and name != "write_file": raise ValueError(f'Unknown function_call name="{name}", use name="write_file"') diff --git a/aider/coders/wholefile_coder.py b/aider/coders/wholefile_coder.py index c70576daebb..6bd7d46349c 100644 --- a/aider/coders/wholefile_coder.py +++ b/aider/coders/wholefile_coder.py @@ -22,11 +22,11 @@ def update_cur_messages(self, edited): def render_incremental_response(self, final): try: - return self.update_files(mode="diff") + return self.get_edits(mode="diff") except ValueError: return self.partial_response_content - def update_files(self, mode="update"): + def get_edits(self, mode="update"): content = self.partial_response_content chat_files = self.get_inchat_relative_files() @@ -46,7 +46,7 @@ def update_files(self, mode="update"): # ending an existing block saw_fname = None - full_path = (Path(self.root) / fname).absolute() + full_path = self.abs_root_path(fname) if mode == "diff": output += self.do_live_diff(full_path, new_lines, True) @@ -104,25 +104,30 @@ def update_files(self, mode="update"): if fname: edits.append((fname, fname_source, new_lines)) - edited = set() + seen = set() + refined_edits = [] # process from most reliable filename, to least reliable for source in ("block", "saw", "chat"): for fname, fname_source, new_lines in edits: if fname_source != source: continue # if a higher priority source already edited the file, skip - if fname in edited: + if fname in seen: continue - # we have a winner - new_lines = "".join(new_lines) - if self.allowed_to_edit(fname, new_lines): - edited.add(fname) + seen.add(fname) + refined_edits.append((fname, fname_source, new_lines)) - return edited + return refined_edits + + def apply_edits(self, edits): + for path, fname_source, new_lines in edits: + full_path = self.abs_root_path(path) + new_lines = "".join(new_lines) + self.io.write_text(full_path, new_lines) def do_live_diff(self, full_path, new_lines, final): - if full_path.exists(): + if Path(full_path).exists(): orig_lines = self.io.read_text(full_path).splitlines(keepends=True) show_diff = diffs.diff_partial_update( diff --git a/aider/coders/wholefile_func_coder.py b/aider/coders/wholefile_func_coder.py index ebf10764d69..987010ea7b6 100644 --- a/aider/coders/wholefile_func_coder.py +++ b/aider/coders/wholefile_func_coder.py @@ -44,6 +44,8 @@ class WholeFileFunctionCoder(Coder): ] def __init__(self, args, *kwargs): + raise RuntimeError("Deprecated, needs to be refactored to support get_edits/apply_edits") + self.gpt_prompts = WholeFileFunctionPrompts() super().__init__(args, *kwargs) @@ -105,7 +107,7 @@ def live_diffs(self, fname, content, final): return "\n".join(show_diff) - def update_files(self): + def _update_files(self): name = self.partial_response_function_call.get("name") if name and name != "write_file": raise ValueError(f'Unknown function_call name="{name}", use name="write_file"') diff --git a/aider/commands.py b/aider/commands.py index af0fa332ece..6047e9438f9 100644 --- a/aider/commands.py +++ b/aider/commands.py @@ -230,7 +230,7 @@ def cmd_diff(self, args): return commits = f"{self.coder.last_aider_commit_hash}~1" - diff = self.coder.repo.get_diffs( + diff = self.coder.repo.diff_commits( self.coder.pretty, commits, self.coder.last_aider_commit_hash, diff --git a/aider/main.py b/aider/main.py index 9ab8eb9b1fe..540c19bfe2b 100644 --- a/aider/main.py +++ b/aider/main.py @@ -522,8 +522,6 @@ def scrub_sensitive_info(text): io.tool_output("Use /help to see in-chat commands, run with --help to see cmd line args") - coder.dirty_commit() - if args.message: io.tool_output() coder.run(with_message=args.message) diff --git a/aider/repo.py b/aider/repo.py index 07a47592c01..92cfb1cb2be 100644 --- a/aider/repo.py +++ b/aider/repo.py @@ -49,24 +49,14 @@ def __init__(self, io, fnames, git_dname): self.repo = git.Repo(repo_paths.pop(), odbt=git.GitDB) self.root = utils.safe_abs_path(self.repo.working_tree_dir) - def add_new_files(self, fnames): - cur_files = [str(Path(fn).resolve()) for fn in self.get_tracked_files()] - for fname in fnames: - if str(Path(fname).resolve()) in cur_files: - continue - if not Path(fname).exists(): - continue - self.io.tool_output(f"Adding {fname} to git") - self.repo.git.add(fname) - - def commit(self, context=None, prefix=None, message=None): - if not self.repo.is_dirty(): + def commit(self, fnames=None, context=None, prefix=None, message=None): + if not fnames and not self.repo.is_dirty(): return if message: commit_message = message else: - diffs = self.get_diffs(False) + diffs = self.get_diffs(fnames) commit_message = self.get_commit_message(diffs, context) if not commit_message: @@ -79,7 +69,16 @@ def commit(self, context=None, prefix=None, message=None): if context: full_commit_message += "\n\n# Aider chat conversation:\n\n" + context - self.repo.git.commit("-a", "-m", full_commit_message, "--no-verify") + cmd = ["-m", full_commit_message, "--no-verify"] + if fnames: + fnames = [str(self.abs_root_path(fn)) for fn in fnames] + for fname in fnames: + self.repo.git.add(fname) + cmd += ["--"] + fnames + else: + cmd += ["-a"] + + self.repo.git.commit(cmd) commit_hash = self.repo.head.commit.hexsha[:7] self.io.tool_output(f"Commit {commit_hash} {commit_message}") @@ -125,41 +124,38 @@ def get_commit_message(self, diffs, context): return commit_message - def get_diffs(self, pretty, args): - args = list(args) - - # if args are specified, just add --pretty if needed - if args: - if pretty: - args = ["--color"] + args - return self.repo.git.diff(args) - - # otherwise, we always want diffs of index and working dir - + def get_diffs(self, fnames=None): + # We always want diffs of index and working dir try: commits = self.repo.iter_commits(self.repo.active_branch) current_branch_has_commits = any(commits) except git.exc.GitCommandError: current_branch_has_commits = False - if pretty: - args = ["--color"] + if not fnames: + fnames = [] if current_branch_has_commits: - # if there is a HEAD, just diff against it to pick up index + working - args += ["HEAD"] + args = ["HEAD", "--"] + list(fnames) return self.repo.git.diff(args) - # diffs in the index - diffs = self.repo.git.diff((args + ["--cached"])) - # plus, diffs in the working dir - diffs += self.repo.git.diff(args) + wd_args = ["--"] + list(fnames) + index_args = ["--cached"] + wd_args + + diffs = self.repo.git.diff(index_args) + diffs += self.repo.git.diff(wd_args) return diffs - def show_diffs(self, pretty): - diffs = self.get_diffs(pretty) - print(diffs) + def diff_commits(self, pretty, from_commit, to_commit): + args = [] + if pretty: + args += ["--color"] + + args += [from_commit, to_commit] + diffs = self.repo.git.diff(*args) + + return diffs def get_tracked_files(self): if not self.repo: @@ -190,5 +186,19 @@ def get_tracked_files(self): return res - def is_dirty(self): - return self.repo.is_dirty() + def path_in_repo(self, path): + if not self.repo: + return + + tracked_files = set(self.get_tracked_files()) + return path in tracked_files + + def abs_root_path(self, path): + res = Path(self.root) / path + return utils.safe_abs_path(res) + + def is_dirty(self, path=None): + if path and not self.path_in_repo(path): + return True + + return self.repo.is_dirty(path=path) diff --git a/docs/faq.md b/docs/faq.md index 789adecb512..806ff0c5508 100644 --- a/docs/faq.md +++ b/docs/faq.md @@ -13,29 +13,29 @@ It is recommended that you use aider with code that is part of a git repo. This allows aider to maintain the safety of your code. Using git makes it easy to: - - Review the changes GPT made to your code - - Undo changes that weren't appropriate + - Undo any changes that weren't appropriate + - Go back later to review the changes GPT made to your code - Manage a series of GPT's changes on a git branch - - etc -Working without git means that GPT might drastically change your code without an easy way to undo the changes. +Working without git means that GPT might drastically change your code +without an easy way to undo the changes. Aider tries to provide safety using git in a few ways: - It asks to create a git repo if you launch it in a directory without one. - - When you add a file to the chat, aider asks permission to add it to the git repo if needed. - - At launch and before sending requests to GPT, aider checks if the repo is dirty and offers to commit those changes for you. This way, the GPT changes will be applied to a clean repo and won't be intermingled with your own changes. - - After GPT changes your code, aider commits those changes with a descriptive commit message. - + - Whenever GPT edits a file, those changes are committed with a descriptive commit message. This makes it easy to revert or review GPT's changes. + - If GPT tries to edit files that already have uncommitted changes (dirty files), aider will first commit those existing changes with a descriptive commit message. This makes sure you never lose your work if GPT makes an inappropriate change to uncommitted code. + Aider also allows you to use in-chat commands to `/diff` or `/undo` the last change made by GPT. -To do more complex management of your git history, you should use `git` on the command line outside of aider. +To do more complex management of your git history, you cat use raw `git` commands, +either by using `/git` or with git tools outside of aider. You can start a branch before using aider to make a sequence of changes. Or you can `git reset` a longer series of aider changes that didn't pan out. Etc. While it is not recommended, you can disable aider's use of git in a few ways: - `--no-auto-commits` will stop aider from git committing each of GPT's changes. - - `--no-dirty-commits` will stop aider from ensuring your repo is clean before sending requests to GPT. + - `--no-dirty-commits` will stop aider from committing dirty files before applying GPT's edits. - `--no-git` will completely stop aider from using git on your files. You should ensure you are keeping sensible backups of the files you are working with.	diff --git a/tests/test_coder.py b/tests/test_coder.py index 1c2eaa8b290..3faf42bc7a8 100644 --- a/tests/test_coder.py +++ b/tests/test_coder.py @@ -22,79 +22,84 @@ def setUp(self): def tearDown(self): self.patcher.stop() - def test_new_file_commit_message(self): + def test_allowed_to_edit(self): with GitTemporaryDirectory(): repo = git.Repo() - fname = Path("foo.txt") - - io = InputOutput(yes=True) - # Initialize the Coder object with the mocked IO and mocked repo - Coder.create(models.GPT4, None, io, fnames=[str(fname)]) - self.assertTrue(fname.exists()) - - # Mock the get_commit_message method to return "I added str(fname)" - repo.get_commit_message = MagicMock(return_value=f"I added {str(fname)}") - # Get the latest commit message - commit_message = repo.get_commit_message() - # Check that the latest commit message is "I added str(fname)" - self.assertEqual(commit_message, f"I added {str(fname)}") + fname = Path("added.txt") + fname.touch() + repo.git.add(str(fname)) - def test_allowed_to_edit(self): - with GitTemporaryDirectory(): - repo = git.Repo(Path.cwd()) - fname = Path("foo.txt") + fname = Path("repo.txt") fname.touch() repo.git.add(str(fname)) + repo.git.commit("-m", "init") + # YES! io = InputOutput(yes=True) - # Initialize the Coder object with the mocked IO and mocked repo - coder = Coder.create(models.GPT4, None, io, fnames=["foo.txt"]) + coder = Coder.create(models.GPT4, None, io, fnames=["added.txt"]) - self.assertTrue(coder.allowed_to_edit("foo.txt")) + self.assertTrue(coder.allowed_to_edit("added.txt")) + self.assertTrue(coder.allowed_to_edit("repo.txt")) self.assertTrue(coder.allowed_to_edit("new.txt")) + self.assertIn("repo.txt", str(coder.abs_fnames)) + self.assertIn("new.txt", str(coder.abs_fnames)) + + self.assertFalse(coder.need_commit_before_edits) + def test_allowed_to_edit_no(self): with GitTemporaryDirectory(): - repo = git.Repo(Path.cwd()) - fname = Path("foo.txt") + repo = git.Repo() + + fname = Path("added.txt") + fname.touch() + repo.git.add(str(fname)) + + fname = Path("repo.txt") fname.touch() repo.git.add(str(fname)) + repo.git.commit("-m", "init") # say NO io = InputOutput(yes=False) - coder = Coder.create(models.GPT4, None, io, fnames=["foo.txt"]) + coder = Coder.create(models.GPT4, None, io, fnames=["added.txt"]) - self.assertTrue(coder.allowed_to_edit("foo.txt")) + self.assertTrue(coder.allowed_to_edit("added.txt")) + self.assertFalse(coder.allowed_to_edit("repo.txt")) self.assertFalse(coder.allowed_to_edit("new.txt")) - def test_get_last_modified(self): - # Mock the IO object - mock_io = MagicMock() + self.assertNotIn("repo.txt", str(coder.abs_fnames)) + self.assertNotIn("new.txt", str(coder.abs_fnames)) + + self.assertFalse(coder.need_commit_before_edits) + def test_allowed_to_edit_dirty(self): with GitTemporaryDirectory(): - repo = git.Repo(Path.cwd()) - fname = Path("new.txt") + repo = git.Repo() + + fname = Path("added.txt") fname.touch() repo.git.add(str(fname)) - repo.git.commit("-m", "new") - # Initialize the Coder object with the mocked IO and mocked repo - coder = Coder.create(models.GPT4, None, mock_io) + repo.git.commit("-m", "init") - mod = coder.get_last_modified() + # say NO + io = InputOutput(yes=False) - fname.write_text("hi") - mod_newer = coder.get_last_modified() - self.assertLess(mod, mod_newer) + coder = Coder.create(models.GPT4, None, io, fnames=["added.txt"]) - fname.unlink() - self.assertEqual(coder.get_last_modified(), 0) + self.assertTrue(coder.allowed_to_edit("added.txt")) + self.assertFalse(coder.need_commit_before_edits) + + fname.write_text("dirty!") + self.assertTrue(coder.allowed_to_edit("added.txt")) + self.assertTrue(coder.need_commit_before_edits) - def test_should_dirty_commit(self): + def test_get_last_modified(self): # Mock the IO object mock_io = MagicMock() @@ -108,11 +113,14 @@ def test_should_dirty_commit(self): # Initialize the Coder object with the mocked IO and mocked repo coder = Coder.create(models.GPT4, None, mock_io) + mod = coder.get_last_modified() + fname.write_text("hi") - self.assertTrue(coder.should_dirty_commit("hi")) + mod_newer = coder.get_last_modified() + self.assertLess(mod, mod_newer) - self.assertFalse(coder.should_dirty_commit("/exit")) - self.assertFalse(coder.should_dirty_commit("/help")) + fname.unlink() + self.assertEqual(coder.get_last_modified(), 0) def test_check_for_file_mentions(self): # Mock the IO object @@ -219,7 +227,6 @@ def test_check_for_subdir_mention(self): mock.return_value = set([str(fname)]) coder.repo.get_tracked_files = mock - dump(fname) # Call the check_for_file_mentions method coder.check_for_file_mentions(f"Please check `{fname}`") @@ -362,5 +369,185 @@ def test_run_with_invalid_request_error(self, mock_chat_completion_create): with self.assertRaises(openai.error.InvalidRequestError): coder.run(with_message="hi") - if __name__ == "__main__": - unittest.main() + def test_new_file_edit_one_commit(self): + """A new file shouldn't get pre-committed before the GPT edit commit""" + with GitTemporaryDirectory(): + repo = git.Repo() + + fname = Path("file.txt") + + io = InputOutput(yes=True) + coder = Coder.create(models.GPT4, "diff", io=io, fnames=[str(fname)]) + + self.assertTrue(fname.exists()) + + # make sure it was not committed + with self.assertRaises(git.exc.GitCommandError): + list(repo.iter_commits(repo.active_branch.name)) + + def mock_send(args, kwargs): + coder.partial_response_content = f""" +Do this: + +{str(fname)} +<<<<<<< HEAD +======= +new +>>>>>>> updated + +""" + coder.partial_response_function_call = dict() + + coder.send = MagicMock(side_effect=mock_send) + coder.repo.get_commit_message = MagicMock() + coder.repo.get_commit_message.return_value = "commit message" + + coder.run(with_message="hi") + + content = fname.read_text() + self.assertEqual(content, "new\n") + + num_commits = len(list(repo.iter_commits(repo.active_branch.name))) + self.assertEqual(num_commits, 1) + + def test_only_commit_gpt_edited_file(self): + """ + Only commit file that gpt edits, not other dirty files. + Also ensure commit msg only depends on diffs from the GPT edited file. + """ + + with GitTemporaryDirectory(): + repo = git.Repo() + + fname1 = Path("file1.txt") + fname2 = Path("file2.txt") + + fname1.write_text("one\n") + fname2.write_text("two\n") + + repo.git.add(str(fname1)) + repo.git.add(str(fname2)) + repo.git.commit("-m", "new") + + # DIRTY! + fname1.write_text("ONE\n") + + io = InputOutput(yes=True) + coder = Coder.create(models.GPT4, "diff", io=io, fnames=[str(fname1), str(fname2)]) + + def mock_send(args, *kwargs): + coder.partial_response_content = f""" +Do this: + +{str(fname2)} +<<<<<<< HEAD +two +======= +TWO +>>>>>>> updated + +""" + coder.partial_response_function_call = dict() + + def mock_get_commit_message(diffs, context): + self.assertNotIn("one", diffs) + self.assertNotIn("ONE", diffs) + return "commit message" + + coder.send = MagicMock(side_effect=mock_send) + coder.repo.get_commit_message = MagicMock(side_effect=mock_get_commit_message) + + coder.run(with_message="hi") + + content = fname2.read_text() + self.assertEqual(content, "TWO\n") + + self.assertTrue(repo.is_dirty(path=str(fname1))) + + def test_gpt_edit_to_dirty_file(self): + """A dirty file should be committed before the GPT edits are committed""" + + with GitTemporaryDirectory(): + repo = git.Repo() + + fname = Path("file.txt") + fname.write_text("one\n") + repo.git.add(str(fname)) + + fname2 = Path("other.txt") + fname2.write_text("other\n") + repo.git.add(str(fname2)) + + repo.git.commit("-m", "new") + + # dirty + fname.write_text("two\n") + fname2.write_text("OTHER\n") + + io = InputOutput(yes=True) + coder = Coder.create(models.GPT4, "diff", io=io, fnames=[str(fname)]) + + def mock_send(args, **kwargs): + coder.partial_response_content = f""" +Do this: + +{str(fname)} +<<<<<<< HEAD +two +======= +three +>>>>>>> updated + +""" + coder.partial_response_function_call = dict() + + saved_diffs = [] + + def mock_get_commit_message(diffs, context): + saved_diffs.append(diffs) + return "commit message" + + coder.repo.get_commit_message = MagicMock(side_effect=mock_get_commit_message) + coder.send = MagicMock(side_effect=mock_send) + + coder.run(with_message="hi") + + content = fname.read_text() + self.assertEqual(content, "three\n") + + num_commits = len(list(repo.iter_commits(repo.active_branch.name))) + self.assertEqual(num_commits, 3) + + diff = repo.git.diff(["HEAD~2", "HEAD~1"]) + self.assertIn("one", diff) + self.assertIn("two", diff) + self.assertNotIn("three", diff) + self.assertNotIn("other", diff) + self.assertNotIn("OTHER", diff) + + diff = saved_diffs[0] + self.assertIn("one", diff) + self.assertIn("two", diff) + self.assertNotIn("three", diff) + self.assertNotIn("other", diff) + self.assertNotIn("OTHER", diff) + + diff = repo.git.diff(["HEAD~1", "HEAD"]) + self.assertNotIn("one", diff) + self.assertIn("two", diff) + self.assertIn("three", diff) + self.assertNotIn("other", diff) + self.assertNotIn("OTHER", diff) + + diff = saved_diffs[1] + self.assertNotIn("one", diff) + self.assertIn("two", diff) + self.assertIn("three", diff) + self.assertNotIn("other", diff) + self.assertNotIn("OTHER", diff) + + self.assertEqual(len(saved_diffs), 2) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_repo.py b/tests/test_repo.py index aee78abdfbc..77092c2da4c 100644 --- a/tests/test_repo.py +++ b/tests/test_repo.py @@ -26,7 +26,7 @@ def test_diffs_empty_repo(self): fname.write_text("workingdir\n") git_repo = GitRepo(InputOutput(), None, ".") - diffs = git_repo.get_diffs(False) + diffs = git_repo.get_diffs() self.assertIn("index", diffs) self.assertIn("workingdir", diffs) @@ -49,7 +49,7 @@ def test_diffs_nonempty_repo(self): fname2.write_text("workingdir\n") git_repo = GitRepo(InputOutput(), None, ".") - diffs = git_repo.get_diffs(False) + diffs = git_repo.get_diffs() self.assertIn("index", diffs) self.assertIn("workingdir", diffs) @@ -67,7 +67,7 @@ def test_diffs_between_commits(self): repo.git.commit("-m", "second") git_repo = GitRepo(InputOutput(), None, ".") - diffs = git_repo.get_diffs(False, ["HEAD~1", "HEAD"]) + diffs = git_repo.diff_commits(False, "HEAD~1", "HEAD") dump(diffs) self.assertIn("two", diffs) diff --git a/tests/test_wholefile.py b/tests/test_wholefile.py index 8f9f89fc5bd..29cc74fa246 100644 --- a/tests/test_wholefile.py +++ b/tests/test_wholefile.py @@ -90,7 +90,7 @@ def test_update_files_live_diff(self): # Set the partial response content with the updated content coder.partial_response_content = f"{sample_file}\n```\n0\n\1\n2\n" - lines = coder.update_files(mode="diff").splitlines() + lines = coder.get_edits(mode="diff").splitlines() # the live diff should be concise, since we haven't changed anything yet self.assertLess(len(lines), 20)	diff --git a/HISTORY.md b/HISTORY.md index b033f264ac7..8f8750dc81e 100644 --- a/HISTORY.md +++ b/HISTORY.md @@ -2,6 +2,7 @@ ### main branch +- [Only git commit dirty files that GPT tries to edit](https://aider.chat/docs/faq.html#how-does-aider-use-git) - Send chat history as prompt/context for Whisper voice transcription - Added `--voice-language` switch to constrain `/voice` to transcribe to a specific language diff --git a/docs/faq.md b/docs/faq.md index 789adecb512..806ff0c5508 100644 --- a/docs/faq.md +++ b/docs/faq.md @@ -13,29 +13,29 @@ It is recommended that you use aider with code that is part of a git repo. This allows aider to maintain the safety of your code. Using git makes it easy to: - - Review the changes GPT made to your code - - Undo changes that weren't appropriate + - Undo any changes that weren't appropriate + - Go back later to review the changes GPT made to your code - Manage a series of GPT's changes on a git branch - - etc -Working without git means that GPT might drastically change your code without an easy way to undo the changes. +Working without git means that GPT might drastically change your code +without an easy way to undo the changes. Aider tries to provide safety using git in a few ways: - It asks to create a git repo if you launch it in a directory without one. - - When you add a file to the chat, aider asks permission to add it to the git repo if needed. - - At launch and before sending requests to GPT, aider checks if the repo is dirty and offers to commit those changes for you. This way, the GPT changes will be applied to a clean repo and won't be intermingled with your own changes. - - After GPT changes your code, aider commits those changes with a descriptive commit message. - + - Whenever GPT edits a file, those changes are committed with a descriptive commit message. This makes it easy to revert or review GPT's changes. + - If GPT tries to edit files that already have uncommitted changes (dirty files), aider will first commit those existing changes with a descriptive commit message. This makes sure you never lose your work if GPT makes an inappropriate change to uncommitted code. + Aider also allows you to use in-chat commands to `/diff` or `/undo` the last change made by GPT. -To do more complex management of your git history, you should use `git` on the command line outside of aider. +To do more complex management of your git history, you cat use raw `git` commands, +either by using `/git` or with git tools outside of aider. You can start a branch before using aider to make a sequence of changes. Or you can `git reset` a longer series of aider changes that didn't pan out. Etc. While it is not recommended, you can disable aider's use of git in a few ways: - `--no-auto-commits` will stop aider from git committing each of GPT's changes. - - `--no-dirty-commits` will stop aider from ensuring your repo is clean before sending requests to GPT. + - `--no-dirty-commits` will stop aider from committing dirty files before applying GPT's edits. - `--no-git` will completely stop aider from using git on your files. You should ensure you are keeping sensible backups of the files you are working with.	[ { "components": [ { "doc": "", "lines": [ 710, 724 ], "name": "Coder.check_for_dirty_commit", "signature": "def check_for_dirty_commit(self, path):", "type": "function" }, { "doc": "", "lines": [ 770,...	[ "tests/test_coder.py::TestCoder::test_allowed_to_edit", "tests/test_coder.py::TestCoder::test_allowed_to_edit_dirty", "tests/test_coder.py::TestCoder::test_allowed_to_edit_no", "tests/test_coder.py::TestCoder::test_gpt_edit_to_dirty_file", "tests/test_coder.py::TestCoder::test_only_commit_gpt_edited_file", ...	[ "tests/test_coder.py::TestCoder::test_check_for_ambiguous_filename_mentions_of_longer_paths", "tests/test_coder.py::TestCoder::test_check_for_file_mentions", "tests/test_coder.py::TestCoder::test_check_for_filename_mentions_of_longer_paths", "tests/test_coder.py::TestCoder::test_check_for_subdir_mention", "...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Only commit dirty files if GPT tries to edit them #200 Discussed in #200 If GPT tries to edit a dirty file, aider will just commit the dirty changes (with a nice message) before applying and committing GPT's edits. You now never get interrupted and asked about pending dirty changes. Aider just commits them for you to keep them distinct from GPT's edits and preserve the ability to cleanly undo GPT's changes. And dirty changes are only ever committed by aider if the file is about to get modified by GPT. As always, aider still respects the --no-dirty-commits flag. If set, it will apply GPT's edits without first committing dirty files. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in aider/coders/base_coder.py] (definition of Coder.check_for_dirty_commit:) def check_for_dirty_commit(self, path): (definition of Coder.prepare_to_edit:) def prepare_to_edit(self, edits): (definition of Coder.update_files:) def update_files(self): [end of new definitions in aider/coders/base_coder.py] [start of new definitions in aider/coders/editblock_coder.py] (definition of EditBlockCoder.get_edits:) def get_edits(self): (definition of EditBlockCoder.apply_edits:) def apply_edits(self, edits): [end of new definitions in aider/coders/editblock_coder.py] [start of new definitions in aider/coders/editblock_func_coder.py] (definition of EditBlockFunctionCoder._update_files:) def _update_files(self): [end of new definitions in aider/coders/editblock_func_coder.py] [start of new definitions in aider/coders/single_wholefile_func_coder.py] (definition of SingleWholeFileFunctionCoder._update_files:) def _update_files(self): [end of new definitions in aider/coders/single_wholefile_func_coder.py] [start of new definitions in aider/coders/wholefile_coder.py] (definition of WholeFileCoder.get_edits:) def get_edits(self, mode="update"): (definition of WholeFileCoder.apply_edits:) def apply_edits(self, edits): [end of new definitions in aider/coders/wholefile_coder.py] [start of new definitions in aider/coders/wholefile_func_coder.py] (definition of WholeFileFunctionCoder._update_files:) def _update_files(self): [end of new definitions in aider/coders/wholefile_func_coder.py] [start of new definitions in aider/repo.py] (definition of GitRepo.diff_commits:) def diff_commits(self, pretty, from_commit, to_commit): (definition of GitRepo.path_in_repo:) def path_in_repo(self, path): (definition of GitRepo.abs_root_path:) def abs_root_path(self, path): [end of new definitions in aider/repo.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		43047c38358d7453c5778d4415475f152e4c562e
sphinx-doc__sphinx-11592	11,592	sphinx-doc/sphinx	7.4	3d118ce81c368c0143e90a096cef3a872be2eece	2023-08-15T08:53:52Z	diff --git a/CHANGES.rst b/CHANGES.rst index fcdcf2df9af..1f178f5c200 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -71,6 +71,9 @@ Features added * #12523: Added configuration option, :confval:`math_numsep`, to define the separator for math numbering. Patch by Thomas Fanning +* #11592: Add :confval:`coverage_modules` to the coverage builder + to allow explicitly specifying which modules should be documented. + Patch by Stephen Finucane. Bugs fixed ---------- diff --git a/doc/usage/extensions/coverage.rst b/doc/usage/extensions/coverage.rst index b9c493b5f3b..75ffc0f59ed 100644 --- a/doc/usage/extensions/coverage.rst +++ b/doc/usage/extensions/coverage.rst @@ -6,15 +6,64 @@ This extension features one additional builder, the :class:`CoverageBuilder`. -.. class:: CoverageBuilder +.. todo:: Write this section. - To use this builder, activate the coverage extension in your configuration - file and give ``-M coverage`` on the command line. +.. note:: -.. todo:: Write this section. + The :doc:`sphinx-apidoc </man/sphinx-apidoc>` command can be used to + automatically generate API documentation for all code in a project, + avoiding the need to manually author these documents and keep them up-to-date. + +.. warning:: + + :mod:`~sphinx.ext.coverage` imports the modules to be documented. + If any modules have side effects on import, + these will be executed by the coverage builder when ``sphinx-build`` is run. + + If you document scripts (as opposed to library modules), + make sure their main routine is protected by a + ``if __name__ == '__main__'`` condition. + +.. note:: + + For Sphinx (actually, the Python interpreter that executes Sphinx) + to find your module, it must be importable. + That means that the module or the package must be in + one of the directories on :data:`sys.path` -- adapt your :data:`sys.path` + in the configuration file accordingly. + +To use this builder, activate the coverage extension in your configuration file +and run ``sphinx-build -M coverage`` on the command line. + + +Builder +------- + +.. py:class:: CoverageBuilder + + +Configuration +------------- + +Several configuration values can be used to specify +what the builder should check: + +.. confval:: coverage_modules + :type: ``list[str]`` + :default: ``[]`` + + List of Python packages or modules to test coverage for. + When this is provided, Sphinx will introspect each package + or module provided in this list as well + as all sub-packages and sub-modules found in each. + When this is not provided, Sphinx will only provide coverage + for Python packages and modules that it is aware of: + that is, any modules documented using the :rst:dir:`py:module` directive + provided in the :doc:`Python domain </usage/domains/python>` + or the :rst:dir:`automodule` directive provided by the + :mod:`~sphinx.ext.autodoc` extension. -Several configuration values can be used to specify what the builder -should check: + .. versionadded:: 7.4 .. confval:: coverage_ignore_modules diff --git a/sphinx/ext/coverage.py b/sphinx/ext/coverage.py index cfe093623c1..f7ce3beaa65 100644 --- a/sphinx/ext/coverage.py +++ b/sphinx/ext/coverage.py @@ -9,6 +9,7 @@ import glob import inspect import pickle +import pkgutil import re import sys from importlib import import_module @@ -23,7 +24,7 @@ from sphinx.util.inspect import safe_getattr if TYPE_CHECKING: - from collections.abc import Iterator + from collections.abc import Iterable, Iterator, Sequence, Set from sphinx.application import Sphinx from sphinx.util.typing import ExtensionMetadata @@ -66,6 +67,93 @@ def _add_row(col_widths: list[int], columns: list[str], separator: str) -> Itera yield _add_line(col_widths, separator) +def _load_modules(mod_name: str, ignored_module_exps: Iterable[re.Pattern[str]]) -> Set[str]: + """Recursively load all submodules. + + :param mod_name: The name of a module to load submodules for. + :param ignored_module_exps: A list of regexes for modules to ignore. + :returns: A set of modules names including the provided module name, + ``mod_name`` + :raises ImportError: If the module indicated by ``mod_name`` could not be + loaded. + """ + if any(exp.match(mod_name) for exp in ignored_module_exps): + return set() + + # This can raise an exception, which must be handled by the caller. + mod = import_module(mod_name) + modules = {mod_name} + if mod.__spec__ is None: + return modules + + search_locations = mod.__spec__.submodule_search_locations + for (_, sub_mod_name, sub_mod_ispkg) in pkgutil.iter_modules(search_locations): + if sub_mod_name == '__main__': + continue + + if sub_mod_ispkg: + modules \|= _load_modules(f'{mod_name}.{sub_mod_name}', ignored_module_exps) + else: + if any(exp.match(sub_mod_name) for exp in ignored_module_exps): + continue + modules.add(f'{mod_name}.{sub_mod_name}') + + return modules + + +def _determine_py_coverage_modules( + coverage_modules: Sequence[str], + seen_modules: Set[str], + ignored_module_exps: Iterable[re.Pattern[str]], + py_undoc: dict[str, dict[str, Any]], +) -> list[str]: + """Return a sorted list of modules to check for coverage. + + Figure out which of the two operating modes to use: + + - If 'coverage_modules' is not specified, we check coverage for all modules + seen in the documentation tree. Any objects found in these modules that are + not documented will be noted. This will therefore only identify missing + objects, but it requires no additional configuration. + + - If 'coverage_modules' is specified, we check coverage for all modules + specified in this configuration value. Any objects found in these modules + that are not documented will be noted. In addition, any objects from other + modules that are documented will be noted. This will therefore identify both + missing modules and missing objects, but it requires manual configuration. + """ + if not coverage_modules: + return sorted(seen_modules) + + modules: set[str] = set() + for mod_name in coverage_modules: + try: + modules \|= _load_modules(mod_name, ignored_module_exps) + except ImportError as err: + # TODO(stephenfin): Define a subtype for all logs in this module + logger.warning(__('module %s could not be imported: %s'), mod_name, err) + py_undoc[mod_name] = {'error': err} + continue + + # if there are additional modules then we warn but continue scanning + if additional_modules := seen_modules - modules: + logger.warning( + __('the following modules are documented but were not specified ' + 'in coverage_modules: %s'), + ', '.join(additional_modules), + ) + + # likewise, if there are missing modules we warn but continue scanning + if missing_modules := modules - seen_modules: + logger.warning( + __('the following modules are specified in coverage_modules ' + 'but were not documented'), + ', '.join(missing_modules), + ) + + return sorted(modules) + + class CoverageBuilder(Builder): """ Evaluates coverage of code in the documentation. @@ -106,12 +194,12 @@ def get_outdated_docs(self) -> str: def write(self, ignored: Any) -> None: self.py_undoc: dict[str, dict[str, Any]] = {} - self.py_undocumented: dict[str, set[str]] = {} - self.py_documented: dict[str, set[str]] = {} + self.py_undocumented: dict[str, Set[str]] = {} + self.py_documented: dict[str, Set[str]] = {} self.build_py_coverage() self.write_py_coverage() - self.c_undoc: dict[str, set[tuple[str, str]]] = {} + self.c_undoc: dict[str, Set[tuple[str, str]]] = {} self.build_c_coverage() self.write_c_coverage() @@ -169,11 +257,14 @@ def ignore_pyobj(self, full_name: str) -> bool: ) def build_py_coverage(self) -> None: - objects = self.env.domaindata['py']['objects'] - modules = self.env.domaindata['py']['modules'] + seen_objects = frozenset(self.env.domaindata['py']['objects']) + seen_modules = frozenset(self.env.domaindata['py']['modules']) skip_undoc = self.config.coverage_skip_undoc_in_source + modules = _determine_py_coverage_modules( + self.config.coverage_modules, seen_modules, self.mod_ignorexps, self.py_undoc, + ) for mod_name in modules: ignore = False for exp in self.mod_ignorexps: @@ -213,7 +304,7 @@ def build_py_coverage(self) -> None: continue if inspect.isfunction(obj): - if full_name not in objects: + if full_name not in seen_objects: for exp in self.fun_ignorexps: if exp.match(name): break @@ -229,7 +320,7 @@ def build_py_coverage(self) -> None: if exp.match(name): break else: - if full_name not in objects: + if full_name not in seen_objects: if skip_undoc and not obj.__doc__: continue # not documented at all @@ -257,7 +348,7 @@ def build_py_coverage(self) -> None: full_attr_name = f'{full_name}.{attr_name}' if self.ignore_pyobj(full_attr_name): continue - if full_attr_name not in objects: + if full_attr_name not in seen_objects: attrs.append(attr_name) undocumented_objects.add(full_attr_name) else: @@ -273,19 +364,17 @@ def build_py_coverage(self) -> None: def _write_py_statistics(self, op: TextIO) -> None: """Outputs the table of ``op``.""" - all_modules = set(self.py_documented.keys()).union( - set(self.py_undocumented.keys())) - all_objects: set[str] = set() - all_documented_objects: set[str] = set() + all_modules = frozenset(self.py_documented.keys() \| self.py_undocumented.keys()) + all_objects: Set[str] = set() + all_documented_objects: Set[str] = set() for module in all_modules: - all_module_objects = self.py_documented[module].union(self.py_undocumented[module]) - all_objects = all_objects.union(all_module_objects) - all_documented_objects = all_documented_objects.union(self.py_documented[module]) + all_objects \|= self.py_documented[module] \| self.py_undocumented[module] + all_documented_objects \|= self.py_documented[module] # prepare tabular table = [['Module', 'Coverage', 'Undocumented']] - for module in all_modules: - module_objects = self.py_documented[module].union(self.py_undocumented[module]) + for module in sorted(all_modules): + module_objects = self.py_documented[module] \| self.py_undocumented[module] if len(module_objects): value = 100.0 len(self.py_documented[module]) / len(module_objects) else: @@ -391,6 +480,7 @@ def finish(self) -> None: def setup(app: Sphinx) -> ExtensionMetadata: app.add_builder(CoverageBuilder) + app.add_config_value('coverage_modules', (), '', types={tuple, list}) app.add_config_value('coverage_ignore_modules', [], '') app.add_config_value('coverage_ignore_functions', [], '') app.add_config_value('coverage_ignore_classes', [], '')	diff --git a/tests/roots/test-ext-coverage/conf.py b/tests/roots/test-ext-coverage/conf.py index d3ec6e87f34..70fd03e91b2 100644 --- a/tests/roots/test-ext-coverage/conf.py +++ b/tests/roots/test-ext-coverage/conf.py @@ -5,8 +5,11 @@ extensions = ['sphinx.ext.autodoc', 'sphinx.ext.coverage'] +coverage_modules = [ + 'grog', +] coverage_ignore_pyobjects = [ - r'^coverage_ignored(\..)?$', + r'^grog\.coverage_ignored(\..)?$', r'\.Ignored$', r'\.Documented\.ignored\d$', ] diff --git a/tests/roots/test-ext-coverage/grog/__init__.py b/tests/roots/test-ext-coverage/grog/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tests/roots/test-ext-coverage/coverage_ignored.py b/tests/roots/test-ext-coverage/grog/coverage_ignored.py similarity index 100% rename from tests/roots/test-ext-coverage/coverage_ignored.py rename to tests/roots/test-ext-coverage/grog/coverage_ignored.py diff --git a/tests/roots/test-ext-coverage/grog/coverage_missing.py b/tests/roots/test-ext-coverage/grog/coverage_missing.py new file mode 100644 index 00000000000..2fe44338caa --- /dev/null +++ b/tests/roots/test-ext-coverage/grog/coverage_missing.py @@ -0,0 +1,7 @@ +"""This module is intentionally not documented.""" + +class Missing: + """An undocumented class.""" + + def missing_a(self): + """An undocumented method.""" diff --git a/tests/roots/test-ext-coverage/coverage_not_ignored.py b/tests/roots/test-ext-coverage/grog/coverage_not_ignored.py similarity index 100% rename from tests/roots/test-ext-coverage/coverage_not_ignored.py rename to tests/roots/test-ext-coverage/grog/coverage_not_ignored.py diff --git a/tests/roots/test-ext-coverage/index.rst b/tests/roots/test-ext-coverage/index.rst index b8468987ee2..85dccf9b1eb 100644 --- a/tests/roots/test-ext-coverage/index.rst +++ b/tests/roots/test-ext-coverage/index.rst @@ -1,6 +1,6 @@ -.. automodule:: coverage_ignored +.. automodule:: grog.coverage_ignored :members: -.. automodule:: coverage_not_ignored +.. automodule:: grog.coverage_not_ignored :members: diff --git a/tests/test_extensions/test_ext_coverage.py b/tests/test_extensions/test_ext_coverage.py index c9e9ba93a6d..ed7b5adac37 100644 --- a/tests/test_extensions/test_ext_coverage.py +++ b/tests/test_extensions/test_ext_coverage.py @@ -10,8 +10,10 @@ def test_build(app, status, warning): app.build(force_all=True) py_undoc = (app.outdir / 'python.txt').read_text(encoding='utf8') - assert py_undoc.startswith('Undocumented Python objects\n' - '===========================\n') + assert py_undoc.startswith( + 'Undocumented Python objects\n' + '===========================\n', + ) assert 'autodoc_target\n--------------\n' in py_undoc assert ' * Class -- missing methods:\n' in py_undoc assert ' * raises\n' in py_undoc @@ -23,8 +25,10 @@ def test_build(app, status, warning): assert "undocumented py" not in status.getvalue() c_undoc = (app.outdir / 'c.txt').read_text(encoding='utf8') - assert c_undoc.startswith('Undocumented C API elements\n' - '===========================\n') + assert c_undoc.startswith( + 'Undocumented C API elements\n' + '===========================\n', + ) assert 'api.h' in c_undoc assert ' * Py_SphinxTest' in c_undoc @@ -54,16 +58,26 @@ def test_coverage_ignore_pyobjects(app, status, warning): Statistics ---------- -+----------------------+----------+--------------+ -\| Module \| Coverage \| Undocumented \| -+======================+==========+==============+ -\| coverage_not_ignored \| 0.00% \| 2 \| -+----------------------+----------+--------------+ -\| TOTAL \| 0.00% \| 2 \| -+----------------------+----------+--------------+ ++---------------------------+----------+--------------+ +\| Module \| Coverage \| Undocumented \| ++===========================+==========+==============+ +\| grog \| 100.00% \| 0 \| ++---------------------------+----------+--------------+ +\| grog.coverage_missing \| 100.00% \| 0 \| ++---------------------------+----------+--------------+ +\| grog.coverage_not_ignored \| 0.00% \| 2 \| ++---------------------------+----------+--------------+ +\| TOTAL \| 0.00% \| 2 \| ++---------------------------+----------+--------------+ + +grog.coverage_missing +--------------------- -coverage_not_ignored --------------------- +Classes: + * Missing + +grog.coverage_not_ignored +------------------------- Classes: * Documented -- missing methods:	diff --git a/CHANGES.rst b/CHANGES.rst index fcdcf2df9af..1f178f5c200 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -71,6 +71,9 @@ Features added * #12523: Added configuration option, :confval:`math_numsep`, to define the separator for math numbering. Patch by Thomas Fanning +* #11592: Add :confval:`coverage_modules` to the coverage builder + to allow explicitly specifying which modules should be documented. + Patch by Stephen Finucane. Bugs fixed ---------- diff --git a/doc/usage/extensions/coverage.rst b/doc/usage/extensions/coverage.rst index b9c493b5f3b..75ffc0f59ed 100644 --- a/doc/usage/extensions/coverage.rst +++ b/doc/usage/extensions/coverage.rst @@ -6,15 +6,64 @@ This extension features one additional builder, the :class:`CoverageBuilder`. -.. class:: CoverageBuilder +.. todo:: Write this section. - To use this builder, activate the coverage extension in your configuration - file and give ``-M coverage`` on the command line. +.. note:: -.. todo:: Write this section. + The :doc:`sphinx-apidoc </man/sphinx-apidoc>` command can be used to + automatically generate API documentation for all code in a project, + avoiding the need to manually author these documents and keep them up-to-date. + +.. warning:: + + :mod:`~sphinx.ext.coverage` imports the modules to be documented. + If any modules have side effects on import, + these will be executed by the coverage builder when ``sphinx-build`` is run. + + If you document scripts (as opposed to library modules), + make sure their main routine is protected by a + ``if __name__ == '__main__'`` condition. + +.. note:: + + For Sphinx (actually, the Python interpreter that executes Sphinx) + to find your module, it must be importable. + That means that the module or the package must be in + one of the directories on :data:`sys.path` -- adapt your :data:`sys.path` + in the configuration file accordingly. + +To use this builder, activate the coverage extension in your configuration file +and run ``sphinx-build -M coverage`` on the command line. + + +Builder +------- + +.. py:class:: CoverageBuilder + + +Configuration +------------- + +Several configuration values can be used to specify +what the builder should check: + +.. confval:: coverage_modules + :type: ``list[str]`` + :default: ``[]`` + + List of Python packages or modules to test coverage for. + When this is provided, Sphinx will introspect each package + or module provided in this list as well + as all sub-packages and sub-modules found in each. + When this is not provided, Sphinx will only provide coverage + for Python packages and modules that it is aware of: + that is, any modules documented using the :rst:dir:`py:module` directive + provided in the :doc:`Python domain </usage/domains/python>` + or the :rst:dir:`automodule` directive provided by the + :mod:`~sphinx.ext.autodoc` extension. -Several configuration values can be used to specify what the builder -should check: + .. versionadded:: 7.4 .. confval:: coverage_ignore_modules	[ { "components": [ { "doc": "Recursively load all submodules.\n\n:param mod_name: The name of a module to load submodules for.\n:param ignored_module_exps: A list of regexes for modules to ignore.\n:returns: A set of modules names including the provided module name,\n ``mod_name``\n:raises Impor...	[ "tests/test_extensions/test_ext_coverage.py::test_coverage_ignore_pyobjects" ]	[ "tests/test_extensions/test_ext_coverage.py::test_build", "tests/test_extensions/test_ext_coverage.py::test_show_missing_items", "tests/test_extensions/test_ext_coverage.py::test_show_missing_items_quiet" ]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> coverage: Specify modules to run coverage for ### Feature or Bugfix Feature ### Purpose Currently, the coverage builder lets you check for partially documented modules, but there is no mechanism to identify totally undocumented modules. Resolve this by introducing a new `coverage_modules` config option. This is a list of modules that should be documented somewhere within the documentation tree. Any modules that are specified in the configuration value but are not documented anywhere will result in a warning. Likewise, any modules that are not in the config option but are documented somewhere will result in a warning. > Note > I have a WIP series locally that will complete the documentation for this module and close out #1288, but I'm keeping that out of this to avoid making it any more complicated than necessary. ### Detail (none) ### Relates (none) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sphinx/ext/coverage.py] (definition of _load_modules:) def _load_modules(mod_name: str, ignored_module_exps: Iterable[re.Pattern[str]]) -> Set[str]: """Recursively load all submodules. :param mod_name: The name of a module to load submodules for. :param ignored_module_exps: A list of regexes for modules to ignore. :returns: A set of modules names including the provided module name, ``mod_name`` :raises ImportError: If the module indicated by ``mod_name`` could not be loaded.""" (definition of _determine_py_coverage_modules:) def _determine_py_coverage_modules( coverage_modules: Sequence[str], seen_modules: Set[str], ignored_module_exps: Iterable[re.Pattern[str]], py_undoc: dict[str, dict[str, Any]], ) -> list[str]: """Return a sorted list of modules to check for coverage. Figure out which of the two operating modes to use: - If 'coverage_modules' is not specified, we check coverage for all modules seen in the documentation tree. Any objects found in these modules that are not documented will be noted. This will therefore only identify missing objects, but it requires no additional configuration. - If 'coverage_modules' is specified, we check coverage for all modules specified in this configuration value. Any objects found in these modules that are not documented will be noted. In addition, any objects from other modules that are documented will be noted. This will therefore identify both missing modules and missing objects, but it requires manual configuration.""" [end of new definitions in sphinx/ext/coverage.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		35e7bfc347f845deff50787f0cd0340ea2ea0a5d
pvlib__pvlib-python-1834	1,834	pvlib/pvlib-python	0.9	2d04aeb72e4d8509839486b4e9085b0d85f58c44	2023-08-14T13:56:53Z	diff --git a/docs/sphinx/source/reference/irradiance/decomposition.rst b/docs/sphinx/source/reference/irradiance/decomposition.rst index 08724be38e..eede9df089 100644 --- a/docs/sphinx/source/reference/irradiance/decomposition.rst +++ b/docs/sphinx/source/reference/irradiance/decomposition.rst @@ -12,6 +12,7 @@ DNI estimation models irradiance.dirint irradiance.dirindex irradiance.erbs + irradiance.erbs_driesse irradiance.orgill_hollands irradiance.boland irradiance.campbell_norman diff --git a/docs/sphinx/source/whatsnew/v0.10.2.rst b/docs/sphinx/source/whatsnew/v0.10.2.rst index 42b81f5e5d..e1bf89dcd3 100644 --- a/docs/sphinx/source/whatsnew/v0.10.2.rst +++ b/docs/sphinx/source/whatsnew/v0.10.2.rst @@ -15,8 +15,10 @@ Enhancements :py:func:`pvlib.iotools.get_pvgis_hourly`, :py:func:`pvlib.iotools.get_cams`, :py:func:`pvlib.iotools.get_bsrn`, and :py:func:`pvlib.iotools.read_midc_raw_data_from_nrel`. (:pull:`1800`) -* Added option to infer threshold values for +* Added option to infer threshold values for :py:func:`pvlib.clearsky.detect_clearsky` (:issue:`1808`, :pull:`1784`) +* Added a continuous version of the Erbs diffuse-fraction/decomposition model. + :py:func:`pvlib.irradiance.erbs_driesse` (:issue:`1755`, :pull:`1834`) Bug fixes @@ -52,5 +54,6 @@ Contributors * Abigail Jones (:ghuser:`ajonesr`) * Taos Transue (:ghuser:`reepoi`) * NativeSci (:ghuser:`nativesci`) +* Anton Driesse (:ghuser:`adriesse`) * Lukas Grossar (:ghuser:`tongpu`) * Areeba Turabi (:ghuser:`aturabi`) diff --git a/pvlib/irradiance.py b/pvlib/irradiance.py index beec6dd0b2..48cc28c33a 100644 --- a/pvlib/irradiance.py +++ b/pvlib/irradiance.py @@ -2267,6 +2267,136 @@ def erbs(ghi, zenith, datetime_or_doy, min_cos_zenith=0.065, max_zenith=87): return data +def erbs_driesse(ghi, zenith, datetime_or_doy=None, dni_extra=None, + min_cos_zenith=0.065, max_zenith=87): + r""" + Estimate DNI and DHI from GHI using the continuous Erbs-Driesse model. + + The Erbs-Driesse model [1]_ is a reformulation of the original Erbs + model [2]_ that provides continuity of the function and its first + derivative at the two transition points. + + .. math:: + + DHI = DF \times GHI + + DNI is then estimated as + + .. math:: + + DNI = (GHI - DHI)/\cos(Z) + + where Z is the zenith angle. + + Parameters + ---------- + ghi: numeric + Global horizontal irradiance in W/m^2. + zenith: numeric + True (not refraction-corrected) zenith angles in decimal degrees. + datetime_or_doy : int, float, array, pd.DatetimeIndex, default None + Day of year or array of days of year e.g. + pd.DatetimeIndex.dayofyear, or pd.DatetimeIndex. + Either datetime_or_doy or dni_extra must be provided. + dni_extra : numeric, default None + Extraterrestrial normal irradiance. + dni_extra can be provided if available to avoid recalculating it + inside this function. In this case datetime_or_doy is not required. + min_cos_zenith : numeric, default 0.065 + Minimum value of cos(zenith) to allow when calculating global + clearness index `kt`. Equivalent to zenith = 86.273 degrees. + max_zenith : numeric, default 87 + Maximum value of zenith to allow in DNI calculation. DNI will be + set to 0 for times with zenith values greater than `max_zenith`. + + Returns + ------- + data : OrderedDict or DataFrame + Contains the following keys/columns: + + * ``dni``: the modeled direct normal irradiance in W/m^2. + * ``dhi``: the modeled diffuse horizontal irradiance in + W/m^2. + * ``kt``: Ratio of global to extraterrestrial irradiance + on a horizontal plane. + + Raises + ------ + ValueError + If neither datetime_or_doy nor dni_extra is provided. + + Notes + ----- + The diffuse fraction DHI/GHI of the Erbs-Driesse model deviates from the + original Erbs model by less than 0.0005. + + References + ---------- + .. [1] A. Driesse, A. Jensen, R. Perez, A Continuous Form of the Perez + Diffuse Sky Model for Forward and Reverse Transposition, forthcoming. + + .. [2] D. G. Erbs, S. A. Klein and J. A. Duffie, Estimation of the + diffuse radiation fraction for hourly, daily and monthly-average + global radiation, Solar Energy 28(4), pp 293-302, 1982. Eq. 1 + + See also + -------- + erbs + dirint + disc + orgill_hollands + boland + """ + # central polynomial coefficients with float64 precision + p = [+12.26911439571261000, + -16.47050842469730700, + +04.24692671521831700, + -00.11390583806313881, + +00.94629663357100100] + + if datetime_or_doy is None and dni_extra is None: + raise ValueError('Either datetime_or_doy or dni_extra ' + 'must be provided.') + + if dni_extra is None: + dni_extra = get_extra_radiation(datetime_or_doy) + + # negative ghi should not reach this point, but just in case + ghi = np.maximum(0, ghi) + + kt = clearness_index(ghi, zenith, dni_extra, min_cos_zenith=min_cos_zenith, + max_clearness_index=1) + + # For all Kt, set the default diffuse fraction + df = 1 - 0.09 * kt + + # For Kt > 0.216, update the diffuse fraction + df = np.where(kt > 0.216, np.polyval(p, kt), df) + + # For Kt > 0.792, update the diffuse fraction again + df = np.where(kt > 0.792, 0.165, df) + + dhi = df * ghi + + dni = (ghi - dhi) / tools.cosd(zenith) + bad_values = (zenith > max_zenith) \| (ghi < 0) \| (dni < 0) + dni = np.where(bad_values, 0, dni) + # ensure that closure relationship remains valid + dhi = np.where(bad_values, ghi, dhi) + + data = OrderedDict() + data['dni'] = dni + data['dhi'] = dhi + data['kt'] = kt + + if isinstance(datetime_or_doy, pd.DatetimeIndex): + data = pd.DataFrame(data, index=datetime_or_doy) + elif isinstance(ghi, pd.Series): + data = pd.DataFrame(data, index=ghi.index) + + return data + + def orgill_hollands(ghi, zenith, datetime_or_doy, dni_extra=None, min_cos_zenith=0.065, max_zenith=87): """Estimate DNI and DHI from GHI using the Orgill and Hollands model.	diff --git a/pvlib/tests/test_irradiance.py b/pvlib/tests/test_irradiance.py index ab1af612a7..2f660d5c97 100644 --- a/pvlib/tests/test_irradiance.py +++ b/pvlib/tests/test_irradiance.py @@ -805,6 +805,34 @@ def test_erbs(): assert_frame_equal(np.round(out, 0), np.round(expected, 0)) +def test_erbs_driesse(): + index = pd.DatetimeIndex(['20190101']3 + ['20190620']) + ghi = pd.Series([0, 50, 1000, 1000], index=index) + zenith = pd.Series([120, 85, 10, 10], index=index) + # expected values are the same as for erbs original test + expected = pd.DataFrame(np.array( + [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [9.67192672e+01, 4.15703604e+01, 4.05723511e-01], + [7.94205651e+02, 2.17860117e+02, 7.18132729e-01], + [8.42001578e+02, 1.70790318e+02, 7.68214312e-01]]), + columns=['dni', 'dhi', 'kt'], index=index) + + out = irradiance.erbs_driesse(ghi, zenith, index) + + assert_frame_equal(np.round(out, 0), np.round(expected, 0)) + + # test with the new optional dni_extra argument + dni_extra = irradiance.get_extra_radiation(index) + + out = irradiance.erbs_driesse(ghi, zenith, dni_extra=dni_extra) + + assert_frame_equal(np.round(out, 0), np.round(expected, 0)) + + # test for required inputs + with pytest.raises(ValueError): + irradiance.erbs_driesse(ghi, zenith) + + def test_boland(): index = pd.DatetimeIndex(['20190101']3 + ['20190620']) ghi = pd.Series([0, 50, 1000, 1000], index=index)	diff --git a/docs/sphinx/source/reference/irradiance/decomposition.rst b/docs/sphinx/source/reference/irradiance/decomposition.rst index 08724be38e..eede9df089 100644 --- a/docs/sphinx/source/reference/irradiance/decomposition.rst +++ b/docs/sphinx/source/reference/irradiance/decomposition.rst @@ -12,6 +12,7 @@ DNI estimation models irradiance.dirint irradiance.dirindex irradiance.erbs + irradiance.erbs_driesse irradiance.orgill_hollands irradiance.boland irradiance.campbell_norman diff --git a/docs/sphinx/source/whatsnew/v0.10.2.rst b/docs/sphinx/source/whatsnew/v0.10.2.rst index 42b81f5e5d..e1bf89dcd3 100644 --- a/docs/sphinx/source/whatsnew/v0.10.2.rst +++ b/docs/sphinx/source/whatsnew/v0.10.2.rst @@ -15,8 +15,10 @@ Enhancements :py:func:`pvlib.iotools.get_pvgis_hourly`, :py:func:`pvlib.iotools.get_cams`, :py:func:`pvlib.iotools.get_bsrn`, and :py:func:`pvlib.iotools.read_midc_raw_data_from_nrel`. (:pull:`1800`) -* Added option to infer threshold values for +* Added option to infer threshold values for :py:func:`pvlib.clearsky.detect_clearsky` (:issue:`1808`, :pull:`1784`) +* Added a continuous version of the Erbs diffuse-fraction/decomposition model. + :py:func:`pvlib.irradiance.erbs_driesse` (:issue:`1755`, :pull:`1834`) Bug fixes @@ -52,5 +54,6 @@ Contributors * Abigail Jones (:ghuser:`ajonesr`) * Taos Transue (:ghuser:`reepoi`) * NativeSci (:ghuser:`nativesci`) +* Anton Driesse (:ghuser:`adriesse`) * Lukas Grossar (:ghuser:`tongpu`) * Areeba Turabi (:ghuser:`aturabi`)	[ { "components": [ { "doc": "Estimate DNI and DHI from GHI using the continuous Erbs-Driesse model.\n\nThe Erbs-Driesse model [1]_ is a reformulation of the original Erbs\nmodel [2]_ that provides continuity of the function and its first\nderivative at the two transition points.\n\n.. math::\n\n ...	[ "pvlib/tests/test_irradiance.py::test_erbs_driesse" ]	[ "pvlib/tests/test_irradiance.py::test_get_extra_radiation[asce-300-1383.636203]", "pvlib/tests/test_irradiance.py::test_get_extra_radiation[asce-300.0-1383.636203]", "pvlib/tests/test_irradiance.py::test_get_extra_radiation[asce-testval2-1383.636203]", "pvlib/tests/test_irradiance.py::test_get_extra_radiation...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Implement C1 continuous version of the Erbs diffuse-fraction/decomposition model <!-- Thank you for your contribution! The following items must be addressed before the code can be merged. Please don't hesitate to ask for help if you're unsure of how to accomplish any of the items. Feel free to remove checklist items that are not relevant to your change. --> - [x] Closes #1755 - [x] I am familiar with the [contributing guidelines](https://pvlib-python.readthedocs.io/en/latest/contributing.html) - [x] Tests added - [x] Updates entries in [`docs/sphinx/source/reference`](https://github.com/pvlib/pvlib-python/blob/main/docs/sphinx/source/reference) for API changes. - [x] Adds description and name entries in the appropriate "what's new" file in [`docs/sphinx/source/whatsnew`](https://github.com/pvlib/pvlib-python/tree/main/docs/sphinx/source/whatsnew) for all changes. Includes link to the GitHub Issue with `` :issue:`num` `` or this Pull Request with `` :pull:`num` ``. Includes contributor name and/or GitHub username (link with `` :ghuser:`user` ``). - [x] New code is fully documented. Includes [numpydoc](https://numpydoc.readthedocs.io/en/latest/format.html) compliant docstrings, examples, and comments where necessary. - [x] Pull request is nearly complete and ready for detailed review. - [x] Maintainer: Appropriate GitHub Labels (including `remote-data`) and Milestone are assigned to the Pull Request and linked Issue. <!-- Brief description of the problem and proposed solution (if not already fully described in the issue linked to above): --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pvlib/irradiance.py] (definition of erbs_driesse:) def erbs_driesse(ghi, zenith, datetime_or_doy=None, dni_extra=None, min_cos_zenith=0.065, max_zenith=87): """Estimate DNI and DHI from GHI using the continuous Erbs-Driesse model. The Erbs-Driesse model [1]_ is a reformulation of the original Erbs model [2]_ that provides continuity of the function and its first derivative at the two transition points. .. math:: DHI = DF \times GHI DNI is then estimated as .. math:: DNI = (GHI - DHI)/\cos(Z) where Z is the zenith angle. Parameters ---------- ghi: numeric Global horizontal irradiance in W/m^2. zenith: numeric True (not refraction-corrected) zenith angles in decimal degrees. datetime_or_doy : int, float, array, pd.DatetimeIndex, default None Day of year or array of days of year e.g. pd.DatetimeIndex.dayofyear, or pd.DatetimeIndex. Either datetime_or_doy or dni_extra must be provided. dni_extra : numeric, default None Extraterrestrial normal irradiance. dni_extra can be provided if available to avoid recalculating it inside this function. In this case datetime_or_doy is not required. min_cos_zenith : numeric, default 0.065 Minimum value of cos(zenith) to allow when calculating global clearness index `kt`. Equivalent to zenith = 86.273 degrees. max_zenith : numeric, default 87 Maximum value of zenith to allow in DNI calculation. DNI will be set to 0 for times with zenith values greater than `max_zenith`. Returns ------- data : OrderedDict or DataFrame Contains the following keys/columns: * ``dni``: the modeled direct normal irradiance in W/m^2. * ``dhi``: the modeled diffuse horizontal irradiance in W/m^2. * ``kt``: Ratio of global to extraterrestrial irradiance on a horizontal plane. Raises ------ ValueError If neither datetime_or_doy nor dni_extra is provided. Notes ----- The diffuse fraction DHI/GHI of the Erbs-Driesse model deviates from the original Erbs model by less than 0.0005. References ---------- .. [1] A. Driesse, A. Jensen, R. Perez, A Continuous Form of the Perez Diffuse Sky Model for Forward and Reverse Transposition, forthcoming. .. [2] D. G. Erbs, S. A. Klein and J. A. Duffie, Estimation of the diffuse radiation fraction for hourly, daily and monthly-average global radiation, Solar Energy 28(4), pp 293-302, 1982. Eq. 1 See also -------- erbs dirint disc orgill_hollands boland""" [end of new definitions in pvlib/irradiance.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Erbs diffuse fraction model has discontinuities at transition points Is your feature request related to a problem? Please describe. If you look closely at the piecewise definition of the Erbs diffuse fraction model you will see that it is discontinuous at the two transition points. This is not usually a problem, but when the Erbs model happens to be used in some kind of numerical optimization the discontinuities could cause problems. Describe the solution you'd like Add a new diffuse fraction function with a piecewise definition that closely matches the original Erbs model but is continuous. And while we're at it we can make the first derivative continuous too. Describe alternatives you've considered Modify the existing model function. Additional context This has been implemented and tested off line but I don't have the bandwidth for a PR currently. I thought I should mention it since it is somewhat relevant to #1753. ---------- -------------------- </issues>	d53f97e984bfdd268aa92f8bf482ced0edda0110
astropy__astropy-15168	15,168	astropy/astropy	5.2	ebefb4f216b9f6df7da895dcc9738e2ca73bdcf0	2023-08-14T02:13:26Z	diff --git a/astropy/cosmology/_io/html.py b/astropy/cosmology/_io/html.py index 948334c2c194..0606d1722b36 100644 --- a/astropy/cosmology/_io/html.py +++ b/astropy/cosmology/_io/html.py @@ -313,15 +313,15 @@ def write_html_table( cosmo_cls = type(cosmology) for name, col in table.columns.items(): - param = getattr(cosmo_cls, name, None) + param = cosmo_cls.parameters.get(name) if not isinstance(param, Parameter) or param.unit in (None, u.one): continue # Replace column with unitless version table.replace_column(name, (col << param.unit).value, copy=False) if latex_names: - new_names = [_FORMAT_TABLE.get(k, k) for k in cosmology.__parameters__] - table.rename_columns(cosmology.__parameters__, new_names) + new_names = [_FORMAT_TABLE.get(k, k) for k in cosmology.parameters] + table.rename_columns(tuple(cosmology.parameters), new_names) # Write HTML, using table I/O table.write(file, overwrite=overwrite, format="ascii.html", kwargs) diff --git a/astropy/cosmology/_io/latex.py b/astropy/cosmology/_io/latex.py index 593a6af2ac17..70644dd156d3 100644 --- a/astropy/cosmology/_io/latex.py +++ b/astropy/cosmology/_io/latex.py @@ -170,7 +170,7 @@ def write_latex( cosmo_cls = type(cosmology) for name in table.columns.keys(): - param = getattr(cosmo_cls, name, None) + param = cosmo_cls.parameters.get(name) if not isinstance(param, Parameter) or param.unit in (None, u.one): continue # Get column to correct unit @@ -178,8 +178,8 @@ def write_latex( # Convert parameter names to LaTeX format if latex_names: - new_names = [_FORMAT_TABLE.get(k, k) for k in cosmology.__parameters__] - table.rename_columns(cosmology.__parameters__, new_names) + new_names = [_FORMAT_TABLE.get(k, k) for k in cosmology.parameters] + table.rename_columns(tuple(cosmology.parameters), new_names) table.write(file, overwrite=overwrite, format="ascii.latex", kwargs) diff --git a/astropy/cosmology/_io/mapping.py b/astropy/cosmology/_io/mapping.py index cbb7872b8062..9b41622469c5 100644 --- a/astropy/cosmology/_io/mapping.py +++ b/astropy/cosmology/_io/mapping.py @@ -403,13 +403,7 @@ def to_mapping( m.update(meta) # Add all the immutable inputs - m.update( - { - k: v - for k, v in cosmology._init_arguments.items() - if k not in ("meta", "name") - } - ) + m.update(cosmology.parameters) # Lastly, add the metadata, if haven't already (above) if not move_from_meta: m["meta"] = meta # TODO? should meta be type(cls) diff --git a/astropy/cosmology/_io/model.py b/astropy/cosmology/_io/model.py index 962e38dd8dfc..a44fbce0075c 100644 --- a/astropy/cosmology/_io/model.py +++ b/astropy/cosmology/_io/model.py @@ -240,17 +240,13 @@ def to_model(cosmology, _, method): attrs["n_inputs"] = n_inputs attrs["n_outputs"] = 1 - params = {} # Parameters (also class attributes) - for n in cosmology.__parameters__: - v = getattr(cosmology, n) # parameter value - - if v is None: # skip unspecified parameters - continue - - # add as Model Parameter - params[n] = convert_parameter_to_model_parameter( - getattr(cosmo_cls, n), v, cosmology.meta.get(n) + params = { + k: convert_parameter_to_model_parameter( + cosmo_cls.parameters[k], v, meta=cosmology.meta.get(k) ) + for k, v in cosmology.parameters.items() + if v is not None + } # class name is cosmology name + Cosmology + method name + Model clsname = ( @@ -269,8 +265,9 @@ def to_model(cosmology, _, method): ) # instantiate class using default values - ps = {n: getattr(cosmology, n) for n in params.keys()} - model = CosmoModel(ps, name=cosmology.name, meta=copy.deepcopy(cosmology.meta)) + model = CosmoModel( + cosmology.parameters, name=cosmology.name, meta=copy.deepcopy(cosmology.meta) + ) return model diff --git a/astropy/cosmology/_io/table.py b/astropy/cosmology/_io/table.py index bb228f598ea3..03eaf8d132e5 100644 --- a/astropy/cosmology/_io/table.py +++ b/astropy/cosmology/_io/table.py @@ -428,9 +428,9 @@ def to_table(cosmology, args, cls=QTable, cosmology_in_meta=True, rename=None): # - list for anything else cosmo_cls = cosmology.__class__ for k, v in data.items(): - if k in cosmology.__parameters__: + if k in cosmology.parameters: col = convert_parameter_to_column( - getattr(cosmo_cls, k), v, cosmology.meta.get(k) + cosmo_cls.parameters[k], v, cosmology.meta.get(k) ) else: col = Column([v]) diff --git a/astropy/cosmology/_utils.py b/astropy/cosmology/_utils.py index 8e080b800c97..6209ace2141d 100644 --- a/astropy/cosmology/_utils.py +++ b/astropy/cosmology/_utils.py @@ -1,7 +1,13 @@ # Licensed under a 3-clause BSD style license - see LICENSE.rst +from __future__ import annotations + +__all__ = [] # nothing is publicly scoped + import functools +import operator from numbers import Number +from typing import Any import numpy as np @@ -9,8 +15,6 @@ from . import units as cu -__all__ = [] # nothing is publicly scoped - def vectorize_redshift_method(func=None, nin=1): """Vectorize a method of redshift(s). @@ -71,3 +75,9 @@ def aszarr(z): return z # not one of the preferred types: Number / array ducktype return Quantity(z, cu.redshift).value + + +def all_cls_vars(obj: object \| type, /) -> dict[str, Any]: + """Return all variables in the whole class hierarchy.""" + cls = obj if isinstance(obj, type) else obj.__class__ + return functools.reduce(operator.__or__, map(vars, cls.mro()[::-1])) diff --git a/astropy/cosmology/core.py b/astropy/cosmology/core.py index 3fdc7b1d8fd1..34d644c3e74e 100644 --- a/astropy/cosmology/core.py +++ b/astropy/cosmology/core.py @@ -4,7 +4,8 @@ import abc import inspect -from typing import TYPE_CHECKING, Any, TypeVar +from types import MappingProxyType +from typing import TYPE_CHECKING, Any, ClassVar, TypeVar import numpy as np @@ -12,6 +13,7 @@ from astropy.utils.decorators import classproperty from astropy.utils.metadata import MetaData +from ._utils import all_cls_vars from .connect import ( CosmologyFromFormat, CosmologyRead, @@ -19,6 +21,7 @@ CosmologyWrite, ) from .parameter import Parameter +from .parameter._descriptors import ParametersAttribute if TYPE_CHECKING: # pragma: no cover from collections.abc import Mapping @@ -93,8 +96,25 @@ class Cosmology(metaclass=abc.ABCMeta): write = UnifiedReadWriteMethod(CosmologyWrite) # Parameters - __parameters__: tuple[str, ...] = () - __all_parameters__: tuple[str, ...] = () + parameters = ParametersAttribute() + """Immutable mapping of the Parameters. + + If accessed from the class, this returns a mapping of the Parameter + objects themselves. If accessed from an instance, this returns a + mapping of the values of the Parameters. + """ + + derived_parameters = ParametersAttribute() + """Immutable mapping of the derived Parameters. + + If accessed from the class, this returns a mapping of the Parameter + objects themselves. If accessed from an instance, this returns a + mapping of the values of the Parameters. + """ + + _parameters: ClassVar = MappingProxyType[str, Parameter]({}) + _derived_parameters: ClassVar = MappingProxyType[str, Parameter]({}) + _parameters_all: ClassVar = frozenset[str]() # --------------------------------------------------------------- @@ -104,29 +124,25 @@ def __init_subclass__(cls): # ------------------- # Parameters - # Get parameters that are still Parameters, either in this class or above. - parameters = [] - derived_parameters = [] - for n in cls.__parameters__: - p = getattr(cls, n) - if isinstance(p, Parameter): - derived_parameters.append(n) if p.derived else parameters.append(n) - - # Add new parameter definitions - for n, v in cls.__dict__.items(): - if n in parameters or n.startswith("_") or not isinstance(v, Parameter): + params = {} + derived_params = {} + for n, v in all_cls_vars(cls).items(): + if not isinstance(v, Parameter): continue - derived_parameters.append(n) if v.derived else parameters.append(n) - - # reorder to match signature - ordered = [ - parameters.pop(parameters.index(n)) + if v.derived: + derived_params[n] = v + else: + params[n] = v + + # reorder to match signature, placing "unordered" at the end + ordered = { + n: params.pop(n) for n in cls._init_signature.parameters.keys() - if n in parameters - ] - parameters = ordered + parameters # place "unordered" at the end - cls.__parameters__ = tuple(parameters) - cls.__all_parameters__ = cls.__parameters__ + tuple(derived_parameters) + if n in params + } + cls._parameters = MappingProxyType(ordered \| params) + cls._derived_parameters = MappingProxyType(derived_params) + cls._parameters_all = frozenset(cls.parameters).union(cls.derived_parameters) # ------------------- # Registration @@ -222,7 +238,7 @@ def clone(self, , meta=None, kwargs): meta = meta if meta is not None else {} new_meta = {self.meta, meta} # Mix kwargs into initial arguments, preferring the former. - new_init = {self._init_arguments, "meta": new_meta, kwargs} + new_init = {self.parameters, "meta": new_meta, kwargs} # Create BoundArgument to handle args versus kwargs. # This also handles all errors from mismatched arguments ba = self._init_signature.bind_partial(new_init) @@ -236,17 +252,6 @@ def clone(self, , meta=None, kwargs): return cloned - @property - def _init_arguments(self): - # parameters - kw = {n: getattr(self, n) for n in self.__parameters__} - - # other info - kw["name"] = self.name - kw["meta"] = self.meta - - return kw - # --------------------------------------------------------------- # comparison methods @@ -350,9 +355,10 @@ def __equiv__(self, other: Any, /) -> bool: # Check all parameters in 'other' match those in 'self' and 'other' has # no extra parameters (latter part should never happen b/c same class) - return set(self.__all_parameters__) == set(other.__all_parameters__) and all( - np.all(getattr(self, k) == getattr(other, k)) - for k in self.__all_parameters__ + # We do not use `self.parameters == other.parameters` because it does not work + # for aggregating the truthiness of arrays, e.g. `m_nu`. + return self._parameters_all == other._parameters_all and all( + np.all(getattr(self, k) == getattr(other, k)) for k in self._parameters_all ) def __eq__(self, other: Any, /) -> bool: @@ -378,11 +384,13 @@ def __eq__(self, other: Any, /) -> bool: self.name == other.name # check all parameters in 'other' match those in 'self' and 'other' # has no extra parameters (latter part should never happen b/c same - # class) TODO! element-wise when there are array cosmologies - and set(self.__all_parameters__) == set(other.__all_parameters__) + # class). We do not use `self.parameters == other.parameters` because + # it does not work for aggregating the truthiness of arrays, e.g. `m_nu`. + # TODO! element-wise when there are array cosmologies + and self._parameters_all == other._parameters_all and all( np.all(getattr(self, k) == getattr(other, k)) - for k in self.__all_parameters__ + for k in self._parameters_all ) ) @@ -391,18 +399,13 @@ def __eq__(self, other: Any, /) -> bool: # --------------------------------------------------------------- def __repr__(self): - namelead = f"{self.__class__.__qualname__}(" - if self.name is not None: - namelead += f"name={self.name!r}, " - # nicely formatted parameters - fmtps = (f"{k}={getattr(self, k)!r}" for k in self.__parameters__) - - return namelead + ", ".join(fmtps) + ")" + fmtps = (f"{k}={v!r}" for k, v in self.parameters.items()) + return f"{type(self).__qualname__}(name={self.name!r}, {', '.join(fmtps)})" def __str__(self): """Return a string representation of the cosmology.""" name_str = "" if self.name is None else f'name="{self.name}", ' - param_strs = (f"{k!s}={getattr(self, k)!s}" for k in self.__parameters__) + param_strs = (f"{k!s}={v!s}" for k, v in self.parameters.items()) return f"{type(self).__name__}({name_str}{', '.join(param_strs)})" def __astropy_table__(self, cls, copy, kwargs): @@ -436,8 +439,8 @@ class FlatCosmologyMixin(metaclass=abc.ABCMeta): ``FlatLambdaCDM`` will* be flat. """ - __all_parameters__: tuple[str, ...] - __parameters__: tuple[str, ...] + _parameters: ClassVar[MappingProxyType[str, Parameter]] + _derived_parameters: ClassVar[MappingProxyType[str, Parameter]] def __init_subclass__(cls: type[_FlatCosmoT]) -> None: super().__init_subclass__() @@ -600,11 +603,11 @@ def __equiv__(self, other): # Check if have equivalent parameters and all parameters in `other` # match those in `self`` and `other`` has no extra parameters. params_eq = ( - set(self.__all_parameters__) == set(other.__all_parameters__) # no extra + # no extra parameters + self._parameters_all == other._parameters_all # equal and all( - np.all(getattr(self, k) == getattr(other, k)) - for k in self.__parameters__ + np.all(getattr(self, k) == getattr(other, k)) for k in self.parameters ) # flatness check and other.is_flat diff --git a/astropy/cosmology/flrw/base.py b/astropy/cosmology/flrw/base.py index 61f429257cc5..dfc8ae6acd6c 100644 --- a/astropy/cosmology/flrw/base.py +++ b/astropy/cosmology/flrw/base.py @@ -95,6 +95,12 @@ def scale_factor(self, z): return 1.0 / (aszarr(z) + 1.0) +ParameterOde0 = Parameter( + doc="Omega dark energy; dark energy density/critical density at z=0.", + fvalidate="float", +) + + class FLRW(Cosmology, _ScaleFactorMixin): """An isotropic and homogeneous (Friedmann-Lemaitre-Robertson-Walker) cosmology. @@ -162,10 +168,7 @@ class FLRW(Cosmology, _ScaleFactorMixin): doc="Omega matter; matter density/critical density at z=0.", fvalidate="non-negative", ) - Ode0 = Parameter( - doc="Omega dark energy; dark energy density/critical density at z=0.", - fvalidate="float", - ) + Ode0 = ParameterOde0 Tcmb0 = Parameter( default=0.0 * u.K, doc="Temperature of the CMB as `~astropy.units.Quantity` at z=0.", @@ -1480,7 +1483,7 @@ class FlatFLRWMixin(FlatCosmologyMixin): parameter values), but ``FlatLambdaCDM`` will be flat. """ - Ode0 = FLRW.Ode0.clone(derived=True) # same as FLRW, but now a derived param. + Ode0 = ParameterOde0.clone(derived=True) # same as FLRW, but derived. def __init_subclass__(cls): super().__init_subclass__() @@ -1500,12 +1503,12 @@ def nonflat(self: _FlatFLRWMixinT) -> _FLRWT: # Create BoundArgument to handle args versus kwargs. # This also handles all errors from mismatched arguments ba = self.__nonflatclass__._init_signature.bind_partial( - self._init_arguments, Ode0=self.Ode0 + self.parameters, Ode0=self.Ode0, name=self.name ) # Make new instance, respecting args vs kwargs inst = self.__nonflatclass__(ba.args, ba.kwargs) # Because of machine precision, make sure parameters exactly match - for n in inst.__all_parameters__ + ("Ok0",): + for n in (inst._parameters_all, "Ok0"): setattr(inst, "_" + n, getattr(self, n)) return inst diff --git a/astropy/cosmology/parameter/__init__.py b/astropy/cosmology/parameter/__init__.py index 5acbc2fc3e9c..9fc4e72a3467 100644 --- a/astropy/cosmology/parameter/__init__.py +++ b/astropy/cosmology/parameter/__init__.py @@ -1,5 +1,6 @@ # Licensed under a 3-clause BSD style license - see LICENSE.rst -__all__ = ["Parameter"] +from . import _core +from ._core import * -from ._core import Parameter +__all__ = _core.__all__ diff --git a/astropy/cosmology/parameter/_core.py b/astropy/cosmology/parameter/_core.py index 3d229bf60626..445b62f99be6 100644 --- a/astropy/cosmology/parameter/_core.py +++ b/astropy/cosmology/parameter/_core.py @@ -2,7 +2,7 @@ from __future__ import annotations -__all__ = [] +__all__ = ["Parameter"] import copy from dataclasses import dataclass, field, fields, replace diff --git a/astropy/cosmology/parameter/_descriptors.py b/astropy/cosmology/parameter/_descriptors.py new file mode 100644 index 000000000000..e75f9a62bdef --- /dev/null +++ b/astropy/cosmology/parameter/_descriptors.py @@ -0,0 +1,47 @@ +# Licensed under a 3-clause BSD style license - see LICENSE.rst + +from __future__ import annotations + +__all__ = [] + +from dataclasses import dataclass, field +from types import MappingProxyType +from typing import TYPE_CHECKING, Any, NoReturn + +from astropy.utils.compat.misc import PYTHON_LT_3_10 + +if TYPE_CHECKING: + from astropy.cosmology.core import Cosmology + + +_dataclass_kwargs = {} if PYTHON_LT_3_10 else {"slots": True} + + +@dataclass(frozen=True, **_dataclass_kwargs) +class ParametersAttribute: + """Immutable mapping of the Parameters. + + If accessed from the class, this returns a mapping of the Parameter + objects themselves. If accessed from an instance, this returns a + mapping of the values of the Parameters. + """ + + attr_name: str = field(init=False) + + def __set_name__(self, owner: type[Cosmology], name: str) -> None: + object.__setattr__(self, "attr_name", f"_{name}") + + def __get__( + self, instance: Cosmology \| None, owner: type[Cosmology] \| None + ) -> MappingProxyType[str, Any]: + # called from the class + if instance is None: + return getattr(owner, self.attr_name) + # called from the instance + return MappingProxyType( + {n: getattr(instance, n) for n in getattr(instance, self.attr_name)} + ) + + def __set__(self, instance: Any, value: Any) -> NoReturn: + msg = f"cannot set {self.attr_name.lstrip('_').rstrip('_')!r} of {instance!r}." + raise AttributeError(msg) diff --git a/docs/changes/cosmology/15168.feature.rst b/docs/changes/cosmology/15168.feature.rst new file mode 100644 index 000000000000..f99ea2b93c7a --- /dev/null +++ b/docs/changes/cosmology/15168.feature.rst @@ -0,0 +1,5 @@ +The ``Cosmology`` class now has two new properties to access the parameters of the +cosmology: ``.parameters`` and ``.derived_parameters``. These properties return a +read-only dictionary of all the (derived) parameter values on the cosmology object. +When accessed from the class (not an instance) the dictionary contains ``Parameter`` +objects, not the values. diff --git a/docs/cosmology/dev.rst b/docs/cosmology/dev.rst index 05c70d773c8a..00742b81e94e 100644 --- a/docs/cosmology/dev.rst +++ b/docs/cosmology/dev.rst @@ -116,10 +116,10 @@ the definition of \|FLRW\|. raise ValueError("baryonic density can not be larger than total matter density.") return value -First note that all the parameters are also arguments in ``__init__``. This is -not strictly necessary, but is good practice. If the parameter has units (and -related equivalencies) these must be specified on the Parameter, as seen in -:attr:`~astropy.cosmology.FLRW.H0` and :attr:`~astropy.cosmology.FLRW.m_nu`. +First note that all the parameters are also arguments in ``__init__()``. This is not +strictly necessary, but is good practice. If the parameter has units (and related +equivalencies) these must be specified on the \|Parameter\|, as seen in +The "H0" item in :attr:`~astropy.cosmology.FLRW.parameters`. The next important thing to note is how the parameter value is set, in ``__init__``. \|Parameter\| allows for a value to be set once (before @@ -147,7 +147,7 @@ parameter and change any constructor argument. For example, see class FlatFLRWMixin(FlatCosmologyMixin): ... - Ode0 = FLRW.Ode0.clone(derived=True) # now a derived param. + Ode0 = FLRW.parameters["Ode0"].clone(derived=True) Mixins ------ diff --git a/docs/whatsnew/6.0.rst b/docs/whatsnew/6.0.rst index fd4bf7b27ff7..707cafaff840 100644 --- a/docs/whatsnew/6.0.rst +++ b/docs/whatsnew/6.0.rst @@ -187,6 +187,32 @@ format:: Planck18 67.66 0.30966 2.7255 3.046 0.0 .. 0.06 0.04897 +New properties to access \|Cosmology\| parameters +----------------------------------------------- + +The :class:`~astropy.cosmology.Cosmology` class now has two new properties +to access the parameters of the cosmology: :attr:`~astropy.cosmology.Cosmology.parameters` +and :attr:`~astropy.cosmology.Cosmology.derived_parameters`. These properties +return a :class:`~types.MappingProxyType` object, which is a read-only dictionary +of all the (derived-)parameter values on the \|Cosmology\| instance. For example:: + + >>> from astropy.cosmology import Planck18 + >>> Planck18.parameters["H0"] + <Quantity 67.66 km / (Mpc s)> + >>> Planck18.derived_parameters["Ode0"] + 0.6888463055445441 + +When accessed from the cosmology class itself, the returned dictionary is +not the parameter values but :class:`~astropy.cosmology.Parameter` objects +with information about the parameter used when setting up the cosmology:: + + >>> from astropy.cosmology import FlatLambdaCDM + >>> FlatLambdaCDM.parameters["H0"] + Parameter(derived=False, unit=Unit("km / (Mpc s)"), equivalencies=[], ...) + >>> FlatLambdaCDM.derived_parameters["Ode0"] + Parameter(derived=True, unit=None, equivalencies=[], ...) + + :class:`~astropy.cosmology.Parameter` as a :func:`~dataclasses.dataclass` ------------------------------------------------------------------------- @@ -196,7 +222,7 @@ This means that the :mod:`dataclasses` machinery can be used to work with >>> from dataclasses import replace >>> from astropy.cosmology import FlatLambdaCDM - >>> m_nu = FlatLambdaCDM.m_nu + >>> m_nu = FlatLambdaCDM.parameters["m_nu"] >>> m_nu Parameter(default=<Quantity 0. eV>, derived=False, unit=Unit("eV"), ...) >>> replace(m_nu, derived=True)	diff --git a/astropy/cosmology/_io/tests/test_html.py b/astropy/cosmology/_io/tests/test_html.py index 8c92b091ca2e..ef4a6f59443b 100644 --- a/astropy/cosmology/_io/tests/test_html.py +++ b/astropy/cosmology/_io/tests/test_html.py @@ -4,7 +4,6 @@ import astropy.units as u from astropy.cosmology._io.html import _FORMAT_TABLE, read_html_table, write_html_table -from astropy.cosmology.parameter import Parameter from astropy.table import QTable, Table, vstack from astropy.utils.compat.optional_deps import HAS_BS4 @@ -190,10 +189,10 @@ def test_readwrite_html_mutlirow(self, cosmo, read, write, tmp_path, add_cu): assert cosmo is not None for n, col in zip(table.colnames, table.itercols()): - if n == "cosmology": + if n not in cosmo_cls.parameters: continue - param = getattr(cosmo_cls, n) - if not isinstance(param, Parameter) or param.unit in (None, u.one): + param = cosmo_cls.parameters[n] + if param.unit in (None, u.one): continue # Replace column with unitless version table.replace_column(n, (col << param.unit).value, copy=False) diff --git a/astropy/cosmology/_io/tests/test_mapping.py b/astropy/cosmology/_io/tests/test_mapping.py index be62907a510f..51f8919d89fd 100644 --- a/astropy/cosmology/_io/tests/test_mapping.py +++ b/astropy/cosmology/_io/tests/test_mapping.py @@ -34,9 +34,9 @@ def test_to_mapping_default(self, cosmo, to_format): assert m.pop("cosmology") is cosmo.__class__ assert keys[1] == "name" assert m.pop("name") == cosmo.name - for i, k in enumerate(cosmo.__parameters__, start=2): + for i, (k, v) in enumerate(cosmo.parameters.items(), start=2): assert keys[i] == k - assert np.array_equal(m.pop(k), getattr(cosmo, k)) + np.testing.assert_array_equal(m.pop(k), v) assert keys[-1] == "meta" assert m.pop("meta") == cosmo.meta diff --git a/astropy/cosmology/_io/tests/test_model.py b/astropy/cosmology/_io/tests/test_model.py index 9cabb63c6646..d9caf1544f26 100644 --- a/astropy/cosmology/_io/tests/test_model.py +++ b/astropy/cosmology/_io/tests/test_model.py @@ -80,7 +80,7 @@ def test_toformat_model(self, cosmo, to_format, method_name): assert isinstance(model, _CosmologyModel) # Parameters - expect = tuple(n for n in cosmo.__parameters__ if getattr(cosmo, n) is not None) + expect = tuple(k for k, v in cosmo.parameters.items() if v is not None) assert model.param_names == expect # scalar result diff --git a/astropy/cosmology/_io/tests/test_table.py b/astropy/cosmology/_io/tests/test_table.py index 65fe677de294..24c93b1d629c 100644 --- a/astropy/cosmology/_io/tests/test_table.py +++ b/astropy/cosmology/_io/tests/test_table.py @@ -74,8 +74,7 @@ def test_to_table(self, cosmo_cls, cosmo, to_format): assert tbl.indices # indexed # Test each Parameter column has expected information. - for n in cosmo.__parameters__: - P = getattr(cosmo_cls, n) # Parameter + for n, P in cosmo_cls.parameters.items(): col = tbl[n] # Column # Compare the two diff --git a/astropy/cosmology/flrw/tests/conftest.py b/astropy/cosmology/flrw/tests/conftest.py index f44cf0e8061f..9fd0898aa721 100644 --- a/astropy/cosmology/flrw/tests/conftest.py +++ b/astropy/cosmology/flrw/tests/conftest.py @@ -2,5 +2,35 @@ """Configure the tests for :mod:`astropy.cosmology`.""" +from __future__ import annotations + +from typing import TYPE_CHECKING, TypeVar + from astropy.cosmology.tests.helper import clean_registry # noqa: F401 from astropy.tests.helper import pickle_protocol # noqa: F401 + +if TYPE_CHECKING: + from collections.abc import Iterable, Mapping, Sequence + +K = TypeVar("K") +V = TypeVar("V") + + +def filter_keys_from_items( + m: Mapping[K, V], /, filter_out: Sequence[K] +) -> Iterable[K, V]: + """Filter ``m``, returning key-value pairs not including keys in ``filter``. + + Parameters + ---------- + m : mapping[K, V] + A mapping from which to remove keys in ``filter_out``. + filter_out : sequence[K] + Sequence of keys to filter out from ``m``. + + Returns + ------- + iterable[K, V] + Iterable of ``(key, value)`` pairs with the ``filter_out`` keys removed. + """ + return ((k, v) for k, v in m.items() if k not in filter_out) diff --git a/astropy/cosmology/flrw/tests/test_base.py b/astropy/cosmology/flrw/tests/test_base.py index 0c2703e50527..83db44c14a08 100644 --- a/astropy/cosmology/flrw/tests/test_base.py +++ b/astropy/cosmology/flrw/tests/test_base.py @@ -2,14 +2,9 @@ """Testing :mod:`astropy.cosmology.flrw.base`.""" -############################################################################## -# IMPORTS - -# STDLIB import abc import copy -# THIRD PARTY import numpy as np import pytest @@ -29,8 +24,11 @@ invalid_zs, valid_zs, ) +from astropy.tests.helper import assert_quantity_allclose from astropy.utils.compat.optional_deps import HAS_SCIPY +from .conftest import filter_keys_from_items + ############################################################################## # SETUP / TEARDOWN @@ -68,16 +66,17 @@ def test_H0(self, cosmo_cls, cosmo): unit = u.Unit("km/(s Mpc)") # on the class - assert isinstance(cosmo_cls.H0, Parameter) - assert "Hubble constant" in cosmo_cls.H0.__doc__ - assert cosmo_cls.H0.unit == unit - assert cosmo_cls.H0.default is MISSING + H0 = cosmo_cls.parameters["H0"] + assert isinstance(H0, Parameter) + assert "Hubble constant" in H0.__doc__ + assert H0.unit == unit + assert H0.default is MISSING # validation - assert cosmo_cls.H0.validate(cosmo, 1) == 1 * unit - assert cosmo_cls.H0.validate(cosmo, 10 * unit) == 10 * unit + assert H0.validate(cosmo, 1) == 1 * unit + assert H0.validate(cosmo, 10 * unit) == 10 * unit with pytest.raises(ValueError, match="H0 is a non-scalar quantity"): - cosmo_cls.H0.validate(cosmo, [1, 2]) + H0.validate(cosmo, [1, 2]) # on the instance assert cosmo.H0 is cosmo._H0 @@ -112,15 +111,16 @@ class ParameterOm0TestMixin(ParameterTestMixin): def test_Om0(self, cosmo_cls, cosmo): """Test Parameter ``Om0``.""" # on the class - assert isinstance(cosmo_cls.Om0, Parameter) - assert "Omega matter" in cosmo_cls.Om0.__doc__ - assert cosmo_cls.Om0.default is MISSING + Om0 = cosmo_cls.parameters["Om0"] + assert isinstance(Om0, Parameter) + assert "Omega matter" in Om0.__doc__ + assert Om0.default is MISSING # validation - assert cosmo_cls.Om0.validate(cosmo, 1) == 1 - assert cosmo_cls.Om0.validate(cosmo, 10 * u.one) == 10 + assert Om0.validate(cosmo, 1) == 1 + assert Om0.validate(cosmo, 10 * u.one) == 10 with pytest.raises(ValueError, match="Om0 cannot be negative"): - cosmo_cls.Om0.validate(cosmo, -1) + Om0.validate(cosmo, -1) # on the instance assert cosmo.Om0 is cosmo._Om0 @@ -155,16 +155,22 @@ class ParameterOde0TestMixin(ParameterTestMixin): def test_Parameter_Ode0(self, cosmo_cls): """Test Parameter ``Ode0`` on the class.""" - assert isinstance(cosmo_cls.Ode0, Parameter) - assert "Omega dark energy" in cosmo_cls.Ode0.__doc__ - assert cosmo_cls.Ode0.default is MISSING + Ode0 = cosmo_cls.parameters.get( + "Ode0", cosmo_cls.derived_parameters.get("Ode0") + ) + assert isinstance(Ode0, Parameter) + assert "Omega dark energy" in Ode0.__doc__ + assert Ode0.default is MISSING def test_Parameter_Ode0_validation(self, cosmo_cls, cosmo): """Test Parameter ``Ode0`` validation.""" - assert cosmo_cls.Ode0.validate(cosmo, 1.1) == 1.1 - assert cosmo_cls.Ode0.validate(cosmo, 10 * u.one) == 10.0 + Ode0 = cosmo_cls.parameters.get( + "Ode0", cosmo_cls.derived_parameters.get("Ode0") + ) + assert Ode0.validate(cosmo, 1.1) == 1.1 + assert Ode0.validate(cosmo, 10 * u.one) == 10.0 with pytest.raises(TypeError, match="only dimensionless"): - cosmo_cls.Ode0.validate(cosmo, 10 * u.km) + Ode0.validate(cosmo, 10 * u.km) def test_Ode0(self, cosmo): """Test Parameter ``Ode0`` validation.""" @@ -208,16 +214,17 @@ class ParameterTcmb0TestMixin(ParameterTestMixin): def test_Tcmb0(self, cosmo_cls, cosmo): """Test Parameter ``Tcmb0``.""" # on the class - assert isinstance(cosmo_cls.Tcmb0, Parameter) - assert "Temperature of the CMB" in cosmo_cls.Tcmb0.__doc__ - assert cosmo_cls.Tcmb0.unit == u.K - assert cosmo_cls.Tcmb0.default == 0.0 * u.K + Tcmb0 = cosmo_cls.parameters["Tcmb0"] + assert isinstance(Tcmb0, Parameter) + assert "Temperature of the CMB" in Tcmb0.__doc__ + assert Tcmb0.unit == u.K + assert Tcmb0.default == 0.0 * u.K # validation - assert cosmo_cls.Tcmb0.validate(cosmo, 1) == 1 * u.K - assert cosmo_cls.Tcmb0.validate(cosmo, 10 * u.K) == 10 * u.K + assert Tcmb0.validate(cosmo, 1) == 1 * u.K + assert Tcmb0.validate(cosmo, 10 * u.K) == 10 * u.K with pytest.raises(ValueError, match="Tcmb0 is a non-scalar quantity"): - cosmo_cls.Tcmb0.validate(cosmo, [1, 2]) + Tcmb0.validate(cosmo, [1, 2]) # on the instance assert cosmo.Tcmb0 is cosmo._Tcmb0 @@ -252,15 +259,16 @@ class ParameterNeffTestMixin(ParameterTestMixin): def test_Neff(self, cosmo_cls, cosmo): """Test Parameter ``Neff``.""" # on the class - assert isinstance(cosmo_cls.Neff, Parameter) - assert "Number of effective neutrino species" in cosmo_cls.Neff.__doc__ - assert cosmo_cls.Neff.default == 3.04 + Neff = cosmo_cls.parameters["Neff"] + assert isinstance(Neff, Parameter) + assert "Number of effective neutrino species" in Neff.__doc__ + assert Neff.default == 3.04 # validation - assert cosmo_cls.Neff.validate(cosmo, 1) == 1 - assert cosmo_cls.Neff.validate(cosmo, 10 * u.one) == 10 + assert Neff.validate(cosmo, 1) == 1 + assert Neff.validate(cosmo, 10 * u.one) == 10 with pytest.raises(ValueError, match="Neff cannot be negative"): - cosmo_cls.Neff.validate(cosmo, -1) + Neff.validate(cosmo, -1) # on the instance assert cosmo.Neff is cosmo._Neff @@ -295,11 +303,12 @@ class Parameterm_nuTestMixin(ParameterTestMixin): def test_m_nu(self, cosmo_cls, cosmo): """Test Parameter ``m_nu``.""" # on the class - assert isinstance(cosmo_cls.m_nu, Parameter) - assert "Mass of neutrino species" in cosmo_cls.m_nu.__doc__ - assert cosmo_cls.m_nu.unit == u.eV - assert cosmo_cls.m_nu.equivalencies == u.mass_energy() - assert cosmo_cls.m_nu.default == 0.0 * u.eV + m_nu = cosmo_cls.parameters["m_nu"] + assert isinstance(m_nu, Parameter) + assert "Mass of neutrino species" in m_nu.__doc__ + assert m_nu.unit == u.eV + assert m_nu.equivalencies == u.mass_energy() + assert m_nu.default == 0.0 * u.eV # on the instance # assert cosmo.m_nu is cosmo._m_nu @@ -404,18 +413,19 @@ class ParameterOb0TestMixin(ParameterTestMixin): def test_Ob0(self, cosmo_cls, cosmo): """Test Parameter ``Ob0``.""" # on the class - assert isinstance(cosmo_cls.Ob0, Parameter) - assert "Omega baryon;" in cosmo_cls.Ob0.__doc__ - assert cosmo_cls.Ob0.default is None + Ob0 = cosmo_cls.parameters["Ob0"] + assert isinstance(Ob0, Parameter) + assert "Omega baryon;" in Ob0.__doc__ + assert Ob0.default is None # validation - assert cosmo_cls.Ob0.validate(cosmo, None) is None - assert cosmo_cls.Ob0.validate(cosmo, 0.1) == 0.1 - assert cosmo_cls.Ob0.validate(cosmo, 0.1 * u.one) == 0.1 + assert Ob0.validate(cosmo, None) is None + assert Ob0.validate(cosmo, 0.1) == 0.1 + assert Ob0.validate(cosmo, 0.1 * u.one) == 0.1 with pytest.raises(ValueError, match="Ob0 cannot be negative"): - cosmo_cls.Ob0.validate(cosmo, -1) + Ob0.validate(cosmo, -1) with pytest.raises(ValueError, match="baryonic density can not be larger"): - cosmo_cls.Ob0.validate(cosmo, cosmo.Om0 + 1) + Ob0.validate(cosmo, cosmo.Om0 + 1) # on the instance assert cosmo.Ob0 is cosmo._Ob0 @@ -753,9 +763,7 @@ def test_clone_change_param(self, cosmo): super().test_clone_change_param(cosmo) # don't change any values - kwargs = cosmo._init_arguments.copy() - kwargs.pop("name", None) # make sure not setting name - kwargs.pop("meta", None) # make sure not setting name + kwargs = dict(cosmo.parameters) c = cosmo.clone(*kwargs) assert c.__class__ == cosmo.__class__ assert c == cosmo @@ -766,14 +774,12 @@ def test_clone_change_param(self, cosmo): assert c.__class__ == cosmo.__class__ assert c.name == cosmo.name + " (modified)" assert c.H0.value == 100 - for n in set(cosmo.__parameters__) - {"H0"}: - v = getattr(c, n) + for n, v in filter_keys_from_items(c.parameters, ("H0",)): + v_expect = getattr(cosmo, n) if v is None: - assert v is getattr(cosmo, n) + assert v is v_expect else: - assert u.allclose( - v, getattr(cosmo, n), atol=1e-4 getattr(v, "unit", 1) - ) + assert_quantity_allclose(v, v_expect, atol=1e-4 * getattr(v, "unit", 1)) assert not u.allclose(c.Ogamma0, cosmo.Ogamma0) assert not u.allclose(c.Onu0, cosmo.Onu0) @@ -784,14 +790,12 @@ def test_clone_change_param(self, cosmo): assert c.H0.value == 100 assert c.Tcmb0.value == 2.8 assert c.meta == {cosmo.meta, dict(zz="tops")} - for n in set(cosmo.__parameters__) - {"H0", "Tcmb0"}: - v = getattr(c, n) + for n, v in filter_keys_from_items(c.parameters, ("H0", "Tcmb0")): + v_expect = getattr(cosmo, n) if v is None: - assert v is getattr(cosmo, n) + assert v is v_expect else: - assert u.allclose( - v, getattr(cosmo, n), atol=1e-4 * getattr(v, "unit", 1) - ) + assert_quantity_allclose(v, v_expect, atol=1e-4 * getattr(v, "unit", 1)) assert not u.allclose(c.Ogamma0, cosmo.Ogamma0) assert not u.allclose(c.Onu0, cosmo.Onu0) assert not u.allclose(c.Tcmb0.value, cosmo.Tcmb0.value) @@ -943,7 +947,8 @@ class ParameterFlatOde0TestMixin(ParameterOde0TestMixin): def test_Parameter_Ode0(self, cosmo_cls): """Test Parameter ``Ode0`` on the class.""" super().test_Parameter_Ode0(cosmo_cls) - assert cosmo_cls.Ode0.derived in (True, np.True_) + Ode0 = cosmo_cls.parameters.get("Ode0", cosmo_cls.derived_parameters["Ode0"]) + assert Ode0.derived in (True, np.True_) def test_Ode0(self, cosmo): """Test no-longer-Parameter ``Ode0``.""" diff --git a/astropy/cosmology/flrw/tests/test_w0cdm.py b/astropy/cosmology/flrw/tests/test_w0cdm.py index 6ab042dc8f03..ef9f1696c87e 100644 --- a/astropy/cosmology/flrw/tests/test_w0cdm.py +++ b/astropy/cosmology/flrw/tests/test_w0cdm.py @@ -14,8 +14,10 @@ from astropy.cosmology import FlatwCDM, wCDM from astropy.cosmology.parameter import Parameter from astropy.cosmology.tests.test_core import ParameterTestMixin, valid_zs +from astropy.tests.helper import assert_quantity_allclose from astropy.utils.compat.optional_deps import HAS_SCIPY +from .conftest import filter_keys_from_items from .test_base import FlatFLRWMixinTest, FLRWTest ############################################################################## @@ -34,10 +36,11 @@ class Parameterw0TestMixin(ParameterTestMixin): def test_w0(self, cosmo_cls, cosmo): """Test Parameter ``w0``.""" # on the class - assert isinstance(cosmo_cls.w0, Parameter) - assert "Dark energy equation of state" in cosmo_cls.w0.__doc__ - assert cosmo_cls.w0.unit is None - assert cosmo_cls.w0.default == -1.0 + w0 = cosmo_cls.parameters["w0"] + assert isinstance(w0, Parameter) + assert "Dark energy equation of state" in w0.__doc__ + assert w0.unit is None + assert w0.default == -1.0 # on the instance assert cosmo.w0 is cosmo._w0 @@ -81,14 +84,12 @@ def test_clone_change_param(self, cosmo): # `w` params c = cosmo.clone(w0=0.1) assert c.w0 == 0.1 - for n in set(cosmo.__parameters__) - {"w0"}: - v = getattr(c, n) + for n, v in filter_keys_from_items(c.parameters, ("w0",)): + v_expect = getattr(cosmo, n) if v is None: - assert v is getattr(cosmo, n) + assert v is v_expect else: - assert u.allclose( - v, getattr(cosmo, n), atol=1e-4 * getattr(v, "unit", 1) - ) + assert_quantity_allclose(v, v_expect, atol=1e-4 * getattr(v, "unit", 1)) @pytest.mark.parametrize("z", valid_zs) def test_w(self, cosmo, z): diff --git a/astropy/cosmology/flrw/tests/test_w0wacdm.py b/astropy/cosmology/flrw/tests/test_w0wacdm.py index 1490b371ce6d..331658b9ef30 100644 --- a/astropy/cosmology/flrw/tests/test_w0wacdm.py +++ b/astropy/cosmology/flrw/tests/test_w0wacdm.py @@ -14,8 +14,10 @@ from astropy.cosmology import Flatw0waCDM, Planck18, w0waCDM from astropy.cosmology.parameter import Parameter from astropy.cosmology.tests.test_core import ParameterTestMixin +from astropy.tests.helper import assert_quantity_allclose from astropy.utils.compat.optional_deps import HAS_SCIPY +from .conftest import filter_keys_from_items from .test_base import FlatFLRWMixinTest, FLRWTest from .test_w0cdm import Parameterw0TestMixin @@ -35,10 +37,11 @@ class ParameterwaTestMixin(ParameterTestMixin): def test_wa(self, cosmo_cls, cosmo): """Test Parameter ``wa``.""" # on the class - assert isinstance(cosmo_cls.wa, Parameter) - assert "Negative derivative" in cosmo_cls.wa.__doc__ - assert cosmo_cls.wa.unit is None - assert cosmo_cls.wa.default == 0.0 + wa = cosmo_cls.parameters["wa"] + assert isinstance(wa, Parameter) + assert "Negative derivative" in wa.__doc__ + assert wa.unit is None + assert wa.default == 0.0 # on the instance assert cosmo.wa is cosmo._wa @@ -82,14 +85,12 @@ def test_clone_change_param(self, cosmo): c = cosmo.clone(w0=0.1, wa=0.2) assert c.w0 == 0.1 assert c.wa == 0.2 - for n in set(cosmo.__parameters__) - {"w0", "wa"}: - v = getattr(c, n) + for n, v in filter_keys_from_items(c.parameters, ("w0", "wa")): + v_expect = getattr(cosmo, n) if v is None: - assert v is getattr(cosmo, n) + assert v is v_expect else: - assert u.allclose( - v, getattr(cosmo, n), atol=1e-4 * getattr(v, "unit", 1) - ) + assert_quantity_allclose(v, v_expect, atol=1e-4 * getattr(v, "unit", 1)) # @pytest.mark.parametrize("z", valid_zs) # TODO! recompute comparisons below def test_w(self, cosmo): @@ -265,7 +266,7 @@ def test_varyde_lumdist_mathematica(): def test_equality(): """Test equality and equivalence.""" # mismatched signatures, both directions. - newcosmo = w0waCDM(Planck18._init_arguments, Ode0=0.6) + newcosmo = w0waCDM(Planck18.parameters, Ode0=0.6) assert newcosmo != Planck18 assert Planck18 != newcosmo diff --git a/astropy/cosmology/flrw/tests/test_w0wzcdm.py b/astropy/cosmology/flrw/tests/test_w0wzcdm.py index f63853503bf5..d30247db0152 100644 --- a/astropy/cosmology/flrw/tests/test_w0wzcdm.py +++ b/astropy/cosmology/flrw/tests/test_w0wzcdm.py @@ -13,6 +13,7 @@ from astropy.cosmology.tests.test_core import ParameterTestMixin, make_valid_zs from astropy.utils.compat.optional_deps import HAS_SCIPY +from .conftest import filter_keys_from_items from .test_base import FlatFLRWMixinTest, FLRWTest from .test_w0cdm import Parameterw0TestMixin @@ -40,10 +41,11 @@ class ParameterwzTestMixin(ParameterTestMixin): def test_wz(self, cosmo_cls, cosmo): """Test Parameter ``wz``.""" # on the class - assert isinstance(cosmo_cls.wz, Parameter) - assert "Derivative of the dark energy" in cosmo_cls.wz.__doc__ - assert cosmo_cls.wz.unit is None - assert cosmo_cls.wz.default == 0.0 + wz = cosmo_cls.parameters["wz"] + assert isinstance(wz, Parameter) + assert "Derivative of the dark energy" in wz.__doc__ + assert wz.unit is None + assert wz.default == 0.0 # on the instance assert cosmo.wz is cosmo._wz @@ -87,8 +89,7 @@ def test_clone_change_param(self, cosmo): c = cosmo.clone(w0=0.1, wz=0.2) assert c.w0 == 0.1 assert c.wz == 0.2 - for n in set(cosmo.__parameters__) - {"w0", "wz"}: - v = getattr(c, n) + for n, v in filter_keys_from_items(c.parameters, ("w0", "wz")): if v is None: assert v is getattr(cosmo, n) else: diff --git a/astropy/cosmology/flrw/tests/test_wpwazpcdm.py b/astropy/cosmology/flrw/tests/test_wpwazpcdm.py index a66381d461bb..fd7d055d312c 100644 --- a/astropy/cosmology/flrw/tests/test_wpwazpcdm.py +++ b/astropy/cosmology/flrw/tests/test_wpwazpcdm.py @@ -13,8 +13,10 @@ from astropy.cosmology import FlatwpwaCDM, wpwaCDM from astropy.cosmology.parameter import Parameter from astropy.cosmology.tests.test_core import ParameterTestMixin +from astropy.tests.helper import assert_quantity_allclose from astropy.utils.compat.optional_deps import HAS_SCIPY +from .conftest import filter_keys_from_items from .test_base import FlatFLRWMixinTest, FLRWTest from .test_w0wacdm import ParameterwaTestMixin @@ -40,10 +42,11 @@ class ParameterwpTestMixin(ParameterTestMixin): def test_wp(self, cosmo_cls, cosmo): """Test Parameter ``wp``.""" # on the class - assert isinstance(cosmo_cls.wp, Parameter) - assert "at the pivot" in cosmo_cls.wp.__doc__ - assert cosmo_cls.wp.unit is None - assert cosmo_cls.wp.default == -1.0 + wp = cosmo_cls.parameters["wp"] + assert isinstance(wp, Parameter) + assert "at the pivot" in wp.__doc__ + assert wp.unit is None + assert wp.default == -1.0 # on the instance assert cosmo.wp is cosmo._wp @@ -78,10 +81,11 @@ class ParameterzpTestMixin(ParameterTestMixin): def test_zp(self, cosmo_cls, cosmo): """Test Parameter ``zp``.""" # on the class - assert isinstance(cosmo_cls.zp, Parameter) - assert "pivot redshift" in cosmo_cls.zp.__doc__ - assert cosmo_cls.zp.unit == cu.redshift - assert cosmo_cls.zp.default == 0.0 + zp = cosmo_cls.parameters["zp"] + assert isinstance(zp, Parameter) + assert "pivot redshift" in zp.__doc__ + assert zp.unit == cu.redshift + assert zp.default == 0.0 # on the instance assert cosmo.zp is cosmo._zp @@ -128,14 +132,12 @@ def test_clone_change_param(self, cosmo): assert c.wp == 0.1 assert c.wa == 0.2 assert c.zp == 14 - for n in set(cosmo.__parameters__) - {"wp", "wa", "zp"}: - v = getattr(c, n) + for n, v in filter_keys_from_items(c.parameters, ("wp", "wa", "zp")): + v_expect = getattr(cosmo, n) if v is None: - assert v is getattr(cosmo, n) + assert v is v_expect else: - assert u.allclose( - v, getattr(cosmo, n), atol=1e-4 * getattr(v, "unit", 1) - ) + assert_quantity_allclose(v, v_expect, atol=1e-4 * getattr(v, "unit", 1)) # @pytest.mark.parametrize("z", valid_zs) # TODO! recompute comparisons below def test_w(self, cosmo): diff --git a/astropy/cosmology/funcs/tests/test_comparison.py b/astropy/cosmology/funcs/tests/test_comparison.py index 167620797f15..22e7f42bc612 100644 --- a/astropy/cosmology/funcs/tests/test_comparison.py +++ b/astropy/cosmology/funcs/tests/test_comparison.py @@ -66,8 +66,7 @@ def converted(self, to_format, format): @pytest.fixture(scope="class") def pert_cosmo(self, cosmo): # change one parameter - p = cosmo.__parameters__[0] - v = getattr(cosmo, p) + p, v = next(iter(cosmo.parameters.items())) cosmo2 = cosmo.clone( *{p: v 1.0001 if v != 0 else 0.001 * getattr(v, "unit", 1)} ) diff --git a/astropy/cosmology/parameter/tests/__init__.py b/astropy/cosmology/parameter/tests/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/astropy/cosmology/parameter/tests/conftest.py b/astropy/cosmology/parameter/tests/conftest.py new file mode 100644 index 000000000000..47de13803227 --- /dev/null +++ b/astropy/cosmology/parameter/tests/conftest.py @@ -0,0 +1,6 @@ +# Licensed under a 3-clause BSD style license - see LICENSE.rst + +"""Configure the tests for :mod:`astropy.cosmology.parameter`.""" + +from astropy.cosmology.tests.helper import clean_registry # noqa: F401 +from astropy.tests.helper import pickle_protocol # noqa: F401 diff --git a/astropy/cosmology/parameter/tests/test_descriptors.py b/astropy/cosmology/parameter/tests/test_descriptors.py new file mode 100644 index 000000000000..da35042b1422 --- /dev/null +++ b/astropy/cosmology/parameter/tests/test_descriptors.py @@ -0,0 +1,42 @@ +# Licensed under a 3-clause BSD style license - see LICENSE.rst + +"""Testing :mod:`astropy.cosmology.parameter._descriptor`.""" + +from types import MappingProxyType + +import pytest + +from astropy.cosmology.parameter import Parameter + + +class ParametersAttributeTestMixin: + """Test the descriptor for ``parameters`` on Cosmology classes.""" + + @pytest.mark.parametrize("name", ["parameters", "derived_parameters"]) + def test_parameters_from_class(self, cosmo_cls, name): + """Test descriptor ``parameters`` accessed from the class.""" + # test presence + assert hasattr(cosmo_cls, name) + # test Parameter is a MappingProxyType + parameters = getattr(cosmo_cls, name) + assert isinstance(parameters, MappingProxyType) + # Test items + assert set(parameters.keys()) == set(getattr(cosmo_cls, f"_{name}")) + assert all(isinstance(p, Parameter) for p in parameters.values()) + + @pytest.mark.parametrize("name", ["parameters", "derived_parameters"]) + def test_parameters_from_instance(self, cosmo, name): + """Test descriptor ``parameters`` accessed from the instance.""" + # test presence + assert hasattr(cosmo, name) + # test Parameter is a MappingProxyType + parameters = getattr(cosmo, name) + assert isinstance(parameters, MappingProxyType) + # Test keys + assert set(parameters) == set(getattr(cosmo, f"_{name}")) + + @pytest.mark.parametrize("name", ["parameters", "derived_parameters"]) + def test_parameters_cannot_set_on_instance(self, cosmo, name): + """Test descriptor ``parameters`` cannot be set on the instance.""" + with pytest.raises(AttributeError, match=f"cannot set {name!r} of"): + setattr(cosmo, name, {}) diff --git a/astropy/cosmology/tests/test_parameter.py b/astropy/cosmology/parameter/tests/test_parameter.py similarity index 84% rename from astropy/cosmology/tests/test_parameter.py rename to astropy/cosmology/parameter/tests/test_parameter.py index 6757a5acc2d0..e6b7153a4e8b 100644 --- a/astropy/cosmology/tests/test_parameter.py +++ b/astropy/cosmology/parameter/tests/test_parameter.py @@ -6,7 +6,6 @@ # IMPORTS # STDLIB -import inspect from typing import Callable # THIRD PARTY @@ -86,20 +85,17 @@ class ParameterTestMixin: @pytest.fixture def parameter(self, cosmo_cls): """Cosmological Parameters""" - # I wish this would work - # yield from {getattr(cosmo_cls, n) for n in cosmo_cls.__parameters__} - - # just return one parameter at random - yield getattr(cosmo_cls, set(cosmo_cls.__parameters__).pop()) + yield from cosmo_cls.parameters.values() @pytest.fixture def all_parameter(self, cosmo_cls): """Cosmological All Parameter instances""" - # I wish this would work - # yield from {getattr(cosmo_cls, n) for n in cosmo_cls.__all_parameters__} - # just return one parameter at random - yield getattr(cosmo_cls, set(cosmo_cls.__all_parameters__).pop()) + n = set(cosmo_cls._parameters_all).pop() + try: + yield cosmo_cls.parameters[n] + except KeyError: + yield cosmo_cls.derived_parameters[n] # =============================================================== # Method Tests @@ -150,9 +146,7 @@ def test_Parameter_derived(self, cosmo_cls, all_parameter): assert isinstance(all_parameter.derived, bool) # test value - assert all_parameter.derived is ( - all_parameter.name not in cosmo_cls.__parameters__ - ) + assert all_parameter.derived is (all_parameter.name not in cosmo_cls.parameters) def test_Parameter_default(self, cosmo_cls, all_parameter): """Test :attr:`astropy.cosmology.Parameter.default`.""" @@ -167,8 +161,9 @@ def test_Parameter_default(self, cosmo_cls, all_parameter): def test_Parameter_descriptor_get(self, cosmo_cls, cosmo, all_parameter): """Test :attr:`astropy.cosmology.Parameter.__get__`.""" # from class - parameter = getattr(cosmo_cls, all_parameter.name) - np.testing.assert_array_equal(parameter.default, all_parameter.default) + np.testing.assert_array_equal( + getattr(cosmo_cls, all_parameter.name).default, all_parameter.default + ) # from instance parameter = getattr(cosmo, all_parameter.name) @@ -196,16 +191,10 @@ def test_Parameter_listed(self, cosmo_cls, all_parameter): assert isinstance(all_parameter, Parameter) # the reverse: check that if it is a Parameter, it's listed. - # note have to check the more inclusive ``__all_parameters__`` - assert all_parameter.name in cosmo_cls.__all_parameters__ - if not all_parameter.derived: - assert all_parameter.name in cosmo_cls.__parameters__ - - def test_parameter_related_attributes_on_Cosmology(self, cosmo_cls): - """Test `astropy.cosmology.Parameter`-related on Cosmology.""" - # establish has expected attribute - assert hasattr(cosmo_cls, "__parameters__") - assert hasattr(cosmo_cls, "__all_parameters__") + if all_parameter.derived: + assert all_parameter.name in cosmo_cls.derived_parameters + else: + assert all_parameter.name in cosmo_cls.parameters def test_Parameter_not_unique(self, cosmo_cls, clean_registry): """Cosmology Parameter not unique to class when subclass defined.""" @@ -217,8 +206,8 @@ class ExampleBase(cosmo_cls): class Example(ExampleBase): pass - assert Example.param is ExampleBase.param - assert Example.__parameters__ == ExampleBase.__parameters__ + assert Example.parameters["param"] is ExampleBase.parameters["param"] + assert Example.parameters == ExampleBase.parameters def test_Parameters_reorder_by_signature(self, cosmo_cls, clean_registry): """Test parameters are reordered.""" @@ -230,11 +219,11 @@ def __init__(self, param, , name=None, meta=None): pass # never actually initialized # param should be 1st, all other parameters next - assert Example.__parameters__[0] == "param" + assert next(iter(Example.parameters)) == "param" # Check the other parameters are as expected. # only run this test if "param" is not already on the cosmology - if cosmo_cls.__parameters__[0] != "param": - assert set(Example.__parameters__[1:]) == set(cosmo_cls.__parameters__) + if next(iter(cosmo_cls.parameters)) != "param": + assert set(tuple(Example.parameters)[1:]) == set(cosmo_cls.parameters) def test_make_from_Parameter(self, cosmo_cls, clean_registry): """Test the parameter creation process. Uses ``__set__``.""" @@ -265,12 +254,14 @@ class TestParameter(ParameterTestMixin): """ def setup_class(self): + Param = Parameter( + doc="Description of example parameter.", + unit=u.m, + equivalencies=u.mass_energy(), + ) + class Example1(Cosmology): - param = Parameter( - doc="Description of example parameter.", - unit=u.m, - equivalencies=u.mass_energy(), - ) + param = Param def __init__(self, param=15): self.param = param @@ -284,7 +275,7 @@ class Example2(Example1): def __init__(self, param=15 u.m): self.param = param - @Example1.param.validator + @Param.validator def param(self, param, value): return value.to(u.km) @@ -308,12 +299,12 @@ def cosmo(self, cosmo_cls): @pytest.fixture(scope="class") def param(self, cosmo_cls): """Get Parameter 'param' from cosmology class.""" - return cosmo_cls.param + return cosmo_cls.parameters["param"] @pytest.fixture(scope="class") - def param_cls(self, cosmo_cls): + def param_cls(self, param): """Get Parameter class from cosmology class.""" - return cosmo_cls.param.__class__ + return type(param) # ============================================================== @@ -453,8 +444,8 @@ def test_Parameter_clone(self, param): # ------------------------------------------- def test_Parameter_equality(self): - """ - Test Parameter equality. + """Test Parameter equality. + Determined from the processed initialization args (including defaults). """ p1 = Parameter(unit="km / (s Mpc)") @@ -495,35 +486,3 @@ def test_Parameter_repr_roundtrip(self, param): NP = eval(repr(P)) # Evaluate string representation back into a param. assert P == NP - - # ============================================================== - - def test_Parameter_doesnt_change_with_generic_class(self): - """Descriptors are initialized once and not updated on subclasses.""" - - class ExampleBase: - def __init__(self, param=15): - self._param = param - - sig = inspect.signature(__init__) - _init_signature = sig.replace(parameters=list(sig.parameters.values())[1:]) - - param = Parameter(doc="example parameter") - - class Example(ExampleBase): - pass - - assert Example.param is ExampleBase.param - - def test_Parameter_doesnt_change_with_cosmology(self, cosmo_cls): - """Cosmology reinitializes all descriptors when a subclass is defined.""" - - # define subclass to show param is same - class Example(cosmo_cls): - pass - - assert Example.param is cosmo_cls.param - - # unregister - _COSMOLOGY_CLASSES.pop(Example.__qualname__) - assert Example.__qualname__ not in _COSMOLOGY_CLASSES diff --git a/astropy/cosmology/tests/helper.py b/astropy/cosmology/tests/helper.py index a64133798977..77d209935f19 100644 --- a/astropy/cosmology/tests/helper.py +++ b/astropy/cosmology/tests/helper.py @@ -5,16 +5,10 @@ from the installed astropy. It makes use of the `pytest`_ testing framework. """ -############################################################################## -# IMPORTS - -# STDLIB import inspect -# THIRD PARTY import pytest -# LOCAL from astropy.cosmology import core __all__ = ["get_redshift_methods", "clean_registry"] diff --git a/astropy/cosmology/tests/test_core.py b/astropy/cosmology/tests/test_core.py index b7eecf7efb90..5bcb3acc86b8 100644 --- a/astropy/cosmology/tests/test_core.py +++ b/astropy/cosmology/tests/test_core.py @@ -14,12 +14,17 @@ from astropy.cosmology import Cosmology, FlatCosmologyMixin from astropy.cosmology.core import _COSMOLOGY_CLASSES from astropy.cosmology.parameter import Parameter +from astropy.cosmology.parameter.tests.test_descriptors import ( + ParametersAttributeTestMixin, +) +from astropy.cosmology.parameter.tests.test_parameter import ParameterTestMixin +from astropy.cosmology.tests.test_connect import ( + ReadWriteTestMixin, + ToFromFormatTestMixin, +) from astropy.table import Column, QTable, Table from astropy.utils.compat import PYTHON_LT_3_11 -from .test_connect import ReadWriteTestMixin, ToFromFormatTestMixin -from .test_parameter import ParameterTestMixin - ############################################################################## # SETUP / TEARDOWN @@ -99,14 +104,13 @@ def test_meta_mutable(self, cosmo): class CosmologyTest( ParameterTestMixin, + ParametersAttributeTestMixin, MetaTestMixin, ReadWriteTestMixin, ToFromFormatTestMixin, metaclass=abc.ABCMeta, ): - """ - Test subclasses of :class:`astropy.cosmology.Cosmology`. - """ + """Test subclasses of :class:`astropy.cosmology.Cosmology`.""" @abc.abstractmethod def setup_class(self): @@ -154,7 +158,7 @@ class InitSubclassTest(cosmo_cls): pass # test parameters - assert InitSubclassTest.__parameters__ == cosmo_cls.__parameters__ + assert InitSubclassTest.parameters == cosmo_cls.parameters # test and cleanup registry registrant = _COSMOLOGY_CLASSES.pop(InitSubclassTest.__qualname__) @@ -168,7 +172,7 @@ class UnRegisteredSubclassTest(cosmo_cls): def _register_cls(cls): """Override to not register.""" - assert UnRegisteredSubclassTest.__parameters__ == cosmo_cls.__parameters__ + assert UnRegisteredSubclassTest.parameters == cosmo_cls.parameters assert UnRegisteredSubclassTest.__qualname__ not in _COSMOLOGY_CLASSES def test_init_signature(self, cosmo_cls, cosmo): @@ -182,9 +186,7 @@ def test_init_signature(self, cosmo_cls, cosmo): # test matches __init__, but without 'self' sig = inspect.signature(cosmo.__init__) # (instances don't have self) - assert set(sig.parameters.keys()) == set( - cosmo._init_signature.parameters.keys() - ) + assert set(sig.parameters) == set(cosmo._init_signature.parameters) assert all( np.all(sig.parameters[k].default == p.default) for k, p in cosmo._init_signature.parameters.items() @@ -320,8 +322,7 @@ def test_repr(self, cosmo_cls, cosmo): r = r[6 + len(cosmo.name) + 3 :] # remove # parameters in string rep - ps = {k: getattr(cosmo, k) for k in cosmo.__parameters__} - for k, v in ps.items(): + for k, v in cosmo.parameters.items(): sv = f"{k}={v!r}" assert sv in r assert r.index(k) == 0 @@ -337,7 +338,7 @@ def test_astropy_table(self, cosmo, table_cls, in_meta): assert isinstance(tbl, table_cls) # the name & all parameters are columns - for n in ("name", cosmo.__parameters__): + for n in ("name", cosmo.parameters): assert n in tbl.colnames assert np.all(tbl[n] == getattr(cosmo, n)) # check if Cosmology is in metadata or a column @@ -359,7 +360,7 @@ def test_immutability(self, cosmo): Test immutability of cosmologies. The metadata is mutable: see ``test_meta_mutable``. """ - for n in cosmo.__all_parameters__: + for n in (cosmo.parameters, cosmo.derived_parameters): with pytest.raises(AttributeError): setattr(cosmo, n, getattr(cosmo, n)) diff --git a/astropy/cosmology/tests/test_parameters.py b/astropy/cosmology/tests/test_parameters.py index 487a69c595ca..242f1576d843 100644 --- a/astropy/cosmology/tests/test_parameters.py +++ b/astropy/cosmology/tests/test_parameters.py @@ -36,8 +36,8 @@ def test_getting_parameters(name): assert params["name"] == cosmo.name assert params["cosmology"] == cosmo.__class__.__qualname__ # All the cosmology parameters are equal - for n in cosmo.__parameters__: - assert np.array_equal(params[n], getattr(cosmo, n)) + for k, v in cosmo.parameters.items(): + np.testing.assert_array_equal(params[k], v) # All the metadata is included. Parameter values take precedence, so only # checking the keys. assert set(cosmo.meta.keys()).issubset(params.keys()) diff --git a/astropy/cosmology/tests/test_utils.py b/astropy/cosmology/tests/test_utils.py index e64d1de58d34..616e4a658b49 100644 --- a/astropy/cosmology/tests/test_utils.py +++ b/astropy/cosmology/tests/test_utils.py @@ -4,7 +4,7 @@ import pytest from astropy.cosmology import utils -from astropy.cosmology._utils import aszarr, vectorize_redshift_method +from astropy.cosmology._utils import all_cls_vars, aszarr, vectorize_redshift_method from astropy.utils.exceptions import AstropyDeprecationWarning from .test_core import invalid_zs, valid_zs, z_arr @@ -73,3 +73,27 @@ def test_invalid(self, z, exc): """Test :func:`astropy.cosmology._utils.aszarr`.""" with pytest.raises(exc): aszarr(z) + + +# ------------------------------------------------------------------- + + +def test_all_cls_vars(): + """Test :func:`astropy.cosmology._utils.all_cls_vars`.""" + + class ClassA: + a = 1 + b = 2 + + all_vars = all_cls_vars(ClassA) + public_all_vars = {k: v for k, v in all_vars.items() if not k.startswith("_")} + assert public_all_vars == {"a": 1, "b": 2} + + class ClassB(ClassA): + c = 3 + + all_vars = all_cls_vars(ClassB) + public_all_vars = {k: v for k, v in all_vars.items() if not k.startswith("_")} + assert public_all_vars == {"a": 1, "b": 2, "c": 3} + assert "a" not in vars(ClassB) + assert "b" not in vars(ClassB)	diff --git a/docs/changes/cosmology/15168.feature.rst b/docs/changes/cosmology/15168.feature.rst new file mode 100644 index 000000000000..f99ea2b93c7a --- /dev/null +++ b/docs/changes/cosmology/15168.feature.rst @@ -0,0 +1,5 @@ +The ``Cosmology`` class now has two new properties to access the parameters of the +cosmology: ``.parameters`` and ``.derived_parameters``. These properties return a +read-only dictionary of all the (derived) parameter values on the cosmology object. +When accessed from the class (not an instance) the dictionary contains ``Parameter`` +objects, not the values. diff --git a/docs/cosmology/dev.rst b/docs/cosmology/dev.rst index 05c70d773c8a..00742b81e94e 100644 --- a/docs/cosmology/dev.rst +++ b/docs/cosmology/dev.rst @@ -116,10 +116,10 @@ the definition of \|FLRW\|. raise ValueError("baryonic density can not be larger than total matter density.") return value -First note that all the parameters are also arguments in ``__init__``. This is -not strictly necessary, but is good practice. If the parameter has units (and -related equivalencies) these must be specified on the Parameter, as seen in -:attr:`~astropy.cosmology.FLRW.H0` and :attr:`~astropy.cosmology.FLRW.m_nu`. +First note that all the parameters are also arguments in ``__init__()``. This is not +strictly necessary, but is good practice. If the parameter has units (and related +equivalencies) these must be specified on the \|Parameter\|, as seen in +The "H0" item in :attr:`~astropy.cosmology.FLRW.parameters`. The next important thing to note is how the parameter value is set, in ``__init__``. \|Parameter\| allows for a value to be set once (before @@ -147,7 +147,7 @@ parameter and change any constructor argument. For example, see class FlatFLRWMixin(FlatCosmologyMixin): ... - Ode0 = FLRW.Ode0.clone(derived=True) # now a derived param. + Ode0 = FLRW.parameters["Ode0"].clone(derived=True) Mixins ------ diff --git a/docs/whatsnew/6.0.rst b/docs/whatsnew/6.0.rst index fd4bf7b27ff7..707cafaff840 100644 --- a/docs/whatsnew/6.0.rst +++ b/docs/whatsnew/6.0.rst @@ -187,6 +187,32 @@ format:: Planck18 67.66 0.30966 2.7255 3.046 0.0 .. 0.06 0.04897 +New properties to access \|Cosmology\| parameters +----------------------------------------------- + +The :class:`~astropy.cosmology.Cosmology` class now has two new properties +to access the parameters of the cosmology: :attr:`~astropy.cosmology.Cosmology.parameters` +and :attr:`~astropy.cosmology.Cosmology.derived_parameters`. These properties +return a :class:`~types.MappingProxyType` object, which is a read-only dictionary +of all the (derived-)parameter values on the \|Cosmology\| instance. For example:: + + >>> from astropy.cosmology import Planck18 + >>> Planck18.parameters["H0"] + <Quantity 67.66 km / (Mpc s)> + >>> Planck18.derived_parameters["Ode0"] + 0.6888463055445441 + +When accessed from the cosmology class itself, the returned dictionary is +not the parameter values but :class:`~astropy.cosmology.Parameter` objects +with information about the parameter used when setting up the cosmology:: + + >>> from astropy.cosmology import FlatLambdaCDM + >>> FlatLambdaCDM.parameters["H0"] + Parameter(derived=False, unit=Unit("km / (Mpc s)"), equivalencies=[], ...) + >>> FlatLambdaCDM.derived_parameters["Ode0"] + Parameter(derived=True, unit=None, equivalencies=[], ...) + + :class:`~astropy.cosmology.Parameter` as a :func:`~dataclasses.dataclass` ------------------------------------------------------------------------- @@ -196,7 +222,7 @@ This means that the :mod:`dataclasses` machinery can be used to work with >>> from dataclasses import replace >>> from astropy.cosmology import FlatLambdaCDM - >>> m_nu = FlatLambdaCDM.m_nu + >>> m_nu = FlatLambdaCDM.parameters["m_nu"] >>> m_nu Parameter(default=<Quantity 0. eV>, derived=False, unit=Unit("eV"), ...) >>> replace(m_nu, derived=True)	[ { "components": [ { "doc": "Return all variables in the whole class hierarchy.", "lines": [ 80, 83 ], "name": "all_cls_vars", "signature": "def all_cls_vars(obj: object \| type, /) -> dict[str, Any]:", "type": "function" } ], ...	[ "astropy/cosmology/_io/tests/test_mapping.py::TestToFromMapping::test_to_mapping_default[cosmo0]", "astropy/cosmology/_io/tests/test_mapping.py::TestToFromMapping::test_to_mapping_wrong_cls[cosmo0]", "astropy/cosmology/_io/tests/test_mapping.py::TestToFromMapping::test_to_mapping_cls[cosmo0-dict]", "astropy/c...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Cosmo parameters properties I've added 2 properties to `Cosmology`: 1. `parameters` : an immutable dictionary of the non-derived ``Parameter``s defined on `Cosmology`. When accessed from the class the values are the Parameter objects. When accessed from the cosmology instance the values are the Parameter values on the cosmology instance. 2. `derived_parameters` : the same, but for the derived parameters, e.g `Ode0` in flat cosmologies. The idea is that when `Cosmology` is a dataclass you eventually won't be able to do `Cosmology.H0` to get the `Parameter` object. But it will be still be easy to access the `Parameter` object as `Cosmology.parameters["H0"]`. For v6.0 I do not plan to remove direct access to `Cosmology.H0`, etc. This will either be deprecated in a future version or will be supported through Python's [dataclass_transform](https://peps.python.org/pep-0681/) mechanism. Pros and cons to both. Please do NOT squash. ---------- Thank you for your contribution to Astropy! 🌌 This checklist is meant to remind the package maintainers who will review this pull request of some common things to look for. - [ ] Do the proposed changes actually accomplish desired goals? - [ ] Do the proposed changes follow the [Astropy coding guidelines](https://docs.astropy.org/en/latest/development/codeguide.html)? - [ ] Are tests added/updated as required? If so, do they follow the [Astropy testing guidelines](https://docs.astropy.org/en/latest/development/testguide.html)? - [ ] Are docs added/updated as required? If so, do they follow the [Astropy documentation guidelines](https://docs.astropy.org/en/latest/development/docguide.html#astropy-documentation-rules-and-guidelines)? - [ ] Is rebase and/or squash necessary? If so, please provide the author with appropriate instructions. Also see instructions for [rebase](https://docs.astropy.org/en/latest/development/workflow/development_workflow.html#rebase-if-necessary) and [squash](https://docs.astropy.org/en/latest/development/workflow/development_workflow.html#squash-if-necessary). - [ ] Did the CI pass? If no, are the failures related? If you need to run daily and weekly cron jobs as part of the PR, please apply the "Extra CI" label. Codestyle issues can be fixed by the [bot](https://docs.astropy.org/en/latest/development/workflow/development_workflow.html#pre-commit). - [ ] Is a change log needed? If yes, did the change log check pass? If no, add the "no-changelog-entry-needed" label. If this is a manual backport, use the "skip-changelog-checks" label unless special changelog handling is necessary. - [ ] Is this a big PR that makes a "What's new?" entry worthwhile and if so, is (1) a "what's new" entry included in this PR and (2) the "whatsnew-needed" label applied? - [ ] Is a milestone set? Milestone must be set but we cannot check for it on Actions; do not let the green checkmark fool you. - [ ] At the time of adding the milestone, if the milestone set requires a backport to release branch(es), apply the appropriate "backport-X.Y.x" label(s) before merge. 👋 Thank you for your draft pull request! Do you know that you can use `[ci skip]` or `[skip ci]` in your commit messages to skip running continuous integration tests until you are ready? I think the RTD failure is a bug in sphinx, or maybe `sphinx-automodapi`. If a descriptor-typed dataclass field without a default value is used in a class, then the field cannot be accessed from the class. Consequently when Sphinx tries to import the field it errors, halting the build! There are 2 solutions. 1 is to try to fix the bug upstream. 2 is to add default values to the Parameters and skirt this bug. Ok. I've registered the bug with Sphinx, but I don't think it will be resolved immediately nor will we immediately update our sphinx version to the most recent build, so it's probably best if I add default values to the `Parameter`. - [x] Need to add tests for the new field `default`. @eerovaher @WilliamJamieson, this PR isn't quite ready (see top comment) but I would appreciate your thoughts on how to solve the `Parameters` vs `parameters` issue, and also adding properties for derived parameters, e.g. `AllParameters` (and `allparameters`) or `get_Parameter`. Thanks! I've settled on using descriptors. This satisfies PEP-8 and keeps the number of additions to `Cosmology`'s namespace to a minimum. </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in astropy/cosmology/_utils.py] (definition of all_cls_vars:) def all_cls_vars(obj: object \| type, /) -> dict[str, Any]: """Return all variables in the whole class hierarchy.""" [end of new definitions in astropy/cosmology/_utils.py] [start of new definitions in astropy/cosmology/parameter/_descriptors.py] (definition of ParametersAttribute:) class ParametersAttribute: """Immutable mapping of the Parameters. If accessed from the class, this returns a mapping of the Parameter objects themselves. If accessed from an instance, this returns a mapping of the values of the Parameters.""" (definition of ParametersAttribute.__set_name__:) def __set_name__(self, owner: type[Cosmology], name: str) -> None: (definition of ParametersAttribute.__get__:) def __get__( self, instance: Cosmology \| None, owner: type[Cosmology] \| None ) -> MappingProxyType[str, Any]: (definition of ParametersAttribute.__set__:) def __set__(self, instance: Any, value: Any) -> NoReturn: [end of new definitions in astropy/cosmology/parameter/_descriptors.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		32bd0ffb6898c6a57b9ec1a55c13c7a0efe8d273
softlayer__softlayer-python-2073	2,073	softlayer/softlayer-python	null	fe65dc3e4978e1497f242e0318ed6d43f6659b0b	2023-08-10T07:29:02Z	diff --git a/SoftLayer/CLI/routes.py b/SoftLayer/CLI/routes.py index 54c1deaad..dbaf1cfe0 100644 --- a/SoftLayer/CLI/routes.py +++ b/SoftLayer/CLI/routes.py @@ -403,6 +403,8 @@ ('user:device-access', 'SoftLayer.CLI.user.device_access:cli'), ('user:vpn-manual', 'SoftLayer.CLI.user.vpn_manual:cli'), ('user:vpn-subnet', 'SoftLayer.CLI.user.vpn_subnet:cli'), + ('user:vpn-enable', 'SoftLayer.CLI.user.vpn_enable_or_disable:vpn_enable'), + ('user:vpn-disable', 'SoftLayer.CLI.user.vpn_enable_or_disable:vpn_disable'), ('user:remove-access', 'SoftLayer.CLI.user.remove_access:cli'), ('user:grant-access', 'SoftLayer.CLI.user.grant_access:cli'), ('user:vpn-password', 'SoftLayer.CLI.user.vpn_password:cli'), diff --git a/SoftLayer/CLI/user/vpn_enable_or_disable.py b/SoftLayer/CLI/user/vpn_enable_or_disable.py new file mode 100644 index 000000000..2e8216d26 --- /dev/null +++ b/SoftLayer/CLI/user/vpn_enable_or_disable.py @@ -0,0 +1,49 @@ +"""Enable or Disable vpn for a user.""" +# :license: MIT, see LICENSE for more details. + + +import click + +import SoftLayer +from SoftLayer.CLI import environment +from SoftLayer.CLI import helpers + + +@click.command(cls=SoftLayer.CLI.command.SLCommand, ) +@click.argument('user') +@environment.pass_env +def vpn_enable(env, user): + """Enable vpn for a user. + + Example:: + slcli user vpn-enable 1234567 + """ + + mgr = SoftLayer.UserManager(env.client) + user_id = helpers.resolve_id(mgr.resolve_ids, user, 'username') + + result = mgr.vpn_enable_or_disable(user_id, True) + message = f"{user} vpn is successfully enabled" + + if result: + click.secho(message, fg='green') + + +@click.command(cls=SoftLayer.CLI.command.SLCommand, ) +@click.argument('user') +@environment.pass_env +def vpn_disable(env, user): + """Disable vpn for a user. + + Example:: + slcli user vpn-disable 1234567 + """ + + mgr = SoftLayer.UserManager(env.client) + user_id = helpers.resolve_id(mgr.resolve_ids, user, 'username') + + result = mgr.vpn_enable_or_disable(user_id, False) + message = f"{user} vpn is successfully disabled" + + if result: + click.secho(message, fg='green') diff --git a/SoftLayer/managers/user.py b/SoftLayer/managers/user.py index 6682c0cf5..cafdf1b8f 100644 --- a/SoftLayer/managers/user.py +++ b/SoftLayer/managers/user.py @@ -361,6 +361,17 @@ def vpn_manual(self, user_id, value): user_object = {'vpnManualConfig': value} return self.edit_user(user_id, user_object) + def vpn_enable_or_disable(self, user_id, value): + """Enable or Disable vpn for a user. + + :param int user_id: User to edit. + :param bool value: Value for vpn enable flag. + or + :param bool value: Value for vpn disable flag. + """ + user_object = {'sslVpnAllowedFlag': value} + return self.edit_user(user_id, user_object) + def vpn_subnet_add(self, user_id, subnet_ids): """Add subnets for a user. diff --git a/docs/cli/users.rst b/docs/cli/users.rst index e3d45bb1d..af86b4a94 100644 --- a/docs/cli/users.rst +++ b/docs/cli/users.rst @@ -64,6 +64,14 @@ Version 5.6.0 introduces the ability to interact with user accounts from the cli :prog: user vpn-password :show-nested: +.. click:: SoftLayer.CLI.user.vpn_enable_or_disable:vpn_enable + :prog: user vpn-enable + :show-nested: + +.. click:: SoftLayer.CLI.user.vpn_enable_or_disable:vpn_disable + :prog: user vpn-disable + :show-nested: + .. click:: SoftLayer.CLI.user.apikey:cli :prog: user apikey :show-nested:	diff --git a/tests/CLI/modules/user_tests.py b/tests/CLI/modules/user_tests.py index 02956e682..804c9ef1d 100644 --- a/tests/CLI/modules/user_tests.py +++ b/tests/CLI/modules/user_tests.py @@ -8,10 +8,9 @@ import sys import unittest -from unittest import mock as mock - from SoftLayer.fixtures import SoftLayer_User_Customer from SoftLayer import testing +from unittest import mock as mock class UserCLITests(testing.TestCase): @@ -416,3 +415,27 @@ def test_remove_api_authentication_key(self): def test_refresh_api_authentication_key(self): result = self.run_command(['user', 'apikey', '123456', '--refresh']) self.assert_no_fail(result) + + def test_vpn_disable(self): + result = self.run_command(['user', 'vpn-disable', '8344458']) + self.assert_no_fail(result) + self.assert_called_with('SoftLayer_User_Customer', 'editObject', identifier=8344458) + + result = self.run_command(['user', 'vpn-disable', '8344458']) + permission_m = self.set_mock('SoftLayer_User_Customer', 'editObject') + permission_m.return_value = {'sslVpnAllowedFlag': False} + self.assert_no_fail(result) + self.assert_called_with('SoftLayer_User_Customer', 'editObject', identifier=8344458) + self.assertEqual('8344458 vpn is successfully disabled\n', result.output) + + def test_vpn_enable(self): + result = self.run_command(['user', 'vpn-enable', '8344458']) + self.assert_no_fail(result) + self.assert_called_with('SoftLayer_User_Customer', 'editObject', identifier=8344458) + + result = self.run_command(['user', 'vpn-enable', '8344458']) + permission_m = self.set_mock('SoftLayer_User_Customer', 'editObject') + permission_m.return_value = {'sslVpnAllowedFlag': True} + self.assert_no_fail(result) + self.assert_called_with('SoftLayer_User_Customer', 'editObject', identifier=8344458) + self.assertEqual('8344458 vpn is successfully enabled\n', result.output)	diff --git a/docs/cli/users.rst b/docs/cli/users.rst index e3d45bb1d..af86b4a94 100644 --- a/docs/cli/users.rst +++ b/docs/cli/users.rst @@ -64,6 +64,14 @@ Version 5.6.0 introduces the ability to interact with user accounts from the cli :prog: user vpn-password :show-nested: +.. click:: SoftLayer.CLI.user.vpn_enable_or_disable:vpn_enable + :prog: user vpn-enable + :show-nested: + +.. click:: SoftLayer.CLI.user.vpn_enable_or_disable:vpn_disable + :prog: user vpn-disable + :show-nested: + .. click:: SoftLayer.CLI.user.apikey:cli :prog: user apikey :show-nested:	[ { "components": [ { "doc": "Enable vpn for a user.\n\nExample::\n slcli user vpn-enable 1234567", "lines": [ 15, 29 ], "name": "vpn_enable", "signature": "def vpn_enable(env, user):", "type": "function" }, { "doc": ...	[ "tests/CLI/modules/user_tests.py::UserCLITests::test_vpn_disable", "tests/CLI/modules/user_tests.py::UserCLITests::test_vpn_enable" ]	[ "tests/CLI/modules/user_tests.py::UserCLITests::test_add_api_authentication_key", "tests/CLI/modules/user_tests.py::UserCLITests::test_api_key_with_all_option", "tests/CLI/modules/user_tests.py::UserCLITests::test_api_key_without_option", "tests/CLI/modules/user_tests.py::UserCLITests::test_create_user", "t...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added new slcli user vpn-disable and slcli user vpn-enable command Hi @allmightyspiff, Fixes: #2069 Title: new slcli user vpn-enable command Description: I have added new features `slcli user vpn-disable` and `slcli user vpn-enable` commands. I have tested it. Please review it. Please find the screen shots. Screen Shot: 1 <img width="745" alt="Screenshot 2023-08-09 at 8 21 07 PM" src="https://github.com/softlayer/softlayer-python/assets/125332006/48023c35-3ad1-4985-8236-2b326e66916b"> Screen Shot: 2 <img width="678" alt="Screenshot 2023-08-09 at 8 22 33 PM" src="https://github.com/softlayer/softlayer-python/assets/125332006/a45bc21d-8cef-487c-87ba-b23be82628f6"> Thanks, Ramkishor Chaladi. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in SoftLayer/CLI/user/vpn_enable_or_disable.py] (definition of vpn_enable:) def vpn_enable(env, user): """Enable vpn for a user. Example:: slcli user vpn-enable 1234567""" (definition of vpn_disable:) def vpn_disable(env, user): """Disable vpn for a user. Example:: slcli user vpn-disable 1234567""" [end of new definitions in SoftLayer/CLI/user/vpn_enable_or_disable.py] [start of new definitions in SoftLayer/managers/user.py] (definition of UserManager.vpn_enable_or_disable:) def vpn_enable_or_disable(self, user_id, value): """Enable or Disable vpn for a user. :param int user_id: User to edit. :param bool value: Value for vpn enable flag. or :param bool value: Value for vpn disable flag.""" [end of new definitions in SoftLayer/managers/user.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		bd1ecce1ec4313b9ceefd3cfea52d1b9274fef9d
sqlfluff__sqlfluff-5076	5,076	sqlfluff/sqlfluff	2.1	cd52dcaaf570b3a36edce2bccefcb032d5abc47c	2023-08-09T13:24:59Z	diff --git a/src/sqlfluff/core/parser/grammar/sequence.py b/src/sqlfluff/core/parser/grammar/sequence.py index 9ca26b757e2..0c5f0d3214f 100644 --- a/src/sqlfluff/core/parser/grammar/sequence.py +++ b/src/sqlfluff/core/parser/grammar/sequence.py @@ -230,7 +230,7 @@ def match(self, segments, parse_context: ParseContext) -> MatchResult: # If we get to here, we've matched all of the elements (or skipped them) # but still have some segments left (or perhaps have precisely zero left). # In either case, we're golden. Return successfully, with any leftovers as - # the unmatched elements. Meta all go at the end regardless of wny trailing + # the unmatched elements. Meta all go at the end regardless of any trailing # whitespace. return MatchResult( diff --git a/src/sqlfluff/core/parser/segments/base.py b/src/sqlfluff/core/parser/segments/base.py index 99bb434782a..d9064d749dd 100644 --- a/src/sqlfluff/core/parser/segments/base.py +++ b/src/sqlfluff/core/parser/segments/base.py @@ -7,53 +7,49 @@ function failed on this block of segments and to prevent further analysis. """ +# Import annotations for py 3.7 to allow `weakref.ReferenceType["BaseSegment"]` +from __future__ import annotations +import logging +import weakref from collections import defaultdict from collections.abc import MutableSet -from copy import deepcopy, copy +from copy import copy, deepcopy from dataclasses import dataclass, field, replace from io import StringIO from itertools import chain from typing import ( + TYPE_CHECKING, Any, Callable, - cast, ClassVar, Dict, - Optional, - List, - Tuple, Iterator, + List, + Optional, Set, - TYPE_CHECKING, + Tuple, + cast, ) -import logging from uuid import UUID, uuid4 from tqdm import tqdm from sqlfluff.core.cached_property import cached_property from sqlfluff.core.config import progress_bar_configuration -from sqlfluff.core.string_helpers import ( - frame_msg, - curtail_string, -) - -from sqlfluff.core.parser.match_result import MatchResult +from sqlfluff.core.parser.context import ParseContext +from sqlfluff.core.parser.helpers import check_still_complete, trim_non_code_segments +from sqlfluff.core.parser.markers import PositionMarker from sqlfluff.core.parser.match_logging import parse_match_logging +from sqlfluff.core.parser.match_result import MatchResult from sqlfluff.core.parser.match_wrapper import match_wrapper -from sqlfluff.core.parser.helpers import ( - check_still_complete, - trim_non_code_segments, -) from sqlfluff.core.parser.matchable import Matchable -from sqlfluff.core.parser.markers import PositionMarker -from sqlfluff.core.parser.context import ParseContext +from sqlfluff.core.string_helpers import curtail_string, frame_msg from sqlfluff.core.templaters.base import TemplatedFile if TYPE_CHECKING: # pragma: no cover - from sqlfluff.core.rules import LintFix from sqlfluff.core.parser.segments import RawSegment + from sqlfluff.core.rules import LintFix # Instantiate the linter logger (only for use in methods involved with fixing.) linter_logger = logging.getLogger("sqlfluff.linter") @@ -263,6 +259,8 @@ class BaseSegment(metaclass=SegmentMetaclass): _cache_key: str # _preface_modifier used in ._preface() _preface_modifier: str = "" + # Optional reference to the parent. Stored as a weakref. + _parent: Optional[weakref.ReferenceType["BaseSegment"]] = None def __init__( self, @@ -304,6 +302,11 @@ def __setattr__(self, key, value) -> None: def __eq__(self, other): # NB: this should also work for RawSegment + if not isinstance(other, BaseSegment): + return False # pragma: no cover + # If the uuids match, then we can easily return early. + if self.uuid == other.uuid: + return True return ( # Same class NAME. (could be constructed elsewhere) self.__class__.__name__ == other.__class__.__name__ @@ -332,6 +335,18 @@ def __hash__(self) -> int: def __repr__(self) -> str: return f"<{self.__class__.__name__}: ({self.pos_marker})>" + def __getstate__(self): + s = self.__dict__.copy() + # Kill the parent ref. It won't pickle well. + s["_parent"] = None + return s + + def __setstate__(self, state): + self.__dict__ = state.copy() + # Once state is ingested - repopulate, NOT recursing. + # Child segments will do it for themselves on unpickling. + self.set_as_parent(recurse=False) + # ################ PRIVATE PROPERTIES @property @@ -372,6 +387,14 @@ def is_code(self) -> bool: """Return True if this segment contains any code.""" return any(seg.is_code for seg in self.segments) + @cached_property + def _code_indices(self) -> Tuple[int, ...]: + """The indices of code elements. + + This is used in the path_to algorithm for tree traversal. + """ + return tuple(idx for idx, seg in enumerate(self.segments) if seg.is_code) + @cached_property def is_comment(self) -> bool: # pragma: no cover TODO? """Return True if this is entirely made of comments.""" @@ -827,8 +850,9 @@ def _recalculate_caches(self) -> None: "first_non_whitespace_segment_raw_upper", "source_fixes", "full_type_set", - "descendant_type_set ", - "direct_descendant_type_set ", + "descendant_type_set", + "direct_descendant_type_set", + "_code_indices", ]: self.__dict__.pop(key, None) @@ -849,6 +873,42 @@ def _preface(self, ident, tabsize) -> str: # ################ PUBLIC INSTANCE METHODS + def set_as_parent(self, recurse=True) -> None: + """Set this segment as parent for child all segments.""" + for seg in self.segments: + seg.set_parent(self) + # Recurse if not disabled + if recurse: + seg.set_as_parent(recurse=recurse) + + def set_parent(self, parent: "BaseSegment") -> None: + """Set the weak reference to the parent. + + NOTE: Don't validate on set, because we might not have fully + initialised the parent yet (because we call this method during + the instantiation of the parent). + """ + self._parent = weakref.ref(parent) + + def get_parent(self) -> Optional["BaseSegment"]: + """Get the parent segment, with some validation. + + This is provided as a performance optimisation when searching + through the syntax tree. Any methods which depend on this should + have an alternative way of assessing position, and ideally also + set the parent of any segments found without them. + + NOTE: We only store a weak reference to the parent so it might + not be present. We also validate here that it's _still_ the parent + and potentially also return None if those checks fail. + """ + if not self._parent: + return None + _parent = self._parent() + if not _parent or self not in _parent.segments: + return None + return _parent + def get_type(self) -> str: """Returns the type of this segment as a string.""" return self.type @@ -1119,32 +1179,72 @@ def path_to(self, other: "BaseSegment") -> List[PathStep]: Technically this could be seen as a "half open interval" of the path between two segments: in that it includes the root segment, but not the leaf. + + We first use any existing parent references to work upward, and then if that + doesn't take us far enough we fill in from the top (setting any missing + references as we go). This tries to be as efficient in that process as + possible. """ # Return empty if they are the same segment. if self is other: return [] # pragma: no cover + # Do we have any child segments at all? + if not self.segments: + return [] + + # Identifying the highest parent we can using any preset parent values. + midpoint = other + lower_path = [] + while True: + _higher = midpoint.get_parent() + # If we've run out of parents, stop for now. + if not _higher: + break + lower_path.append( + PathStep( + _higher, + _higher.segments.index(midpoint), + len(_higher.segments), + _higher._code_indices, + ) + ) + midpoint = _higher + # If we're found the target segment we can also stop. + if midpoint == self: + break + + # Reverse the path so far + lower_path.reverse() + + # Have we already found the parent? + if midpoint == self: + return lower_path + # Have we gone all the way up to the file segment? + elif isinstance(midpoint, BaseFileSegment): + return [] # pragma: no cover # Are we in the right ballpark? # NOTE: Comparisons have a higher precedence than `not`. - if not self.get_start_loc() <= other.get_start_loc() <= self.get_end_loc(): + elif not self.get_start_loc() <= midpoint.get_start_loc() <= self.get_end_loc(): return [] - # Do we have any child segments at all? - if not self.segments: - return [] + # From here, we've worked "up" as far as we can, we now work "down". + # When working down, we only need to go as far as the `midpoint`. - # Check code idxs - code_idxs = tuple(idx for idx, seg in enumerate(self.segments) if seg.is_code) # Check through each of the child segments for idx, seg in enumerate(self.segments): - step = PathStep(self, idx, len(self.segments), code_idxs) + # Set the parent if it's not already set. + seg.set_parent(self) + # Build the step. + step = PathStep(self, idx, len(self.segments), self._code_indices) # Have we found the target? - if seg is other: - return [step] + # NOTE: Check for _equality_ not _identity_ here as that's most reliable. + if seg == midpoint: + return [step] + lower_path # Is there a path to the target? - res = seg.path_to(other) + res = seg.path_to(midpoint) if res: - return [step] + res + return [step] + res + lower_path # Not found. return [] # pragma: no cover @@ -1249,13 +1349,15 @@ def parse( parse_context.parse_depth + 1, self.__class__.__name__, self.stringify() ) ) - parse_context.logger.debug(parse_depth_msg) with parse_context.deeper_parse(name=self.__class__.__name__) as ctx: self.segments = self.expand( self.segments, parse_context=ctx, ) + # Once parsed, populate any parent relationships. + for _seg in self.segments: + _seg.set_as_parent() return (self,) @@ -1338,6 +1440,7 @@ def apply_fixes( # of a create_before/create_after pair, also add # this segment before the edit. seg_buffer.append(seg) + seg.set_parent(self) # We're doing a replacement (it could be a single # segment or an iterable) @@ -1345,6 +1448,7 @@ def apply_fixes( consumed_pos = False for s in f.edit: seg_buffer.append(s) + s.set_parent(self) # If one of them has the same raw representation # then the first that matches gets to take the # original position marker. @@ -1360,6 +1464,7 @@ def apply_fixes( # in the case of a creation before, also add this # segment on the end seg_buffer.append(seg) + seg.set_parent(self) else: # pragma: no cover raise ValueError( @@ -1369,6 +1474,7 @@ def apply_fixes( ) else: seg_buffer.append(seg) + seg.set_parent(self) # Invalidate any caches self.invalidate_caches()	diff --git a/test/core/parser/segments/__init__.py b/test/core/parser/segments/__init__.py new file mode 100644 index 00000000000..47449fecad1 --- /dev/null +++ b/test/core/parser/segments/__init__.py @@ -0,0 +1,1 @@ +"""Tests for the segments module.""" diff --git a/test/core/parser/segments/conftest.py b/test/core/parser/segments/conftest.py new file mode 100644 index 00000000000..79c53271efd --- /dev/null +++ b/test/core/parser/segments/conftest.py @@ -0,0 +1,41 @@ +"""Common fixtures for segment tests.""" + +import pytest + +from sqlfluff.core.parser import BaseSegment + + +@pytest.fixture(scope="module") +def raw_seg_list(generate_test_segments): + """Construct a list of raw segments as a fixture.""" + return generate_test_segments(["foobar", ".barfoo"]) + + +@pytest.fixture(scope="module") +def raw_seg(raw_seg_list): + """Construct a raw segment as a fixture.""" + return raw_seg_list[0] + + +@pytest.fixture(scope="session") +def DummySegment(): + """Construct a raw segment as a fixture.""" + + class DummySegment(BaseSegment): + """A dummy segment for testing with no grammar.""" + + type = "dummy" + + return DummySegment + + +@pytest.fixture(scope="session") +def DummyAuxSegment(): + """Construct a raw segment as a fixture.""" + + class DummyAuxSegment(BaseSegment): + """A different dummy segment for testing with no grammar.""" + + type = "dummy_aux" + + return DummyAuxSegment diff --git a/test/core/parser/segments_base_test.py b/test/core/parser/segments/segments_base_test.py similarity index 75% rename from test/core/parser/segments_base_test.py rename to test/core/parser/segments/segments_base_test.py index d34a882d873..549fafae84d 100644 --- a/test/core/parser/segments_base_test.py +++ b/test/core/parser/segments/segments_base_test.py @@ -1,44 +1,17 @@ -"""The Test file for The New Parser (Base Segment Classes).""" +"""Test the BaseSegment class.""" + +import pickle import pytest -from sqlfluff.core.parser import ( - PositionMarker, - RawSegment, - BaseSegment, - BaseFileSegment, -) -from sqlfluff.core.parser.segments.base import PathStep -from sqlfluff.core.templaters import TemplatedFile +from sqlfluff.core.parser import BaseSegment, PositionMarker, RawSegment from sqlfluff.core.parser.context import ParseContext +from sqlfluff.core.parser.segments.base import PathStep from sqlfluff.core.rules.base import LintFix +from sqlfluff.core.templaters import TemplatedFile -@pytest.fixture(scope="module") -def raw_seg_list(generate_test_segments): - """Construct a list of raw segments as a fixture.""" - return generate_test_segments(["foobar", ".barfoo"]) - - -@pytest.fixture(scope="module") -def raw_seg(raw_seg_list): - """Construct a raw segment as a fixture.""" - return raw_seg_list[0] - - -class DummySegment(BaseSegment): - """A dummy segment for testing with no grammar.""" - - type = "dummy" - - -class DummyAuxSegment(BaseSegment): - """A different dummy segment for testing with no grammar.""" - - type = "dummy_aux" - - -def test__parser__base_segments_type(): +def test__parser__base_segments_type(DummySegment): """Test the .is_type() method.""" assert BaseSegment.class_is_type("base") assert not BaseSegment.class_is_type("foo") @@ -48,24 +21,30 @@ def test__parser__base_segments_type(): assert DummySegment.class_is_type("base", "foo", "bar") -def test__parser__base_segments_class_types(): +def test__parser__base_segments_class_types(DummySegment): """Test the metaclass ._class_types attribute.""" assert DummySegment._class_types == {"dummy", "base"} -def test__parser__base_segments_descendant_type_set(raw_seg_list): +def test__parser__base_segments_descendant_type_set( + raw_seg_list, DummySegment, DummyAuxSegment +): """Test the .descendant_type_set() method.""" test_seg = DummySegment([DummyAuxSegment(raw_seg_list)]) assert test_seg.descendant_type_set == {"raw", "base", "dummy_aux"} -def test__parser__base_segments_direct_descendant_type_set(raw_seg_list): +def test__parser__base_segments_direct_descendant_type_set( + raw_seg_list, DummySegment, DummyAuxSegment +): """Test the .direct_descendant_type_set() method.""" test_seg = DummySegment([DummyAuxSegment(raw_seg_list)]) assert test_seg.direct_descendant_type_set == {"base", "dummy_aux"} -def test__parser__base_segments_count_segments(raw_seg_list): +def test__parser__base_segments_count_segments( + raw_seg_list, DummySegment, DummyAuxSegment +): """Test the .count_segments() method.""" test_seg = DummySegment([DummyAuxSegment(raw_seg_list)]) assert test_seg.count_segments() == 4 @@ -122,7 +101,7 @@ def test__parser_base_segments_compute_anchor_edit_info(raw_seg_list): ) -def test__parser__base_segments_path_to(raw_seg_list): +def test__parser__base_segments_path_to(raw_seg_list, DummySegment, DummyAuxSegment): """Test the .path_to() method.""" test_seg_a = DummyAuxSegment(raw_seg_list) test_seg_b = DummySegment([test_seg_a]) @@ -170,7 +149,7 @@ def test__parser__base_segments_raw(raw_seg): assert raw_seg.to_tuple(show_raw=True) == ("raw", "foobar") -def test__parser__base_segments_base(raw_seg_list, fresh_ansi_dialect): +def test__parser__base_segments_base(raw_seg_list, fresh_ansi_dialect, DummySegment): """Test base segments behave as expected.""" base_seg = DummySegment(raw_seg_list) # Check we assume the position correctly @@ -212,7 +191,7 @@ def test__parser__base_segments_raw_compare(): assert rs1 == rs2 -def test__parser__base_segments_base_compare(): +def test__parser__base_segments_base_compare(DummySegment, DummyAuxSegment): """Test comparison of base segments.""" template = TemplatedFile.from_string("foobar") rs1 = RawSegment("foobar", PositionMarker(slice(0, 6), slice(0, 6), template)) @@ -228,35 +207,12 @@ def test__parser__base_segments_base_compare(): assert ds1 != dsa2 -def test__parser__base_segments_file(raw_seg_list): - """Test BaseFileSegment to behave as expected.""" - base_seg = BaseFileSegment(raw_seg_list, fname="/some/dir/file.sql") - assert base_seg.type == "file" - assert base_seg.file_path == "/some/dir/file.sql" - assert base_seg.can_start_end_non_code - assert base_seg.allow_empty - - -def test__parser__raw_get_raw_segments(raw_seg_list): - """Test niche case of calling get_raw_segments on a raw segment.""" - for s in raw_seg_list: - assert s.get_raw_segments() == [s] - - -def test__parser__raw_segments_with_ancestors(raw_seg_list): - """Test raw_segments_with_ancestors. - - This is used in the reflow module to assess parse depth. - """ - test_seg = DummySegment([DummyAuxSegment(raw_seg_list[:1]), raw_seg_list[1]]) - # Result should be the same raw segment, but with appropriate parents - assert test_seg.raw_segments_with_ancestors == [ - ( - raw_seg_list[0], - [ - PathStep(test_seg, 0, 2, (0, 1)), - PathStep(test_seg.segments[0], 0, 1, (0,)), - ], - ), - (raw_seg_list[1], [PathStep(test_seg, 1, 2, (0, 1))]), - ] +def test__parser__base_segments_pickle_safe(raw_seg_list): + """Test pickling and unpickling of BaseSegment.""" + test_seg = BaseSegment([BaseSegment(raw_seg_list)]) + test_seg.set_as_parent() + pickled = pickle.dumps(test_seg) + result_seg = pickle.loads(pickled) + assert test_seg == result_seg + # Check specifically the treatment of the parent position. + assert result_seg.segments[0].get_parent() is result_seg diff --git a/test/core/parser/segments_common_test.py b/test/core/parser/segments/segments_common_test.py similarity index 96% rename from test/core/parser/segments_common_test.py rename to test/core/parser/segments/segments_common_test.py index 5fc71cb316d..272c4cf7fab 100644 --- a/test/core/parser/segments_common_test.py +++ b/test/core/parser/segments/segments_common_test.py @@ -1,4 +1,4 @@ -"""The Test file for The New Parser (Marker Classes).""" +"""Test the KeywordSegment and EphemeralSegment classes.""" import pytest @@ -8,6 +8,7 @@ from sqlfluff.core.parser.segments.base import UnparsableSegment +# NOTE: For legacy reasons we override this fixture for this module @pytest.fixture(scope="module") def raw_seg_list(generate_test_segments): """A generic list of raw segments to test against.""" diff --git a/test/core/parser/segments/segments_file_test.py b/test/core/parser/segments/segments_file_test.py new file mode 100644 index 00000000000..789a1ee6f80 --- /dev/null +++ b/test/core/parser/segments/segments_file_test.py @@ -0,0 +1,20 @@ +"""Test the BaseFileSegment class.""" + +import pytest + +from sqlfluff.core.parser import BaseFileSegment + + +@pytest.fixture(scope="module") +def raw_seg_list(generate_test_segments): + """Construct a list of raw segments as a fixture.""" + return generate_test_segments(["foobar", ".barfoo"]) + + +def test__parser__base_segments_file(raw_seg_list): + """Test BaseFileSegment to behave as expected.""" + base_seg = BaseFileSegment(raw_seg_list, fname="/some/dir/file.sql") + assert base_seg.type == "file" + assert base_seg.file_path == "/some/dir/file.sql" + assert base_seg.can_start_end_non_code + assert base_seg.allow_empty diff --git a/test/core/parser/segments/segments_raw_test.py b/test/core/parser/segments/segments_raw_test.py new file mode 100644 index 00000000000..d20369af2b6 --- /dev/null +++ b/test/core/parser/segments/segments_raw_test.py @@ -0,0 +1,30 @@ +"""Test the RawSegment class.""" + +from sqlfluff.core.parser.segments.base import PathStep + + +def test__parser__raw_get_raw_segments(raw_seg_list): + """Test niche case of calling get_raw_segments on a raw segment.""" + for s in raw_seg_list: + assert s.get_raw_segments() == [s] + + +def test__parser__raw_segments_with_ancestors( + raw_seg_list, DummySegment, DummyAuxSegment +): + """Test raw_segments_with_ancestors. + + This is used in the reflow module to assess parse depth. + """ + test_seg = DummySegment([DummyAuxSegment(raw_seg_list[:1]), raw_seg_list[1]]) + # Result should be the same raw segment, but with appropriate parents + assert test_seg.raw_segments_with_ancestors == [ + ( + raw_seg_list[0], + [ + PathStep(test_seg, 0, 2, (0, 1)), + PathStep(test_seg.segments[0], 0, 1, (0,)), + ], + ), + (raw_seg_list[1], [PathStep(test_seg, 1, 2, (0, 1))]), + ]		[ { "components": [ { "doc": "", "lines": [ 338, 342 ], "name": "BaseSegment.__getstate__", "signature": "def __getstate__(self):", "type": "function" }, { "doc": "", "lines": [ 344, 348 ...	[ "test/core/parser/segments/segments_base_test.py::test__parser__base_segments_pickle_safe" ]	[ "test/core/parser/segments/segments_base_test.py::test__parser__base_segments_type", "test/core/parser/segments/segments_base_test.py::test__parser__base_segments_class_types", "test/core/parser/segments/segments_base_test.py::test__parser__base_segments_descendant_type_set", "test/core/parser/segments/segmen...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Parent references and more efficient path_to @WittierDinosaur has been suggesting that segments should maintain a reference to their parent for a while. This PR implements that. I found during some performance investigations on the most recent release that some rules take disproportionately longer than others. Especially RF01, and most of that time was spent in `path_to`. The lack of a reference to the parent means that the algorithm used for searching here was especially slow. This introduces a `weakref` to the parent segment on `BaseSegment`. It's not populated on instantiation (because that proved difficult) and also includes a bit of validation on read because we definitely move segments around and there's a risk that the parent reference becomes out of date. That parent reference can then be used to speed up the `path_to` method and in my testing on some large files, this roughly halves the runtime of RF01, AL04, AL05 & AM04 🚀 (which are also some of the currently slowest rules). This same functionality should enable some speedups in the reflow libraries too, but I'll handle that in a second PR (currently this doesn't show a significant gain there). In the process, I also added a new pickle test for segments (similar to the ones done for errors), and that triggered me to break apart the segment tests into smaller file. The only change to the test suite is that new test - otherwise it's the same tests, just in smaller files (similar to #5078). ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/sqlfluff/core/parser/segments/base.py] (definition of BaseSegment.__getstate__:) def __getstate__(self): (definition of BaseSegment.__setstate__:) def __setstate__(self, state): (definition of BaseSegment._code_indices:) def _code_indices(self) -> Tuple[int, ...]: """The indices of code elements. This is used in the path_to algorithm for tree traversal.""" (definition of BaseSegment.set_as_parent:) def set_as_parent(self, recurse=True) -> None: """Set this segment as parent for child all segments.""" (definition of BaseSegment.set_parent:) def set_parent(self, parent: "BaseSegment") -> None: """Set the weak reference to the parent. NOTE: Don't validate on set, because we might not have fully initialised the parent yet (because we call this method during the instantiation of the parent).""" (definition of BaseSegment.get_parent:) def get_parent(self) -> Optional["BaseSegment"]: """Get the parent segment, with some validation. This is provided as a performance optimisation when searching through the syntax tree. Any methods which depend on this should have an alternative way of assessing position, and ideally also set the parent of any segments found without them. NOTE: We only store a weak reference to the parent so it might not be present. We also validate here that it's _still_ the parent and potentially also return None if those checks fail.""" [end of new definitions in src/sqlfluff/core/parser/segments/base.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		cd52dcaaf570b3a36edce2bccefcb032d5abc47c
tobymao__sqlglot-2006	2,006	tobymao/sqlglot	null	2a76eb8bcdf78c53f91f9e3f228dc6dad0223b03	2023-08-08T09:40:25Z	diff --git a/sqlglot/dialects/__init__.py b/sqlglot/dialects/__init__.py index fc342621ae..821266946b 100644 --- a/sqlglot/dialects/__init__.py +++ b/sqlglot/dialects/__init__.py @@ -60,6 +60,7 @@ class Generator(Generator): from sqlglot.dialects.clickhouse import ClickHouse from sqlglot.dialects.databricks import Databricks from sqlglot.dialects.dialect import Dialect, Dialects +from sqlglot.dialects.doris import Doris from sqlglot.dialects.drill import Drill from sqlglot.dialects.duckdb import DuckDB from sqlglot.dialects.hive import Hive diff --git a/sqlglot/dialects/dialect.py b/sqlglot/dialects/dialect.py index 1d0584c679..e73cfc8bd2 100644 --- a/sqlglot/dialects/dialect.py +++ b/sqlglot/dialects/dialect.py @@ -39,6 +39,7 @@ class Dialects(str, Enum): TERADATA = "teradata" TRINO = "trino" TSQL = "tsql" + Doris = "doris" class _Dialect(type): diff --git a/sqlglot/dialects/doris.py b/sqlglot/dialects/doris.py new file mode 100644 index 0000000000..50e18ad1f8 --- /dev/null +++ b/sqlglot/dialects/doris.py @@ -0,0 +1,105 @@ +from __future__ import annotations + +import typing as t + +from sqlglot import exp, generator +from sqlglot.dialects.dialect import ( + approx_count_distinct_sql, + arrow_json_extract_sql, + rename_func, +) +from sqlglot.dialects.mysql import MySQL +from sqlglot.helper import seq_get + + +def _to_date_sql(self: MySQL.Generator, expression: exp.TsOrDsToDate) -> str: + this = self.sql(expression, "this") + self.format_time(expression) + return f"TO_DATE({this})" + + +def _time_format( + self: generator.Generator, expression: exp.UnixToStr \| exp.StrToUnix +) -> t.Optional[str]: + time_format = self.format_time(expression) + if time_format == Doris.TIME_FORMAT: + return None + return time_format + + +class Doris(MySQL): + DATE_FORMAT = "'yyyy-MM-dd'" + DATEINT_FORMAT = "'yyyyMMdd'" + TIME_FORMAT = "'yyyy-MM-dd HH:mm:ss'" + + TIME_MAPPING = { + "%M": "%B", + "%m": "%%-M", + "%c": "%-m", + "%e": "%-d", + "%h": "%I", + "%S": "%S", + "%u": "%W", + "%k": "%-H", + "%l": "%-I", + "%W": "%a", + "%Y": "%Y", + "%d": "%%-d", + "%H": "%%-H", + "%s": "%%-S", + "%D": "%%-j", + "%a": "%%p", + "%y": "%%Y", + "%": "%%", + } + + class Parser(MySQL.Parser): + FUNCTIONS = { + MySQL.Parser.FUNCTIONS, + "DATE_TRUNC": lambda args: exp.TimestampTrunc( + this=seq_get(args, 1), unit=seq_get(args, 0) + ), + "REGEXP": exp.RegexpLike.from_arg_list, + } + + class Generator(MySQL.Generator): + CAST_MAPPING = {} + + TYPE_MAPPING = { + MySQL.Generator.TYPE_MAPPING, + exp.DataType.Type.TEXT: "STRING", + exp.DataType.Type.TIMESTAMP: "DATETIME", + exp.DataType.Type.TIMESTAMPTZ: "DATETIME", + } + + TRANSFORMS = { + *MySQL.Generator.TRANSFORMS, + exp.ApproxDistinct: approx_count_distinct_sql, + exp.ArrayAgg: rename_func("COLLECT_LIST"), + exp.Coalesce: rename_func("NVL"), + exp.CurrentTimestamp: lambda _: "NOW()", + exp.DateTrunc: lambda self, e: self.func( + "DATE_TRUNC", e.this, "'" + e.text("unit") + "'" + ), + exp.JSONExtractScalar: arrow_json_extract_sql, + exp.JSONExtract: arrow_json_extract_sql, + exp.RegexpLike: rename_func("REGEXP"), + exp.RegexpSplit: rename_func("SPLIT_BY_STRING"), + exp.SetAgg: rename_func("COLLECT_SET"), + exp.StrToUnix: lambda self, e: f"UNIX_TIMESTAMP({self.sql(e, 'this')}, {self.format_time(e)})", + exp.Split: rename_func("SPLIT_BY_STRING"), + exp.TimeStrToDate: rename_func("TO_DATE"), + exp.ToChar: lambda self, e: f"DATE_FORMAT({self.sql(e, 'this')}, {self.format_time(e)})", + exp.TsOrDsAdd: lambda self, e: f"DATE_ADD({self.sql(e, 'this')}, {self.sql(e, 'expression')})", # Only for day level + exp.TsOrDsToDate: lambda self, e: self.func("TO_DATE", e.this), + exp.TimeStrToUnix: rename_func("UNIX_TIMESTAMP"), + exp.TimeToUnix: rename_func("UNIX_TIMESTAMP"), + exp.TimestampTrunc: lambda self, e: self.func( + "DATE_TRUNC", e.this, "'" + e.text("unit") + "'" + ), + exp.UnixToStr: lambda self, e: self.func( + "FROM_UNIXTIME", e.this, _time_format(self, e) + ), + exp.UnixToTime: rename_func("FROM_UNIXTIME"), + exp.Map: rename_func("ARRAY_MAP"), + }	diff --git a/tests/dialects/test_dialect.py b/tests/dialects/test_dialect.py index aaaffab785..9873038f8f 100644 --- a/tests/dialects/test_dialect.py +++ b/tests/dialects/test_dialect.py @@ -90,6 +90,7 @@ def test_cast(self): "snowflake": "CAST(a AS TEXT)", "spark": "CAST(a AS STRING)", "starrocks": "CAST(a AS STRING)", + "doris": "CAST(a AS STRING)", }, ) self.validate_all( @@ -169,6 +170,7 @@ def test_cast(self): "snowflake": "CAST(a AS TEXT)", "spark": "CAST(a AS STRING)", "starrocks": "CAST(a AS STRING)", + "doris": "CAST(a AS STRING)", }, ) self.validate_all( @@ -186,6 +188,7 @@ def test_cast(self): "snowflake": "CAST(a AS VARCHAR)", "spark": "CAST(a AS STRING)", "starrocks": "CAST(a AS VARCHAR)", + "doris": "CAST(a AS VARCHAR)", }, ) self.validate_all( @@ -203,6 +206,7 @@ def test_cast(self): "snowflake": "CAST(a AS VARCHAR(3))", "spark": "CAST(a AS VARCHAR(3))", "starrocks": "CAST(a AS VARCHAR(3))", + "doris": "CAST(a AS VARCHAR(3))", }, ) self.validate_all( @@ -221,6 +225,7 @@ def test_cast(self): "spark": "CAST(a AS SMALLINT)", "sqlite": "CAST(a AS INTEGER)", "starrocks": "CAST(a AS SMALLINT)", + "doris": "CAST(a AS SMALLINT)", }, ) self.validate_all( @@ -234,6 +239,7 @@ def test_cast(self): "drill": "CAST(a AS DOUBLE)", "postgres": "CAST(a AS DOUBLE PRECISION)", "redshift": "CAST(a AS DOUBLE PRECISION)", + "doris": "CAST(a AS DOUBLE)", }, ) @@ -267,6 +273,7 @@ def test_cast(self): write={ "starrocks": "CAST(a AS DATETIME)", "redshift": "CAST(a AS TIMESTAMP)", + "doris": "CAST(a AS DATETIME)", }, ) self.validate_all( @@ -274,6 +281,7 @@ def test_cast(self): write={ "starrocks": "CAST(a AS DATETIME)", "redshift": "CAST(a AS TIMESTAMPTZ)", + "doris": "CAST(a AS DATETIME)", }, ) self.validate_all("CAST(a AS TINYINT)", write={"oracle": "CAST(a AS NUMBER)"}) @@ -408,6 +416,7 @@ def test_time(self): "hive": "UNIX_TIMESTAMP('2020-01-01', 'yyyy-mm-dd')", "presto": "TO_UNIXTIME(DATE_PARSE('2020-01-01', '%Y-%i-%d'))", "starrocks": "UNIX_TIMESTAMP('2020-01-01', '%Y-%i-%d')", + "doris": "UNIX_TIMESTAMP('2020-01-01', '%Y-%M-%d')", }, ) self.validate_all( @@ -418,6 +427,7 @@ def test_time(self): "hive": "TO_DATE('2020-01-01')", "presto": "CAST('2020-01-01' AS TIMESTAMP)", "starrocks": "TO_DATE('2020-01-01')", + "doris": "TO_DATE('2020-01-01')", }, ) self.validate_all( @@ -428,6 +438,7 @@ def test_time(self): "hive": "CAST('2020-01-01' AS TIMESTAMP)", "presto": "CAST('2020-01-01' AS TIMESTAMP)", "sqlite": "'2020-01-01'", + "doris": "CAST('2020-01-01' AS DATETIME)", }, ) self.validate_all( @@ -437,6 +448,7 @@ def test_time(self): "hive": "UNIX_TIMESTAMP('2020-01-01')", "mysql": "UNIX_TIMESTAMP('2020-01-01')", "presto": "TO_UNIXTIME(DATE_PARSE('2020-01-01', '%Y-%m-%d %T'))", + "doris": "UNIX_TIMESTAMP('2020-01-01')", }, ) self.validate_all( @@ -449,6 +461,7 @@ def test_time(self): "postgres": "TO_CHAR(x, 'YYYY-MM-DD')", "presto": "DATE_FORMAT(x, '%Y-%m-%d')", "redshift": "TO_CHAR(x, 'YYYY-MM-DD')", + "doris": "DATE_FORMAT(x, '%Y-%m-%d')", }, ) self.validate_all( @@ -459,6 +472,7 @@ def test_time(self): "hive": "CAST(x AS STRING)", "presto": "CAST(x AS VARCHAR)", "redshift": "CAST(x AS VARCHAR(MAX))", + "doris": "CAST(x AS STRING)", }, ) self.validate_all( @@ -468,6 +482,7 @@ def test_time(self): "duckdb": "EPOCH(x)", "hive": "UNIX_TIMESTAMP(x)", "presto": "TO_UNIXTIME(x)", + "doris": "UNIX_TIMESTAMP(x)", }, ) self.validate_all( @@ -476,6 +491,7 @@ def test_time(self): "duckdb": "SUBSTRING(CAST(x AS TEXT), 1, 10)", "hive": "SUBSTRING(CAST(x AS STRING), 1, 10)", "presto": "SUBSTRING(CAST(x AS VARCHAR), 1, 10)", + "doris": "SUBSTRING(CAST(x AS STRING), 1, 10)", }, ) self.validate_all( @@ -487,6 +503,7 @@ def test_time(self): "postgres": "CAST(x AS DATE)", "presto": "CAST(CAST(x AS TIMESTAMP) AS DATE)", "snowflake": "CAST(x AS DATE)", + "doris": "TO_DATE(x)", }, ) self.validate_all( @@ -505,6 +522,7 @@ def test_time(self): "hive": "FROM_UNIXTIME(x, y)", "presto": "DATE_FORMAT(FROM_UNIXTIME(x), y)", "starrocks": "FROM_UNIXTIME(x, y)", + "doris": "FROM_UNIXTIME(x, y)", }, ) self.validate_all( @@ -516,6 +534,7 @@ def test_time(self): "postgres": "TO_TIMESTAMP(x)", "presto": "FROM_UNIXTIME(x)", "starrocks": "FROM_UNIXTIME(x)", + "doris": "FROM_UNIXTIME(x)", }, ) self.validate_all( @@ -582,6 +601,7 @@ def test_time(self): "sqlite": "DATE(x, '1 DAY')", "starrocks": "DATE_ADD(x, INTERVAL 1 DAY)", "tsql": "DATEADD(DAY, 1, x)", + "doris": "DATE_ADD(x, INTERVAL 1 DAY)", }, ) self.validate_all( @@ -595,6 +615,7 @@ def test_time(self): "presto": "DATE_ADD('day', 1, x)", "spark": "DATE_ADD(x, 1)", "starrocks": "DATE_ADD(x, INTERVAL 1 DAY)", + "doris": "DATE_ADD(x, INTERVAL 1 DAY)", }, ) self.validate_all( @@ -612,6 +633,7 @@ def test_time(self): "snowflake": "DATE_TRUNC('day', x)", "starrocks": "DATE_TRUNC('day', x)", "spark": "TRUNC(x, 'day')", + "doris": "DATE_TRUNC(x, 'day')", }, ) self.validate_all( @@ -624,6 +646,7 @@ def test_time(self): "snowflake": "DATE_TRUNC('day', x)", "starrocks": "DATE_TRUNC('day', x)", "spark": "DATE_TRUNC('day', x)", + "doris": "DATE_TRUNC('day', x)", }, ) self.validate_all( @@ -684,6 +707,7 @@ def test_time(self): "snowflake": "DATE_TRUNC('year', x)", "starrocks": "DATE_TRUNC('year', x)", "spark": "TRUNC(x, 'year')", + "doris": "DATE_TRUNC(x, 'year')", }, ) self.validate_all( @@ -698,6 +722,7 @@ def test_time(self): write={ "bigquery": "TIMESTAMP_TRUNC(x, year)", "spark": "DATE_TRUNC('year', x)", + "doris": "DATE_TRUNC(x, 'year')", }, ) self.validate_all( @@ -719,6 +744,7 @@ def test_time(self): "hive": "CAST(FROM_UNIXTIME(UNIX_TIMESTAMP(x, 'yyyy-MM-ddTHH:mm:ss')) AS DATE)", "presto": "CAST(DATE_PARSE(x, '%Y-%m-%dT%T') AS DATE)", "spark": "TO_DATE(x, 'yyyy-MM-ddTHH:mm:ss')", + "doris": "STR_TO_DATE(x, '%Y-%m-%dT%H:%M:%S')", }, ) self.validate_all( @@ -730,6 +756,7 @@ def test_time(self): "hive": "CAST(x AS DATE)", "presto": "CAST(DATE_PARSE(x, '%Y-%m-%d') AS DATE)", "spark": "TO_DATE(x)", + "doris": "STR_TO_DATE(x, '%Y-%m-%d')", }, ) self.validate_all( @@ -784,6 +811,7 @@ def test_time(self): "mysql": "CAST('2022-01-01' AS TIMESTAMP)", "starrocks": "CAST('2022-01-01' AS DATETIME)", "hive": "CAST('2022-01-01' AS TIMESTAMP)", + "doris": "CAST('2022-01-01' AS DATETIME)", }, ) self.validate_all( @@ -792,6 +820,7 @@ def test_time(self): "mysql": "TIMESTAMP('2022-01-01')", "starrocks": "TIMESTAMP('2022-01-01')", "hive": "TIMESTAMP('2022-01-01')", + "doris": "TIMESTAMP('2022-01-01')", }, ) @@ -807,6 +836,7 @@ def test_time(self): "mysql", "presto", "starrocks", + "doris", ) }, write={ @@ -820,6 +850,7 @@ def test_time(self): "hive", "spark", "starrocks", + "doris", ) }, ) @@ -886,6 +917,7 @@ def test_json(self): "postgres": "x->'y'", "presto": "JSON_EXTRACT(x, 'y')", "starrocks": "x -> 'y'", + "doris": "x -> 'y'", }, write={ "mysql": "JSON_EXTRACT(x, 'y')", @@ -893,6 +925,7 @@ def test_json(self): "postgres": "x -> 'y'", "presto": "JSON_EXTRACT(x, 'y')", "starrocks": "x -> 'y'", + "doris": "x -> 'y'", }, ) self.validate_all( @@ -1115,6 +1148,7 @@ def test_operators(self): "sqlite": "LOWER(x) LIKE '%y'", "starrocks": "LOWER(x) LIKE '%y'", "trino": "LOWER(x) LIKE '%y'", + "doris": "LOWER(x) LIKE '%y'", }, ) self.validate_all( diff --git a/tests/dialects/test_doris.py b/tests/dialects/test_doris.py new file mode 100644 index 0000000000..63325a6b4d --- /dev/null +++ b/tests/dialects/test_doris.py @@ -0,0 +1,20 @@ +from tests.dialects.test_dialect import Validator + + +class TestDoris(Validator): + dialect = "doris" + + def test_identity(self): + self.validate_identity("SELECT CAST(`a`.`b` AS INT) FROM foo") + self.validate_identity("SELECT APPROX_COUNT_DISTINCT(a) FROM x") + + def test_time(self): + self.validate_identity("TIMESTAMP('2022-01-01')") + + def test_regex(self): + self.validate_all( + "SELECT REGEXP_LIKE(abc, '%foo%')", + write={ + "doris": "SELECT REGEXP(abc, '%foo%')", + }, + )		[]	[ "tests/dialects/test_dialect.py::TestDialect::test_cast", "tests/dialects/test_dialect.py::TestDialect::test_json", "tests/dialects/test_dialect.py::TestDialect::test_operators", "tests/dialects/test_dialect.py::TestDialect::test_time", "tests/dialects/test_doris.py::TestDoris::test_identity", "tests/dial...	[ "tests/dialects/test_dialect.py::TestDialect::test_alias", "tests/dialects/test_dialect.py::TestDialect::test_array", "tests/dialects/test_dialect.py::TestDialect::test_count_if", "tests/dialects/test_dialect.py::TestDialect::test_cross_join", "tests/dialects/test_dialect.py::TestDialect::test_decode", "t...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat: add apache doris dialect Implemented dialect support for Apache Doris ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		ceb42fabad60312699e4b15936aeebac00e22e4d
pvlib__pvlib-python-1827	1,827	pvlib/pvlib-python	0.9	ae848177c7cafae78e4a28a7f9871c29ac484f92	2023-08-03T20:49:37Z	diff --git a/docs/examples/reflections/plot_convert_iam_models.py b/docs/examples/reflections/plot_convert_iam_models.py new file mode 100644 index 0000000000..6b0ec78ab3 --- /dev/null +++ b/docs/examples/reflections/plot_convert_iam_models.py @@ -0,0 +1,162 @@ + +""" +IAM Model Conversion +==================== + +Illustrates how to convert from one IAM model to a different model using +:py:func:`~pvlib.iam.convert`. + +""" + +# %% +# An incidence angle modifier (IAM) model quantifies the fraction of direct +# irradiance that is reflected away from a module's surface. Three popular +# IAM models are Martin-Ruiz :py:func:`~pvlib.iam.martin_ruiz`, physical +# :py:func:`~pvlib.iam.physical`, and ASHRAE :py:func:`~pvlib.iam.ashrae`. +# Each model requires one or more parameters. +# +# Here, we show how to use +# :py:func:`~pvlib.iam.convert` to estimate parameters for a desired target +# IAM model from a source IAM model. Model conversion uses a weight +# function that can assign more influence to some AOI values than others. +# We illustrate how to provide a custom weight function to +# :py:func:`~pvlib.iam.convert`. + +import numpy as np +import matplotlib.pyplot as plt + +from pvlib.tools import cosd +from pvlib.iam import (ashrae, martin_ruiz, physical, convert) + +# %% +# Converting from one IAM model to another model +# ---------------------------------------------- +# +# Here we'll show how to convert from the Martin-Ruiz model to the +# physical and the ASHRAE models. + +# Compute IAM values using the martin_ruiz model. +aoi = np.linspace(0, 90, 100) +martin_ruiz_params = {'a_r': 0.16} +martin_ruiz_iam = martin_ruiz(aoi, martin_ruiz_params) + +# Get parameters for the physical model and compute IAM using these parameters. +physical_params = convert('martin_ruiz', martin_ruiz_params, 'physical') +physical_iam = physical(aoi, physical_params) + +# Get parameters for the ASHRAE model and compute IAM using these parameters. +ashrae_params = convert('martin_ruiz', martin_ruiz_params, 'ashrae') +ashrae_iam = ashrae(aoi, ashrae_params) + +fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(11, 5), sharey=True) + +# Plot each model's IAM vs. angle-of-incidence (AOI). +ax1.plot(aoi, martin_ruiz_iam, label='Martin-Ruiz') +ax1.plot(aoi, physical_iam, label='physical') +ax1.set_xlabel('AOI (degrees)') +ax1.set_title('Convert from Martin-Ruiz to physical') +ax1.legend() + +ax2.plot(aoi, martin_ruiz_iam, label='Martin-Ruiz') +ax2.plot(aoi, ashrae_iam, label='ASHRAE') +ax2.set_xlabel('AOI (degrees)') +ax2.set_title('Convert from Martin-Ruiz to ASHRAE') +ax2.legend() + +ax1.set_ylabel('IAM') +plt.show() + + +# %% +# The weight function +# ------------------- +# :py:func:`pvlib.iam.convert` uses a weight function when computing residuals +# between the two models. The default weight +# function is :math:`1 - \sin(aoi)`. We can instead pass a custom weight +# function to :py:func:`pvlib.iam.convert`. +# +# In some cases, the choice of weight function has a minimal effect on the +# returned model parameters. This is especially true when converting between +# the Martin-Ruiz and physical models, because the curves described by these +# models can match quite closely. However, when conversion involves the ASHRAE +# model, the choice of weight function can have a meaningful effect on the +# returned parameters for the target model. +# +# Here we'll show examples of both of these cases, starting with an example +# where the choice of weight function does not have much impact. In doing +# so, we'll show how to pass in a custom weight function of our choice. + +# Compute IAM using the Martin-Ruiz model. +aoi = np.linspace(0, 90, 100) +martin_ruiz_params = {'a_r': 0.16} +martin_ruiz_iam = martin_ruiz(aoi, martin_ruiz_params) + +# Get parameters for the physical model ... + +# ... using the default weight function. +physical_params_default = convert('martin_ruiz', martin_ruiz_params, + 'physical') +physical_iam_default = physical(aoi, physical_params_default) + + +# ... using a custom weight function. The weight function must take ``aoi`` +# as its argument and return a vector of the same length as ``aoi``. +def weight_function(aoi): + return cosd(aoi) + + +physical_params_custom = convert('martin_ruiz', martin_ruiz_params, 'physical', + weight=weight_function) +physical_iam_custom = physical(aoi, physical_params_custom) + +# Plot IAM vs AOI. +plt.plot(aoi, martin_ruiz_iam, label='Martin-Ruiz') +plt.plot(aoi, physical_iam_default, label='Default weight function') +plt.plot(aoi, physical_iam_custom, label='Custom weight function') +plt.xlabel('AOI (degrees)') +plt.ylabel('IAM') +plt.title('Martin-Ruiz to physical') +plt.legend() +plt.show() + +# %% +# For this choice of source and target models, the weight function has little +# effect on the target model's parameters. +# +# Now we'll look at an example where the weight function does affect the +# output. + +# Get parameters for the ASHRAE model ... + +# ... using the default weight function. +ashrae_params_default = convert('martin_ruiz', martin_ruiz_params, 'ashrae') +ashrae_iam_default = ashrae(aoi, ashrae_params_default) + +# ... using the custom weight function +ashrae_params_custom = convert('martin_ruiz', martin_ruiz_params, 'ashrae', + weight=weight_function) +ashrae_iam_custom = ashrae(aoi, ashrae_params_custom) + +# Plot IAM vs AOI. +plt.plot(aoi, martin_ruiz_iam, label='Martin-Ruiz') +plt.plot(aoi, ashrae_iam_default, label='Default weight function') +plt.plot(aoi, ashrae_iam_custom, label='Custom weight function') +plt.xlabel('AOI (degrees)') +plt.ylabel('IAM') +plt.title('Martin-Ruiz to ASHRAE') +plt.legend() +plt.show() + +# %% +# In this case, each of the two ASHRAE looks quite different. +# Finding the right weight function and parameters in such cases will require +# knowing where you want the target model to be more accurate. The default +# weight function was chosen because it yielded IAM models that produce +# similar annual insolation for a simulated PV system. + +# %% +# Reference +# --------- +# .. [1] Jones, A. R., Hansen, C. W., Anderson, K. S. Parameter estimation +# for incidence angle modifier models for photovoltaic modules. Sandia +# report SAND2023-13944 (2023). diff --git a/docs/examples/reflections/plot_fit_iam_models.py b/docs/examples/reflections/plot_fit_iam_models.py new file mode 100644 index 0000000000..6feb84423a --- /dev/null +++ b/docs/examples/reflections/plot_fit_iam_models.py @@ -0,0 +1,99 @@ + +""" +IAM Model Fitting +================================ + +Illustrates how to fit an IAM model to data using :py:func:`~pvlib.iam.fit`. + +""" + +# %% +# An incidence angle modifier (IAM) model quantifies the fraction of direct +# irradiance is that is reflected away from a module's surface. Three popular +# IAM models are Martin-Ruiz :py:func:`~pvlib.iam.martin_ruiz`, physical +# :py:func:`~pvlib.iam.physical`, and ASHRAE :py:func:`~pvlib.iam.ashrae`. +# Each model requires one or more parameters. +# +# Here, we show how to use +# :py:func:`~pvlib.iam.fit` to estimate a model's parameters from data. +# +# Model fitting require a weight function that can assign +# more influence to some AOI values than others. We illustrate how to provide +# a custom weight function to :py:func:`~pvlib.iam.fit`. + +import numpy as np +from random import uniform +import matplotlib.pyplot as plt + +from pvlib.tools import cosd +from pvlib.iam import (martin_ruiz, physical, fit) + + +# %% +# Fitting an IAM model to data +# ---------------------------- +# +# Here, we'll show how to fit an IAM model to data. +# We'll generate some data by perturbing output from the Martin-Ruiz model to +# mimic measured data and then we'll fit the physical model to the perturbed +# data. + +# Create some IAM data. +aoi = np.linspace(0, 85, 10) +params = {'a_r': 0.16} +iam = martin_ruiz(aoi, *params) +data = iam np.array([uniform(0.98, 1.02) for _ in range(len(iam))]) + +# Get parameters for the physical model by fitting to the perturbed data. +physical_params = fit(aoi, data, 'physical') + +# Compute IAM with the fitted physical model parameters. +physical_iam = physical(aoi, physical_params) + +# Plot IAM vs. AOI +plt.scatter(aoi, data, c='darkorange', label='Data') +plt.plot(aoi, physical_iam, label='physical') +plt.xlabel('AOI (degrees)') +plt.ylabel('IAM') +plt.title('Fitting the physical model to data') +plt.legend() +plt.show() + + +# %% +# The weight function +# ------------------- +# :py:func:`pvlib.iam.fit` uses a weight function when computing residuals +# between the model and data. The default weight +# function is :math:`1 - \sin(aoi)`. We can instead pass a custom weight +# function to :py:func:`pvlib.iam.fit`. +# + +# Define a custom weight function. The weight function must take ``aoi`` +# as its argument and return a vector of the same length as ``aoi``. +def weight_function(aoi): + return cosd(aoi) + + +physical_params_custom = fit(aoi, data, 'physical', weight=weight_function) + +physical_iam_custom = physical(aoi, physical_params_custom) + +# Plot IAM vs AOI. +fig, ax = plt.subplots(2, 1, figsize=(5, 8)) +ax[0].plot(aoi, data, '.', label='Data (from Martin-Ruiz model)') +ax[0].plot(aoi, physical_iam, label='With default weight function') +ax[0].plot(aoi, physical_iam_custom, label='With custom weight function') +ax[0].set_xlabel('AOI (degrees)') +ax[0].set_ylabel('IAM') +ax[0].legend() + +ax[1].plot(aoi, physical_iam_custom - physical_iam, label='Custom - default') +ax[1].set_xlabel('AOI (degrees)') +ax[1].set_ylabel('Diff. in IAM') +ax[1].legend() +plt.tight_layout() +plt.show() + +print("Parameters with default weights: " + str(physical_params)) +print("Parameters with custom weights: " + str(physical_params_custom)) diff --git a/docs/sphinx/source/reference/pv_modeling/iam.rst b/docs/sphinx/source/reference/pv_modeling/iam.rst index 1871f9b4a2..e12a0c519e 100644 --- a/docs/sphinx/source/reference/pv_modeling/iam.rst +++ b/docs/sphinx/source/reference/pv_modeling/iam.rst @@ -17,3 +17,5 @@ Incident angle modifiers iam.marion_integrate iam.schlick iam.schlick_diffuse + iam.convert + iam.fit diff --git a/docs/sphinx/source/whatsnew/v0.10.3.rst b/docs/sphinx/source/whatsnew/v0.10.3.rst index 4d0cc774c8..30fd46648f 100644 --- a/docs/sphinx/source/whatsnew/v0.10.3.rst +++ b/docs/sphinx/source/whatsnew/v0.10.3.rst @@ -15,6 +15,8 @@ Enhancements * :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance` and :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance_poa` now include shaded fraction in returned variables. (:pull:`1871`) +* Added :py:func:`~pvlib.iam.convert` and :py:func:`~pvlib.iam.fit` that + convert between IAM models, and that fit an IAM model to data. (:issue:`1824`, :pull:`1827`) Bug fixes ~~~~~~~~~ @@ -50,6 +52,8 @@ Contributors * Miguel Sánchez de León Peque (:ghuser:`Peque`) * Will Hobbs (:ghuser:`williamhobbs`) * Anton Driesse (:ghuser:`adriesse`) +* Abigail Jones (:ghuser:`ajonesr`) +* Cliff Hansen (:ghuser:`cwhanse`) * Gilles Fischer (:ghuser:`GillesFischerV`) * Adam R. Jensen (:ghusuer:`AdamRJensen`) * :ghuser:`matsuobasho` diff --git a/pvlib/iam.py b/pvlib/iam.py index 4f32d352ee..83b8955e2f 100644 --- a/pvlib/iam.py +++ b/pvlib/iam.py @@ -11,7 +11,8 @@ import numpy as np import pandas as pd import functools -from pvlib.tools import cosd, sind +from scipy.optimize import minimize +from pvlib.tools import cosd, sind, acosd # a dict of required parameter names for each IAM model # keys are the function names for the IAM models @@ -856,7 +857,7 @@ def schlick_diffuse(surface_tilt): Unlike the Fresnel reflection factor itself, Schlick's approximation can be integrated analytically to derive a closed-form equation for diffuse IAM factors for the portions of the sky and ground visible - from a tilted surface if isotropic distributions are assumed. + from a tilted surface if isotropic distributions are assumed. This function implements the integration of the Schlick approximation provided by Xie et al. [2]_. @@ -940,3 +941,362 @@ def schlick_diffuse(surface_tilt): cug = pd.Series(cug, surface_tilt.index) return cuk, cug + + +def _get_model(model_name): + # check that model is implemented + model_dict = {'ashrae': ashrae, 'martin_ruiz': martin_ruiz, + 'physical': physical} + try: + model = model_dict[model_name] + except KeyError: + raise NotImplementedError(f"The {model_name} model has not been " + "implemented") + + return model + + +def _check_params(model_name, params): + # check that the parameters passed in with the model + # belong to the model + exp_params = _IAM_MODEL_PARAMS[model_name] + if set(params.keys()) != exp_params: + raise ValueError(f"The {model_name} model was expecting to be passed " + "{', '.join(list(exp_params))}, but " + "was handed {', '.join(list(params.keys()))}") + + +def _sin_weight(aoi): + return 1 - sind(aoi) + + +def _residual(aoi, source_iam, target, target_params, + weight=_sin_weight): + # computes a sum of weighted differences between the source model + # and target model, using the provided weight function + + weights = weight(aoi) + + # if aoi contains values outside of interval (0, 90), annihilate + # the associated weights (we don't want IAM values from AOI outside + # of (0, 90) to affect the fit; this is a possible issue when using + # `iam.fit`, but not an issue when using `iam.convert`, since in + # that case aoi is defined internally) + weights = weights * np.logical_and(aoi >= 0, aoi <= 90).astype(int) + + diff = np.abs(source_iam - np.nan_to_num(target(aoi, target_params))) + return np.sum(diff weights) + + +def _get_ashrae_intercept(b): + # find x-intercept of ashrae model + return acosd(b / (1 + b)) + + +def _ashrae_to_physical(aoi, ashrae_iam, weight, fix_n, b): + if fix_n: + # the ashrae model has an x-intercept less than 90 + # we solve for this intercept, and fix n so that the physical + # model will have the same x-intercept + intercept = _get_ashrae_intercept(b) + n = sind(intercept) + + # with n fixed, we will optimize for L (recall that K and L always + # appear in the physical model as a product, so it is enough to + # optimize for just L, and to fix K=4) + + # we will pass n to the optimizer to simplify things later on, + # but because we are setting (n, n) as the bounds, the optimizer + # will leave n fixed + bounds = [(1e-6, 0.08), (n, n)] + guess = [0.002, n] + + else: + # we don't fix n, so physical won't have same x-intercept as ashrae + # the fit will be worse, but the parameters returned for the physical + # model will be more realistic + bounds = [(1e-6, 0.08), (0.8, 2)] # L, n + guess = [0.002, 1.0] + + def residual_function(target_params): + L, n = target_params + return _residual(aoi, ashrae_iam, physical, [n, 4, L], weight) + + return residual_function, guess, bounds + + +def _martin_ruiz_to_physical(aoi, martin_ruiz_iam, weight, a_r): + # we will optimize for both n and L (recall that K and L always + # appear in the physical model as a product, so it is enough to + # optimize for just L, and to fix K=4) + # set lower bound for n at 1.0 so that x-intercept will be at 90 + # order for Powell's method depends on a_r value + bounds = [(1e-6, 0.08), (1.05, 2)] # L, n + guess = [0.002, 1.1] # L, n + # get better results if we reverse order to n, L at high a_r + if a_r > 0.22: + bounds.reverse() + guess.reverse() + + # the product of K and L is more important in determining an initial + # guess for the location of the minimum, so we pass L in first + def residual_function(target_params): + # unpack target_params for either search order + if target_params[0] < target_params[1]: + # L will always be less than n + L, n = target_params + else: + n, L = target_params + return _residual(aoi, martin_ruiz_iam, physical, [n, 4, L], weight) + + return residual_function, guess, bounds + + +def _minimize(residual_function, guess, bounds, xtol): + if xtol is not None: + options = {'xtol': xtol} + else: + options = None + with np.errstate(invalid='ignore'): + optimize_result = minimize(residual_function, guess, method="powell", + bounds=bounds, options=options) + + if not optimize_result.success: + try: + message = "Optimizer exited unsuccessfully:" \ + + optimize_result.message + except AttributeError: + message = "Optimizer exited unsuccessfully: \ + No message explaining the failure was returned. \ + If you would like to see this message, please \ + update your scipy version (try version 1.8.0 \ + or beyond)." + raise RuntimeError(message) + + return optimize_result + + +def _process_return(target_name, optimize_result): + if target_name == "ashrae": + target_params = {'b': optimize_result.x.item()} + + elif target_name == "martin_ruiz": + target_params = {'a_r': optimize_result.x.item()} + + elif target_name == "physical": + L, n = optimize_result.x + # have to unpack order because search order may be different + if L > n: + L, n = n, L + target_params = {'n': n, 'K': 4, 'L': L} + + return target_params + + +def convert(source_name, source_params, target_name, weight=_sin_weight, + fix_n=True, xtol=None): + """ + Convert a source IAM model to a target IAM model. + + Parameters + ---------- + source_name : str + Name of the source model. Must be ``'ashrae'``, ``'martin_ruiz'``, or + ``'physical'``. + + source_params : dict + A dictionary of parameters for the source model. + + If source model is ``'ashrae'``, the dictionary must contain + the key ``'b'``. + + If source model is ``'martin_ruiz'``, the dictionary must + contain the key ``'a_r'``. + + If source model is ``'physical'``, the dictionary must + contain the keys ``'n'``, ``'K'``, and ``'L'``. + + target_name : str + Name of the target model. Must be ``'ashrae'``, ``'martin_ruiz'``, or + ``'physical'``. + + weight : function, optional + A single-argument function of AOI (degrees) that calculates weights for + the residuals between models. Must return a float or an array-like + object. The default weight function is :math:`f(aoi) = 1 - sin(aoi)`. + + fix_n : bool, default True + A flag to determine which method is used when converting from the + ASHRAE model to the physical model. + + When ``source_name`` is ``'ashrae'`` and ``target_name`` is + ``'physical'``, if `fix_n` is ``True``, + :py:func:`iam.convert` will fix ``n`` so that the returned physical + model has the same x-intercept as the inputted ASHRAE model. + Fixing ``n`` like this improves the fit of the conversion, but often + returns unrealistic values for the parameters of the physical model. + If more physically meaningful parameters are wanted, + set `fix_n` to False. + + xtol : float, optional + Passed to scipy.optimize.minimize. + + Returns + ------- + dict + Parameters for the target model. + + If target model is ``'ashrae'``, the dictionary will contain + the key ``'b'``. + + If target model is ``'martin_ruiz'``, the dictionary will + contain the key ``'a_r'``. + + If target model is ``'physical'``, the dictionary will + contain the keys ``'n'``, ``'K'``, and ``'L'``. + + Note + ---- + Target model parameters are determined by minimizing + + .. math:: + + \\sum_{\\theta=0}^{90} weight \\left(\\theta \\right) \\times + \\\| source \\left(\\theta \\right) - target \\left(\\theta \\right) \\\| + + The sum is over :math:`\\theta = 0, 1, 2, ..., 90`. + + References + ---------- + .. [1] Jones, A. R., Hansen, C. W., Anderson, K. S. Parameter estimation + for incidence angle modifier models for photovoltaic modules. Sandia + report SAND2023-13944 (2023). + + See Also + -------- + pvlib.iam.fit + pvlib.iam.ashrae + pvlib.iam.martin_ruiz + pvlib.iam.physical + """ + source = _get_model(source_name) + target = _get_model(target_name) + + aoi = np.linspace(0, 90, 91) + _check_params(source_name, source_params) + source_iam = source(aoi, **source_params) + + if target_name == "physical": + # we can do some special set-up to improve the fit when the + # target model is physical + if source_name == "ashrae": + residual_function, guess, bounds = \ + _ashrae_to_physical(aoi, source_iam, weight, fix_n, + source_params['b']) + elif source_name == "martin_ruiz": + residual_function, guess, bounds = \ + _martin_ruiz_to_physical(aoi, source_iam, weight, + source_params['a_r']) + + else: + # otherwise, target model is ashrae or martin_ruiz, and scipy + # does fine without any special set-up + bounds = [(1e-04, 1)] + guess = [1e-03] + + def residual_function(target_param): + return _residual(aoi, source_iam, target, target_param, weight) + + optimize_result = _minimize(residual_function, guess, bounds, + xtol=xtol) + + return _process_return(target_name, optimize_result) + + +def fit(measured_aoi, measured_iam, model_name, weight=_sin_weight, xtol=None): + """ + Find model parameters that best fit the data. + + Parameters + ---------- + measured_aoi : array-like + Angle of incidence values associated with the + measured IAM values. [degrees] + + measured_iam : array-like + IAM values. [unitless] + + model_name : str + Name of the model to be fit. Must be ``'ashrae'``, ``'martin_ruiz'``, + or ``'physical'``. + + weight : function, optional + A single-argument function of AOI (degrees) that calculates weights for + the residuals between models. Must return a float or an array-like + object. The default weight function is :math:`f(aoi) = 1 - sin(aoi)`. + + xtol : float, optional + Passed to scipy.optimize.minimize. + + Returns + ------- + dict + Parameters for target model. + + If target model is ``'ashrae'``, the dictionary will contain + the key ``'b'``. + + If target model is ``'martin_ruiz'``, the dictionary will + contain the key ``'a_r'``. + + If target model is ``'physical'``, the dictionary will + contain the keys ``'n'``, ``'K'``, and ``'L'``. + + References + ---------- + .. [1] Jones, A. R., Hansen, C. W., Anderson, K. S. Parameter estimation + for incidence angle modifier models for photovoltaic modules. Sandia + report SAND2023-13944 (2023). + + Note + ---- + Model parameters are determined by minimizing + + .. math:: + + \\sum_{AOI} weight \\left( AOI \\right) \\times + \\\| IAM \\left( AOI \\right) - model \\left( AOI \\right) \\\| + + The sum is over ``measured_aoi`` and :math:`IAM \\left( AOI \\right)` + is ``measured_IAM``. + + See Also + -------- + pvlib.iam.convert + pvlib.iam.ashrae + pvlib.iam.martin_ruiz + pvlib.iam.physical + """ + target = _get_model(model_name) + + if model_name == "physical": + bounds = [(0, 0.08), (1, 2)] + guess = [0.002, 1+1e-08] + + def residual_function(target_params): + L, n = target_params + return _residual(measured_aoi, measured_iam, target, [n, 4, L], + weight) + + # otherwise, target_name is martin_ruiz or ashrae + else: + bounds = [(1e-08, 1)] + guess = [0.05] + + def residual_function(target_param): + return _residual(measured_aoi, measured_iam, target, + target_param, weight) + + optimize_result = _minimize(residual_function, guess, bounds, xtol) + + return _process_return(model_name, optimize_result)	diff --git a/pvlib/tests/conftest.py b/pvlib/tests/conftest.py index 15b0cd70e8..f579ef45f2 100644 --- a/pvlib/tests/conftest.py +++ b/pvlib/tests/conftest.py @@ -11,6 +11,7 @@ import pvlib from pvlib.location import Location + pvlib_base_version = Version(Version(pvlib.__version__).base_version) diff --git a/pvlib/tests/test_iam.py b/pvlib/tests/test_iam.py index 3d017ef7c2..f5ca231bd4 100644 --- a/pvlib/tests/test_iam.py +++ b/pvlib/tests/test_iam.py @@ -265,10 +265,10 @@ def test_marion_diffuse_model(mocker): assert physical_spy.call_count == 3 for k, v in ashrae_expected.items(): - np.testing.assert_allclose(ashrae_actual[k], v) + assert_allclose(ashrae_actual[k], v) for k, v in physical_expected.items(): - np.testing.assert_allclose(physical_actual[k], v) + assert_allclose(physical_actual[k], v) def test_marion_diffuse_kwargs(): @@ -281,7 +281,7 @@ def test_marion_diffuse_kwargs(): actual = _iam.marion_diffuse('ashrae', 20, b=0.04) for k, v in expected.items(): - np.testing.assert_allclose(actual[k], v) + assert_allclose(actual[k], v) def test_marion_diffuse_invalid(): @@ -395,3 +395,161 @@ def test_schlick_diffuse(): assert_series_equal(pd.Series(expected_sky, idx), actual_sky) assert_series_equal(pd.Series(expected_ground, idx), actual_ground, rtol=1e-6) + + +@pytest.mark.parametrize('source,source_params,target,expected', [ + ('physical', {'n': 1.5, 'K': 4.5, 'L': 0.004}, 'martin_ruiz', + {'a_r': 0.174037}), + ('physical', {'n': 1.5, 'K': 4.5, 'L': 0.004}, 'ashrae', + {'b': 0.042896}), + ('ashrae', {'b': 0.15}, 'physical', + {'n': 0.991457, 'K': 4, 'L': 0.037813}), + ('ashrae', {'b': 0.15}, 'martin_ruiz', {'a_r': 0.302390}), + ('martin_ruiz', {'a_r': 0.15}, 'physical', + {'n': 1.240190, 'K': 4, 'L': 0.002791055}), + ('martin_ruiz', {'a_r': 0.15}, 'ashrae', {'b': 0.025458})]) +def test_convert(source, source_params, target, expected): + target_params = _iam.convert(source, source_params, target) + exp = [expected[k] for k in expected] + tar = [target_params[k] for k in expected] + assert_allclose(exp, tar, rtol=1e-05) + + +@pytest.mark.parametrize('source,source_params', [ + ('ashrae', {'b': 0.15}), + ('ashrae', {'b': 0.05}), + ('martin_ruiz', {'a_r': 0.15})]) +def test_convert_recover(source, source_params): + # convert isn't set up to handle both source and target = 'physical' + target_params = _iam.convert(source, source_params, source, xtol=1e-7) + exp = [source_params[k] for k in source_params] + tar = [target_params[k] for k in source_params] + assert_allclose(exp, tar, rtol=1e-05) + + +def test_convert_ashrae_physical_no_fix_n(): + # convert ashrae to physical, without fixing n + source_params = {'b': 0.15} + target_params = _iam.convert('ashrae', source_params, 'physical', + fix_n=False) + expected = {'n': 0.989019, 'K': 4, 'L': 0.037382} + exp = [expected[k] for k in expected] + tar = [target_params[k] for k in expected] + assert_allclose(exp, tar, rtol=1e-05) + + +def test_convert_reverse_order_in_physical(): + source_params = {'a_r': 0.25} + target_params = _iam.convert('martin_ruiz', source_params, 'physical') + expected = {'n': 1.691398, 'K': 4, 'L': 0.071633} + exp = [expected[k] for k in expected] + tar = [target_params[k] for k in expected] + assert_allclose(exp, tar, rtol=1e-05) + + +def test_convert_xtol(): + source_params = {'b': 0.15} + target_params = _iam.convert('ashrae', source_params, 'physical', + xtol=1e-8) + expected = {'n': 0.9914568914, 'K': 4, 'L': 0.0378126985} + exp = [expected[k] for k in expected] + tar = [target_params[k] for k in expected] + assert_allclose(exp, tar, rtol=1e-6) + + +def test_convert_custom_weight_func(): + aoi = np.linspace(0, 90, 91) + + # convert physical to martin_ruiz, using custom weight function + source_params = {'n': 1.5, 'K': 4.5, 'L': 0.004} + source_iam = _iam.physical(aoi, *source_params) + + # define custom weight function that takes in other arguments + def scaled_weight(aoi): + return 2. aoi + + # expected value calculated from computing residual function over + # a range of inputs, and taking minimum of these values + expected_min_res = 16.39724 + + actual_dict = _iam.convert('physical', source_params, 'martin_ruiz', + weight=scaled_weight) + actual_min_res = _iam._residual(aoi, source_iam, _iam.martin_ruiz, + [actual_dict['a_r']], scaled_weight) + + assert np.isclose(expected_min_res, actual_min_res, atol=1e-06) + + +def test_convert_model_not_implemented(): + with pytest.raises(NotImplementedError, match='model has not been'): + _iam.convert('ashrae', {'b': 0.1}, 'foo') + + +def test_convert_wrong_model_parameters(): + with pytest.raises(ValueError, match='model was expecting'): + _iam.convert('ashrae', {'B': 0.1}, 'physical') + + +def test_convert__minimize_fails(): + # to make scipy.optimize.minimize fail, we'll pass in a nonsense + # weight function that only outputs nans + def nan_weight(aoi): + return np.nan + + with pytest.raises(RuntimeError, match='Optimizer exited unsuccessfully'): + _iam.convert('ashrae', {'b': 0.1}, 'physical', weight=nan_weight) + + +def test_fit(): + aoi = np.linspace(0, 90, 5) + perturb = np.array([1.2, 1.01, 0.95, 1, 0.98]) + perturbed_iam = _iam.martin_ruiz(aoi, a_r=0.14) * perturb + + expected_a_r = 0.14 + + actual_dict = _iam.fit(aoi, perturbed_iam, 'martin_ruiz') + actual_a_r = actual_dict['a_r'] + + assert np.isclose(expected_a_r, actual_a_r, atol=1e-04) + + +def test_fit_custom_weight_func(): + # define custom weight function that takes in other arguments + def scaled_weight(aoi): + return 2. * aoi + + aoi = np.linspace(0, 90, 5) + perturb = np.array([1.2, 1.01, 0.95, 1, 0.98]) + perturbed_iam = _iam.martin_ruiz(aoi, a_r=0.14) * perturb + + expected_a_r = 0.14 + + actual_dict = _iam.fit(aoi, perturbed_iam, 'martin_ruiz', + weight=scaled_weight) + actual_a_r = actual_dict['a_r'] + + assert np.isclose(expected_a_r, actual_a_r, atol=1e-04) + + +def test_fit_model_not_implemented(): + with pytest.raises(NotImplementedError, match='model has not been'): + _iam.fit(np.array([0, 10]), np.array([1, 0.99]), 'foo') + + +def test_fit__minimize_fails(): + # to make scipy.optimize.minimize fail, we'll pass in a nonsense + # weight function that only outputs nans + def nan_weight(aoi): + return np.nan + + with pytest.raises(RuntimeError, match='Optimizer exited unsuccessfully'): + _iam.fit(np.array([0, 10]), np.array([1, 0.99]), 'physical', + weight=nan_weight) + + +def test__residual_zero_outside_range(): + # check that _residual annihilates any weights that come from aoi + # outside of interval [0, 90] (this is important for `iam.fit`, when + # the `measured_aoi` contains angles outside this range + residual = _iam._residual(101, _iam.ashrae(101), _iam.martin_ruiz, [0.16]) + assert residual == 0.0	diff --git a/docs/sphinx/source/reference/pv_modeling/iam.rst b/docs/sphinx/source/reference/pv_modeling/iam.rst index 1871f9b4a2..e12a0c519e 100644 --- a/docs/sphinx/source/reference/pv_modeling/iam.rst +++ b/docs/sphinx/source/reference/pv_modeling/iam.rst @@ -17,3 +17,5 @@ Incident angle modifiers iam.marion_integrate iam.schlick iam.schlick_diffuse + iam.convert + iam.fit diff --git a/docs/sphinx/source/whatsnew/v0.10.3.rst b/docs/sphinx/source/whatsnew/v0.10.3.rst index 4d0cc774c8..30fd46648f 100644 --- a/docs/sphinx/source/whatsnew/v0.10.3.rst +++ b/docs/sphinx/source/whatsnew/v0.10.3.rst @@ -15,6 +15,8 @@ Enhancements * :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance` and :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance_poa` now include shaded fraction in returned variables. (:pull:`1871`) +* Added :py:func:`~pvlib.iam.convert` and :py:func:`~pvlib.iam.fit` that + convert between IAM models, and that fit an IAM model to data. (:issue:`1824`, :pull:`1827`) Bug fixes ~~~~~~~~~ @@ -50,6 +52,8 @@ Contributors * Miguel Sánchez de León Peque (:ghuser:`Peque`) * Will Hobbs (:ghuser:`williamhobbs`) * Anton Driesse (:ghuser:`adriesse`) +* Abigail Jones (:ghuser:`ajonesr`) +* Cliff Hansen (:ghuser:`cwhanse`) * Gilles Fischer (:ghuser:`GillesFischerV`) * Adam R. Jensen (:ghusuer:`AdamRJensen`) * :ghuser:`matsuobasho`	[ { "components": [ { "doc": "", "lines": [ 104, 105 ], "name": "weight_function", "signature": "def weight_function(aoi):", "type": "function" } ], "file": "docs/examples/reflections/plot_convert_iam_models.py" }, { "...	[ "pvlib/tests/test_iam.py::test_convert[physical-source_params0-martin_ruiz-expected0]", "pvlib/tests/test_iam.py::test_convert[physical-source_params1-ashrae-expected1]", "pvlib/tests/test_iam.py::test_convert[ashrae-source_params2-physical-expected2]", "pvlib/tests/test_iam.py::test_convert[ashrae-source_par...	[ "pvlib/tests/test_iam.py::test_ashrae", "pvlib/tests/test_iam.py::test_ashrae_scalar", "pvlib/tests/test_iam.py::test_physical", "pvlib/tests/test_iam.py::test_physical_n1_L0", "pvlib/tests/test_iam.py::test_physical_ar", "pvlib/tests/test_iam.py::test_physical_noar", "pvlib/tests/test_iam.py::test_phys...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add functions to fit and convert IAM models - [x] Closes #1824 - [x] I am familiar with the [contributing guidelines](https://pvlib-python.readthedocs.io/en/latest/contributing.html) - [x] Tests added - [x] Updates entries in [`docs/sphinx/source/reference`](https://github.com/pvlib/pvlib-python/blob/main/docs/sphinx/source/reference) for API changes. - [x] Adds description and name entries in the appropriate "what's new" file in [`docs/sphinx/source/whatsnew`](https://github.com/pvlib/pvlib-python/tree/main/docs/sphinx/source/whatsnew) for all changes. Includes link to the GitHub Issue with `` :issue:`num` `` or this Pull Request with `` :pull:`num` ``. Includes contributor name and/or GitHub username (link with `` :ghuser:`user` ``). - [x] New code is fully documented. Includes [numpydoc](https://numpydoc.readthedocs.io/en/latest/format.html) compliant docstrings, examples, and comments where necessary. - [x] Pull request is nearly complete and ready for detailed review. - [x] Maintainer: Appropriate GitHub Labels (including `remote-data`) and Milestone are assigned to the Pull Request and linked Issue. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in docs/examples/reflections/plot_convert_iam_models.py] (definition of weight_function:) def weight_function(aoi): [end of new definitions in docs/examples/reflections/plot_convert_iam_models.py] [start of new definitions in docs/examples/reflections/plot_fit_iam_models.py] (definition of weight_function:) def weight_function(aoi): [end of new definitions in docs/examples/reflections/plot_fit_iam_models.py] [start of new definitions in pvlib/iam.py] (definition of _get_model:) def _get_model(model_name): (definition of _check_params:) def _check_params(model_name, params): (definition of _sin_weight:) def _sin_weight(aoi): (definition of _residual:) def _residual(aoi, source_iam, target, target_params, weight=_sin_weight): (definition of _get_ashrae_intercept:) def _get_ashrae_intercept(b): (definition of _ashrae_to_physical:) def _ashrae_to_physical(aoi, ashrae_iam, weight, fix_n, b): (definition of _ashrae_to_physical.residual_function:) def residual_function(target_params): (definition of _martin_ruiz_to_physical:) def _martin_ruiz_to_physical(aoi, martin_ruiz_iam, weight, a_r): (definition of _martin_ruiz_to_physical.residual_function:) def residual_function(target_params): (definition of _minimize:) def _minimize(residual_function, guess, bounds, xtol): (definition of _process_return:) def _process_return(target_name, optimize_result): (definition of convert:) def convert(source_name, source_params, target_name, weight=_sin_weight, fix_n=True, xtol=None): """Convert a source IAM model to a target IAM model. Parameters ---------- source_name : str Name of the source model. Must be ``'ashrae'``, ``'martin_ruiz'``, or ``'physical'``. source_params : dict A dictionary of parameters for the source model. If source model is ``'ashrae'``, the dictionary must contain the key ``'b'``. If source model is ``'martin_ruiz'``, the dictionary must contain the key ``'a_r'``. If source model is ``'physical'``, the dictionary must contain the keys ``'n'``, ``'K'``, and ``'L'``. target_name : str Name of the target model. Must be ``'ashrae'``, ``'martin_ruiz'``, or ``'physical'``. weight : function, optional A single-argument function of AOI (degrees) that calculates weights for the residuals between models. Must return a float or an array-like object. The default weight function is :math:`f(aoi) = 1 - sin(aoi)`. fix_n : bool, default True A flag to determine which method is used when converting from the ASHRAE model to the physical model. When ``source_name`` is ``'ashrae'`` and ``target_name`` is ``'physical'``, if `fix_n` is ``True``, :py:func:`iam.convert` will fix ``n`` so that the returned physical model has the same x-intercept as the inputted ASHRAE model. Fixing ``n`` like this improves the fit of the conversion, but often returns unrealistic values for the parameters of the physical model. If more physically meaningful parameters are wanted, set `fix_n` to False. xtol : float, optional Passed to scipy.optimize.minimize. Returns ------- dict Parameters for the target model. If target model is ``'ashrae'``, the dictionary will contain the key ``'b'``. If target model is ``'martin_ruiz'``, the dictionary will contain the key ``'a_r'``. If target model is ``'physical'``, the dictionary will contain the keys ``'n'``, ``'K'``, and ``'L'``. Note ---- Target model parameters are determined by minimizing .. math:: \sum_{\theta=0}^{90} weight \left(\theta \right) \times \\| source \left(\theta \right) - target \left(\theta \right) \\| The sum is over :math:`\theta = 0, 1, 2, ..., 90`. References ---------- .. [1] Jones, A. R., Hansen, C. W., Anderson, K. S. Parameter estimation for incidence angle modifier models for photovoltaic modules. Sandia report SAND2023-13944 (2023). See Also -------- pvlib.iam.fit pvlib.iam.ashrae pvlib.iam.martin_ruiz pvlib.iam.physical""" (definition of convert.residual_function:) def residual_function(target_param): (definition of fit:) def fit(measured_aoi, measured_iam, model_name, weight=_sin_weight, xtol=None): """Find model parameters that best fit the data. Parameters ---------- measured_aoi : array-like Angle of incidence values associated with the measured IAM values. [degrees] measured_iam : array-like IAM values. [unitless] model_name : str Name of the model to be fit. Must be ``'ashrae'``, ``'martin_ruiz'``, or ``'physical'``. weight : function, optional A single-argument function of AOI (degrees) that calculates weights for the residuals between models. Must return a float or an array-like object. The default weight function is :math:`f(aoi) = 1 - sin(aoi)`. xtol : float, optional Passed to scipy.optimize.minimize. Returns ------- dict Parameters for target model. If target model is ``'ashrae'``, the dictionary will contain the key ``'b'``. If target model is ``'martin_ruiz'``, the dictionary will contain the key ``'a_r'``. If target model is ``'physical'``, the dictionary will contain the keys ``'n'``, ``'K'``, and ``'L'``. References ---------- .. [1] Jones, A. R., Hansen, C. W., Anderson, K. S. Parameter estimation for incidence angle modifier models for photovoltaic modules. Sandia report SAND2023-13944 (2023). Note ---- Model parameters are determined by minimizing .. math:: \sum_{AOI} weight \left( AOI \right) \times \\| IAM \left( AOI \right) - model \left( AOI \right) \\| The sum is over ``measured_aoi`` and :math:`IAM \left( AOI \right)` is ``measured_IAM``. See Also -------- pvlib.iam.convert pvlib.iam.ashrae pvlib.iam.martin_ruiz pvlib.iam.physical""" (definition of fit.residual_function:) def residual_function(target_param): [end of new definitions in pvlib/iam.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Functions to fit and convert IAM models It would be useful to be able to convert parameters between IAM models (e.g., physical to martin_ruiz). To convert from an interpolation approach to a model described by an equation, it would also be useful to have a "fit" function. Describe the solution you'd like Add `fit` and `convert` functions to `pvlib.iam.py`. `convert` could be implemented as ``` target_params = convert(source_model, source_params, target_model) ``` Add an example to the gallery showing how to use these functions, and demonstrating that a converted model yields similar effective insolation for a representative system. Describe alternatives you've considered An example showing how to do this. The example would contain the fit/convert code, which seems like a less-than-useful implementation. ---------- -------------------- </issues>	d53f97e984bfdd268aa92f8bf482ced0edda0110
scverse__scanpy-2590	2,590	scverse/scanpy	null	b4ba81dc9eab9f75b761d85e473e548a5c37b49e	2023-08-03T15:46:47Z	diff --git a/docs/api/get.md b/docs/api/get.md index 82f74ed411..039769d0a6 100644 --- a/docs/api/get.md +++ b/docs/api/get.md @@ -19,5 +19,6 @@ useful formats. get.obs_df get.var_df get.rank_genes_groups_df + get.aggregate ``` diff --git a/docs/release-notes/1.10.0.md b/docs/release-notes/1.10.0.md index 542ee15fd9..0266b2bdf9 100644 --- a/docs/release-notes/1.10.0.md +++ b/docs/release-notes/1.10.0.md @@ -15,6 +15,7 @@ * Enhanced dask support for some internal utilities, paving the way for more extensive dask support {pr}`2696` {smaller}`P Angerer` * {func}`scanpy.pp.pca`, {func}`scanpy.pp.scale`, {func}`scanpy.pl.embedding`, and {func}`scanpy.experimental.pp.normalize_pearson_residuals_pca` now support a `mask` parameter {pr}`2272` {smaller}`C Bright, T Marcella, & P Angerer` +* New function {func}`scanpy.get.aggregate` which allows grouped aggregations over your data. Useful for pseudobulking! {pr}`2590` {smaller}`Isaac Virshup` {smaller}`Ilan Gold` {smaller}`Jon Bloom` * {func}`scanpy.tl.rank_genes_groups` no longer warns that it's default was changed from t-test_overestim_var to t-test {pr}`2798` {smaller}`L Heumos` * {func}`scanpy.tl.leiden` now offers `igraph`'s implementation of the leiden algorithm via via `flavor` when set to `igraph`. `leidenalg`'s implementation is still default, but discouraged. {pr}`2815` {smaller}`I Gold` * {func}`scanpy.pp.highly_variable_genes` has new flavor `seurat_v3_paper` that is in its implementation consistent with the paper description in Stuart et al 2018. {pr}`2792` {smaller}`E Roellin` diff --git a/scanpy/_utils/__init__.py b/scanpy/_utils/__init__.py index 625e3b71e3..3ef16300aa 100644 --- a/scanpy/_utils/__init__.py +++ b/scanpy/_utils/__init__.py @@ -874,3 +874,13 @@ def _choose_graph(adata, obsp, neighbors_key): "to compute a neighborhood graph." ) return neighbors["connectivities"] + + +def _resolve_axis( + axis: Literal["obs", 0, "var", 1], +) -> tuple[Literal[0], Literal["obs"]] \| tuple[Literal[1], Literal["var"]]: + if axis in {0, "obs"}: + return (0, "obs") + if axis in {1, "var"}: + return (1, "var") + raise ValueError(f"`axis` must be either 0, 1, 'obs', or 'var', was {axis!r}") diff --git a/scanpy/get/__init__.py b/scanpy/get/__init__.py index 08567cfc6e..56c0d3c130 100644 --- a/scanpy/get/__init__.py +++ b/scanpy/get/__init__.py @@ -1,7 +1,6 @@ -# Public -# Private from __future__ import annotations +from ._aggregated import aggregate from .get import ( _check_mask, _get_obs_rep, @@ -15,6 +14,7 @@ "_check_mask", "_get_obs_rep", "_set_obs_rep", + "aggregate", "obs_df", "rank_genes_groups_df", "var_df", diff --git a/scanpy/get/_aggregated.py b/scanpy/get/_aggregated.py new file mode 100644 index 0000000000..159f7572e3 --- /dev/null +++ b/scanpy/get/_aggregated.py @@ -0,0 +1,387 @@ +from __future__ import annotations + +from functools import singledispatch +from typing import TYPE_CHECKING, Literal, Union, get_args + +import numpy as np +import pandas as pd +from anndata import AnnData, utils +from scipy import sparse + +from .._utils import _resolve_axis +from .get import _check_mask + +if TYPE_CHECKING: + from collections.abc import Collection, Iterable + + from numpy.typing import NDArray + +Array = Union[np.ndarray, sparse.csc_matrix, sparse.csr_matrix] +AggType = Literal["count_nonzero", "mean", "sum", "var"] + + +class Aggregate: + """\ + Functionality for generic grouping and aggregating. + + There is currently support for count_nonzero, sum, mean, and variance. + + Implementation + + Moments are computed using weighted sum aggregation of data by some feature + via multiplication by a sparse coordinate matrix A. + + Runtime is effectively computation of the product `A @ X`, i.e. the count of (non-zero) + entries in X with multiplicity the number of group memberships for that entry. + This is `O(data)` for partitions (each observation belonging to exactly one group), + independent of the number of groups. + + Params + ------ + groupby + :class:`~pandas.Categorical` containing values for grouping by. + data + Data matrix for aggregation. + mask + Mask to be used for aggregation. + """ + + def __init__( + self, + groupby: pd.Categorical, + data: Array, + , + mask: NDArray[np.bool_] \| None = None, + ) -> None: + self.groupby = groupby + self.indicator_matrix = sparse_indicator(groupby, mask=mask) + self.data = data + + groupby: pd.Categorical + indicator_matrix: sparse.coo_matrix + data: Array + + def count_nonzero(self) -> NDArray[np.integer]: + """\ + Count the number of observations in each group. + + Returns + ------- + Array of counts. + """ + # pattern = self.data._with_data(np.broadcast_to(1, len(self.data.data))) + # return self.indicator_matrix @ pattern + return self.indicator_matrix @ (self.data != 0) + + def sum(self) -> Array: + """\ + Compute the sum per feature per group of observations. + + Returns + ------- + Array of sum. + """ + return utils.asarray(self.indicator_matrix @ self.data) + + def mean(self) -> Array: + """\ + Compute the mean per feature per group of observations. + + Returns + ------- + Array of mean. + """ + return ( + utils.asarray(self.indicator_matrix @ self.data) + / np.bincount(self.groupby.codes)[:, None] + ) + + def mean_var(self, dof: int = 1) -> tuple[np.ndarray, np.ndarray]: + """\ + Compute the count, as well as mean and variance per feature, per group of observations. + + The formula `Var(X) = E(X^2) - E(X)^2` suffers loss of precision when the variance is a + very small fraction of the squared mean. In particular, when X is constant, the formula may + nonetheless be non-zero. By default, our implementation resets the variance to exactly zero + when the computed variance, relative to the squared mean, nears limit of precision of the + floating-point significand. + + Params + ------ + dof + Degrees of freedom for variance. + + Returns + ------- + Object with `count`, `mean`, and `var` attributes. + """ + assert dof >= 0 + + group_counts = np.bincount(self.groupby.codes) + mean_ = self.mean() + # sparse matrices do not support * for elementwise power. + mean_sq = ( + utils.asarray(self.indicator_matrix @ _power(self.data, 2)) + / group_counts[:, None] + ) + sq_mean = mean_*2 + var_ = mean_sq - sq_mean + # TODO: Why these values exactly? Because they are high relative to the datatype? + # (unchanged from original code: https://github.com/scverse/anndata/pull/564) + precision = 2 << (42 if self.data.dtype == np.float64 else 20) + # detects loss of precision in mean_sq - sq_mean, which suggests variance is 0 + var_[precision var_ < sq_mean] = 0 + if dof != 0: + var_ = (group_counts / (group_counts - dof))[:, np.newaxis] + return mean_, var_ + + +def _power(X: Array, power: float \| int) -> Array: + """\ + Generate elementwise power of a matrix. + + Needed for non-square sparse matrices because they do not support `` so the `.power` function is used. + + Params + ------ + X + Matrix whose power is to be raised. + power + Integer power value + + Returns + ------- + Matrix whose power has been raised. + """ + return Xpower if isinstance(X, np.ndarray) else X.power(power) + + +@singledispatch +def aggregate( + adata: AnnData, + by: str \| Collection[str], + func: AggType \| Iterable[AggType], + , + axis: Literal["obs", 0, "var", 1] \| None = None, + mask: NDArray[np.bool_] \| str \| None = None, + dof: int = 1, + layer: str \| None = None, + obsm: str \| None = None, + varm: str \| None = None, +) -> AnnData: + """\ + Aggregate data matrix based on some categorical grouping. + + This function is useful for pseudobulking as well as plotting. + + Aggregation to perform is specified by `func`, which can be a single metric or a + list of metrics. Each metric is computed over the group and results in a new layer + in the output `AnnData` object. + + If none of `layer`, `obsm`, or `varm` are passed in, `X` will be used for aggregation data. + If `func` only has length 1 or is just an `AggType`, then aggregation data is written to `X`. + Otherwise, it is written to `layers` or `xxxm` as appropriate for the dimensions of the aggregation data. + + Params + ------ + adata + :class:`~anndata.AnnData` to be aggregated. + by + Key of the column to be grouped-by. + func + How to aggregate. + axis + Axis on which to find group by column. + mask + Boolean mask (or key to column containing mask) to apply along the axis. + dof + Degrees of freedom for variance. Defaults to 1. + layer + If not None, key for aggregation data. + obsm + If not None, key for aggregation data. + varm + If not None, key for aggregation data. + + Returns + ------- + Aggregated :class:`~anndata.AnnData`. + + Examples + -------- + + Calculating mean expression and number of nonzero entries per cluster: + + >>> import scanpy as sc, pandas as pd + >>> pbmc = sc.datasets.pbmc3k_processed().raw.to_adata() + >>> pbmc.shape + (2638, 13714) + >>> aggregated = sc.get.aggregate(pbmc, by="louvain", func=["mean", "count_nonzero"]) + >>> aggregated + AnnData object with n_obs × n_vars = 8 × 13714 + obs: 'louvain' + var: 'n_cells' + layers: 'mean', 'count_nonzero' + + We can group over multiple columns: + + >>> pbmc.obs["percent_mito_binned"] = pd.cut(pbmc.obs["percent_mito"], bins=5) + >>> sc.get.aggregate(pbmc, by=["louvain", "percent_mito_binned"], func=["mean", "count_nonzero"]) + AnnData object with n_obs × n_vars = 40 × 13714 + obs: 'louvain', 'percent_mito_binned' + var: 'n_cells' + layers: 'mean', 'count_nonzero' + + Note that this filters out any combination of groups that wasn't present in the original data. + """ + if axis is None: + axis = 1 if varm else 0 + axis, axis_name = _resolve_axis(axis) + if mask is not None: + mask = _check_mask(adata, mask, axis_name) + data = adata.X + if sum(p is not None for p in [varm, obsm, layer]) > 1: + raise TypeError("Please only provide one (or none) of varm, obsm, or layer") + + if varm is not None: + if axis != 1: + raise ValueError("varm can only be used when axis is 1") + data = adata.varm[varm] + elif obsm is not None: + if axis != 0: + raise ValueError("obsm can only be used when axis is 0") + data = adata.obsm[obsm] + elif layer is not None: + data = adata.layers[layer] + if axis == 1: + data = data.T + elif axis == 1: + # i.e., all of `varm`, `obsm`, `layers` are None so we use `X` which must be transposed + data = data.T + + dim_df = getattr(adata, axis_name) + categorical, new_label_df = _combine_categories(dim_df, by) + # Actual computation + layers = aggregate( + data, + by=categorical, + func=func, + mask=mask, + dof=dof, + ) + result = AnnData( + layers=layers, + obs=new_label_df, + var=getattr(adata, "var" if axis == 0 else "obs"), + ) + + if axis == 1: + return result.T + else: + return result + + +@aggregate.register(np.ndarray) +@aggregate.register(sparse.spmatrix) +def aggregate_array( + data, + by: pd.Categorical, + func: AggType \| Iterable[AggType], + , + mask: NDArray[np.bool_] \| None = None, + dof: int = 1, +) -> dict[AggType, np.ndarray]: + groupby = Aggregate(groupby=by, data=data, mask=mask) + result = {} + + funcs = set([func] if isinstance(func, str) else func) + if unknown := funcs - set(get_args(AggType)): + raise ValueError(f"func {unknown} is not one of {get_args(AggType)}") + + if "sum" in funcs: # sum is calculated separately from the rest + agg = groupby.sum() + result["sum"] = agg + # here and below for count, if var is present, these can be calculate alongside var + if "mean" in funcs and "var" not in funcs: + agg = groupby.mean() + result["mean"] = agg + if "count_nonzero" in funcs: + result["count_nonzero"] = groupby.count_nonzero() + if "var" in funcs: + mean_, var_ = groupby.mean_var(dof) + result["var"] = var_ + if "mean" in funcs: + result["mean"] = mean_ + + return result + + +def _combine_categories( + label_df: pd.DataFrame, cols: Collection[str] \| str +) -> tuple[pd.Categorical, pd.DataFrame]: + """ + Returns both the result categories and a dataframe labelling each row + """ + from itertools import product + + if isinstance(cols, str): + cols = [cols] + + df = pd.DataFrame( + {c: pd.Categorical(label_df[c]).remove_unused_categories() for c in cols}, + ) + n_categories = [len(df[c].cat.categories) for c in cols] + + # It's like np.concatenate([x for x in product([range(n) for n in n_categories])]) + code_combinations = np.indices(n_categories).reshape(len(n_categories), -1) + result_categories = pd.Index( + ["_".join(map(str, x)) for x in product([df[c].cat.categories for c in cols])] + ) + + # Dataframe with unique combination of categories for each row + new_label_df = pd.DataFrame( + { + c: pd.Categorical.from_codes(code_combinations[i], df[c].cat.categories) + for i, c in enumerate(cols) + }, + index=result_categories, + ) + + # Calculating result codes + factors = np.ones(len(cols) + 1, dtype=np.int32) # First factor needs to be 1 + np.cumsum(n_categories[::-1], out=factors[1:]) + factors = factors[:-1][::-1] + + code_array = np.zeros((len(cols), df.shape[0]), dtype=np.int32) + for i, c in enumerate(cols): + code_array[i] = df[c].cat.codes + code_array = factors[:, None] + + result_categorical = pd.Categorical.from_codes( + code_array.sum(axis=0), categories=result_categories + ) + + # Filter unused categories + result_categorical = result_categorical.remove_unused_categories() + new_label_df = new_label_df.loc[result_categorical.categories] + + return result_categorical, new_label_df + + +def sparse_indicator( + categorical: pd.Categorical, + , + mask: NDArray[np.bool_] \| None = None, + weight: NDArray[np.floating] \| None = None, +) -> sparse.coo_matrix: + if mask is not None and weight is None: + weight = mask.astype(np.float32) + elif mask is not None and weight is not None: + weight = mask weight + elif mask is None and weight is None: + weight = np.broadcast_to(1.0, len(categorical)) + A = sparse.coo_matrix( + (weight, (categorical.codes, np.arange(len(categorical)))), + shape=(len(categorical.categories), len(categorical)), + ) + return A	diff --git a/scanpy/tests/test_aggregated.py b/scanpy/tests/test_aggregated.py new file mode 100644 index 0000000000..4439f3e0eb --- /dev/null +++ b/scanpy/tests/test_aggregated.py @@ -0,0 +1,373 @@ +from __future__ import annotations + +import anndata as ad +import numpy as np +import pandas as pd +import pytest +from scipy.sparse import csr_matrix + +import scanpy as sc +from scanpy._utils import _resolve_axis +from scanpy.testing._helpers import assert_equal +from scanpy.testing._helpers.data import pbmc3k_processed +from scanpy.testing._pytest.params import ARRAY_TYPES_MEM + + +@pytest.fixture +def df_base(): + ax_base = ["A", "B"] + return pd.DataFrame(index=ax_base) + + +@pytest.fixture +def df_groupby(): + ax_groupby = [ + ["v0", "v1", "v2"], + ["w0", "w1"], + ["a1", "a2", "a3"], + ["b1", "b2"], + ["c1", "c2"], + "d0", + ] + + df_groupby = pd.DataFrame(index=pd.Index(ax_groupby, name="cell")) + df_groupby["key"] = pd.Categorical([c[0] for c in ax_groupby]) + df_groupby["key_superset"] = pd.Categorical([c[0] for c in ax_groupby]).map( + {"v": "v", "w": "v", "a": "a", "b": "a", "c": "a", "d": "a"} + ) + df_groupby["key_subset"] = pd.Categorical([c[1] for c in ax_groupby]) + df_groupby["weight"] = 2.0 + return df_groupby + + +@pytest.fixture +def X(): + data = [ + [[0, -2], [1, 13], [2, 1]], # v + [[3, 12], [4, 2]], # w + [[5, 11], [6, 3], [7, 10]], # a + [[8, 4], [9, 9]], # b + [[10, 5], [11, 8]], # c + [12, 6], # d + ] + return np.array(data, dtype=np.float32) + + +def gen_adata(data_key, dim, df_base, df_groupby, X): + if (data_key == "varm" and dim == "obs") or (data_key == "obsm" and dim == "var"): + pytest.skip("invalid parameter combination") + + obs_df, var_df = (df_groupby, df_base) if dim == "obs" else (df_base, df_groupby) + data = X.T if dim == "var" and data_key != "varm" else X + if data_key != "X": + data_dict_sparse = {data_key: {"test": csr_matrix(data)}} + data_dict_dense = {data_key: {"test": data}} + else: + data_dict_sparse = {data_key: csr_matrix(data)} + data_dict_dense = {data_key: data} + + adata_sparse = ad.AnnData(obs=obs_df, var=var_df, data_dict_sparse) + adata_dense = ad.AnnData(obs=obs_df, var=var_df, data_dict_dense) + return adata_sparse, adata_dense + + +@pytest.mark.parametrize("axis", [0, 1]) +def test_mask(axis): + blobs = sc.datasets.blobs() + mask = blobs.obs["blobs"] == 0 + blobs.obs["mask_col"] = mask + if axis == 1: + blobs = blobs.T + by_name = sc.get.aggregate(blobs, "blobs", "sum", axis=axis, mask="mask_col") + by_value = sc.get.aggregate(blobs, "blobs", "sum", axis=axis, mask=mask) + + assert_equal(by_name, by_value) + + assert np.all(by_name["0"].layers["sum"] == 0) + + +@pytest.mark.parametrize("array_type", ARRAY_TYPES_MEM) +@pytest.mark.parametrize("metric", ["sum", "mean", "var", "count_nonzero"]) +def test_aggregate_vs_pandas(metric, array_type): + adata = pbmc3k_processed().raw.to_adata() + adata = adata[ + adata.obs["louvain"].isin(adata.obs["louvain"].cat.categories[:5]), :1_000 + ].copy() + adata.X = array_type(adata.X) + adata.obs["percent_mito_binned"] = pd.cut(adata.obs["percent_mito"], bins=5) + result = sc.get.aggregate(adata, ["louvain", "percent_mito_binned"], metric) + + if metric == "count_nonzero": + expected = ( + (adata.to_df() != 0) + .astype(np.float64) + .join(adata.obs[["louvain", "percent_mito_binned"]]) + .groupby(["louvain", "percent_mito_binned"], observed=True) + .agg("sum") + ) + else: + expected = ( + adata.to_df() + .astype(np.float64) + .join(adata.obs[["louvain", "percent_mito_binned"]]) + .groupby(["louvain", "percent_mito_binned"], observed=True) + .agg(metric) + ) + # TODO: figure out the axis names + expected.index = expected.index.to_frame().apply( + lambda x: "_".join(map(str, x)), axis=1 + ) + expected.index.name = None + expected.columns.name = None + + result_df = result.to_df(layer=metric) + result_df.index.name = None + result_df.columns.name = None + + pd.testing.assert_frame_equal(result_df, expected, check_dtype=False, atol=1e-5) + + +@pytest.mark.parametrize("array_type", ARRAY_TYPES_MEM) +@pytest.mark.parametrize("metric", ["sum", "mean", "var", "count_nonzero"]) +def test_aggregate_axis(array_type, metric): + adata = pbmc3k_processed().raw.to_adata() + adata = adata[ + adata.obs["louvain"].isin(adata.obs["louvain"].cat.categories[:5]), :1_000 + ].copy() + adata.X = array_type(adata.X) + expected = sc.get.aggregate(adata, ["louvain"], metric) + actual = sc.get.aggregate(adata.T, ["louvain"], metric, axis=1).T + + assert_equal(expected, actual) + + +def test_aggregate_entry(): + args = ("blobs", ["mean", "var", "count_nonzero"]) + + adata = sc.datasets.blobs() + X_result = sc.get.aggregate(adata, args) + # layer adata + layer_adata = ad.AnnData( + obs=adata.obs, + var=adata.var, + layers={"test": adata.X.copy()}, + ) + layer_result = sc.get.aggregate(layer_adata, args, layer="test") + obsm_adata = ad.AnnData( + obs=adata.obs, + var=adata.var, + obsm={"test": adata.X.copy()}, + ) + obsm_result = sc.get.aggregate(obsm_adata, args, obsm="test") + varm_adata = ad.AnnData( + obs=adata.var, + var=adata.obs, + varm={"test": adata.X.copy()}, + ) + varm_result = sc.get.aggregate(varm_adata, args, varm="test") + + X_result_min = X_result.copy() + del X_result_min.var + X_result_min.var_names = [str(x) for x in np.arange(X_result_min.n_vars)] + + assert_equal(X_result, layer_result) + assert_equal(X_result_min, obsm_result) + assert_equal(X_result.layers, obsm_result.layers) + assert_equal(X_result.layers, varm_result.T.layers) + + +def test_aggregate_incorrect_dim(): + adata = pbmc3k_processed().raw.to_adata() + + with pytest.raises(ValueError, match="was 'foo'"): + sc.get.aggregate(adata, ["louvain"], "sum", axis="foo") + + +@pytest.mark.parametrize("axis_name", ["obs", "var"]) +def test_aggregate_axis_specification(axis_name): + axis, axis_name = _resolve_axis(axis_name) + by = "blobs" if axis == 0 else "labels" + + adata = sc.datasets.blobs() + adata.var["labels"] = np.tile(["a", "b"], adata.shape[1])[: adata.shape[1]] + + agg_index = sc.get.aggregate(adata, by=by, func="mean", axis=axis) + agg_name = sc.get.aggregate(adata, by=by, func="mean", axis=axis_name) + + np.testing.assert_equal(agg_index.layers["mean"], agg_name.layers["mean"]) + + if axis_name == "obs": + agg_unspecified = sc.get.aggregate(adata, by=by, func="mean") + np.testing.assert_equal(agg_name.layers["mean"], agg_unspecified.layers["mean"]) + + +@pytest.mark.parametrize( + ("matrix", "df", "keys", "metrics", "expected"), + [ + pytest.param( + np.block( + [ + [np.ones((2, 2)), np.zeros((2, 2))], + [np.zeros((2, 2)), np.ones((2, 2))], + ] + ), + pd.DataFrame( + { + "a": ["a", "a", "b", "b"], + "b": ["c", "d", "d", "d"], + } + ), + ["a", "b"], + ["count_nonzero"], # , "sum", "mean"], + ad.AnnData( + obs=pd.DataFrame( + {"a": ["a", "a", "b"], "b": ["c", "d", "d"]}, + index=["a_c", "a_d", "b_d"], + ).astype("category"), + var=pd.DataFrame(index=[f"gene_{i}" for i in range(4)]), + layers={ + "count_nonzero": np.array( + [[1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 2, 2]] + ), + # "sum": np.array([[2, 0], [0, 2]]), + # "mean": np.array([[1, 0], [0, 1]]), + }, + ), + id="count_nonzero", + ), + pytest.param( + np.block( + [ + [np.ones((2, 2)), np.zeros((2, 2))], + [np.zeros((2, 2)), np.ones((2, 2))], + ] + ), + pd.DataFrame( + { + "a": ["a", "a", "b", "b"], + "b": ["c", "d", "d", "d"], + } + ), + ["a", "b"], + ["sum", "mean", "count_nonzero"], + ad.AnnData( + obs=pd.DataFrame( + {"a": ["a", "a", "b"], "b": ["c", "d", "d"]}, + index=["a_c", "a_d", "b_d"], + ).astype("category"), + var=pd.DataFrame(index=[f"gene_{i}" for i in range(4)]), + layers={ + "sum": np.array([[1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 2, 2]]), + "mean": np.array([[1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 1, 1]]), + "count_nonzero": np.array( + [[1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 2, 2]] + ), + }, + ), + id="sum-mean-count_nonzero", + ), + pytest.param( + np.block( + [ + [np.ones((2, 2)), np.zeros((2, 2))], + [np.zeros((2, 2)), np.ones((2, 2))], + ] + ), + pd.DataFrame( + { + "a": ["a", "a", "b", "b"], + "b": ["c", "d", "d", "d"], + } + ), + ["a", "b"], + ["mean"], + ad.AnnData( + obs=pd.DataFrame( + {"a": ["a", "a", "b"], "b": ["c", "d", "d"]}, + index=["a_c", "a_d", "b_d"], + ).astype("category"), + var=pd.DataFrame(index=[f"gene_{i}" for i in range(4)]), + layers={ + "mean": np.array([[1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 1, 1]]), + }, + ), + id="mean", + ), + ], +) +def test_aggregate_examples(matrix, df, keys, metrics, expected): + adata = ad.AnnData( + X=matrix, + obs=df, + var=pd.DataFrame(index=[f"gene_{i}" for i in range(matrix.shape[1])]), + ) + result = sc.get.aggregate(adata, by=keys, func=metrics) + + print(result) + print(expected) + + assert_equal(expected, result) + + +@pytest.mark.parametrize( + ("label_cols", "cols", "expected"), + [ + pytest.param( + dict( + a=pd.Categorical(["a", "b", "c"]), + b=pd.Categorical(["d", "d", "f"]), + ), + ["a", "b"], + pd.Categorical(["a_d", "b_d", "c_f"]), + id="two_of_two", + ), + pytest.param( + dict( + a=pd.Categorical(["a", "b", "c"]), + b=pd.Categorical(["d", "d", "f"]), + c=pd.Categorical(["g", "h", "h"]), + ), + ["a", "b", "c"], + pd.Categorical(["a_d_g", "b_d_h", "c_f_h"]), + id="three_of_three", + ), + pytest.param( + dict( + a=pd.Categorical(["a", "b", "c"]), + b=pd.Categorical(["d", "d", "f"]), + c=pd.Categorical(["g", "h", "h"]), + ), + ["a", "c"], + pd.Categorical(["a_g", "b_h", "c_h"]), + id="two_of_three-1", + ), + pytest.param( + dict( + a=pd.Categorical(["a", "b", "c"]), + b=pd.Categorical(["d", "d", "f"]), + c=pd.Categorical(["g", "h", "h"]), + ), + ["b", "c"], + pd.Categorical(["d_g", "d_h", "f_h"]), + id="two_of_three-2", + ), + ], +) +def test_combine_categories(label_cols, cols, expected): + from scanpy.get._aggregated import _combine_categories + + label_df = pd.DataFrame(label_cols) + result, result_label_df = _combine_categories(label_df, cols) + + assert isinstance(result, pd.Categorical) + + pd.testing.assert_extension_array_equal(result, expected) + + pd.testing.assert_index_equal( + pd.Index(result), result_label_df.index.astype("category") + ) + + reconstructed_df = pd.DataFrame( + [x.split("_") for x in result], columns=cols, index=result.astype(str) + ).astype("category") + pd.testing.assert_frame_equal(reconstructed_df, result_label_df)	diff --git a/docs/api/get.md b/docs/api/get.md index 82f74ed411..039769d0a6 100644 --- a/docs/api/get.md +++ b/docs/api/get.md @@ -19,5 +19,6 @@ useful formats. get.obs_df get.var_df get.rank_genes_groups_df + get.aggregate ``` diff --git a/docs/release-notes/1.10.0.md b/docs/release-notes/1.10.0.md index 542ee15fd9..0266b2bdf9 100644 --- a/docs/release-notes/1.10.0.md +++ b/docs/release-notes/1.10.0.md @@ -15,6 +15,7 @@ * Enhanced dask support for some internal utilities, paving the way for more extensive dask support {pr}`2696` {smaller}`P Angerer` * {func}`scanpy.pp.pca`, {func}`scanpy.pp.scale`, {func}`scanpy.pl.embedding`, and {func}`scanpy.experimental.pp.normalize_pearson_residuals_pca` now support a `mask` parameter {pr}`2272` {smaller}`C Bright, T Marcella, & P Angerer` +* New function {func}`scanpy.get.aggregate` which allows grouped aggregations over your data. Useful for pseudobulking! {pr}`2590` {smaller}`Isaac Virshup` {smaller}`Ilan Gold` {smaller}`Jon Bloom` * {func}`scanpy.tl.rank_genes_groups` no longer warns that it's default was changed from t-test_overestim_var to t-test {pr}`2798` {smaller}`L Heumos` * {func}`scanpy.tl.leiden` now offers `igraph`'s implementation of the leiden algorithm via via `flavor` when set to `igraph`. `leidenalg`'s implementation is still default, but discouraged. {pr}`2815` {smaller}`I Gold` * {func}`scanpy.pp.highly_variable_genes` has new flavor `seurat_v3_paper` that is in its implementation consistent with the paper description in Stuart et al 2018. {pr}`2792` {smaller}`E Roellin`	[ { "components": [ { "doc": "", "lines": [ 879, 886 ], "name": "_resolve_axis", "signature": "def _resolve_axis( axis: Literal[\"obs\", 0, \"var\", 1], ) -> tuple[Literal[0], Literal[\"obs\"]] \| tuple[Literal[1], Literal[\"var\"]]:", "type...	[ "scanpy/tests/test_aggregated.py::test_mask[0]", "scanpy/tests/test_aggregated.py::test_mask[1]", "scanpy/tests/test_aggregated.py::test_aggregate_vs_pandas[sum-numpy_ndarray]", "scanpy/tests/test_aggregated.py::test_aggregate_vs_pandas[sum-scipy_csr]", "scanpy/tests/test_aggregated.py::test_aggregate_vs_pa...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> (feat): Aggregation via group-by in `sc.get` <!-- Thanks for opening a PR to scanpy! Please be sure to follow the guidelines in our contribution guide (https://scanpy.readthedocs.io/en/latest/dev/index.html) to familiarize yourself with our workflow and speed up review. --> Modified (for `scanpy`) version of https://github.com/scverse/anndata/pull/564. Fixes https://github.com/scverse/anndata/issues/556 Big points of change: 1. No more tuple-indices and related functionality (i.e., scoring pairwise) 2. Allow for `obs` and `var` group-by +`varm`, `obsm`, `layers` as options for data to aggregate 3. Output is `AnnData` object instead of `DataFrame` 4. `scanpy`-style public API ## TODO (by @ivirshup): Necessary: - [x] Docs - [x] Aggregate along other axis - [x] Keep grouping cols in result - [x] Reconsider API for non-anndata version (maybe return a dict of arrays?) - [ ] Decide on naming convention for `"nonzero"` variations, should this be `"nonzero_count"` so it's a little like `"nanmean"` Optional, can do later: - [ ] Weighted (although.... Idk, maybe can skip. Does "weights" affect "count_nonzero"?) - [ ] Option for keeping around unseen groups, probably needs `fill_value` argument for those values - [x] Support for `obsm`, `varm` - [ ] Directly pass Series to groupby - [ ] More aggregation functions (mean_nonzero, min, max, std, `nan` variations) - [ ] Mask argument - [ ] Dask support ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in scanpy/_utils/__init__.py] (definition of _resolve_axis:) def _resolve_axis( axis: Literal["obs", 0, "var", 1], ) -> tuple[Literal[0], Literal["obs"]] \| tuple[Literal[1], Literal["var"]]: [end of new definitions in scanpy/_utils/__init__.py] [start of new definitions in scanpy/get/_aggregated.py] (definition of Aggregate:) class Aggregate: """Functionality for generic grouping and aggregating. There is currently support for count_nonzero, sum, mean, and variance. Implementation* Moments are computed using weighted sum aggregation of data by some feature via multiplication by a sparse coordinate matrix A. Runtime is effectively computation of the product `A @ X`, i.e. the count of (non-zero) entries in X with multiplicity the number of group memberships for that entry. This is `O(data)` for partitions (each observation belonging to exactly one group), independent of the number of groups. Params ------ groupby :class:`~pandas.Categorical` containing values for grouping by. data Data matrix for aggregation. mask Mask to be used for aggregation.""" (definition of Aggregate.__init__:) def __init__( self, groupby: pd.Categorical, data: Array, , mask: NDArray[np.bool_] \| None = None, ) -> None: (definition of Aggregate.count_nonzero:) def count_nonzero(self) -> NDArray[np.integer]: """Count the number of observations in each group. Returns ------- Array of counts.""" (definition of Aggregate.sum:) def sum(self) -> Array: """Compute the sum per feature per group of observations. Returns ------- Array of sum.""" (definition of Aggregate.mean:) def mean(self) -> Array: """Compute the mean per feature per group of observations. Returns ------- Array of mean.""" (definition of Aggregate.mean_var:) def mean_var(self, dof: int = 1) -> tuple[np.ndarray, np.ndarray]: """Compute the count, as well as mean and variance per feature, per group of observations. The formula `Var(X) = E(X^2) - E(X)^2` suffers loss of precision when the variance is a very small fraction of the squared mean. In particular, when X is constant, the formula may nonetheless be non-zero. By default, our implementation resets the variance to exactly zero when the computed variance, relative to the squared mean, nears limit of precision of the floating-point significand. Params ------ dof Degrees of freedom for variance. Returns ------- Object with `count`, `mean`, and `var` attributes.""" (definition of _power:) def _power(X: Array, power: float \| int) -> Array: """Generate elementwise power of a matrix. Needed for non-square sparse matrices because they do not support `` so the `.power` function is used. Params ------ X Matrix whose power is to be raised. power Integer power value Returns ------- Matrix whose power has been raised.""" (definition of aggregate:) def aggregate( adata: AnnData, by: str \| Collection[str], func: AggType \| Iterable[AggType], , axis: Literal["obs", 0, "var", 1] \| None = None, mask: NDArray[np.bool_] \| str \| None = None, dof: int = 1, layer: str \| None = None, obsm: str \| None = None, varm: str \| None = None, ) -> AnnData: """Aggregate data matrix based on some categorical grouping. This function is useful for pseudobulking as well as plotting. Aggregation to perform is specified by `func`, which can be a single metric or a list of metrics. Each metric is computed over the group and results in a new layer in the output `AnnData` object. If none of `layer`, `obsm`, or `varm` are passed in, `X` will be used for aggregation data. If `func` only has length 1 or is just an `AggType`, then aggregation data is written to `X`. Otherwise, it is written to `layers` or `xxxm` as appropriate for the dimensions of the aggregation data. Params ------ adata :class:`~anndata.AnnData` to be aggregated. by Key of the column to be grouped-by. func How to aggregate. axis Axis on which to find group by column. mask Boolean mask (or key to column containing mask) to apply along the axis. dof Degrees of freedom for variance. Defaults to 1. layer If not None, key for aggregation data. obsm If not None, key for aggregation data. varm If not None, key for aggregation data. Returns ------- Aggregated :class:`~anndata.AnnData`. Examples -------- Calculating mean expression and number of nonzero entries per cluster: >>> import scanpy as sc, pandas as pd >>> pbmc = sc.datasets.pbmc3k_processed().raw.to_adata() >>> pbmc.shape (2638, 13714) >>> aggregated = sc.get.aggregate(pbmc, by="louvain", func=["mean", "count_nonzero"]) >>> aggregated AnnData object with n_obs × n_vars = 8 × 13714 obs: 'louvain' var: 'n_cells' layers: 'mean', 'count_nonzero' We can group over multiple columns: >>> pbmc.obs["percent_mito_binned"] = pd.cut(pbmc.obs["percent_mito"], bins=5) >>> sc.get.aggregate(pbmc, by=["louvain", "percent_mito_binned"], func=["mean", "count_nonzero"]) AnnData object with n_obs × n_vars = 40 × 13714 obs: 'louvain', 'percent_mito_binned' var: 'n_cells' layers: 'mean', 'count_nonzero' Note that this filters out any combination of groups that wasn't present in the original data.""" (definition of aggregate_array:) def aggregate_array( data, by: pd.Categorical, func: AggType \| Iterable[AggType], , mask: NDArray[np.bool_] \| None = None, dof: int = 1, ) -> dict[AggType, np.ndarray]: (definition of _combine_categories:) def _combine_categories( label_df: pd.DataFrame, cols: Collection[str] \| str ) -> tuple[pd.Categorical, pd.DataFrame]: """Returns both the result categories and a dataframe labelling each row""" (definition of sparse_indicator:) def sparse_indicator( categorical: pd.Categorical, , mask: NDArray[np.bool_] \| None = None, weight: NDArray[np.floating] \| None = None, ) -> sparse.coo_matrix: [end of new definitions in scanpy/get/_aggregated.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		2f0afac72be3644624cf996323197239580f14f9
conan-io__conan-14382	14,382	conan-io/conan	null	bc4ed4d79fd92edd825fc846dfa515c7b3912138	2023-07-27T18:08:40Z	diff --git a/conan/tools/system/package_manager.py b/conan/tools/system/package_manager.py index 25bc96d6a0a..b5476f376df 100644 --- a/conan/tools/system/package_manager.py +++ b/conan/tools/system/package_manager.py @@ -40,6 +40,7 @@ def get_default_tool(self): elif os_name == "Windows" and self._conanfile.conf.get("tools.microsoft.bash:subsystem") == "msys2": os_name = "msys2" manager_mapping = {"apt-get": ["Linux", "ubuntu", "debian", "raspbian"], + "apk": ["alpine"], "yum": ["pidora", "scientific", "xenserver", "amazon", "oracle", "amzn", "almalinux", "rocky"], "dnf": ["fedora", "rhel", "centos", "mageia"], @@ -332,6 +333,25 @@ def __init__(self, conanfile, arch_names=None): self._arch_separator = "-" +class Apk(_SystemPackageManagerTool): + tool_name = "apk" + install_command = "{sudo}{tool} add --no-cache {packages}" + update_command = "{sudo}{tool} update" + check_command = "{tool} info -e {package}" + + def __init__(self, conanfile, _arch_names=None): + """ + Constructor method. + Note that Apk does not support architecture names since Alpine Linux does not support + multiarch. Therefore, the ``arch_names`` argument is ignored. + + :param conanfile: the current recipe object. Always use ``self``. + """ + super(Apk, self).__init__(conanfile) + self._arch_names = {} + self._arch_separator = "" + + class Zypper(_SystemPackageManagerTool): tool_name = "zypper" install_command = "{sudo}{tool} --non-interactive in {packages}"	diff --git a/conans/test/integration/tools/system/package_manager_test.py b/conans/test/integration/tools/system/package_manager_test.py index 07f7bdf02b6..a533f647ccf 100644 --- a/conans/test/integration/tools/system/package_manager_test.py +++ b/conans/test/integration/tools/system/package_manager_test.py @@ -5,8 +5,8 @@ import pytest from unittest.mock import PropertyMock -from conan.tools.system.package_manager import Apt, Dnf, Yum, Brew, Pkg, PkgUtil, Chocolatey, Zypper, \ - PacMan, _SystemPackageManagerTool +from conan.tools.system.package_manager import Apt, Apk, Dnf, Yum, Brew, Pkg, PkgUtil, Chocolatey, \ + Zypper, PacMan, _SystemPackageManagerTool from conans.errors import ConanException from conans.model.conf import Conf from conans.model.settings import Settings @@ -58,6 +58,7 @@ def test_msys2(): ("opensuse-leap", "zypper"), ("opensuse-next_version", "zypper"), ("freebsd", "pkg"), + ("alpine", "apk"), ]) @pytest.mark.skipif(platform.system() != "Linux", reason="Only linux") def test_package_manager_distro(distro, tool): @@ -107,7 +108,7 @@ def test_apt_install_recommends(recommends, recommends_str): @pytest.mark.parametrize("tool_class", - [Apt, Yum, Dnf, Brew, Pkg, PkgUtil, Chocolatey, PacMan, Zypper]) + [Apk, Apt, Yum, Dnf, Brew, Pkg, PkgUtil, Chocolatey, PacMan, Zypper]) def test_tools_install_mode_check(tool_class): conanfile = ConanFileMock() conanfile.conf = Conf() @@ -132,6 +133,7 @@ def fake_check(args, kwargs): @pytest.mark.parametrize("tool_class, result", [ + (Apk, "apk update"), (Apt, "apt-get update"), (Yum, "yum check-update -y"), (Dnf, "dnf check-update -y"), @@ -198,6 +200,7 @@ def fake_run(command, win_bash=False, subsystem=None, env=None, ignore_errors=Fa @pytest.mark.parametrize("tool_class, arch_host, result", [ # not cross-compile -> do not add host architecture + (Apk, 'x86_64', 'apk add --no-cache package1 package2'), (Apt, 'x86_64', 'apt-get install -y --no-install-recommends package1 package2'), (Yum, 'x86_64', 'yum install -y package1 package2'), (Dnf, 'x86_64', 'dnf install -y package1 package2'), @@ -221,7 +224,7 @@ def fake_run(command, win_bash=False, subsystem=None, env=None, ignore_errors=Fa def test_tools_install_mode_install_different_archs(tool_class, arch_host, result): conanfile = ConanFileMock() conanfile.conf = Conf() - conanfile.settings = MockSettings({"arch": f"{arch_host}"}) + conanfile.settings = MockSettings({"arch": arch_host}) conanfile.settings_build = MockSettings({"arch": "x86_64"}) conanfile.conf.define("tools.system.package_manager:tool", tool_class.tool_name) conanfile.conf.define("tools.system.package_manager:mode", "install") @@ -267,6 +270,7 @@ def fake_check(args, **kwargs): @pytest.mark.parametrize("tool_class, result", [ + (Apk, 'apk info -e package'), (Apt, 'dpkg-query -W -f=\'${Status}\' package \| grep -q "ok installed"'), (Yum, 'rpm -q package'), (Dnf, 'rpm -q package'),		[ { "components": [ { "doc": "", "lines": [ 336, 352 ], "name": "Apk", "signature": "class Apk(_SystemPackageManagerTool):", "type": "class" }, { "doc": "Constructor method.\nNote that Apk does not support architecture...	[ "conans/test/integration/tools/system/package_manager_test.py::test_package_manager_platform[Linux-apt-get]", "conans/test/integration/tools/system/package_manager_test.py::test_package_manager_platform[Windows-choco]", "conans/test/integration/tools/system/package_manager_test.py::test_package_manager_platform...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> tools: Add support for Alpine Linux This commit closes #14307. Changelog: Feature: Added support for `apk` package manager and Alpine Linux Docs: https://github.com/conan-io/docs/pull/3312 - [X] Refer to the issue that supports this Pull Request. - [X] I've read the [Contributing guide](https://github.com/conan-io/conan/blob/develop/.github/CONTRIBUTING.md). - [X] I've followed the PEP8 style guides for Python code. - [X] I've opened another PR in the Conan docs repo to the ``develop2`` branch, documenting this one. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conan/tools/system/package_manager.py] (definition of Apk:) class Apk(_SystemPackageManagerTool): (definition of Apk.__init__:) def __init__(self, conanfile, _arch_names=None): """Constructor method. Note that Apk does not support architecture names since Alpine Linux does not support multiarch. Therefore, the ``arch_names`` argument is ignored. :param conanfile: the current recipe object. Always use ``self``.""" [end of new definitions in conan/tools/system/package_manager.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> [feature] Support Alpine Linux system package manager ### What is your suggestion? Hi, The system manager support in conan is really handy and already covers a large list of distributions/tools. It would be very nice though if it could also support [`apk`](https://wiki.alpinelinux.org/wiki/Alpine_Package_Keeper) for the Alpine Linux distribution. ### Have you read the CONTRIBUTING guide? - [X] I've read the CONTRIBUTING guide ---------- Hi @Sahnvour Thanks for your suggestion. Just to be sure, this is to add the ``Apk`` package manager to the Conan tool, but that doesn't mean that package recipes in ConanCenter will necessarily add its usage (Alpine not tested in ConanCenter CI). So it is for your own private recipes, isn't it? We don't know much about ``apk``, would you like to contribute the feature yourself? It should be relatively straightforward, copying one of the existing ones. Hi @memsharded, > So it is for your own private recipes, isn't it? Yes, I am building my projects on Alpine in CI because it's a musl-based distribution that improves coverage, and I also think it is quite used in the docker space because of its small default size. As such, I'd be glad to let conan install system dependencies by itself instead of manually listing them myself. I understand ConanCenter would probably not have prebuilt binaries but it's ok. I don't know much about `apk` myself, however if you can give me some pointers on where to start in conan I will have a look at it (no promises). > I don't know much about apk myself, however if you can give me some pointers on where to start in conan I will have a look at it (no promises). Sure, no commitment here at all, just if you like to do it. Some pointers: - The entry point, and possibly the only file necessary to change is this one: https://github.com/conan-io/conan/blob/release/2.0/conan/tools/system/package_manager.py - Copy and paste the ``Apt`` or the ``Yum`` class, and then start customizing for the ``apk`` case. - If you clone and pip-install as editable the source project (https://github.com/conan-io/conan#setup), you can run ``conan`` commands using your clone changes - Write a small recipe ``conanfile.py`` with a ``system_requirements()`` method that uses your new ``Apk`` class - Try things. - Finally, some integration tests would be enough, in this file: https://github.com/conan-io/conan/blob/release/2.0/conans/test/integration/tools/system/package_manager_test.py Hey @memsharded ! Thanks for the pointers! One issue I realized while poking into that is the fact that Alpine is a no-multilib distro. Hence, the concept of adding an arch separator and an explicit architecture to the package name is not applicable there. So far I'm not sure how much of a problem this is. Let's see. -------------------- </issues>	4a5b19a75db9225316c8cb022a2dfb9705a2af34
roboflow__supervision-245	245	roboflow/supervision	null	36cdcf1b128e38cb9a086290fbfb0130fa64ac5b	2023-07-26T08:25:02Z	diff --git a/supervision/dataset/core.py b/supervision/dataset/core.py index ce7e0edb5..6e47d747f 100644 --- a/supervision/dataset/core.py +++ b/supervision/dataset/core.py @@ -31,7 +31,6 @@ train_test_split, ) from supervision.detection.core import Detections -from supervision.utils.file import list_files_with_extensions @dataclass @@ -197,7 +196,10 @@ def as_pascal_voc( @classmethod def from_pascal_voc( - cls, images_directory_path: str, annotations_directory_path: str + cls, + images_directory_path: str, + annotations_directory_path: str, + force_masks: bool = False, ) -> DetectionDataset: """ Creates a Dataset instance from PASCAL VOC formatted data. @@ -205,6 +207,7 @@ def from_pascal_voc( Args: images_directory_path (str): The path to the directory containing the images. annotations_directory_path (str): The path to the directory containing the PASCAL VOC XML annotations. + force_masks (bool, optional): If True, forces masks to be loaded for all annotations, regardless of whether they are present. Returns: DetectionDataset: A DetectionDataset instance containing the loaded images and annotations. @@ -222,7 +225,7 @@ def from_pascal_voc( >>> project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID) >>> dataset = project.version(PROJECT_VERSION).download("voc") - >>> ds = sv.DetectionDataset.from_yolo( + >>> ds = sv.DetectionDataset.from_pascal_voc( ... images_directory_path=f"{dataset.location}/train/images", ... annotations_directory_path=f"{dataset.location}/train/labels" ... ) @@ -231,34 +234,13 @@ def from_pascal_voc( ['dog', 'person'] ``` """ - image_paths = list_files_with_extensions( - directory=images_directory_path, extensions=["jpg", "jpeg", "png"] - ) - annotation_paths = list_files_with_extensions( - directory=annotations_directory_path, extensions=["xml"] - ) - raw_annotations: List[Tuple[str, Detections, List[str]]] = [ - load_pascal_voc_annotations(annotation_path=str(annotation_path)) - for annotation_path in annotation_paths - ] - - classes = [] - for annotation in raw_annotations: - classes.extend(annotation[2]) - classes = list(set(classes)) - - for annotation in raw_annotations: - class_id = [classes.index(class_name) for class_name in annotation[2]] - annotation[1].class_id = np.array(class_id) - - images = { - image_path.name: cv2.imread(str(image_path)) for image_path in image_paths - } + classes, images, annotations = load_pascal_voc_annotations( + images_directory_path=images_directory_path, + annotations_directory_path=annotations_directory_path, + force_masks=force_masks, + ) - annotations = { - image_name: detections for image_name, detections, _ in raw_annotations - } return DetectionDataset(classes=classes, images=images, annotations=annotations) @classmethod diff --git a/supervision/dataset/formats/pascal_voc.py b/supervision/dataset/formats/pascal_voc.py index a3005eb90..4efb29173 100644 --- a/supervision/dataset/formats/pascal_voc.py +++ b/supervision/dataset/formats/pascal_voc.py @@ -1,12 +1,16 @@ -from typing import List, Optional, Tuple +import os +from pathlib import Path +from typing import Dict, List, Optional, Tuple from xml.dom.minidom import parseString from xml.etree.ElementTree import Element, SubElement, parse, tostring +import cv2 import numpy as np from supervision.dataset.utils import approximate_mask_with_polygons from supervision.detection.core import Detections -from supervision.detection.utils import polygon_to_xyxy +from supervision.detection.utils import polygon_to_mask, polygon_to_xyxy +from supervision.utils.file import list_files_with_extensions def object_to_pascal_voc( @@ -120,24 +124,91 @@ def detections_to_pascal_voc( def load_pascal_voc_annotations( - annotation_path: str, -) -> Tuple[str, Detections, List[str]]: + images_directory_path: str, + annotations_directory_path: str, + force_masks: bool = False, +) -> Tuple[List[str], Dict[str, np.ndarray], Dict[str, Detections]]: """ - Loads PASCAL VOC XML annotations and returns the image name, a Detections instance, and a list of class names. + Loads PASCAL VOC annotations and returns class names, images, and their corresponding detections. Args: - annotation_path (str): The path to the PASCAL VOC XML annotations file. + images_directory_path (str): The path to the directory containing the images. + annotations_directory_path (str): The path to the directory containing the PASCAL VOC annotation files. + force_masks (bool, optional): If True, forces masks to be loaded for all annotations, regardless of whether they are present. Returns: - Tuple[str, Detections, List[str]]: A tuple containing the image name, a Detections instance, and a list of class names of objects in the detections. + Tuple[List[str], Dict[str, np.ndarray], Dict[str, Detections]]: A tuple containing a list of class names, a dictionary with image names as keys and images as values, and a dictionary with image names as keys and corresponding Detections instances as values. """ - tree = parse(annotation_path) - root = tree.getroot() - image_name = root.find("filename").text + image_paths = list_files_with_extensions( + directory=images_directory_path, extensions=["jpg", "jpeg", "png"] + ) + classes = [] + images = {} + annotations = {} + + for image_path in image_paths: + image_name = Path(image_path).stem + image = cv2.imread(str(image_path)) + + annotation_path = os.path.join(annotations_directory_path, f"{image_name}.xml") + if not os.path.exists(annotation_path): + images[image_path.name] = image + annotations[image_path.name] = Detections.empty() + continue + + tree = parse(annotation_path) + root = tree.getroot() + + resolution_wh = (image.shape[1], image.shape[0]) + annotation, classes = detections_from_xml_obj( + root, classes, resolution_wh, force_masks + ) + + images[image_path.name] = image + annotations[image_path.name] = annotation + + return classes, images, annotations + + +def detections_from_xml_obj( + root: Element, classes: List[str], resolution_wh, force_masks: bool = False +) -> Tuple[Detections, List[str]]: + """ + Converts an XML object in Pascal VOC format to a Detections object. + Expected XML format: + <annotation> + ... + <object> + <name>dog</name> + <bndbox> + <xmin>48</xmin> + <ymin>240</ymin> + <xmax>195</xmax> + <ymax>371</ymax> + </bndbox> + <polygon> + <x1>48</x1> + <y1>240</y1> + <x2>195</x2> + <y2>240</y2> + <x3>195</x3> + <y3>371</y3> + <x4>48</x4> + <y4>371</y4> + </polygon> + </object> + </annotation> + + Returns: + Tuple[Detections, List[str]]: A tuple containing a Detections object and an updated list of class names, extended with the class names from the XML object. + """ xyxy = [] class_names = [] + masks = [] + with_masks = False + extended_classes = classes[:] for obj in root.findall("object"): class_name = obj.find("name").text class_names.append(class_name) @@ -150,7 +221,40 @@ def load_pascal_voc_annotations( xyxy.append([x1, y1, x2, y2]) - xyxy = np.array(xyxy) - detections = Detections(xyxy=xyxy) + with_masks = obj.find("polygon") is not None + with_masks = force_masks if force_masks else with_masks + + for polygon in obj.findall("polygon"): + polygon_points = parse_polygon_points(polygon) + + mask_from_polygon = polygon_to_mask( + polygon=np.array(polygon_points), + resolution_wh=resolution_wh, + ) + masks.append(mask_from_polygon) + + xyxy = np.array(xyxy) if len(xyxy) > 0 else np.empty((0, 4)) + for k in set(class_names): + if k not in extended_classes: + extended_classes.append(k) + class_id = np.array( + [extended_classes.index(class_name) for class_name in class_names] + ) + + if with_masks: + annotation = Detections( + xyxy=xyxy, mask=np.array(masks).astype(bool), class_id=class_id + ) + else: + annotation = Detections(xyxy=xyxy, class_id=class_id) + return annotation, extended_classes + - return image_name, detections, class_names +def parse_polygon_points(polygon: Element) -> List[List[int]]: + polygon_points = [] + coords = polygon.findall(".//*") + for i in range(0, len(coords), 2): + x = int(coords[i].text) + y = int(coords[i + 1].text) + polygon_points.append([x, y]) + return polygon_points diff --git a/supervision/detection/utils.py b/supervision/detection/utils.py index 63206ddcc..e30e6a053 100644 --- a/supervision/detection/utils.py +++ b/supervision/detection/utils.py @@ -17,7 +17,7 @@ def polygon_to_mask(polygon: np.ndarray, resolution_wh: Tuple[int, int]) -> np.n np.ndarray: The generated 2D mask, where the polygon is marked with `1`'s and the rest is filled with `0`'s. """ width, height = resolution_wh - mask = np.zeros((height, width), dtype=np.uint8) + mask = np.zeros((height, width)) cv2.fillPoly(mask, [polygon], color=1) return mask	diff --git a/test/dataset/formats/test_pascal_voc.py b/test/dataset/formats/test_pascal_voc.py new file mode 100644 index 000000000..fa3f11244 --- /dev/null +++ b/test/dataset/formats/test_pascal_voc.py @@ -0,0 +1,147 @@ +import xml.etree.ElementTree as ET +from contextlib import ExitStack as DoesNotRaise +from test.utils import mock_detections +from typing import List, Optional + +import numpy as np +import pytest + +from supervision.dataset.formats.pascal_voc import ( + detections_from_xml_obj, + object_to_pascal_voc, + parse_polygon_points, +) + + +def are_xml_elements_equal(elem1, elem2): + if ( + elem1.tag != elem2.tag + or elem1.attrib != elem2.attrib + or elem1.text != elem2.text + or len(elem1) != len(elem2) + ): + return False + + for child1, child2 in zip(elem1, elem2): + if not are_xml_elements_equal(child1, child2): + return False + + return True + + +@pytest.mark.parametrize( + "xyxy, name, polygon, expected_result, exception", + [ + ( + [0, 0, 10, 10], + "test", + None, + ET.fromstring( + """<object><name>test</name><bndbox><xmin>0</xmin><ymin>0</ymin><xmax>10</xmax><ymax>10</ymax></bndbox></object>""" + ), + DoesNotRaise(), + ), + ( + [0, 0, 10, 10], + "test", + [[0, 0], [10, 0], [10, 10], [0, 10]], + ET.fromstring( + """<object><name>test</name><bndbox><xmin>0</xmin><ymin>0</ymin><xmax>10</xmax><ymax>10</ymax></bndbox><polygon><x1>0</x1><y1>0</y1><x2>10</x2><y2>0</y2><x3>10</x3><y3>10</y3><x4>0</x4><y4>10</y4></polygon></object>""" + ), + DoesNotRaise(), + ), + ], +) +def test_object_to_pascal_voc( + xyxy: np.ndarray, + name: str, + polygon: Optional[np.ndarray], + expected_result, + exception: Exception, +): + with exception: + result = object_to_pascal_voc(xyxy=xyxy, name=name, polygon=polygon) + assert are_xml_elements_equal(result, expected_result) + + +@pytest.mark.parametrize( + "polygon_element, expected_result, exception", + [ + ( + ET.fromstring( + """<polygon><x1>0</x1><y1>0</y1><x2>10</x2><y2>0</y2><x3>10</x3><y3>10</y3><x4>0</x4><y4>10</y4></polygon>""" + ), + [[0, 0], [10, 0], [10, 10], [0, 10]], + DoesNotRaise(), + ) + ], +) +def test_parse_polygon_points( + polygon_element, + expected_result: List[list], + exception, +): + with exception: + result = parse_polygon_points(polygon_element) + assert result == expected_result + + +ONE_CLASS_N_BBOX = """<annotation><object><name>test</name><bndbox><xmin>0</xmin><ymin>0</ymin><xmax>10</xmax><ymax>10</ymax></bndbox></object><object><name>test</name><bndbox><xmin>10</xmin><ymin>10</ymin><xmax>20</xmax><ymax>20</ymax></bndbox></object></annotation>""" + + +ONE_CLASS_ONE_BBOX = """<annotation><object><name>test</name><bndbox><xmin>0</xmin><ymin>0</ymin><xmax>10</xmax><ymax>10</ymax></bndbox></object></annotation>""" + + +N_CLASS_N_BBOX = """<annotation><object><name>test</name><bndbox><xmin>0</xmin><ymin>0</ymin><xmax>10</xmax><ymax>10</ymax></bndbox></object><object><name>test</name><bndbox><xmin>20</xmin><ymin>30</ymin><xmax>30</xmax><ymax>40</ymax></bndbox></object><object><name>test2</name><bndbox><xmin>10</xmin><ymin>10</ymin><xmax>20</xmax><ymax>20</ymax></bndbox></object></annotation>""" + +NO_DETECTIONS = """<annotation></annotation>""" + + +@pytest.mark.parametrize( + "xml_string, classes, resolution_wh, force_masks, expected_result, exception", + [ + ( + ONE_CLASS_ONE_BBOX, + ["test"], + (100, 100), + False, + mock_detections(np.array([[0, 0, 10, 10]]), None, [0]), + DoesNotRaise(), + ), + ( + ONE_CLASS_N_BBOX, + ["test"], + (100, 100), + False, + mock_detections(np.array([[0, 0, 10, 10], [10, 10, 20, 20]]), None, [0, 0]), + DoesNotRaise(), + ), + ( + N_CLASS_N_BBOX, + ["test", "test2"], + (100, 100), + False, + mock_detections( + np.array([[0, 0, 10, 10], [20, 30, 30, 40], [10, 10, 20, 20]]), + None, + [0, 0, 1], + ), + DoesNotRaise(), + ), + ( + NO_DETECTIONS, + [], + (100, 100), + False, + mock_detections(np.empty((0, 4)), None, []), + DoesNotRaise(), + ), + ], +) +def test_detections_from_xml_obj( + xml_string, classes, resolution_wh, force_masks, expected_result, exception +): + with exception: + root = ET.fromstring(xml_string) + result, _ = detections_from_xml_obj(root, classes, resolution_wh, force_masks) + assert result == expected_result		[ { "components": [ { "doc": "Converts an XML object in Pascal VOC format to a Detections object.\nExpected XML format:\n<annotation>\n ...\n <object>\n <name>dog</name>\n <bndbox>\n <xmin>48</xmin>\n <ymin>240</ymin>\n <xmax>195</xmax>\n ...	[ "test/dataset/formats/test_pascal_voc.py::test_object_to_pascal_voc[xyxy0-test-None-expected_result0-exception0]", "test/dataset/formats/test_pascal_voc.py::test_object_to_pascal_voc[xyxy1-test-polygon1-expected_result1-exception1]", "test/dataset/formats/test_pascal_voc.py::test_parse_polygon_points[polygon_el...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add support for loading segmentation datasets in Pascal VOC format # Description Add possibility to load PASCAL VOC segmentation masks in addition to object detection ([related issue](https://github.com/roboflow/supervision/issues/244)). Changes were made to core.DetectionDataset.from_pascal_voc and format.pascal_voc.load_pascal_voc_annotations. ## Type of change Please delete options that are not relevant. - [+] New feature (non-breaking change which adds functionality) ## How has this change been tested, please provide a testcase or example of how you tested the change? Via new tests. ## Any specific deployment considerations For example, documentation changes, usability, usage/costs, secrets, etc. ## Docs - [ ] Docs updated? What were the changes: ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in supervision/dataset/formats/pascal_voc.py] (definition of detections_from_xml_obj:) def detections_from_xml_obj( root: Element, classes: List[str], resolution_wh, force_masks: bool = False ) -> Tuple[Detections, List[str]]: """Converts an XML object in Pascal VOC format to a Detections object. Expected XML format: <annotation> ... <object> <name>dog</name> <bndbox> <xmin>48</xmin> <ymin>240</ymin> <xmax>195</xmax> <ymax>371</ymax> </bndbox> <polygon> <x1>48</x1> <y1>240</y1> <x2>195</x2> <y2>240</y2> <x3>195</x3> <y3>371</y3> <x4>48</x4> <y4>371</y4> </polygon> </object> </annotation> Returns: Tuple[Detections, List[str]]: A tuple containing a Detections object and an updated list of class names, extended with the class names from the XML object.""" (definition of parse_polygon_points:) def parse_polygon_points(polygon: Element) -> List[List[int]]: [end of new definitions in supervision/dataset/formats/pascal_voc.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		3eb5c0b024e3e46877b7fe4fd66e6177d1308ba0
roboflow__supervision-236	236	roboflow/supervision	null	36cdcf1b128e38cb9a086290fbfb0130fa64ac5b	2023-07-24T18:37:19Z	diff --git a/docs/metrics/detection.md b/docs/metrics/detection.md index 9e7844645..feea7cce8 100644 --- a/docs/metrics/detection.md +++ b/docs/metrics/detection.md @@ -6,3 +6,7 @@ ## ConfusionMatrix :::supervision.metrics.detection.ConfusionMatrix + +## MeanAveragePrecision + +:::supervision.metrics.detection.MeanAveragePrecision diff --git a/supervision/__init__.py b/supervision/__init__.py index 9c0252fb0..edb9675dc 100644 --- a/supervision/__init__.py +++ b/supervision/__init__.py @@ -30,7 +30,7 @@ from supervision.draw.utils import draw_filled_rectangle, draw_polygon, draw_text from supervision.geometry.core import Point, Position, Rect from supervision.geometry.utils import get_polygon_center -from supervision.metrics.detection import ConfusionMatrix +from supervision.metrics.detection import ConfusionMatrix, MeanAveragePrecision from supervision.utils.file import list_files_with_extensions from supervision.utils.image import ImageSink, crop from supervision.utils.notebook import plot_image, plot_images_grid diff --git a/supervision/metrics/detection.py b/supervision/metrics/detection.py index 5b5f710a9..d126f82e4 100644 --- a/supervision/metrics/detection.py +++ b/supervision/metrics/detection.py @@ -12,6 +12,59 @@ from supervision.detection.utils import box_iou_batch +def detections_to_tensor( + detections: Detections, with_confidence: bool = False +) -> np.ndarray: + """ + Convert Supervision Detections to numpy tensors for further computation + Args: + detections (sv.Detections): Detections/Targets in the format of sv.Detections + with_confidence (bool): Whether to include confidence in the tensor + Returns: + (np.ndarray): Detections as numpy tensors as in (xyxy, class_id, confidence) order + """ + if detections.class_id is None: + raise ValueError( + "ConfusionMatrix can only be calculated for Detections with class_id" + ) + + arrays_to_concat = [detections.xyxy, np.expand_dims(detections.class_id, 1)] + + if with_confidence: + if detections.confidence is None: + raise ValueError( + "ConfusionMatrix can only be calculated for Detections with confidence" + ) + arrays_to_concat.append(np.expand_dims(detections.confidence, 1)) + + return np.concatenate(arrays_to_concat, axis=1) + + +def validate_input_tensors(predictions: List[np.ndarray], targets: List[np.ndarray]): + """ + Checks for shape consistency of input tensors. + """ + if len(predictions) != len(targets): + raise ValueError( + f"Number of predictions ({len(predictions)}) and targets ({len(targets)}) must be equal." + ) + if len(predictions) > 0: + if not isinstance(predictions[0], np.ndarray) or not isinstance( + targets[0], np.ndarray + ): + raise ValueError( + f"Predictions and targets must be lists of numpy arrays. Got {type(predictions[0])} and {type(targets[0])} instead." + ) + if predictions[0].shape[1] != 6: + raise ValueError( + f"Predictions must have shape (N, 6). Got {predictions[0].shape} instead." + ) + if targets[0].shape[1] != 5: + raise ValueError( + f"Targets must have shape (N, 5). Got {targets[0].shape} instead." + ) + + @dataclass class ConfusionMatrix: """ @@ -85,11 +138,9 @@ def from_detections( target_tensors = [] for prediction, target in zip(predictions, targets): prediction_tensors.append( - ConfusionMatrix.detections_to_tensor(prediction, with_confidence=True) - ) - target_tensors.append( - ConfusionMatrix.detections_to_tensor(target, with_confidence=False) + detections_to_tensor(prediction, with_confidence=True) ) + target_tensors.append(detections_to_tensor(target, with_confidence=False)) return cls.from_tensors( predictions=prediction_tensors, targets=target_tensors, @@ -98,26 +149,6 @@ def from_detections( iou_threshold=iou_threshold, ) - @staticmethod - def detections_to_tensor( - detections: Detections, with_confidence: bool = False - ) -> np.ndarray: - if detections.class_id is None: - raise ValueError( - "ConfusionMatrix can only be calculated for Detections with class_id" - ) - - arrays_to_concat = [detections.xyxy, np.expand_dims(detections.class_id, 1)] - - if with_confidence: - if detections.confidence is None: - raise ValueError( - "ConfusionMatrix can only be calculated for Detections with confidence" - ) - arrays_to_concat.append(np.expand_dims(detections.confidence, 1)) - - return np.concatenate(arrays_to_concat, axis=1) - @classmethod def from_tensors( cls, @@ -184,7 +215,7 @@ def from_tensors( ]) ``` """ - cls._validate_input_tensors(predictions, targets) + validate_input_tensors(predictions, targets) num_classes = len(classes) matrix = np.zeros((num_classes + 1, num_classes + 1)) @@ -203,33 +234,6 @@ def from_tensors( iou_threshold=iou_threshold, ) - @classmethod - def _validate_input_tensors( - cls, predictions: List[np.ndarray], targets: List[np.ndarray] - ): - """ - Checks for shape consistency of input tensors. - """ - if len(predictions) != len(targets): - raise ValueError( - f"Number of predictions ({len(predictions)}) and targets ({len(targets)}) must be equal." - ) - if len(predictions) > 0: - if not isinstance(predictions[0], np.ndarray) or not isinstance( - targets[0], np.ndarray - ): - raise ValueError( - f"Predictions and targets must be lists of numpy arrays. Got {type(predictions[0])} and {type(targets[0])} instead." - ) - if predictions[0].shape[1] != 6: - raise ValueError( - f"Predictions must have shape (N, 6). Got {predictions[0].shape} instead." - ) - if targets[0].shape[1] != 5: - raise ValueError( - f"Targets must have shape (N, 5). Got {targets[0].shape} instead." - ) - @staticmethod def evaluate_detection_batch( predictions: np.ndarray, @@ -319,7 +323,7 @@ def benchmark( iou_threshold: float = 0.5, ) -> ConfusionMatrix: """ - Create confusion matrix from dataset and callback function. + Calculate confusion matrix from dataset and callback function. Args: dataset (DetectionDataset): Object detection dataset used for evaluation. @@ -456,3 +460,331 @@ def plot( save_path, dpi=250, facecolor=fig.get_facecolor(), transparent=True ) return fig + + +@dataclass(frozen=True) +class MeanAveragePrecision: + """ + Mean Average Precision for object detection tasks. + + Attributes: + map (float): mAP value. + map50 (float): mAP value at IoU `threshold = 0.5`. + map75 (float): mAP value at IoU `threshold = 0.75`. + per_class_ap (np.ndarray): values for every classes. + """ + + map: float + map50: float + map75: float + per_class_ap: np.ndarray + + @classmethod + def from_detections( + cls, + predictions: List[Detections], + targets: List[Detections], + ) -> MeanAveragePrecision: + """ + Calculate mean average precision based on predicted and ground-truth detections. + + Args: + targets (List[Detections]): Detections objects from ground-truth. + predictions (List[Detections]): Detections objects predicted by the model. + Returns: + MeanAveragePrecision: New instance of ConfusionMatrix. + + Example: + ```python + >>> import supervision as sv + + >>> targets = [ + ... sv.Detections(...), + ... sv.Detections(...) + ... ] + + >>> predictions = [ + ... sv.Detections(...), + ... sv.Detections(...) + ... ] + + >>> mean_average_precision = sv.MeanAveragePrecision.from_detections( + ... predictions=predictions, + ... targets=target, + ... ) + + >>> mean_average_precison.map + 0.2899 + ``` + """ + prediction_tensors = [] + target_tensors = [] + for prediction, target in zip(predictions, targets): + prediction_tensors.append( + detections_to_tensor(prediction, with_confidence=True) + ) + target_tensors.append(detections_to_tensor(target, with_confidence=False)) + return cls.from_tensors( + predictions=prediction_tensors, + targets=target_tensors, + ) + + @classmethod + def benchmark( + cls, + dataset: DetectionDataset, + callback: Callable[[np.ndarray], Detections], + ) -> MeanAveragePrecision: + """ + Calculate mean average precision from dataset and callback function. + + Args: + dataset (DetectionDataset): Object detection dataset used for evaluation. + callback (Callable[[np.ndarray], Detections]): Function that takes an image as input and returns Detections object. + Returns: + MeanAveragePrecision: New instance of MeanAveragePrecision. + + Example: + ```python + >>> import supervision as sv + >>> from ultralytics import YOLO + + >>> dataset = sv.DetectionDataset.from_yolo(...) + + >>> model = YOLO(...) + >>> def callback(image: np.ndarray) -> sv.Detections: + ... result = model(image)[0] + ... return sv.Detections.from_yolov8(result) + + >>> mean_average_precision = sv.MeanAveragePrecision.benchmark( + ... dataset = dataset, + ... callback = callback + ... ) + + >>> mean_average_precision.map + 0.433 + ``` + """ + predictions, targets = [], [] + for img_name, img in dataset.images.items(): + predictions_batch = callback(img) + predictions.append(predictions_batch) + targets_batch = dataset.annotations[img_name] + targets.append(targets_batch) + return cls.from_detections( + predictions=predictions, + targets=targets, + ) + + @classmethod + def from_tensors( + cls, + predictions: List[np.ndarray], + targets: List[np.ndarray], + ) -> MeanAveragePrecision: + """ + Calculate Mean Average Precision based on predicted and ground-truth detections at different threshold. + + Args: + predictions (List[np.ndarray]): Each element of the list describes a single image and has `shape = (M, 6)` where `M` is the number of detected objects. Each row is expected to be in `(x_min, y_min, x_max, y_max, class, conf)` format. + targets (List[np.ndarray]): Each element of the list describes a single image and has `shape = (N, 5)` where `N` is the number of ground-truth objects. Each row is expected to be in `(x_min, y_min, x_max, y_max, class)` format. + Returns: + MeanAveragePrecision: New instance of MeanAveragePrecision. + + Example: + ```python + >>> import supervision as sv + + >>> targets = ( + ... [ + ... array( + ... [ + ... [0.0, 0.0, 3.0, 3.0, 1], + ... [2.0, 2.0, 5.0, 5.0, 1], + ... [6.0, 1.0, 8.0, 3.0, 2], + ... ] + ... ), + ... array([1.0, 1.0, 2.0, 2.0, 2]), + ... ] + ... ) + + >>> predictions = [ + ... array( + ... [ + ... [0.0, 0.0, 3.0, 3.0, 1, 0.9], + ... [0.1, 0.1, 3.0, 3.0, 0, 0.9], + ... [6.0, 1.0, 8.0, 3.0, 1, 0.8], + ... [1.0, 6.0, 2.0, 7.0, 1, 0.8], + ... ] + ... ), + ... array([[1.0, 1.0, 2.0, 2.0, 2, 0.8]]) + ... ] + + >>> mean_average_precison = sv.MeanAveragePrecision.from_tensors( + ... predictions=predictions, + ... targets=targets, + ... ) + + >>> mean_average_precison.map + 0.2899 + ``` + """ + validate_input_tensors(predictions, targets) + map, map50, map75 = 0, 0, 0 + + class_index = 4 + conf_index = 5 + + stats, average_precisions = [], [] + iou_levels = np.linspace(0.5, 0.95, 10) + num_ious = iou_levels.size + + for true_batch, detection_batch in zip(targets, predictions): + nl, npr = ( + true_batch.shape[0], + detection_batch.shape[0], + ) + correct = np.zeros((npr, num_ious), dtype=bool) + + if npr == 0: + if nl: + stats.append((correct, np.zeros((2, 0)), true_batch[:, 4])) + continue + if nl: + correct = MeanAveragePrecision._match_detection_batch( + predictions=detection_batch, + targets=true_batch, + iou_levels=iou_levels, + ) + stats.append( + ( + correct, + detection_batch[:, conf_index], + detection_batch[:, class_index], + true_batch[:, class_index], + ) + ) + + stats = [np.concatenate(x, 0) for x in zip(stats)] + + if len(stats) and stats[0].any(): + average_precisions = cls._average_precisions_per_class(*stats) + ap50, ap75, average_precisions = ( + average_precisions[:, 0], + average_precisions[:, 5], + average_precisions.mean(1), + ) + map50, map75, map = ap50.mean(), ap75.mean(), average_precisions.mean() + + return cls(map=map, map50=map50, map75=map75, per_class_ap=average_precisions) + + @staticmethod + def _match_detection_batch( + predictions: np.ndarray, targets: np.ndarray, iou_levels: np.ndarray + ) -> np.ndarray: + """ + Args: + predictions (np.ndarray): batch prediction + targets (np.ndarray): batch target labels + iou_levels (np.ndarray): iou levels array contains different iou levels + + Returns: + (np.ndarray): matched prediction with target lebels result + """ + correct = np.zeros((predictions.shape[0], iou_levels.shape[0])).astype(bool) + iou = box_iou_batch(targets[:, :4], predictions[:, :4]) + + correct_class = targets[:, 4:5] == predictions[:, 4] + + for i in range(len(iou_levels)): + x = np.where((iou >= iou_levels[i]) & correct_class) + + if x[0].shape[0]: + _X1 = np.concatenate( + [np.expand_dims(x[0], 1), np.expand_dims(x[1], 1)], axis=1 + ) + _x2 = iou[x[0], x[1]][:, None] + matches = np.concatenate([_X1, _x2], axis=1) + if x[0].shape[0] > 1: + matches = matches[matches[:, 2].argsort()[::-1]] + matches = matches[np.unique(matches[:, 1], return_index=True)[1]] + matches = matches[np.unique(matches[:, 0], return_index=True)[1]] + correct[matches[:, 1].astype(int), i] = True + correct[matches[:, 1].astype(int), i] = True + return correct + + @staticmethod + def compute_average_precision(recall: np.ndarray, precision: np.ndarray) -> float: + """ + Compute the average precision using 101-point interpolation (COCO), given the recall and precision curves. + + Args: + recall (np.ndarray): The recall curve. + precision (np.ndarray): The precision curve. + + Returns: + float: Average precision. + """ + extended_recall = np.concatenate(([0.0], recall, [1.0])) + extended_precision = np.concatenate(([1.0], precision, [0.0])) + max_accumulated_precision = np.flip( + np.maximum.accumulate(np.flip(extended_precision)) + ) + interpolated_recall_levels = np.linspace(0, 1, 101) + interpolated_precision = np.interp( + interpolated_recall_levels, extended_recall, max_accumulated_precision + ) + average_precision = np.trapz(interpolated_precision, interpolated_recall_levels) + return average_precision + + @staticmethod + def _average_precisions_per_class( + matches: np.ndarray, + prediction_confidence: np.ndarray, + prediction_class_ids: np.ndarray, + true_batch_class_ids: np.ndarray, + eps: float = 1e-16, + ) -> np.ndarray: + """ + Compute the average precision, given the recall and precision curves. + Source: https://github.com/rafaelpadilla/Object-Detection-Metrics. + Args: + matches (np.ndarray): True positives (nparray, nx1 or nx10). + prediction_confidence (np.ndarray): Objectness value from 0-1 (nparray). + prediction_class_ids (np.ndarray): Predicted object classes (nparray). + true_batch_class_ids (np.ndarray): True object classes (nparray). + Returns: + (np.ndarray): Average precision for different iou level array + """ + sorted_confidences = np.argsort(-prediction_confidence) + matches = matches[sorted_confidences] + prediction_class_ids = prediction_class_ids[sorted_confidences] + + # Find unique classes + unique_classes, class_counts = np.unique( + true_batch_class_ids, return_counts=True + ) + num_classes = unique_classes.shape[0] # number of classes, number of detections + + average_precisions = np.zeros((num_classes, matches.shape[1])) + for ci, c in enumerate(unique_classes): + valid = prediction_class_ids == c + num_targets = class_counts[ci] # number of labels + num_predictions = valid.sum() # number of predictions + if num_predictions == 0 or num_targets == 0: + continue + + fp_pool = (1 - matches[valid]).cumsum(0) + tp_pool = matches[valid].cumsum(0) + + recall = tp_pool / (num_targets + eps) + precision = tp_pool / (tp_pool + fp_pool) + + for j in range(matches.shape[1]): + average_precisions[ + ci, j + ] = MeanAveragePrecision.compute_average_precision( + recall[:, j], precision[:, j] + ) + + return average_precisions	diff --git a/test/metrics/test_detection.py b/test/metrics/test_detection.py index 0ecab3f0b..e0a5f2ced 100644 --- a/test/metrics/test_detection.py +++ b/test/metrics/test_detection.py @@ -5,8 +5,8 @@ import pytest from supervision.detection.core import Detections -from supervision.metrics.detection import ConfusionMatrix -from test.utils import mock_detections +from supervision.metrics.detection import ConfusionMatrix, detections_to_tensor, MeanAveragePrecision +from test.utils import mock_detections, assert_almost_equal CLASSES = np.arange(80) NUM_CLASSES = len(CLASSES) @@ -167,7 +167,7 @@ def test_detections_to_tensor( exception: Exception ): with exception: - result = ConfusionMatrix.detections_to_tensor( + result = detections_to_tensor( detections=detections, with_confidence=with_confidence ) @@ -400,3 +400,43 @@ def test_drop_extra_matches( result = ConfusionMatrix._drop_extra_matches(matches) assert np.array_equal(result, expected_result) + + +@pytest.mark.parametrize( + 'recall, precision, expected_result, exception', + [ + ( + np.array([1.0]), + np.array([1.0]), + 1.0, + DoesNotRaise() + ), # perfect recall and precision + ( + np.array([0.0]), + np.array([0.0]), + 0.0, + DoesNotRaise() + ), # no recall and precision + ( + np.array([0.0, 0.2, 0.2, 0.8, 0.8, 1.0]), + np.array([0.7, 0.8, 0.4, 0.5, 0.1, 0.2]), + 0.5, + DoesNotRaise() + ), + ( + np.array([0.0, 0.5, 0.5, 1.0]), + np.array([0.75, 0.75, 0.75, 0.75]), + 0.75, + DoesNotRaise() + ) + ] +) +def test_compute_average_precision( + recall: np.ndarray, + precision: np.ndarray, + expected_result: float, + exception: Exception +) -> None: + with exception: + result = MeanAveragePrecision.compute_average_precision(recall=recall, precision=precision) + assert_almost_equal(result, expected_result, tolerance=0.01) diff --git a/test/utils.py b/test/utils.py index 20c294e5b..a1d6907eb 100644 --- a/test/utils.py +++ b/test/utils.py @@ -21,3 +21,7 @@ def mock_detections( if tracker_id is None else np.array(tracker_id, dtype=int), ) + + +def assert_almost_equal(actual, expected, tolerance=1e-5): + assert abs(actual - expected) < tolerance, f"Expected {expected}, but got {actual}."	diff --git a/docs/metrics/detection.md b/docs/metrics/detection.md index 9e7844645..feea7cce8 100644 --- a/docs/metrics/detection.md +++ b/docs/metrics/detection.md @@ -6,3 +6,7 @@ ## ConfusionMatrix :::supervision.metrics.detection.ConfusionMatrix + +## MeanAveragePrecision + +:::supervision.metrics.detection.MeanAveragePrecision	[ { "components": [ { "doc": "Convert Supervision Detections to numpy tensors for further computation\nArgs:\n detections (sv.Detections): Detections/Targets in the format of sv.Detections\n with_confidence (bool): Whether to include confidence in the tensor\nReturns:\n (np.ndarray): Detect...	[ "test/metrics/test_detection.py::test_detections_to_tensor[detections0-False-expected_result0-exception0]", "test/metrics/test_detection.py::test_detections_to_tensor[detections1-True-expected_result1-exception1]", "test/metrics/test_detection.py::test_detections_to_tensor[detections2-False-expected_result2-exc...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feature MeanAveragePrecision 🔥 # Description This pr is related to feature #206 and #232. ## Type of change - [x] New feature (non-breaking change which adds functionality) - [x] This change requires a documentation update ## How has this change been tested, please provide a testcase or example of how you tested the change? Google colab for testing:https://colab.research.google.com/drive/1MT5wc6H8WPshQfPoQITr6mLOcfd47x5E?usp=sharing ## Any specific deployment considerations For example, documentation changes, usability, usage/costs, secrets, etc. ## Docs - [x] Docs updated at `docs/supervision/metrics/detection` ## Basline Metrics for comparision: - Ultralytics - Torchmetrics (utilizes CocoApi) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in supervision/metrics/detection.py] (definition of detections_to_tensor:) def detections_to_tensor( detections: Detections, with_confidence: bool = False ) -> np.ndarray: """Convert Supervision Detections to numpy tensors for further computation Args: detections (sv.Detections): Detections/Targets in the format of sv.Detections with_confidence (bool): Whether to include confidence in the tensor Returns: (np.ndarray): Detections as numpy tensors as in (xyxy, class_id, confidence) order""" (definition of validate_input_tensors:) def validate_input_tensors(predictions: List[np.ndarray], targets: List[np.ndarray]): """Checks for shape consistency of input tensors.""" (definition of MeanAveragePrecision:) class MeanAveragePrecision: """Mean Average Precision for object detection tasks. Attributes: map (float): mAP value. map50 (float): mAP value at IoU `threshold = 0.5`. map75 (float): mAP value at IoU `threshold = 0.75`. per_class_ap (np.ndarray): values for every classes.""" (definition of MeanAveragePrecision.from_detections:) def from_detections( cls, predictions: List[Detections], targets: List[Detections], ) -> MeanAveragePrecision: """Calculate mean average precision based on predicted and ground-truth detections. Args: targets (List[Detections]): Detections objects from ground-truth. predictions (List[Detections]): Detections objects predicted by the model. Returns: MeanAveragePrecision: New instance of ConfusionMatrix. Example: ```python >>> import supervision as sv >>> targets = [ ... sv.Detections(...), ... sv.Detections(...) ... ] >>> predictions = [ ... sv.Detections(...), ... sv.Detections(...) ... ] >>> mean_average_precision = sv.MeanAveragePrecision.from_detections( ... predictions=predictions, ... targets=target, ... ) >>> mean_average_precison.map 0.2899 ```""" (definition of MeanAveragePrecision.benchmark:) def benchmark( cls, dataset: DetectionDataset, callback: Callable[[np.ndarray], Detections], ) -> MeanAveragePrecision: """Calculate mean average precision from dataset and callback function. Args: dataset (DetectionDataset): Object detection dataset used for evaluation. callback (Callable[[np.ndarray], Detections]): Function that takes an image as input and returns Detections object. Returns: MeanAveragePrecision: New instance of MeanAveragePrecision. Example: ```python >>> import supervision as sv >>> from ultralytics import YOLO >>> dataset = sv.DetectionDataset.from_yolo(...) >>> model = YOLO(...) >>> def callback(image: np.ndarray) -> sv.Detections: ... result = model(image)[0] ... return sv.Detections.from_yolov8(result) >>> mean_average_precision = sv.MeanAveragePrecision.benchmark( ... dataset = dataset, ... callback = callback ... ) >>> mean_average_precision.map 0.433 ```""" (definition of MeanAveragePrecision.from_tensors:) def from_tensors( cls, predictions: List[np.ndarray], targets: List[np.ndarray], ) -> MeanAveragePrecision: """Calculate Mean Average Precision based on predicted and ground-truth detections at different threshold. Args: predictions (List[np.ndarray]): Each element of the list describes a single image and has `shape = (M, 6)` where `M` is the number of detected objects. Each row is expected to be in `(x_min, y_min, x_max, y_max, class, conf)` format. targets (List[np.ndarray]): Each element of the list describes a single image and has `shape = (N, 5)` where `N` is the number of ground-truth objects. Each row is expected to be in `(x_min, y_min, x_max, y_max, class)` format. Returns: MeanAveragePrecision: New instance of MeanAveragePrecision. Example: ```python >>> import supervision as sv >>> targets = ( ... [ ... array( ... [ ... [0.0, 0.0, 3.0, 3.0, 1], ... [2.0, 2.0, 5.0, 5.0, 1], ... [6.0, 1.0, 8.0, 3.0, 2], ... ] ... ), ... array([1.0, 1.0, 2.0, 2.0, 2]), ... ] ... ) >>> predictions = [ ... array( ... [ ... [0.0, 0.0, 3.0, 3.0, 1, 0.9], ... [0.1, 0.1, 3.0, 3.0, 0, 0.9], ... [6.0, 1.0, 8.0, 3.0, 1, 0.8], ... [1.0, 6.0, 2.0, 7.0, 1, 0.8], ... ] ... ), ... array([[1.0, 1.0, 2.0, 2.0, 2, 0.8]]) ... ] >>> mean_average_precison = sv.MeanAveragePrecision.from_tensors( ... predictions=predictions, ... targets=targets, ... ) >>> mean_average_precison.map 0.2899 ```""" (definition of MeanAveragePrecision._match_detection_batch:) def _match_detection_batch( predictions: np.ndarray, targets: np.ndarray, iou_levels: np.ndarray ) -> np.ndarray: """Args: predictions (np.ndarray): batch prediction targets (np.ndarray): batch target labels iou_levels (np.ndarray): iou levels array contains different iou levels Returns: (np.ndarray): matched prediction with target lebels result""" (definition of MeanAveragePrecision.compute_average_precision:) def compute_average_precision(recall: np.ndarray, precision: np.ndarray) -> float: """Compute the average precision using 101-point interpolation (COCO), given the recall and precision curves. Args: recall (np.ndarray): The recall curve. precision (np.ndarray): The precision curve. Returns: float: Average precision.""" (definition of MeanAveragePrecision._average_precisions_per_class:) def _average_precisions_per_class( matches: np.ndarray, prediction_confidence: np.ndarray, prediction_class_ids: np.ndarray, true_batch_class_ids: np.ndarray, eps: float = 1e-16, ) -> np.ndarray: """Compute the average precision, given the recall and precision curves. Source: https://github.com/rafaelpadilla/Object-Detection-Metrics. Args: matches (np.ndarray): True positives (nparray, nx1 or nx10). prediction_confidence (np.ndarray): Objectness value from 0-1 (nparray). prediction_class_ids (np.ndarray): Predicted object classes (nparray). true_batch_class_ids (np.ndarray): True object classes (nparray). Returns: (np.ndarray): Average precision for different iou level array""" [end of new definitions in supervision/metrics/detection.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		3eb5c0b024e3e46877b7fe4fd66e6177d1308ba0
scrapy__scrapy-5979	5,979	scrapy/scrapy	null	8055a948dc2544c4d8ebe7aa1c6227e19b1583ac	2023-07-18T10:33:03Z	diff --git a/docs/topics/extensions.rst b/docs/topics/extensions.rst index 96e0216b8f0..8d4749ab33d 100644 --- a/docs/topics/extensions.rst +++ b/docs/topics/extensions.rst @@ -258,6 +258,7 @@ The conditions for closing a spider can be configured through the following settings: * :setting:`CLOSESPIDER_TIMEOUT` +* :setting:`CLOSESPIDER_TIMEOUT_NO_ITEM` * :setting:`CLOSESPIDER_ITEMCOUNT` * :setting:`CLOSESPIDER_PAGECOUNT` * :setting:`CLOSESPIDER_ERRORCOUNT` @@ -280,6 +281,18 @@ more than that number of second, it will be automatically closed with the reason ``closespider_timeout``. If zero (or non set), spiders won't be closed by timeout. +.. setting:: CLOSESPIDER_TIMEOUT_NO_ITEM + +CLOSESPIDER_TIMEOUT_NO_ITEM +""""""""""""""""""""""""""" + +Default: ``0`` + +An integer which specifies a number of seconds. If the spider has not produced +any items in the last number of seconds, it will be closed with the reason +``closespider_timeout_no_item``. If zero (or non set), spiders won't be closed +regardless if it hasn't produced any items. + .. setting:: CLOSESPIDER_ITEMCOUNT CLOSESPIDER_ITEMCOUNT diff --git a/scrapy/extensions/closespider.py b/scrapy/extensions/closespider.py index bb6f832f296..4307b417028 100644 --- a/scrapy/extensions/closespider.py +++ b/scrapy/extensions/closespider.py @@ -4,11 +4,14 @@ See documentation in docs/topics/extensions.rst """ +import logging from collections import defaultdict from scrapy import signals from scrapy.exceptions import NotConfigured +logger = logging.getLogger(__name__) + class CloseSpider: def __init__(self, crawler): @@ -19,6 +22,7 @@ def __init__(self, crawler): "itemcount": crawler.settings.getint("CLOSESPIDER_ITEMCOUNT"), "pagecount": crawler.settings.getint("CLOSESPIDER_PAGECOUNT"), "errorcount": crawler.settings.getint("CLOSESPIDER_ERRORCOUNT"), + "timeout_no_item": crawler.settings.getint("CLOSESPIDER_TIMEOUT_NO_ITEM"), } if not any(self.close_on.values()): @@ -34,6 +38,15 @@ def __init__(self, crawler): crawler.signals.connect(self.spider_opened, signal=signals.spider_opened) if self.close_on.get("itemcount"): crawler.signals.connect(self.item_scraped, signal=signals.item_scraped) + if self.close_on.get("timeout_no_item"): + self.timeout_no_item = self.close_on["timeout_no_item"] + self.items_in_period = 0 + crawler.signals.connect( + self.spider_opened_no_item, signal=signals.spider_opened + ) + crawler.signals.connect( + self.item_scraped_no_item, signal=signals.item_scraped + ) crawler.signals.connect(self.spider_closed, signal=signals.spider_closed) @classmethod @@ -69,3 +82,31 @@ def spider_closed(self, spider): task = getattr(self, "task", False) if task and task.active(): task.cancel() + + task_no_item = getattr(self, "task_no_item", False) + if task_no_item and task_no_item.running: + task_no_item.stop() + + def spider_opened_no_item(self, spider): + from twisted.internet import task + + self.task_no_item = task.LoopingCall(self._count_items_produced, spider) + self.task_no_item.start(self.timeout_no_item, now=False) + + logger.info( + f"Spider will stop when no items are produced after " + f"{self.timeout_no_item} seconds." + ) + + def item_scraped_no_item(self, item, spider): + self.items_in_period += 1 + + def _count_items_produced(self, spider): + if self.items_in_period >= 1: + self.items_in_period = 0 + else: + logger.info( + f"Closing spider since no items were produced in the last " + f"{self.timeout_no_item} seconds." + ) + self.crawler.engine.close_spider(spider, "closespider_timeout_no_item")	diff --git a/tests/spiders.py b/tests/spiders.py index 6ff48f4710c..f29dea2a12b 100644 --- a/tests/spiders.py +++ b/tests/spiders.py @@ -77,6 +77,22 @@ def errback(self, failure): self.t2_err = time.time() +class SlowSpider(DelaySpider): + name = "slow" + + def start_requests(self): + # 1st response is fast + url = self.mockserver.url("/delay?n=0&b=0") + yield Request(url, callback=self.parse, errback=self.errback) + + # 2nd response is slow + url = self.mockserver.url(f"/delay?n={self.n}&b={self.b}") + yield Request(url, callback=self.parse, errback=self.errback) + + def parse(self, response): + yield Item() + + class SimpleSpider(MetaSpider): name = "simple" diff --git a/tests/test_closespider.py b/tests/test_closespider.py index 9b39187d583..38ede70e449 100644 --- a/tests/test_closespider.py +++ b/tests/test_closespider.py @@ -3,7 +3,7 @@ from scrapy.utils.test import get_crawler from tests.mockserver import MockServer -from tests.spiders import ErrorSpider, FollowAllSpider, ItemSpider +from tests.spiders import ErrorSpider, FollowAllSpider, ItemSpider, SlowSpider class TestCloseSpider(TestCase): @@ -54,3 +54,13 @@ def test_closespider_timeout(self): self.assertEqual(reason, "closespider_timeout") total_seconds = crawler.stats.get_value("elapsed_time_seconds") self.assertTrue(total_seconds >= close_on) + + @defer.inlineCallbacks + def test_closespider_timeout_no_item(self): + timeout = 1 + crawler = get_crawler(SlowSpider, {"CLOSESPIDER_TIMEOUT_NO_ITEM": timeout}) + yield crawler.crawl(n=3, mockserver=self.mockserver) + reason = crawler.spider.meta["close_reason"] + self.assertEqual(reason, "closespider_timeout_no_item") + total_seconds = crawler.stats.get_value("elapsed_time_seconds") + self.assertTrue(total_seconds >= timeout)	diff --git a/docs/topics/extensions.rst b/docs/topics/extensions.rst index 96e0216b8f0..8d4749ab33d 100644 --- a/docs/topics/extensions.rst +++ b/docs/topics/extensions.rst @@ -258,6 +258,7 @@ The conditions for closing a spider can be configured through the following settings: * :setting:`CLOSESPIDER_TIMEOUT` +* :setting:`CLOSESPIDER_TIMEOUT_NO_ITEM` * :setting:`CLOSESPIDER_ITEMCOUNT` * :setting:`CLOSESPIDER_PAGECOUNT` * :setting:`CLOSESPIDER_ERRORCOUNT` @@ -280,6 +281,18 @@ more than that number of second, it will be automatically closed with the reason ``closespider_timeout``. If zero (or non set), spiders won't be closed by timeout. +.. setting:: CLOSESPIDER_TIMEOUT_NO_ITEM + +CLOSESPIDER_TIMEOUT_NO_ITEM +""""""""""""""""""""""""""" + +Default: ``0`` + +An integer which specifies a number of seconds. If the spider has not produced +any items in the last number of seconds, it will be closed with the reason +``closespider_timeout_no_item``. If zero (or non set), spiders won't be closed +regardless if it hasn't produced any items. + .. setting:: CLOSESPIDER_ITEMCOUNT CLOSESPIDER_ITEMCOUNT	[ { "components": [ { "doc": "", "lines": [ 90, 98 ], "name": "CloseSpider.spider_opened_no_item", "signature": "def spider_opened_no_item(self, spider):", "type": "function" }, { "doc": "", "lines": [ ...	[ "tests/test_closespider.py::TestCloseSpider::test_closespider_timeout_no_item" ]	[ "tests/test_closespider.py::TestCloseSpider::test_closespider_errorcount", "tests/test_closespider.py::TestCloseSpider::test_closespider_itemcount", "tests/test_closespider.py::TestCloseSpider::test_closespider_pagecount", "tests/test_closespider.py::TestCloseSpider::test_closespider_timeout" ]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> introduce CLOSESPIDER_TIMEOUT_NO_ITEM in CloseSpider Motivation: Sometimes spiders still keep running without producing any items. This could be due to a variety of reasons like poor dupe URL filtration, bad crawling strategy, etc. Proposal: Auto-close the spider if it hasn't produced any items in the past number of seconds. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in scrapy/extensions/closespider.py] (definition of CloseSpider.spider_opened_no_item:) def spider_opened_no_item(self, spider): (definition of CloseSpider.item_scraped_no_item:) def item_scraped_no_item(self, item, spider): (definition of CloseSpider._count_items_produced:) def _count_items_produced(self, spider): [end of new definitions in scrapy/extensions/closespider.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		57a5460529ff71c42e4d0381265b1b512b1eb09b
sqlfluff__sqlfluff-4974	4,974	sqlfluff/sqlfluff	2.0	33916fc72f7576a985efa22dfcdd728348544899	2023-07-17T08:44:38Z	diff --git a/src/sqlfluff/core/default_config.cfg b/src/sqlfluff/core/default_config.cfg index cfd85cf4dc6..b3f385c9bb0 100644 --- a/src/sqlfluff/core/default_config.cfg +++ b/src/sqlfluff/core/default_config.cfg @@ -384,3 +384,6 @@ wildcard_policy = single [sqlfluff:rules:structure.subquery] # By default, allow subqueries in from clauses, but not join clauses forbid_subquery_in = join + +[sqlfluff:rules:structure.first_table] +preferred_first_table_in_join_clause = earlier diff --git a/src/sqlfluff/core/rules/config_info.py b/src/sqlfluff/core/rules/config_info.py index 28e067bb375..62e7235501c 100644 --- a/src/sqlfluff/core/rules/config_info.py +++ b/src/sqlfluff/core/rules/config_info.py @@ -213,6 +213,13 @@ "validation": ["consistent", "shorthand", "convert", "cast"], "definition": ("The expectation for using sql type casting"), }, + "preferred_first_table_in_join_clause": { + "validation": ["earlier", "later"], + "definition": ( + "Which table to list first when joining two tables. " + "Defaults to ``earlier``." + ), + }, } diff --git a/src/sqlfluff/rules/structure/ST09.py b/src/sqlfluff/rules/structure/ST09.py new file mode 100644 index 00000000000..b0732d77e47 --- /dev/null +++ b/src/sqlfluff/rules/structure/ST09.py @@ -0,0 +1,291 @@ +"""Implementation of Rule ST09.""" +from typing import Optional, Tuple, List, cast +from sqlfluff.core.parser.segments.raw import BaseSegment, SymbolSegment +from sqlfluff.core.rules import BaseRule, LintFix, LintResult, RuleContext +from sqlfluff.core.rules.crawlers import SegmentSeekerCrawler +from sqlfluff.utils.functional import Segments, FunctionalContext +from sqlfluff.dialects.dialect_ansi import ( + FromExpressionElementSegment, + JoinClauseSegment, +) + + +class Rule_ST09(BaseRule): + """Joins should list the table referenced earlier/later first. + + This rule will break conditions from join clauses down into subconditions + using the "and" and "or" binary operators. + + Subconditions that are made up of a qualified column reference, + a comparison operator and another qualified column reference + are then evaluated to check whether they list the table that was referenced + earlier - or later, depending on the ``preferred_first_table_in_join_clause`` + configuration. + + Subconditions that do not follow that pattern are ignored by this rule. + + .. note:: + Joins in ``WHERE`` clauses are currently not supported by this rule. + + Anti-pattern + + In this example, the tables that were referenced later are listed first + and the ``preferred_first_table_in_join_clause`` configuration + is set to ``earlier``. + + .. code-block:: sql + + select + foo.a, + foo.b, + bar.c + from foo + left join bar + -- This subcondition does not list + -- the table referenced earlier first: + on bar.a = foo.a + -- Neither does this subcondition: + and bar.b = foo.b + + Best practice + + List the tables that were referenced earlier first. + + .. code-block:: sql + + select + foo.a, + foo.b, + bar.c + from foo + left join bar + on foo.a = bar.a + and foo.b = bar.b + """ + + name = "structure.first_table" + aliases = () + groups: Tuple[str, ...] = ("all", "structure") + config_keywords = ["preferred_first_table_in_join_clause"] + crawl_behaviour = SegmentSeekerCrawler({"from_expression"}) + is_fix_compatible = True + + def _eval(self, context: RuleContext) -> Optional[LintResult]: + """Find rule violations and provide fixes. + + 0. Grab all table aliases into a table_aliases list. + 1. Grab all conditions from the different join_on_condition segments. + 2. Break conditions down into subconditions using the "and" and "or" + binary operators. + 3. Keep subconditions that are made up of a qualified column_reference, + a comparison_operator and another qualified column_reference segments. + 4. Check whether the table associated with the first column_reference segment + has a greater index in table_aliases than the second column_reference segment. + If so, populate the fixes list (lower index instead of greater index + if preferred_first_table_in_join_clause == "later"). + 5.a. If fixes is empty the rule passes. + 5.b. If fixes isn't empty we return a LintResult object with fixable violations. + """ + self.preferred_first_table_in_join_clause: str + + assert context.segment.is_type("from_expression") + + # STEP 0. + table_aliases: List[str] = [] + + children = FunctionalContext(context).segment.children() + + # we use recursive_crawl to deal with brackets + join_clauses = children.recursive_crawl("join_clause") + + join_on_conditions = join_clauses.children().recursive_crawl( + "join_on_condition" + ) + + # we only care about join_on_condition segments + if len(join_on_conditions) == 0: + return None + + # the first alias comes from the from clause + from_expression_alias: str = ( + cast( + FromExpressionElementSegment, + children.recursive_crawl("from_expression_element")[0], + ) + .get_eventual_alias() + .ref_str + ) + + table_aliases.append(from_expression_alias) + + # the rest of the aliases come from the different join clauses + join_clause_aliases: List[str] = [ + cast(JoinClauseSegment, join_clause).get_eventual_aliases()[0][1].ref_str + for join_clause in [clause for clause in join_clauses] + ] + + table_aliases = table_aliases + join_clause_aliases + + table_aliases = [alias.upper() for alias in table_aliases] + + # STEP 1. + conditions: List[List[BaseSegment]] = [] + + join_on_condition__expressions = join_on_conditions.children().recursive_crawl( + "expression" + ) + + for expression in join_on_condition__expressions: + expression_group = [] + for element in Segments(expression).children(): + if element.type not in ("whitespace", "newline"): + expression_group.append(element) + conditions.append(expression_group) + + # STEP 2. + subconditions: List[List[List[BaseSegment]]] = [] + + for expression_group in conditions: + subconditions.append( + self._split_list_by_segment_type( + segment_list=expression_group, + delimiter_type="binary_operator", + delimiters=["and", "or"], + ) + ) + + subconditions_flattened: List[List[BaseSegment]] = [ + item for sublist in subconditions for item in sublist + ] + + # STEP 3. + column_operator_column_subconditions: List[List[BaseSegment]] = [ + subcondition + for subcondition in subconditions_flattened + if self._is_qualified_column_operator_qualified_column_sequence( + subcondition + ) + ] + + # STEP 4. + fixes: List[LintFix] = [] + + for subcondition in column_operator_column_subconditions: + comparison_operator = subcondition[1] + first_column_reference = subcondition[0] + second_column_reference = subcondition[2] + raw_comparison_operators = comparison_operator.get_children( + "raw_comparison_operator" + ) + + first_table = first_column_reference.get_child("naked_identifier").raw_upper + second_table = second_column_reference.get_child( + "naked_identifier" + ).raw_upper + + # if we swap the two column references around the comparison operator + # we might have to replace the comparison operator with a different one + raw_comparison_operator_opposites = {"<": ">", ">": "<"} + + # there seem to be edge cases where either the first table or the second + # table is not in table_aliases, in which case we cannot provide any fix + if first_table not in table_aliases or second_table not in table_aliases: + continue + + if ( + table_aliases.index(first_table) > table_aliases.index(second_table) + and self.preferred_first_table_in_join_clause == "earlier" + ) or ( + table_aliases.index(first_table) < table_aliases.index(second_table) + and self.preferred_first_table_in_join_clause == "later" + ): + fixes = ( + fixes + + [ + LintFix.replace( + first_column_reference, + [second_column_reference], + ) + ] + + [ + LintFix.replace( + second_column_reference, + [first_column_reference], + ) + ] + + ( + [ + LintFix.replace( + raw_comparison_operators[0], + [ + SymbolSegment( + raw=raw_comparison_operator_opposites[ + raw_comparison_operators[0].raw + ], + type="raw_comparison_operator", + ) + ], + ) + ] + if raw_comparison_operators[0].raw + in raw_comparison_operator_opposites + and [r.raw for r in raw_comparison_operators] != ["<", ">"] + else [] + ) + ) + + # STEP 5.a. + if fixes == []: + return None + + # STEP 5.b. + else: + return LintResult( + anchor=context.segment, + fixes=fixes, + description=( + "Joins should list the table referenced " + f"{self.preferred_first_table_in_join_clause} first." + ), + ) + + @staticmethod + def _split_list_by_segment_type( + segment_list: List[BaseSegment], delimiter_type: str, delimiters: List[str] + ) -> List: + # Break down a list into multiple sub-lists using a set of delimiters + delimiters = [delimiter.upper() for delimiter in delimiters] + new_list = [] + sub_list = [] + for i in range(len(segment_list)): + if i == len(segment_list) - 1: + sub_list.append(segment_list[i]) + new_list.append(sub_list) + elif ( + segment_list[i].type == delimiter_type + and segment_list[i].raw_upper in delimiters + ): + new_list.append(sub_list) + sub_list = [] + else: + sub_list.append(segment_list[i]) + + return new_list + + @staticmethod + def _is_qualified_column_operator_qualified_column_sequence( + segment_list: List[BaseSegment], + ) -> bool: + # Check if list is made up of a qualified column_reference segment, + # a comparison_operator segment and another qualified column_reference segment + if len(segment_list) != 3: + return False + if ( + segment_list[0].type == "column_reference" + and "dot" in segment_list[0].direct_descendant_type_set + and segment_list[1].type == "comparison_operator" + and segment_list[2].type == "column_reference" + and "dot" in segment_list[2].direct_descendant_type_set + ): + return True + return False diff --git a/src/sqlfluff/rules/structure/__init__.py b/src/sqlfluff/rules/structure/__init__.py index fdb48e021c5..5ece4f71de0 100644 --- a/src/sqlfluff/rules/structure/__init__.py +++ b/src/sqlfluff/rules/structure/__init__.py @@ -20,6 +20,7 @@ def get_rules() -> List[Type[BaseRule]]: from sqlfluff.rules.structure.ST06 import Rule_ST06 from sqlfluff.rules.structure.ST07 import Rule_ST07 from sqlfluff.rules.structure.ST08 import Rule_ST08 + from sqlfluff.rules.structure.ST09 import Rule_ST09 return [ Rule_ST01, @@ -30,4 +31,5 @@ def get_rules() -> List[Type[BaseRule]]: Rule_ST06, Rule_ST07, Rule_ST08, + Rule_ST09, ]	diff --git a/test/cli/commands_test.py b/test/cli/commands_test.py index 292a5ac51d8..0a3ad125f2c 100644 --- a/test/cli/commands_test.py +++ b/test/cli/commands_test.py @@ -1432,7 +1432,7 @@ def test__cli__command_lint_serialize_multiple_files(serialize, write_file, tmp_ print("Result length:", payload_length) if serialize == "human": - assert payload_length == 23 if write_file else 32 + assert payload_length == 25 if write_file else 34 elif serialize == "none": assert payload_length == 1 # There will be a single newline. elif serialize == "json": @@ -1450,7 +1450,7 @@ def test__cli__command_lint_serialize_multiple_files(serialize, write_file, tmp_ # SQLFluff produces trailing newline if result[-1] == "": del result[-1] - assert len(result) == 11 + assert len(result) == 12 else: raise Exception @@ -1960,8 +1960,10 @@ def test_cli_fix_disabled_progress_bar_deprecated_option( multiple_expected_output = """==== finding fixable violations ==== == [test/fixtures/linter/multiple_sql_errors.sql] FAIL L: 12 \| P: 1 \| LT02 \| Expected indent of 4 spaces. [layout.indent] +L: 40 \| P: 10 \| ST09 \| Joins should list the table referenced earlier first. + \| [structure.first_table] ==== fixing violations ==== -1 fixable linting violations found +2 fixable linting violations found Are you sure you wish to attempt to fix these? [Y/n] ... Invalid input, please enter 'Y' or 'N' Aborting... @@ -2008,7 +2010,7 @@ def test__cli__fix_multiple_errors_quiet_force(): normalised_output = result.output.replace("\\", "/") assert normalised_output.startswith( """== [test/fixtures/linter/multiple_sql_errors.sql] FIXED -1 fixable linting violations found""" +2 fixable linting violations found""" ) @@ -2031,7 +2033,7 @@ def test__cli__fix_multiple_errors_quiet_no_force(): ) normalised_output = result.output.replace("\\", "/") assert normalised_output.startswith( - """1 fixable linting violations found + """2 fixable linting violations found Are you sure you wish to attempt to fix these? [Y/n] ... == [test/fixtures/linter/multiple_sql_errors.sql] FIXED All Finished"""	diff --git a/src/sqlfluff/core/default_config.cfg b/src/sqlfluff/core/default_config.cfg index cfd85cf4dc6..b3f385c9bb0 100644 --- a/src/sqlfluff/core/default_config.cfg +++ b/src/sqlfluff/core/default_config.cfg @@ -384,3 +384,6 @@ wildcard_policy = single [sqlfluff:rules:structure.subquery] # By default, allow subqueries in from clauses, but not join clauses forbid_subquery_in = join + +[sqlfluff:rules:structure.first_table] +preferred_first_table_in_join_clause = earlier	[ { "components": [ { "doc": "Joins should list the table referenced earlier/later first.\n\nThis rule will break conditions from join clauses down into subconditions\nusing the \"and\" and \"or\" binary operators.\n\nSubconditions that are made up of a qualified column reference,\na comparison oper...	[ "test/cli/commands_test.py::test__cli__command_lint_serialize_multiple_files[None-github-annotation-native]", "test/cli/commands_test.py::test__cli__command_lint_serialize_multiple_files[outfile-human]", "test/cli/commands_test.py::test__cli__command_lint_serialize_multiple_files[outfile-github-annotation-nativ...	[ "test/cli/commands_test.py::test__cli__command_directed", "test/cli/commands_test.py::test__cli__command_dialect", "test/cli/commands_test.py::test__cli__command_no_dialect", "test/cli/commands_test.py::test__cli__command_parse_error_dialect_explicit_warning", "test/cli/commands_test.py::test__cli__command_...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add new rule ST09: Joins should list the table referenced earlier (default)/later first <!--Thanks for adding this feature!--> <!--Please give the Pull Request a meaningful title for the release notes--> ### Brief summary of the change made <!--Please include `fixes #XXXX` to automatically close any corresponding issue when the pull request is merged. Alternatively if not fully closed you can say `makes progress on #XXXX`.--> Fixes #2395. ### Are there any other side effects of this change that we should be aware of? There shouldn't be any. ### Pull Request checklist - [x] Please confirm you have completed any of the necessary steps below. - Included test cases to demonstrate any code changes, which may be one or more of the following: - `.yml` rule test cases in `test/fixtures/rules/std_rule_cases`. - `.sql`/`.yml` parser test cases in `test/fixtures/dialects` (note YML files can be auto generated with `tox -e generate-fixture-yml`). - Full autofix test cases in `test/fixtures/linter/autofix`. - Other. - Added appropriate documentation for the change. - Created GitHub issues for any relevant followup/future enhancements if appropriate. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/sqlfluff/rules/structure/ST09.py] (definition of Rule_ST09:) class Rule_ST09(BaseRule): """Joins should list the table referenced earlier/later first. This rule will break conditions from join clauses down into subconditions using the "and" and "or" binary operators. Subconditions that are made up of a qualified column reference, a comparison operator and another qualified column reference are then evaluated to check whether they list the table that was referenced earlier - or later, depending on the ``preferred_first_table_in_join_clause`` configuration. Subconditions that do not follow that pattern are ignored by this rule. .. note:: Joins in ``WHERE`` clauses are currently not supported by this rule. Anti-pattern In this example, the tables that were referenced later are listed first and the ``preferred_first_table_in_join_clause`` configuration is set to ``earlier``. .. code-block:: sql select foo.a, foo.b, bar.c from foo left join bar -- This subcondition does not list -- the table referenced earlier first: on bar.a = foo.a -- Neither does this subcondition: and bar.b = foo.b Best practice List the tables that were referenced earlier first. .. code-block:: sql select foo.a, foo.b, bar.c from foo left join bar on foo.a = bar.a and foo.b = bar.b""" (definition of Rule_ST09._eval:) def _eval(self, context: RuleContext) -> Optional[LintResult]: """Find rule violations and provide fixes. 0. Grab all table aliases into a table_aliases list. 1. Grab all conditions from the different join_on_condition segments. 2. Break conditions down into subconditions using the "and" and "or" binary operators. 3. Keep subconditions that are made up of a qualified column_reference, a comparison_operator and another qualified column_reference segments. 4. Check whether the table associated with the first column_reference segment has a greater index in table_aliases than the second column_reference segment. If so, populate the fixes list (lower index instead of greater index if preferred_first_table_in_join_clause == "later"). 5.a. If fixes is empty the rule passes. 5.b. If fixes isn't empty we return a LintResult object with fixable violations.""" (definition of Rule_ST09._split_list_by_segment_type:) def _split_list_by_segment_type( segment_list: List[BaseSegment], delimiter_type: str, delimiters: List[str] ) -> List: (definition of Rule_ST09._is_qualified_column_operator_qualified_column_sequence:) def _is_qualified_column_operator_qualified_column_sequence( segment_list: List[BaseSegment], ) -> bool: [end of new definitions in src/sqlfluff/rules/structure/ST09.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> New Rule: In ON clause of JOIN statement specify source table first and join table second <!--Note: This is for general enhancements to the project. Please use the Bug report template instead to raise parsing/linting/syntax issues for existing supported dialects--> From GitLab SQL style guide: https://about.gitlab.com/handbook/business-technology/data-team/platform/sql-style-guide/#joins `Specify the order of a join with the FROM table first and JOIN table second:` ```sql -- Good FROM source LEFT JOIN other_source ON source.id = other_source.id WHERE ... -- Bad FROM source LEFT JOIN other_source ON other_source.id = source.id WHERE ... ``` More generally put the SOURCE table first and JOIN table second (since the source isn't always necessarily with a FROM clause): ```sql -- Good FROM source LEFT JOIN other_source ON source.id = other_source.id LEFT JOIN different_source ON other_source.id = different_source.id WHERE ... -- Bad FROM source LEFT JOIN other_source ON other_source.id = source.id LEFT JOIN different_source ON different_source.id = other_source.id WHERE ... ``` The motivation is that we already know the JOIN table from the JOIN clause so we want to be able to quickly scan for the SOURCE table. ---------- though i personally prefer the other way arround, it would be awesome to have such a rule. Consistent ordering in ONs is really appreciated... I would also love to have such a rule, it's definitely one of the rules from the [dbt Style Guide](https://github.com/dbt-labs/corp/blob/main/dbt_style_guide.md#sql-style-guide) that I hate seeing breached... -------------------- </issues>	3629c3e702939c07264cc5ea903566ddc9ea2bb0
tobymao__sqlglot-1925	1,925	tobymao/sqlglot	null	aaee59457eca7255540c27a4aa13a7a4f87e6acc	2023-07-16T23:05:32Z	diff --git a/sqlglot/dataframe/sql/functions.py b/sqlglot/dataframe/sql/functions.py index bdc1fb4083..353bdc0f02 100644 --- a/sqlglot/dataframe/sql/functions.py +++ b/sqlglot/dataframe/sql/functions.py @@ -875,8 +875,16 @@ def regexp_extract(str: ColumnOrName, pattern: str, idx: t.Optional[int] = None) ) -def regexp_replace(str: ColumnOrName, pattern: str, replacement: str) -> Column: - return Column.invoke_anonymous_function(str, "REGEXP_REPLACE", lit(pattern), lit(replacement)) +def regexp_replace( + str: ColumnOrName, pattern: str, replacement: str, position: t.Optional[int] = None +) -> Column: + return Column.invoke_expression_over_column( + str, + expression.RegexpReplace, + expression=lit(pattern), + replacement=lit(replacement), + position=position, + ) def initcap(col: ColumnOrName) -> Column: diff --git a/sqlglot/dialects/bigquery.py b/sqlglot/dialects/bigquery.py index 35892f73ac..ae1eaf0d7f 100644 --- a/sqlglot/dialects/bigquery.py +++ b/sqlglot/dialects/bigquery.py @@ -15,6 +15,7 @@ min_or_least, no_ilike_sql, parse_date_delta_with_interval, + regexp_replace_sql, rename_func, timestrtotime_sql, ts_or_ds_to_date_sql, @@ -415,6 +416,7 @@ class Generator(generator.Generator): e.args.get("position"), e.args.get("occurrence"), ), + exp.RegexpReplace: regexp_replace_sql, exp.RegexpLike: rename_func("REGEXP_CONTAINS"), exp.ReturnsProperty: _returnsproperty_sql, exp.Select: transforms.preprocess( diff --git a/sqlglot/dialects/dialect.py b/sqlglot/dialects/dialect.py index 5376dffdb5..938440a3c2 100644 --- a/sqlglot/dialects/dialect.py +++ b/sqlglot/dialects/dialect.py @@ -630,6 +630,16 @@ def regexp_extract_sql(self: Generator, expression: exp.RegexpExtract) -> str: ) +def regexp_replace_sql(self: Generator, expression: exp.RegexpReplace) -> str: + bad_args = list(filter(expression.args.get, ("position", "occurrence", "parameters"))) + if bad_args: + self.unsupported(f"REGEXP_REPLACE does not support the following arg(s): {bad_args}") + + return self.func( + "REGEXP_REPLACE", expression.this, expression.expression, expression.args["replacement"] + ) + + def pivot_column_names(aggregations: t.List[exp.Expression], dialect: DialectType) -> t.List[str]: names = [] for agg in aggregations: diff --git a/sqlglot/dialects/duckdb.py b/sqlglot/dialects/duckdb.py index 1d8a7fbb7b..ae48474a62 100644 --- a/sqlglot/dialects/duckdb.py +++ b/sqlglot/dialects/duckdb.py @@ -16,6 +16,7 @@ no_safe_divide_sql, pivot_column_names, regexp_extract_sql, + regexp_replace_sql, rename_func, str_position_sql, str_to_time_sql, @@ -219,6 +220,7 @@ class Generator(generator.Generator): exp.LogicalAnd: rename_func("BOOL_AND"), exp.Properties: no_properties_sql, exp.RegexpExtract: regexp_extract_sql, + exp.RegexpReplace: regexp_replace_sql, exp.RegexpLike: rename_func("REGEXP_MATCHES"), exp.RegexpSplit: rename_func("STR_SPLIT_REGEX"), exp.SafeDivide: no_safe_divide_sql, diff --git a/sqlglot/dialects/hive.py b/sqlglot/dialects/hive.py index 8d322912da..42a29ffcba 100644 --- a/sqlglot/dialects/hive.py +++ b/sqlglot/dialects/hive.py @@ -18,6 +18,7 @@ no_safe_divide_sql, no_trycast_sql, regexp_extract_sql, + regexp_replace_sql, rename_func, right_to_substring_sql, strposition_to_locate_sql, @@ -369,6 +370,7 @@ class Generator(generator.Generator): exp.Quantile: rename_func("PERCENTILE"), exp.ApproxQuantile: rename_func("PERCENTILE_APPROX"), exp.RegexpExtract: regexp_extract_sql, + exp.RegexpReplace: regexp_replace_sql, exp.RegexpLike: lambda self, e: self.binary(e, "RLIKE"), exp.RegexpSplit: rename_func("SPLIT"), exp.Right: right_to_substring_sql, diff --git a/sqlglot/dialects/snowflake.py b/sqlglot/dialects/snowflake.py index dea33e65ac..499e085810 100644 --- a/sqlglot/dialects/snowflake.py +++ b/sqlglot/dialects/snowflake.py @@ -30,7 +30,7 @@ def _check_int(s: str) -> bool: # from https://docs.snowflake.com/en/sql-reference/functions/to_timestamp.html -def _snowflake_to_timestamp(args: t.List) -> t.Union[exp.StrToTime, exp.UnixToTime]: +def _parse_to_timestamp(args: t.List) -> t.Union[exp.StrToTime, exp.UnixToTime]: if len(args) == 2: first_arg, second_arg = args if second_arg.is_string: @@ -137,7 +137,7 @@ def _parse_date_part(self: parser.Parser) -> t.Optional[exp.Expression]: # https://docs.snowflake.com/en/sql-reference/functions/div0 -def _div0_to_if(args: t.List) -> exp.Expression: +def _div0_to_if(args: t.List) -> exp.If: cond = exp.EQ(this=seq_get(args, 1), expression=exp.Literal.number(0)) true = exp.Literal.number(0) false = exp.Div(this=seq_get(args, 0), expression=seq_get(args, 1)) @@ -145,13 +145,13 @@ def _div0_to_if(args: t.List) -> exp.Expression: # https://docs.snowflake.com/en/sql-reference/functions/zeroifnull -def _zeroifnull_to_if(args: t.List) -> exp.Expression: +def _zeroifnull_to_if(args: t.List) -> exp.If: cond = exp.Is(this=seq_get(args, 0), expression=exp.Null()) return exp.If(this=cond, true=exp.Literal.number(0), false=seq_get(args, 0)) # https://docs.snowflake.com/en/sql-reference/functions/zeroifnull -def _nullifzero_to_if(args: t.List) -> exp.Expression: +def _nullifzero_to_if(args: t.List) -> exp.If: cond = exp.EQ(this=seq_get(args, 0), expression=exp.Literal.number(0)) return exp.If(this=cond, true=exp.Null(), false=seq_get(args, 0)) @@ -164,12 +164,21 @@ def _datatype_sql(self: generator.Generator, expression: exp.DataType) -> str: return self.datatype_sql(expression) -def _parse_convert_timezone(args: t.List) -> exp.Expression: +def _parse_convert_timezone(args: t.List) -> t.Union[exp.Anonymous, exp.AtTimeZone]: if len(args) == 3: return exp.Anonymous(this="CONVERT_TIMEZONE", expressions=args) return exp.AtTimeZone(this=seq_get(args, 1), zone=seq_get(args, 0)) +def _parse_regexp_replace(args: t.List) -> exp.RegexpReplace: + regexp_replace = exp.RegexpReplace.from_arg_list(args) + + if not regexp_replace.args.get("replacement"): + regexp_replace.set("replacement", exp.Literal.string("")) + + return regexp_replace + + class Snowflake(Dialect): # https://docs.snowflake.com/en/sql-reference/identifiers-syntax RESOLVES_IDENTIFIERS_AS_UPPERCASE = True @@ -223,13 +232,14 @@ class Parser(parser.Parser): "IFF": exp.If.from_arg_list, "NULLIFZERO": _nullifzero_to_if, "OBJECT_CONSTRUCT": _parse_object_construct, + "REGEXP_REPLACE": _parse_regexp_replace, "REGEXP_SUBSTR": exp.RegexpExtract.from_arg_list, "RLIKE": exp.RegexpLike.from_arg_list, "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)), "TIMEDIFF": _parse_datediff, "TIMESTAMPDIFF": _parse_datediff, "TO_ARRAY": exp.Array.from_arg_list, - "TO_TIMESTAMP": _snowflake_to_timestamp, + "TO_TIMESTAMP": _parse_to_timestamp, "TO_VARCHAR": exp.ToChar.from_arg_list, "ZEROIFNULL": _zeroifnull_to_if, } diff --git a/sqlglot/dialects/spark2.py b/sqlglot/dialects/spark2.py index f9e287ac24..2d0137e480 100644 --- a/sqlglot/dialects/spark2.py +++ b/sqlglot/dialects/spark2.py @@ -197,6 +197,13 @@ class Generator(Hive.Generator): exp.Map: _map_sql, exp.Pivot: transforms.preprocess([_unqualify_pivot_columns]), exp.Reduce: rename_func("AGGREGATE"), + exp.RegexpReplace: lambda self, e: self.func( + "REGEXP_REPLACE", + e.this, + e.expression, + e.args["replacement"], + e.args.get("position"), + ), exp.StrToDate: _str_to_date, exp.StrToTime: lambda self, e: f"TO_TIMESTAMP({self.sql(e, 'this')}, {self.format_time(e)})", exp.TimestampTrunc: lambda self, e: self.func( diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index fb2575d4d3..29c0a0bf6b 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -4431,6 +4431,17 @@ class RegexpExtract(Func): } +class RegexpReplace(Func): + arg_types = { + "this": True, + "expression": True, + "replacement": True, + "position": False, + "occurrence": False, + "parameters": False, + } + + class RegexpLike(Func): arg_types = {"this": True, "expression": True, "flag": False}	diff --git a/tests/dialects/test_snowflake.py b/tests/dialects/test_snowflake.py index ee8a11ff0e..82762e8aa1 100644 --- a/tests/dialects/test_snowflake.py +++ b/tests/dialects/test_snowflake.py @@ -915,6 +915,58 @@ def test_regexp_substr(self, logger): }, ) + @mock.patch("sqlglot.generator.logger") + def test_regexp_replace(self, logger): + self.validate_all( + "REGEXP_REPLACE(subject, pattern)", + write={ + "bigquery": "REGEXP_REPLACE(subject, pattern, '')", + "duckdb": "REGEXP_REPLACE(subject, pattern, '')", + "hive": "REGEXP_REPLACE(subject, pattern, '')", + "snowflake": "REGEXP_REPLACE(subject, pattern, '')", + "spark": "REGEXP_REPLACE(subject, pattern, '')", + }, + ) + self.validate_all( + "REGEXP_REPLACE(subject, pattern, replacement)", + read={ + "bigquery": "REGEXP_REPLACE(subject, pattern, replacement)", + "duckdb": "REGEXP_REPLACE(subject, pattern, replacement)", + "hive": "REGEXP_REPLACE(subject, pattern, replacement)", + "spark": "REGEXP_REPLACE(subject, pattern, replacement)", + }, + write={ + "bigquery": "REGEXP_REPLACE(subject, pattern, replacement)", + "duckdb": "REGEXP_REPLACE(subject, pattern, replacement)", + "hive": "REGEXP_REPLACE(subject, pattern, replacement)", + "snowflake": "REGEXP_REPLACE(subject, pattern, replacement)", + "spark": "REGEXP_REPLACE(subject, pattern, replacement)", + }, + ) + self.validate_all( + "REGEXP_REPLACE(subject, pattern, replacement, position)", + read={ + "spark": "REGEXP_REPLACE(subject, pattern, replacement, position)", + }, + write={ + "bigquery": "REGEXP_REPLACE(subject, pattern, replacement)", + "duckdb": "REGEXP_REPLACE(subject, pattern, replacement)", + "hive": "REGEXP_REPLACE(subject, pattern, replacement)", + "snowflake": "REGEXP_REPLACE(subject, pattern, replacement, position)", + "spark": "REGEXP_REPLACE(subject, pattern, replacement, position)", + }, + ) + self.validate_all( + "REGEXP_REPLACE(subject, pattern, replacement, position, occurrence, parameters)", + write={ + "bigquery": "REGEXP_REPLACE(subject, pattern, replacement)", + "duckdb": "REGEXP_REPLACE(subject, pattern, replacement)", + "hive": "REGEXP_REPLACE(subject, pattern, replacement)", + "snowflake": "REGEXP_REPLACE(subject, pattern, replacement, position, occurrence, parameters)", + "spark": "REGEXP_REPLACE(subject, pattern, replacement, position)", + }, + ) + def test_match_recognize(self): for row in ( "ONE ROW PER MATCH",		[]	[ "tests/dialects/test_snowflake.py::TestSnowflake::test_regexp_replace" ]	[ "tests/dialects/test_snowflake.py::TestSnowflake::test_ddl", "tests/dialects/test_snowflake.py::TestSnowflake::test_describe_table", "tests/dialects/test_snowflake.py::TestSnowflake::test_flatten", "tests/dialects/test_snowflake.py::TestSnowflake::test_match_recognize", "tests/dialects/test_snowflake.py::Te...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat: add RegexpReplace expression References: - https://docs.snowflake.com/en/sql-reference/functions/regexp_replace - https://spark.apache.org/docs/latest/api/sql/index.html#regexp_replace - https://cwiki.apache.org/confluence/display/hive/languagemanual+udf - https://cloud.google.com/bigquery/docs/reference/standard-sql/string_functions#regexp_replace - https://duckdb.org/docs/sql/functions/patternmatching.html ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		ceb42fabad60312699e4b15936aeebac00e22e4d
matplotlib__matplotlib-26293	26,293	matplotlib/matplotlib	3.7	a4dca24d04f928a9e614db403c716237446140b2	2023-07-12T06:31:49Z	diff --git a/doc/api/axes_api.rst b/doc/api/axes_api.rst index 3457368fa51c..8b01a120da5b 100644 --- a/doc/api/axes_api.rst +++ b/doc/api/axes_api.rst @@ -335,6 +335,8 @@ Autoscaling and margins Axes.use_sticky_edges Axes.margins + Axes.get_xmargin + Axes.get_ymargin Axes.set_xmargin Axes.set_ymargin diff --git a/doc/api/toolkits/mplot3d/axes3d.rst b/doc/api/toolkits/mplot3d/axes3d.rst index f6d8e2529896..b581494e4883 100644 --- a/doc/api/toolkits/mplot3d/axes3d.rst +++ b/doc/api/toolkits/mplot3d/axes3d.rst @@ -137,6 +137,7 @@ Autoscaling and margins :template: autosummary.rst :nosignatures: + get_zmargin set_zmargin margins autoscale diff --git a/doc/users/next_whats_new/margin_getters.rst b/doc/users/next_whats_new/margin_getters.rst new file mode 100644 index 000000000000..c43709a17d52 --- /dev/null +++ b/doc/users/next_whats_new/margin_getters.rst @@ -0,0 +1,4 @@ +Getters for xmargin, ymargin and zmargin +---------------------------------------- +``.Axes.get_xmargin()``, ``.Axes.get_ymargin()`` and ``.Axes3D.get_zmargin()`` methods have been added to return +the margin values set by ``.Axes.set_xmargin()``, ``.Axes.set_ymargin()`` and ``.Axes3D.set_zmargin()``, respectively. diff --git a/lib/matplotlib/axes/_base.py b/lib/matplotlib/axes/_base.py index 3796d9bbe508..ad06e6d552bc 100644 --- a/lib/matplotlib/axes/_base.py +++ b/lib/matplotlib/axes/_base.py @@ -2617,6 +2617,38 @@ def use_sticky_edges(self, b): self._use_sticky_edges = bool(b) # No effect until next autoscaling, which will mark the Axes as stale. + def get_xmargin(self): + """ + Retrieve autoscaling margin of the x-axis. + + .. versionadded:: 3.9 + + Returns + ------- + xmargin : float + + See Also + -------- + matplotlib.axes.Axes.set_xmargin + """ + return self._xmargin + + def get_ymargin(self): + """ + Retrieve autoscaling margin of the y-axis. + + .. versionadded:: 3.9 + + Returns + ------- + ymargin : float + + See Also + -------- + matplotlib.axes.Axes.set_ymargin + """ + return self._ymargin + def set_xmargin(self, m): """ Set padding of X data limits prior to autoscaling. diff --git a/lib/matplotlib/axes/_base.pyi b/lib/matplotlib/axes/_base.pyi index d41ecae1803c..e3644585296d 100644 --- a/lib/matplotlib/axes/_base.pyi +++ b/lib/matplotlib/axes/_base.pyi @@ -242,6 +242,8 @@ class _AxesBase(martist.Artist): def use_sticky_edges(self) -> bool: ... @use_sticky_edges.setter def use_sticky_edges(self, b: bool) -> None: ... + def get_xmargin(self) -> float: ... + def get_ymargin(self) -> float: ... def set_xmargin(self, m: float) -> None: ... def set_ymargin(self, m: float) -> None: ... diff --git a/lib/mpl_toolkits/mplot3d/axes3d.py b/lib/mpl_toolkits/mplot3d/axes3d.py index aeb6a66d2c98..e7abdc0767b5 100644 --- a/lib/mpl_toolkits/mplot3d/axes3d.py +++ b/lib/mpl_toolkits/mplot3d/axes3d.py @@ -513,6 +513,22 @@ def update_datalim(self, xys, **kwargs): get_autoscalez_on = _axis_method_wrapper("zaxis", "_get_autoscale_on") set_autoscalez_on = _axis_method_wrapper("zaxis", "_set_autoscale_on") + def get_zmargin(self): + """ + Retrieve autoscaling margin of the z-axis. + + .. versionadded:: 3.9 + + Returns + ------- + zmargin : float + + See Also + -------- + mpl_toolkits.mplot3d.axes3d.Axes3D.set_zmargin + """ + return self._zmargin + def set_zmargin(self, m): """ Set padding of Z data limits prior to autoscaling.	diff --git a/lib/matplotlib/tests/test_axes.py b/lib/matplotlib/tests/test_axes.py index 0fcb2eb26cbb..6dea39a702fc 100644 --- a/lib/matplotlib/tests/test_axes.py +++ b/lib/matplotlib/tests/test_axes.py @@ -6153,6 +6153,14 @@ def test_margins(): ymax + (ymax - ymin) * 0.5) +def test_margin_getters(): + fig = plt.figure() + ax = fig.add_subplot() + ax.margins(0.2, 0.3) + assert ax.get_xmargin() == 0.2 + assert ax.get_ymargin() == 0.3 + + def test_set_margin_updates_limits(): mpl.style.use("default") fig, ax = plt.subplots() diff --git a/lib/mpl_toolkits/mplot3d/tests/test_axes3d.py b/lib/mpl_toolkits/mplot3d/tests/test_axes3d.py index 1f8764cbab9d..df9f2ae52fd7 100644 --- a/lib/mpl_toolkits/mplot3d/tests/test_axes3d.py +++ b/lib/mpl_toolkits/mplot3d/tests/test_axes3d.py @@ -1994,6 +1994,15 @@ def test_margins(): assert ax.margins() == (0, 0.1, 0) +def test_margin_getters(): + fig = plt.figure() + ax = fig.add_subplot(projection='3d') + ax.margins(0.1, 0.2, 0.3) + assert ax.get_xmargin() == 0.1 + assert ax.get_ymargin() == 0.2 + assert ax.get_zmargin() == 0.3 + + @pytest.mark.parametrize('err, args, kwargs, match', ( (ValueError, (-1,), {}, r'margin must be greater than -0\.5'), (ValueError, (1, -1, 1), {}, r'margin must be greater than -0\.5'),	diff --git a/doc/api/axes_api.rst b/doc/api/axes_api.rst index 3457368fa51c..8b01a120da5b 100644 --- a/doc/api/axes_api.rst +++ b/doc/api/axes_api.rst @@ -335,6 +335,8 @@ Autoscaling and margins Axes.use_sticky_edges Axes.margins + Axes.get_xmargin + Axes.get_ymargin Axes.set_xmargin Axes.set_ymargin diff --git a/doc/api/toolkits/mplot3d/axes3d.rst b/doc/api/toolkits/mplot3d/axes3d.rst index f6d8e2529896..b581494e4883 100644 --- a/doc/api/toolkits/mplot3d/axes3d.rst +++ b/doc/api/toolkits/mplot3d/axes3d.rst @@ -137,6 +137,7 @@ Autoscaling and margins :template: autosummary.rst :nosignatures: + get_zmargin set_zmargin margins autoscale diff --git a/doc/users/next_whats_new/margin_getters.rst b/doc/users/next_whats_new/margin_getters.rst new file mode 100644 index 000000000000..c43709a17d52 --- /dev/null +++ b/doc/users/next_whats_new/margin_getters.rst @@ -0,0 +1,4 @@ +Getters for xmargin, ymargin and zmargin +---------------------------------------- +``.Axes.get_xmargin()``, ``.Axes.get_ymargin()`` and ``.Axes3D.get_zmargin()`` methods have been added to return +the margin values set by ``.Axes.set_xmargin()``, ``.Axes.set_ymargin()`` and ``.Axes3D.set_zmargin()``, respectively. diff --git a/lib/matplotlib/axes/_base.pyi b/lib/matplotlib/axes/_base.pyi index d41ecae1803c..e3644585296d 100644 --- a/lib/matplotlib/axes/_base.pyi +++ b/lib/matplotlib/axes/_base.pyi @@ -242,6 +242,8 @@ class _AxesBase(martist.Artist): def use_sticky_edges(self) -> bool: ... @use_sticky_edges.setter def use_sticky_edges(self, b: bool) -> None: ... + def get_xmargin(self) -> float: ... + def get_ymargin(self) -> float: ... def set_xmargin(self, m: float) -> None: ... def set_ymargin(self, m: float) -> None: ...	[ { "components": [ { "doc": "Retrieve autoscaling margin of the x-axis.\n\n.. versionadded:: 3.9\n\nReturns\n-------\nxmargin : float\n\nSee Also\n--------\nmatplotlib.axes.Axes.set_xmargin", "lines": [ 2620, 2634 ], "name": "_AxesBase.get_xmargin", ...	[ "lib/matplotlib/tests/test_axes.py::test_margin_getters", "lib/mpl_toolkits/mplot3d/tests/test_axes3d.py::test_margin_getters" ]	[ "lib/matplotlib/tests/test_axes.py::test_invisible_axes[png]", "lib/matplotlib/tests/test_axes.py::test_get_labels", "lib/matplotlib/tests/test_axes.py::test_repr", "lib/matplotlib/tests/test_axes.py::test_label_loc_vertical[png]", "lib/matplotlib/tests/test_axes.py::test_label_loc_horizontal[png]", "lib/...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added get_xmargin(), get_ymargin() and get_zmargin() and tests. ## PR summary Closes #26281 by adding `get_xmargin()`, `get_ymargin()` for` _AxesBase` and `get_zmargin()` for `Axes3D`, as well as tests for them. ## PR checklist <!-- Please mark any checkboxes that do not apply to this PR as [N/A].--> - [x] "closes #0000" is in the body of the PR description to [link the related issue](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue) - [x] new and changed code is [tested](https://matplotlib.org/devdocs/devel/testing.html) - [N/A] Plotting related features are demonstrated in an [example](https://matplotlib.org/devdocs/devel/documenting_mpl.html#writing-examples-and-tutorials) - [ ] New Features and API Changes are noted with a [directive and release note](https://matplotlib.org/devdocs/devel/coding_guide.html#new-features-and-api-changes) - [ ] Documentation complies with [general](https://matplotlib.org/devdocs/devel/documenting_mpl.html#writing-rest-pages) and [docstring](https://matplotlib.org/devdocs/devel/documenting_mpl.html#writing-docstrings) guidelines <!-- Thank you so much for your PR! To help us review your contribution, please consider the following points: - A development guide is available at https://matplotlib.org/devdocs/devel/index.html. - Help with git and github is available at https://matplotlib.org/devdocs/devel/development_workflow.html - Create a separate branch for your changes and open the PR from this branch. Please avoid working on `main`. - The PR title should summarize the changes, for example "Raise ValueError on non-numeric input to set_xlim". Avoid non-descriptive titles such as "Addresses issue #8576". - The summary should provide at least 1-2 sentences describing the pull request in detail (Why is this change required? What problem does it solve?) and link to any relevant issues. - If you are contributing fixes to docstrings, please pay attention to https://matplotlib.org/stable/devel/documenting_mpl.html#formatting-conventions. In particular, note the difference between using single backquotes, double backquotes, and asterisks in the markup. We understand that PRs can sometimes be overwhelming, especially as the reviews start coming in. Please let us know if the reviews are unclear or the recommended next step seems overly demanding, if you would like help in addressing a reviewer's comments, or if you have been waiting too long to hear back on your PR. --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in lib/matplotlib/axes/_base.py] (definition of _AxesBase.get_xmargin:) def get_xmargin(self): """Retrieve autoscaling margin of the x-axis. .. versionadded:: 3.9 Returns ------- xmargin : float See Also -------- matplotlib.axes.Axes.set_xmargin""" (definition of _AxesBase.get_ymargin:) def get_ymargin(self): """Retrieve autoscaling margin of the y-axis. .. versionadded:: 3.9 Returns ------- ymargin : float See Also -------- matplotlib.axes.Axes.set_ymargin""" [end of new definitions in lib/matplotlib/axes/_base.py] [start of new definitions in lib/mpl_toolkits/mplot3d/axes3d.py] (definition of Axes3D.get_zmargin:) def get_zmargin(self): """Retrieve autoscaling margin of the z-axis. .. versionadded:: 3.9 Returns ------- zmargin : float See Also -------- mpl_toolkits.mplot3d.axes3d.Axes3D.set_zmargin""" [end of new definitions in lib/mpl_toolkits/mplot3d/axes3d.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> [ENH]: Add get_xmargin, get_ymargin, get_zmargin axes methods ### Problem Currently, I think the only public API to retrieve the margins settings on an Axes is ax.margins(), which has a somewhat peculiar API (basically inherited from pyplot/matlab); adding get_xmargin/get_ymargin/get_zmargin Axes methods would be nice (there's already the corresponding setters). Bonus points for moving the private _xmargin/_ymargin/_zmargin to the Axis instances, adding Axis.{get,set}_margin, and using axis_method_wrapper, though I haven't checked it'll actually work. ### Proposed solution _No response_ ---------- Hi! Does zmargin exist? I couldn't find it -- both the public docs and the code in _base.py only have xmargin and ymargin. Am I missing something? It is in Axes3D. -------------------- </issues>	a4dca24d04f928a9e614db403c716237446140b2
tobymao__sqlglot-1907	1,907	tobymao/sqlglot	null	69a69f67d06ebf8d328eb30fd0ef7d717758a4c9	2023-07-10T23:56:18Z	diff --git a/sqlglot/dialects/tsql.py b/sqlglot/dialects/tsql.py index b77c2c0bb7..efb49bd9a9 100644 --- a/sqlglot/dialects/tsql.py +++ b/sqlglot/dialects/tsql.py @@ -138,7 +138,8 @@ def _format_sql(self: generator.Generator, expression: exp.NumberToStr \| exp.Tim if isinstance(expression, exp.NumberToStr) else exp.Literal.string( format_time( - expression.text("format"), t.cast(t.Dict[str, str], TSQL.INVERSE_TIME_MAPPING) + expression.text("format"), + t.cast(t.Dict[str, str], TSQL.INVERSE_TIME_MAPPING), ) ) ) @@ -314,7 +315,9 @@ class Parser(parser.Parser): FUNCTIONS = { **parser.Parser.FUNCTIONS, "CHARINDEX": lambda args: exp.StrPosition( - this=seq_get(args, 1), substr=seq_get(args, 0), position=seq_get(args, 2) + this=seq_get(args, 1), + substr=seq_get(args, 0), + position=seq_get(args, 2), ), "DATEADD": parse_date_delta(exp.DateAdd, unit_mapping=DATE_DELTA_INTERVAL), "DATEDIFF": parse_date_delta(exp.DateDiff, unit_mapping=DATE_DELTA_INTERVAL), @@ -365,6 +368,57 @@ class Parser(parser.Parser): CONCAT_NULL_OUTPUTS_STRING = True + def _parse_commit_or_rollback(self) -> exp.Commit \| exp.Rollback: + """Applies to SQL Server and Azure SQL Database + COMMIT [ { TRAN \| TRANSACTION } + [ transaction_name \| @tran_name_variable ] ] + [ WITH ( DELAYED_DURABILITY = { OFF \| ON } ) ] + [ ; ] + + ROLLBACK { TRAN \| TRANSACTION } + [ transaction_name \| @tran_name_variable + \| savepoint_name \| @savepoint_variable ] + [ ; ] + """ + rollback = self._prev.token_type == TokenType.ROLLBACK + + self._match_texts({"TRAN", "TRANSACTION"}) + txn_name = self._parse_id_var() + + durability = None + if self._match_pair(TokenType.WITH, TokenType.L_PAREN): + self._match_text_seq("DELAYED_DURABILITY") + self._match(TokenType.EQ) + if self._match_text_seq("OFF"): + durability = False + else: + self._match(TokenType.ON) + durability = True + + self._match_r_paren() + + if rollback: + return self.expression(exp.Rollback, this=txn_name) + + return self.expression(exp.Commit, this=txn_name, durability=durability) + + def _parse_transaction(self) -> exp.Transaction \| exp.Command: + """Applies to SQL Server and Azure SQL Database + BEGIN { TRAN \| TRANSACTION } + [ { transaction_name \| @tran_name_variable } + [ WITH MARK [ 'description' ] ] + ] + [ ; ] + """ + if self._match_texts(("TRAN", "TRANSACTION")): + # we have a transaction and not a BEGIN + transaction = self.expression(exp.Transaction, this=self._parse_id_var()) + if self._match_text_seq("WITH", "MARK"): + transaction.set("mark", self._parse_string()) + return transaction + + return self._parse_as_command(self._prev) + def _parse_system_time(self) -> t.Optional[exp.Expression]: if not self._match_text_seq("FOR", "SYSTEM_TIME"): return None @@ -496,7 +550,9 @@ class Generator(generator.Generator): exp.Select: transforms.preprocess([transforms.eliminate_distinct_on]), exp.SHA: lambda self, e: self.func("HASHBYTES", exp.Literal.string("SHA1"), e.this), exp.SHA2: lambda self, e: self.func( - "HASHBYTES", exp.Literal.string(f"SHA2_{e.args.get('length', 256)}"), e.this + "HASHBYTES", + exp.Literal.string(f"SHA2_{e.args.get('length', 256)}"), + e.this, ), exp.TimeToStr: _format_sql, } @@ -539,3 +595,31 @@ def returning_sql(self, expression: exp.Returning) -> str: into = self.sql(expression, "into") into = self.seg(f"INTO {into}") if into else "" return f"{self.seg('OUTPUT')} {self.expressions(expression, flat=True)}{into}" + + def transaction_sql(self, expression: exp.Transaction) -> str: + this = self.sql(expression, "this") + if this in ["TRAN", "TRANSACTION"]: + mark = self.sql(expression, "mark") + mark = f" WITH MARK {mark}" if mark else "" + return f"BEGIN TRANSACTION{mark}" + else: + this = f" {this}" if this else "" + mark = self.sql(expression, "mark") + mark = f" WITH MARK {mark}" if mark else "" + return f"BEGIN TRANSACTION{this}{mark}" + + def commit_sql(self, expression: exp.Commit) -> str: + this = self.sql(expression, "this") + this = f" {this}" if this else "" + durability = expression.args.get("durability") + durability = ( + f" WITH (DELAYED_DURABILITY = {'ON' if durability else 'OFF'})" + if durability is not None + else "" + ) + return f"COMMIT TRANSACTION{this}{durability}" + + def rollback_sql(self, expression: exp.Rollback) -> str: + this = self.sql(expression, "this") + this = f" {this}" if this else "" + return f"ROLLBACK TRANSACTION{this}" diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index 1efedc7b78..e4edeed1cf 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -3472,15 +3472,15 @@ class Command(Expression): class Transaction(Expression): - arg_types = {"this": False, "modes": False} + arg_types = {"this": False, "modes": False, "mark": False} class Commit(Expression): - arg_types = {"chain": False} + arg_types = {"chain": False, "this": False, "durability": False} class Rollback(Expression): - arg_types = {"savepoint": False} + arg_types = {"savepoint": False, "this": False} class AlterTable(Expression): diff --git a/sqlglot/parser.py b/sqlglot/parser.py index 508a273705..166e3b8e66 100644 --- a/sqlglot/parser.py +++ b/sqlglot/parser.py @@ -4351,7 +4351,7 @@ def _parse_ddl_select(self) -> t.Optional[exp.Expression]: self._parse_set_operations(self._parse_select(nested=True, parse_subquery_alias=False)) ) - def _parse_transaction(self) -> exp.Transaction: + def _parse_transaction(self) -> exp.Transaction \| exp.Command: this = None if self._match_texts(self.TRANSACTION_KIND): this = self._prev.text	diff --git a/tests/dialects/test_dialect.py b/tests/dialects/test_dialect.py index 05738cf34e..3ca47aba2b 100644 --- a/tests/dialects/test_dialect.py +++ b/tests/dialects/test_dialect.py @@ -1512,6 +1512,7 @@ def test_transactions(self): "redshift": "BEGIN", "snowflake": "BEGIN", "sqlite": "BEGIN TRANSACTION", + "tsql": "BEGIN TRANSACTION", }, ) self.validate_all( diff --git a/tests/dialects/test_tsql.py b/tests/dialects/test_tsql.py index 065cdd09f9..5fa881b616 100644 --- a/tests/dialects/test_tsql.py +++ b/tests/dialects/test_tsql.py @@ -389,7 +389,58 @@ def test_types_bin(self): }, ) + def test_ddl(self): + self.validate_all( + "CREATE TABLE #mytemp (a INTEGER, b CHAR(2), c TIME(4), d FLOAT(24))", + write={ + "tsql": "CREATE TABLE #mytemp (a INTEGER, b CHAR(2), c TIMESTAMP(4), d FLOAT(24))" + }, + ) + + def test_transaction(self): + # BEGIN { TRAN \| TRANSACTION } + # [ { transaction_name \| @tran_name_variable } + # [ WITH MARK [ 'description' ] ] + # ] + # [ ; ] + self.validate_identity("BEGIN TRANSACTION") + self.validate_all("BEGIN TRAN", write={"tsql": "BEGIN TRANSACTION"}) + self.validate_identity("BEGIN TRANSACTION transaction_name") + self.validate_identity("BEGIN TRANSACTION @tran_name_variable") + self.validate_identity("BEGIN TRANSACTION transaction_name WITH MARK 'description'") + + def test_commit(self): + # COMMIT [ { TRAN \| TRANSACTION } [ transaction_name \| @tran_name_variable ] ] [ WITH ( DELAYED_DURABILITY = { OFF \| ON } ) ] [ ; ] + + self.validate_all("COMMIT", write={"tsql": "COMMIT TRANSACTION"}) + self.validate_all("COMMIT TRAN", write={"tsql": "COMMIT TRANSACTION"}) + self.validate_identity("COMMIT TRANSACTION") + self.validate_identity("COMMIT TRANSACTION transaction_name") + self.validate_identity("COMMIT TRANSACTION @tran_name_variable") + + self.validate_identity( + "COMMIT TRANSACTION @tran_name_variable WITH (DELAYED_DURABILITY = ON)" + ) + self.validate_identity( + "COMMIT TRANSACTION transaction_name WITH (DELAYED_DURABILITY = OFF)" + ) + + def test_rollback(self): + # Applies to SQL Server and Azure SQL Database + # ROLLBACK { TRAN \| TRANSACTION } + # [ transaction_name \| @tran_name_variable + # \| savepoint_name \| @savepoint_variable ] + # [ ; ] + self.validate_all("ROLLBACK", write={"tsql": "ROLLBACK TRANSACTION"}) + self.validate_all("ROLLBACK TRAN", write={"tsql": "ROLLBACK TRANSACTION"}) + self.validate_identity("ROLLBACK TRANSACTION") + self.validate_identity("ROLLBACK TRANSACTION transaction_name") + self.validate_identity("ROLLBACK TRANSACTION @tran_name_variable") + def test_udf(self): + self.validate_identity( + "DECLARE @DWH_DateCreated DATETIME = CONVERT(DATETIME, getdate(), 104)" + ) self.validate_identity( "CREATE PROCEDURE foo @a INTEGER, @b INTEGER AS SELECT @a = SUM(bla) FROM baz AS bar" ) @@ -446,6 +497,12 @@ def test_udf(self): pretty=True, ) + def test_procedure_keywords(self): + self.validate_identity("BEGIN") + self.validate_identity("END") + self.validate_identity("SET XACT_ABORT ON") + + def test_fullproc(self): sql = """ CREATE procedure [TRANSF].[SP_Merge_Sales_Real] @Loadid INTEGER @@ -838,7 +895,8 @@ def test_format(self): write={"spark": "SELECT FORMAT_NUMBER(1000000.01, '###,###.###')"}, ) self.validate_all( - "SELECT FORMAT(1234567, 'f')", write={"spark": "SELECT FORMAT_NUMBER(1234567, 'f')"} + "SELECT FORMAT(1234567, 'f')", + write={"spark": "SELECT FORMAT_NUMBER(1234567, 'f')"}, ) self.validate_all( "SELECT FORMAT('01-01-1991', 'dd.mm.yyyy')", @@ -853,7 +911,8 @@ def test_format(self): write={"spark": "SELECT DATE_FORMAT(date_col, 'MMMM d')"}, ) self.validate_all( - "SELECT FORMAT(num_col, 'c')", write={"spark": "SELECT FORMAT_NUMBER(num_col, 'c')"} + "SELECT FORMAT(num_col, 'c')", + write={"spark": "SELECT FORMAT_NUMBER(num_col, 'c')"}, ) def test_string(self):		[]	[ "tests/dialects/test_dialect.py::TestDialect::test_transactions", "tests/dialects/test_tsql.py::TestTSQL::test_commit", "tests/dialects/test_tsql.py::TestTSQL::test_rollback", "tests/dialects/test_tsql.py::TestTSQL::test_transaction" ]	[ "tests/dialects/test_dialect.py::TestDialect::test_alias", "tests/dialects/test_dialect.py::TestDialect::test_array", "tests/dialects/test_dialect.py::TestDialect::test_cast", "tests/dialects/test_dialect.py::TestDialect::test_count_if", "tests/dialects/test_dialect.py::TestDialect::test_cross_join", "tes...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat(tsql): improve support for transaction statements Enrich syntax parsing for BEGIN, COMMIT and ROLLBACK Transactions. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		ceb42fabad60312699e4b15936aeebac00e22e4d
Textualize__textual-2906	2,906	Textualize/textual	null	90a93e08abe813da495712ad99d4d6da5215728b	2023-07-09T17:04:07Z	diff --git a/src/textual/_fuzzy.py b/src/textual/_fuzzy.py new file mode 100644 index 0000000000..2d9766e054 --- /dev/null +++ b/src/textual/_fuzzy.py @@ -0,0 +1,82 @@ +from re import compile, escape + +import rich.repr +from rich.text import Text + +from ._cache import LRUCache + + +@rich.repr.auto +class Matcher: + """A fuzzy matcher.""" + + def __init__(self, query: str) -> None: + """ + Args: + query: A query as typed in by the user. + """ + self.query = query + self._query_regex = ".?".join(f"({escape(character)})" for character in query) + self._query_regex_compiled = compile(self._query_regex) + self._cache: LRUCache[str, float] = LRUCache(1024 4) + + def match(self, input: str) -> float: + """Match the input against the query + + Args: + input: Input string to match against. + + Returns: + Strength of the match from 0 to 1. + """ + cached = self._cache.get(input) + if cached is not None: + return cached + match = self._query_regex_compiled.search(input) + if match is None: + score = 0.0 + else: + assert match.lastindex is not None + offsets = [ + match.span(group_no)[0] for group_no in range(1, match.lastindex + 1) + ] + group_count = 0 + last_offset = -2 + for offset in offsets: + if offset > last_offset + 1: + group_count += 1 + last_offset = offset + + score = 1.0 - ((group_count - 1) / len(input)) + self._cache[input] = score + return score + + def highlight(self, input: str) -> Text: + """Highlight the input with the fuzzy match. + + Args: + input: User input. + + Returns: + A Text object with matched letters in bold. + """ + match = self._query_regex_compiled.search(input) + text = Text(input) + if match is None: + return text + assert match.lastindex is not None + offsets = [ + match.span(group_no)[0] for group_no in range(1, match.lastindex + 1) + ] + for offset in offsets: + text.stylize("bold", offset, offset + 1) + + return text + + +if __name__ == "__main__": + from rich import print + + matcher = Matcher("foo.bar") + print(matcher.match("xz foo.bar sdf")) + print(matcher.highlight("xz foo.bar sdf"))	diff --git a/tests/test_fuzzy.py b/tests/test_fuzzy.py new file mode 100644 index 0000000000..71c073d9f2 --- /dev/null +++ b/tests/test_fuzzy.py @@ -0,0 +1,40 @@ +from rich.text import Span + +from textual._fuzzy import Matcher + + +def test_match(): + matcher = Matcher("foo.bar") + + # No match + assert matcher.match("egg") == 0 + assert matcher.match("") == 0 + + # Perfect match + assert matcher.match("foo.bar") == 1.0 + # Perfect match (with superfluous characters) + assert matcher.match("foo.bar sdf") == 1.0 + assert matcher.match("xz foo.bar sdf") == 1.0 + + # Partial matches + # 2 Groups + assert matcher.match("foo egg.bar") == 1.0 - 1 / 11 + + # 3 Groups + assert matcher.match("foo .ba egg r") == 1.0 - 2 / 13 + + +def test_highlight(): + matcher = Matcher("foo.bar") + + spans = matcher.highlight("foo/egg.bar").spans + print(spans) + assert spans == [ + Span(0, 1, "bold"), + Span(1, 2, "bold"), + Span(2, 3, "bold"), + Span(7, 8, "bold"), + Span(8, 9, "bold"), + Span(9, 10, "bold"), + Span(10, 11, "bold"), + ]		[ { "components": [ { "doc": "A fuzzy matcher.", "lines": [ 10, 74 ], "name": "Matcher", "signature": "class Matcher:", "type": "class" }, { "doc": "Args:\n query: A query as typed in by the user.", "lines": [...	[ "tests/test_fuzzy.py::test_match", "tests/test_fuzzy.py::test_highlight" ]	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> fuzzy matcher Some initial work for the "command palette", which will use "fuzzy matching". This implements the fuzzy part. Commands will be matched against the user's input. A match is recorded if all the users characters are in the command and in the correct order. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/textual/_fuzzy.py] (definition of Matcher:) class Matcher: """A fuzzy matcher.""" (definition of Matcher.__init__:) def __init__(self, query: str) -> None: """Args: query: A query as typed in by the user.""" (definition of Matcher.match:) def match(self, input: str) -> float: """Match the input against the query Args: input: Input string to match against. Returns: Strength of the match from 0 to 1.""" (definition of Matcher.highlight:) def highlight(self, input: str) -> Text: """Highlight the input with the fuzzy match. Args: input: User input. Returns: A Text object with matched letters in bold.""" [end of new definitions in src/textual/_fuzzy.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		86e93536b991014e0ea4bf993068202b446bb698
conan-io__conan-14233	14,233	conan-io/conan	null	57c7049c758a685cdc02e870eb77617af5e45da6	2023-07-06T06:04:41Z	diff --git a/conan/tools/gnu/pkgconfigdeps.py b/conan/tools/gnu/pkgconfigdeps.py index e793711ee81..1aa86e9d472 100644 --- a/conan/tools/gnu/pkgconfigdeps.py +++ b/conan/tools/gnu/pkgconfigdeps.py @@ -1,12 +1,13 @@ import os +import re import textwrap from collections import namedtuple from jinja2 import Template, StrictUndefined +from conan.errors import ConanException from conan.internal import check_duplicated_generator from conan.tools.gnu.gnudeps_flags import GnuDepsFlags -from conan.errors import ConanException from conans.model.dependencies import get_transitive_requires from conans.util.files import save @@ -75,8 +76,8 @@ def _get_suffix(req, build_context_suffix=None): return build_context_suffix.get(req.ref.name, "") -def _get_formatted_dirs(folders, prefix_path_): - ret = [] +def _get_formatted_dirs(folder_name, folders, prefix_path_): + ret = {} for i, directory in enumerate(folders): directory = os.path.normpath(directory).replace("\\", "/") prefix = "" @@ -85,7 +86,9 @@ def _get_formatted_dirs(folders, prefix_path_): elif directory.startswith(prefix_path_): prefix = "${prefix}/" directory = os.path.relpath(directory, prefix_path_).replace("\\", "/") - ret.append("%s%s" % (prefix, directory)) + suffix = str(i) if i else "" + var_name = f"{folder_name}{suffix}" + ret[var_name] = f"{prefix}{directory}" return ret @@ -95,71 +98,19 @@ def _get_formatted_dirs(folders, prefix_path_): class _PCContentGenerator: template = textwrap.dedent("""\ - {%- macro get_libs(libdirs, cpp_info, gnudeps_flags) -%} - {%- for _ in libdirs -%} - {{ '-L"${libdir%s}"' % (loop.index0 or "") + " " }} - {%- endfor -%} - {%- for sys_lib in (cpp_info.libs + cpp_info.system_libs) -%} - {{ "-l%s" % sys_lib + " " }} - {%- endfor -%} - {%- for shared_flag in (cpp_info.sharedlinkflags + cpp_info.exelinkflags) -%} - {{ shared_flag + " " }} - {%- endfor -%} - {%- for framework in (gnudeps_flags.frameworks + gnudeps_flags.framework_paths) -%} - {{ framework + " " }} - {%- endfor -%} - {%- endmacro -%} - - {%- macro get_cflags(includedirs, cxxflags, cflags, defines) -%} - {%- for _ in includedirs -%} - {{ '-I"${includedir%s}"' % (loop.index0 or "") + " " }} - {%- endfor -%} - {%- for cxxflag in cxxflags -%} - {{ cxxflag + " " }} - {%- endfor -%} - {%- for cflag in cflags-%} - {{ cflag + " " }} - {%- endfor -%} - {%- for define in defines-%} - {{ "-D%s" % define + " " }} - {%- endfor -%} - {%- endmacro -%} - - prefix={{ prefix_path }} - {% for path in libdirs %} - {{ "libdir{}={}".format((loop.index0 or ""), path) }} - {% endfor %} - {% for path in includedirs %} - {{ "includedir%s=%s" % ((loop.index0 or ""), path) }} - {% endfor %} - {% for path in bindirs %} - {{ "bindir{}={}".format((loop.index0 or ""), path) }} + {% for k, v in pc_variables.items() %} + {{ "{}={}".format(k, v) }} {% endfor %} - {% if pkg_config_custom_content %} - # Custom PC content - {{ pkg_config_custom_content }} - {% endif %} Name: {{ name }} Description: {{ description }} Version: {{ version }} - Libs: {{ get_libs(libdirs, cpp_info, gnudeps_flags) }} - Cflags: {{ get_cflags(includedirs, cxxflags, cflags, defines) }} - {% if requires\|length %} - Requires: {{ requires\|join(' ') }} + {% if libflags %} + Libs: {{ libflags }} {% endif %} - """) - - shortened_template = textwrap.dedent("""\ - prefix={{ prefix_path }} - {% if pkg_config_custom_content %} - # Custom PC content - {{ pkg_config_custom_content }} + {% if cflags %} + Cflags: {{ cflags }} {% endif %} - - Name: {{ name }} - Description: {{ description }} - Version: {{ version }} {% if requires\|length %} Requires: {{ requires\|join(' ') }} {% endif %} @@ -175,50 +126,74 @@ def _get_prefix_path(self): else self._dep.package_folder return root_folder.replace("\\", "/") - def content(self, info): - assert isinstance(info, _PCInfo) and info.cpp_info is not None - + def _get_pc_variables(self, cpp_info): + """ + Get all the freeform variables defined by Conan and + users (through ``pkg_config_custom_content``). This last ones will override the + Conan defined variables. + """ prefix_path = self._get_prefix_path() - version = info.cpp_info.get_property("component_version") or self._dep.ref.version - libdirs = _get_formatted_dirs(info.cpp_info.libdirs, prefix_path) - includedirs = _get_formatted_dirs(info.cpp_info.includedirs, prefix_path) - bindirs = _get_formatted_dirs(info.cpp_info.bindirs, prefix_path) - custom_content = info.cpp_info.get_property("pkg_config_custom_content") - + pc_variables = {"prefix": prefix_path} + if cpp_info is None: + return pc_variables + # Already formatted directories + pc_variables.update(_get_formatted_dirs("libdir", cpp_info.libdirs, prefix_path)) + pc_variables.update(_get_formatted_dirs("includedir", cpp_info.includedirs, prefix_path)) + pc_variables.update(_get_formatted_dirs("bindir", cpp_info.bindirs, prefix_path)) + # Get the custom content introduced by user and sanitize it + custom_content = cpp_info.get_property("pkg_config_custom_content") + if isinstance(custom_content, dict): + pc_variables.update(custom_content) + elif custom_content: # Legacy: custom content is string + pc_variable_pattern = re.compile("^(.)=(.)") + for line in custom_content.splitlines(): + match = pc_variable_pattern.match(line) + if match: + key, value = match.group(1).strip(), match.group(2).strip() + pc_variables[key] = value + return pc_variables + + def _get_lib_flags(self, libdirvars, cpp_info): + gnudeps_flags = GnuDepsFlags(self._conanfile, cpp_info) + libdirsflags = ['-L"${%s}"' % d for d in libdirvars] + system_libs = ["-l%s" % l for l in (cpp_info.libs + cpp_info.system_libs)] + shared_flags = cpp_info.sharedlinkflags + cpp_info.exelinkflags + framework_flags = gnudeps_flags.frameworks + gnudeps_flags.framework_paths + return " ".join(libdirsflags + system_libs + shared_flags + framework_flags) + + def _get_cflags(self, includedirvars, cpp_info): + includedirsflags = ['-I"${%s}"' % d for d in includedirvars] + cxxflags = [var.replace('"', '\\"') for var in cpp_info.cxxflags] + cflags = [var.replace('"', '\\"') for var in cpp_info.cflags] + defines = ["-D%s" % var.replace('"', '\\"') for var in cpp_info.defines] + return " ".join(includedirsflags + cxxflags + cflags + defines) + + def _get_context(self, info): + pc_variables = self._get_pc_variables(info.cpp_info) context = { - "prefix_path": prefix_path, - "libdirs": libdirs, - "includedirs": includedirs, - "bindirs": bindirs, - "pkg_config_custom_content": custom_content, "name": info.name, "description": info.description, - "version": version, + "version": self._dep.ref.version, "requires": info.requires, - "cpp_info": info.cpp_info, - "cxxflags": [var.replace('"', '\\"') for var in info.cpp_info.cxxflags], - "cflags": [var.replace('"', '\\"') for var in info.cpp_info.cflags], - "defines": [var.replace('"', '\\"') for var in info.cpp_info.defines], - "gnudeps_flags": GnuDepsFlags(self._conanfile, info.cpp_info) + "pc_variables": pc_variables, + "cflags": "", + "libflags": "" } - template = Template(self.template, trim_blocks=True, lstrip_blocks=True, - undefined=StrictUndefined) - return template.render(context) + if info.cpp_info is not None: + context.update({ + "version": info.cpp_info.get_property("component_version") or self._dep.ref.version, + "cflags": self._get_cflags([d for d in pc_variables if d.startswith("includedir")], + info.cpp_info), + "libflags": self._get_lib_flags([d for d in pc_variables if d.startswith("libdir")], + info.cpp_info) + }) + return context - def shortened_content(self, info): + def content(self, info): assert isinstance(info, _PCInfo) - custom_content = info.cpp_info.get_property("pkg_config_custom_content") if info.cpp_info \ - else None - context = { - "prefix_path": self._get_prefix_path(), - "pkg_config_custom_content": custom_content, - "name": info.name, - "description": info.description, - "version": self._dep.ref.version, - "requires": info.requires - } - template = Template(self.shortened_template, trim_blocks=True, - lstrip_blocks=True, undefined=StrictUndefined) + context = self._get_context(info) + template = Template(self.template, trim_blocks=True, lstrip_blocks=True, + undefined=StrictUndefined) return template.render(context) @@ -340,7 +315,7 @@ def _update_pc_files(info): pc_files[f"{info.name}.pc"] = self._content_generator.content(info) for alias in info.aliases: alias_info = _PCInfo(alias, [info.name], f"Alias {alias} for {info.name}", None, []) - pc_files[f"{alias}.pc"] = self._content_generator.shortened_content(alias_info) + pc_files[f"{alias}.pc"] = self._content_generator.content(alias_info) pc_files = {} # If the package has no components, then we have to calculate only the root pc file @@ -365,11 +340,11 @@ def _update_pc_files(info): package_info = _PCInfo(pkg_name, pkg_requires, f"Conan package: {pkg_name}", self._dep.cpp_info, _get_package_aliases(self._dep)) # It'll be enough creating a shortened PC file. This file will be like an alias - pc_files[f"{package_info.name}.pc"] = self._content_generator.shortened_content(package_info) + pc_files[f"{package_info.name}.pc"] = self._content_generator.content(package_info) for alias in package_info.aliases: alias_info = _PCInfo(alias, [package_info.name], f"Alias {alias} for {package_info.name}", None, []) - pc_files[f"{alias}.pc"] = self._content_generator.shortened_content(alias_info) + pc_files[f"{alias}.pc"] = self._content_generator.content(alias_info) return pc_files	diff --git a/conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py b/conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py index e211bd6e889..fb6bc02c644 100644 --- a/conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py +++ b/conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py @@ -94,9 +94,7 @@ def package_info(self): expected = textwrap.dedent(""" Name: mylib Description: Conan package: mylib - Version: 0.1 - Libs:%s - Cflags: """ % " ") # ugly hack for trailing whitespace removed by IDEs + Version: 0.1""") assert "\n".join(pc_content.splitlines()[1:]) == expected @@ -173,9 +171,10 @@ def package(self): def package_info(self): custom_content = textwrap.dedent(\""" + bindir=${prefix}/my/bin/folder + fakelibdir=${prefix}/my/lib/folder datadir=${prefix}/share schemasdir=${datadir}/mylib/schemas - bindir=${prefix}/bin \""") self.cpp_info.set_property("pkg_config_custom_content", custom_content) self.cpp_info.includedirs = ["include"] @@ -187,11 +186,23 @@ def package_info(self): client.run("install --requires=pkg/0.1@ -g PkgConfigDeps") pc_content = client.load("pkg.pc") - assert "libdir=${prefix}/lib" in pc_content - assert "datadir=${prefix}/share" in pc_content - assert "schemasdir=${datadir}/mylib/schemas" in pc_content - assert "bindir=${prefix}/bin" in pc_content - assert "Name: pkg" in pc_content + prefix = pc_content.splitlines()[0] + expected = textwrap.dedent(f"""\ + {prefix} + libdir=${{prefix}}/lib + includedir=${{prefix}}/include + bindir=${{prefix}}/my/bin/folder + fakelibdir=${{prefix}}/my/lib/folder + datadir=${{prefix}}/share + schemasdir=${{datadir}}/mylib/schemas + + Name: pkg + Description: Conan package: pkg + Version: 0.1 + Libs: -L"${{libdir}}" + Cflags: -I"${{includedir}}" + """) + assert expected == pc_content def test_custom_content_and_version_components(): @@ -446,15 +457,17 @@ def package_info(self): pc_content = client.load("pkg_other_name.pc") content = textwrap.dedent(f"""\ {prefix} - # Custom PC content - + libdir=${{prefix}}/lib + includedir=${{prefix}}/include + bindir=${{prefix}}/bin datadir=${{prefix}}/share schemasdir=${{datadir}}/mylib/schemas - Name: pkg_other_name Description: Conan package: pkg_other_name Version: 0.3 + Libs: -L"${{libdir}}" + Cflags: -I"${{includedir}}" Requires: compo1 """) assert content == pc_content		[ { "components": [ { "doc": "Get all the freeform variables defined by Conan and\nusers (through ``pkg_config_custom_content``). This last ones will override the\nConan defined variables.", "lines": [ 129, 154 ], "name": "_PCContentGenerator._get_pc_varia...	[ "conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py::test_empty_dirs", "conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py::test_custom_content", "conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py::test_pkg_config_name_full_aliases" ]	[ "conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py::test_pkg_config_dirs", "conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py::test_system_libs", "conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py::test_multiple_include", "conans/test/integration/toolchains/gnu/test_pkgconfigd...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [PkgConfigDeps] `pkg_config_custom_content` property overwrites variables Changelog: Feature: Let `pkg_config_custom_content` overwrite default `.pc` variables created by `PkgConfigDeps`. Changelog: Feature: Let `pkg_config_custom_content` be a dict-like object too. Docs: https://github.com/conan-io/docs/pull/3293 UPDATED: Simplified internal `PkgConfigDeps` logic: only one template and more straightforward, one context, Python is formatting the template, etc. * `pkg_config_custom_content` overwrites Conan-defined freeform variables, not keyword metadata ones. * `pkg_config_custom_content` could be defined as a dictionary instead of a string. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conan/tools/gnu/pkgconfigdeps.py] (definition of _PCContentGenerator._get_pc_variables:) def _get_pc_variables(self, cpp_info): """Get all the freeform variables defined by Conan and users (through ``pkg_config_custom_content``). This last ones will override the Conan defined variables.""" (definition of _PCContentGenerator._get_lib_flags:) def _get_lib_flags(self, libdirvars, cpp_info): (definition of _PCContentGenerator._get_cflags:) def _get_cflags(self, includedirvars, cpp_info): (definition of _PCContentGenerator._get_context:) def _get_context(self, info): [end of new definitions in conan/tools/gnu/pkgconfigdeps.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		4a5b19a75db9225316c8cb022a2dfb9705a2af34
django__django-17045	17,045	django/django	5.0	2ddfa3e2b63d7a77270711dbe63aafb86abf4ddd	2023-07-04T13:41:24Z	diff --git a/AUTHORS b/AUTHORS index 40df3589c024..6cafad023aa5 100644 --- a/AUTHORS +++ b/AUTHORS @@ -62,6 +62,7 @@ answer newbie questions, and generally made Django that much better: Aljaž Košir <aljazkosir5@gmail.com> Aljosa Mohorovic <aljosa.mohorovic@gmail.com> Alokik Vijay <alokik.roe@gmail.com> + Amir Karimi <amk9978@gmail.com> Amit Chakradeo <https://amit.chakradeo.net/> Amit Ramon <amit.ramon@gmail.com> Amit Upadhyay <http://www.amitu.com/blog/> diff --git a/django/urls/resolvers.py b/django/urls/resolvers.py index b021673772a1..432bf50076e2 100644 --- a/django/urls/resolvers.py +++ b/django/urls/resolvers.py @@ -318,7 +318,10 @@ def match(self, path): return None def check(self): - warnings = self._check_pattern_startswith_slash() + warnings = [ + self._check_pattern_startswith_slash(), + self._check_pattern_unmatched_angle_brackets(), + ] route = self._route if "(?P<" in route or route.startswith("^") or route.endswith("$"): warnings.append( @@ -331,6 +334,34 @@ def check(self): ) return warnings + def _check_pattern_unmatched_angle_brackets(self): + warnings = [] + segments = self._route.split("/") + for segment in segments: + open_bracket_counter = 0 + unmatched_angle_bracket = None + for char in segment: + if char == "<": + open_bracket_counter += 1 + elif char == ">": + open_bracket_counter -= 1 + if open_bracket_counter < 0: + unmatched_angle_bracket = ">" + break + else: + if open_bracket_counter > 0: + unmatched_angle_bracket = "<" + + if unmatched_angle_bracket is not None: + warnings.append( + Warning( + "Your URL pattern %s has an unmatched '%s' bracket." + % (self.describe(), unmatched_angle_bracket), + id="urls.W010", + ) + ) + return warnings + def _compile(self, route): return re.compile(_route_to_regex(route, self._is_endpoint)[0])	diff --git a/tests/check_framework/test_urls.py b/tests/check_framework/test_urls.py index a9038c6f13ce..4b6a4a6f3eb3 100644 --- a/tests/check_framework/test_urls.py +++ b/tests/check_framework/test_urls.py @@ -161,6 +161,47 @@ def test_check_view_not_class(self): ], ) + @override_settings( + ROOT_URLCONF="check_framework.urls.path_compatibility.matched_angle_brackets" + ) + def test_no_warnings_matched_angle_brackets(self): + self.assertEqual(check_url_config(None), []) + + @override_settings( + ROOT_URLCONF="check_framework.urls.path_compatibility.unmatched_angle_brackets" + ) + def test_warning_unmatched_angle_brackets(self): + self.assertEqual( + check_url_config(None), + [ + Warning( + "Your URL pattern 'beginning-with/<angle_bracket' has an unmatched " + "'<' bracket.", + id="urls.W010", + ), + Warning( + "Your URL pattern 'ending-with/angle_bracket>' has an unmatched " + "'>' bracket.", + id="urls.W010", + ), + Warning( + "Your URL pattern 'closed_angle>/x/<opened_angle' has an unmatched " + "'>' bracket.", + id="urls.W010", + ), + Warning( + "Your URL pattern 'closed_angle>/x/<opened_angle' has an unmatched " + "'<' bracket.", + id="urls.W010", + ), + Warning( + "Your URL pattern '<mixed>angle_bracket>' has an unmatched '>' " + "bracket.", + id="urls.W010", + ), + ], + ) + class UpdatedToPathTests(SimpleTestCase): @override_settings( diff --git a/tests/check_framework/urls/path_compatibility/matched_angle_brackets.py b/tests/check_framework/urls/path_compatibility/matched_angle_brackets.py new file mode 100644 index 000000000000..de3076942d92 --- /dev/null +++ b/tests/check_framework/urls/path_compatibility/matched_angle_brackets.py @@ -0,0 +1,5 @@ +from django.urls import path + +urlpatterns = [ + path("<int:angle_bracket>", lambda x: x), +] diff --git a/tests/check_framework/urls/path_compatibility/unmatched_angle_brackets.py b/tests/check_framework/urls/path_compatibility/unmatched_angle_brackets.py new file mode 100644 index 000000000000..e53685ec7a3a --- /dev/null +++ b/tests/check_framework/urls/path_compatibility/unmatched_angle_brackets.py @@ -0,0 +1,8 @@ +from django.urls import path + +urlpatterns = [ + path("beginning-with/<angle_bracket", lambda x: x), + path("ending-with/angle_bracket>", lambda x: x), + path("closed_angle>/x/<opened_angle", lambda x: x), + path("<mixed>angle_bracket>", lambda x: x), +]	diff --git a/AUTHORS b/AUTHORS index 40df3589c024..6cafad023aa5 100644 --- a/AUTHORS +++ b/AUTHORS @@ -62,6 +62,7 @@ answer newbie questions, and generally made Django that much better: Aljaž Košir <aljazkosir5@gmail.com> Aljosa Mohorovic <aljosa.mohorovic@gmail.com> Alokik Vijay <alokik.roe@gmail.com> + Amir Karimi <amk9978@gmail.com> Amit Chakradeo <https://amit.chakradeo.net/> Amit Ramon <amit.ramon@gmail.com> Amit Upadhyay <http://www.amitu.com/blog/>	[ { "components": [ { "doc": "", "lines": [ 337, 363 ], "name": "RoutePattern._check_pattern_unmatched_angle_brackets", "signature": "def _check_pattern_unmatched_angle_brackets(self):", "type": "function" } ], "file": "django...	[ "test_warning_unmatched_angle_brackets (check_framework.test_urls.CheckUrlConfigTests.test_warning_unmatched_angle_brackets)" ]	[ "test_empty_string_no_errors (check_framework.test_urls.CheckURLSettingsTests.test_empty_string_no_errors)", "test_media_url_no_slash (check_framework.test_urls.CheckURLSettingsTests.test_media_url_no_slash)", "test_slash_no_errors (check_framework.test_urls.CheckURLSettingsTests.test_slash_no_errors)", "test...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Fixed #34691 -- Added system check for unmatched angle brackets in path(). I added the bracket checker like what we have for $. This is my first contribution to the Django project! Let me know if there is anything to modify :) I'm doubtful of naming the warning id (I know it might happen by upgrading Django, but I don't know in which version it will be used). Do I need to update it to 5? or what? Plus, do I need to include it in the docs/releases/4.3.txt? or docs/releases/5.0.txt? ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in django/urls/resolvers.py] (definition of RoutePattern._check_pattern_unmatched_angle_brackets:) def _check_pattern_unmatched_angle_brackets(self): [end of new definitions in django/urls/resolvers.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Add a system check for unmatched URL paths' < / > Description Currently, unmatched angle brackets are silently ignored: path('<int:question_id/vote/', views.vote, name='vote'), This leads to a frustrating debugging experience, where a 404 or NoReverseMatch could occur and only the eagle-eyed could spot why. Similar to the ^/$ system check added in #28663, I propose a new check in RoutePattern.check() for unmatched < or >. It's rather unlikely those characters are legitimately used in URLs. (Inspired by a new user making this mistake and asking for help on the forum.) ---------- Seems essential. I can work on it by splitting the routes based on '/' and checking if each part having started with '<' must have ended with '>'. Sounds reasonable, this should raise a system check warning, not an error. https://github.com/django/django/pull/17045 -------------------- </issues>	8edaf07a28a3e3848ab1edbdcd2fdc25e6bd6015
roboflow__supervision-170	170	roboflow/supervision	null	dd80753b2b17389ca0645c067d7f218bc9caa762	2023-07-02T21:27:03Z	diff --git a/docs/detection/annotate.md b/docs/detection/annotate.md index d37f14823..cc0be9fc1 100644 --- a/docs/detection/annotate.md +++ b/docs/detection/annotate.md @@ -1,11 +1,19 @@ -## BoxAnnotator +## BoundingBoxAnnotator -:::supervision.detection.annotate.BoxAnnotator +:::supervision.annotators.core.BoundingBoxAnnotator ## MaskAnnotator -:::supervision.detection.annotate.MaskAnnotator +:::supervision.annotators.core.MaskAnnotator -## TraceAnnotator +## EllipseAnnotator -:::supervision.detection.annotate.TraceAnnotator +:::supervision.annotators.core.EllipseAnnotator + +## BoxCornerAnnotator + +:::supervision.annotators.core.BoxCornerAnnotator + +## LabelAnnotator + +:::supervision.annotators.core.LabelAnnotator diff --git a/docs/geometry/core.md b/docs/geometry/core.md new file mode 100644 index 000000000..978ad2cf6 --- /dev/null +++ b/docs/geometry/core.md @@ -0,0 +1,3 @@ +## Position + +:::supervision.geometry.core.Position diff --git a/examples/tracking/script.py b/examples/tracking/script.py index 4b7d51ed9..51367896d 100644 --- a/examples/tracking/script.py +++ b/examples/tracking/script.py @@ -16,7 +16,8 @@ def process_video( model = YOLO(source_weights_path) tracker = sv.ByteTrack() - box_annotator = sv.BoxAnnotator() + box_annotator = sv.BoundingBoxAnnotator() + label_annotator = sv.LabelAnnotator(classes=model.names) frame_generator = sv.get_video_frames_generator(source_path=source_video_path) video_info = sv.VideoInfo.from_video_path(video_path=source_video_path) @@ -28,16 +29,15 @@ def process_video( detections = sv.Detections.from_ultralytics(results) detections = tracker.update_with_detections(detections) - labels = [ - f"#{tracker_id} {model.model.names[class_id]}" - for _, _, _, class_id, tracker_id in detections - ] - annotated_frame = box_annotator.annotate( - scene=frame.copy(), detections=detections, labels=labels + scene=frame.copy(), detections=detections + ) + + annotated_labeled_frame = label_annotator.annotate( + scene=annotated_frame, detections=detections ) - sink.write_frame(frame=annotated_frame) + sink.write_frame(frame=annotated_labeled_frame) if __name__ == "__main__": diff --git a/examples/traffic_analysis/requirements.txt b/examples/traffic_analysis/requirements.txt index 3103d0056..c793f725e 100644 --- a/examples/traffic_analysis/requirements.txt +++ b/examples/traffic_analysis/requirements.txt @@ -1,4 +1,4 @@ -supervision==0.15.0rc1 +supervision>=0.15.0rc1 tqdm ultralytics gdown diff --git a/supervision/__init__.py b/supervision/__init__.py index 2599393ce..517602e00 100644 --- a/supervision/__init__.py +++ b/supervision/__init__.py @@ -6,14 +6,20 @@ except importlib_metadata.PackageNotFoundError: __version__ = "development" - +from supervision.annotators.core import ( + BoundingBoxAnnotator, + BoxCornerAnnotator, + EllipseAnnotator, + LabelAnnotator, + MaskAnnotator, +) from supervision.classification.core import Classifications from supervision.dataset.core import ( BaseDataset, ClassificationDataset, DetectionDataset, ) -from supervision.detection.annotate import BoxAnnotator, MaskAnnotator, TraceAnnotator +from supervision.detection.annotate import BoxAnnotator, TraceAnnotator from supervision.detection.core import Detections from supervision.detection.line_counter import LineZone, LineZoneAnnotator from supervision.detection.tools.inference_slicer import InferenceSlicer diff --git a/supervision/annotators/__init__.py b/supervision/annotators/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/supervision/annotators/base.py b/supervision/annotators/base.py new file mode 100644 index 000000000..d9a6e29ac --- /dev/null +++ b/supervision/annotators/base.py @@ -0,0 +1,58 @@ +from abc import ABC, abstractmethod +from enum import Enum +from typing import Union + +import numpy as np + +from supervision.detection.core import Detections +from supervision.draw.color import Color, ColorPalette + + +class ColorMap(Enum): + """ + Enum for annotator color mapping. + """ + + INDEX = "index" + CLASS = "class" + TRACK = "track" + + +def resolve_color_idx( + detections: Detections, detection_idx: int, color_map: ColorMap = ColorMap.CLASS +) -> int: + if detection_idx >= len(detections): + raise ValueError( + f"Detection index {detection_idx}" + f"is out of bounds for detections of length {len(detections)}" + ) + + if color_map == ColorMap.INDEX: + return detection_idx + elif color_map == ColorMap.CLASS: + if detections.class_id is None: + raise ValueError( + "Could not resolve color by class because" + "Detections do not have class_id" + ) + return detections.class_id[detection_idx] + elif color_map == ColorMap.TRACK: + if detections.tracker_id is None: + raise ValueError( + "Could not resolve color by track because" + "Detections do not have tracker_id" + ) + return detections.tracker_id[detection_idx] + + +def resolve_color(color: Union[Color, ColorPalette], idx: int) -> Color: + if isinstance(color, ColorPalette): + return color.by_idx(idx) + else: + return color + + +class BaseAnnotator(ABC): + @abstractmethod + def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: + pass diff --git a/supervision/annotators/core.py b/supervision/annotators/core.py new file mode 100644 index 000000000..481a17b73 --- /dev/null +++ b/supervision/annotators/core.py @@ -0,0 +1,478 @@ +from typing import List, Tuple, Union + +import cv2 +import numpy as np + +from supervision.annotators.base import ( + BaseAnnotator, + ColorMap, + resolve_color, + resolve_color_idx, +) +from supervision.detection.core import Detections +from supervision.draw.color import Color, ColorPalette +from supervision.geometry.core import Position + + +class BoundingBoxAnnotator(BaseAnnotator): + """ + A class for drawing bounding boxes on an image using provided detections. + """ + + def __init__( + self, + color: Union[Color, ColorPalette] = ColorPalette.default(), + thickness: int = 2, + color_map: str = "class", + ): + """ + Args: + color (Union[Color, ColorPalette]): The color or color palette to use for + annotating detections. + thickness (int): Thickness of the bounding box lines. + color_map (str): Strategy for mapping colors to annotations. + Options are `index`, `class`, or `track`. + """ + self.color: Union[Color, ColorPalette] = color + self.thickness: int = thickness + self.color_map: ColorMap = ColorMap(color_map) + + def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: + """ + Annotates the given scene with bounding boxes based on the provided detections. + + Args: + scene (np.ndarray): The image where bounding boxes will be drawn. + detections (Detections): Object detections to annotate. + + Returns: + np.ndarray: The annotated image. + + Example: + ```python + >>> import supervision as sv + + >>> image = ... + >>> detections = sv.Detections(...) + + >>> bounding_box_annotator = sv.BoundingBoxAnnotator() + >>> annotated_frame = bounding_box_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + ``` + + ![bounding-box-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/bounding-box-annotator-example.png) + """ + for detection_idx in range(len(detections)): + x1, y1, x2, y2 = detections.xyxy[detection_idx].astype(int) + idx = resolve_color_idx( + detections=detections, + detection_idx=detection_idx, + color_map=self.color_map, + ) + color = resolve_color(color=self.color, idx=idx) + cv2.rectangle( + img=scene, + pt1=(x1, y1), + pt2=(x2, y2), + color=color.as_bgr(), + thickness=self.thickness, + ) + return scene + + +class MaskAnnotator(BaseAnnotator): + """ + A class for drawing masks on an image using provided detections. + """ + + def __init__( + self, + color: Union[Color, ColorPalette] = ColorPalette.default(), + opacity: float = 0.5, + color_map: str = "class", + ): + """ + Args: + color (Union[Color, ColorPalette]): The color or color palette to use for + annotating detections. + opacity (float): Opacity of the overlay mask. Must be between `0` and `1`. + color_map (str): Strategy for mapping colors to annotations. + Options are `index`, `class`, or `track`. + """ + self.color: Union[Color, ColorPalette] = color + self.opacity = opacity + self.color_map: ColorMap = ColorMap(color_map) + + def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: + """ + Annotates the given scene with masks based on the provided detections. + + Args: + scene (np.ndarray): The image where masks will be drawn. + detections (Detections): Object detections to annotate. + + Returns: + np.ndarray: The annotated image. + + Example: + ```python + >>> import supervision as sv + + >>> image = ... + >>> detections = sv.Detections(...) + + >>> mask_annotator = sv.MaskAnnotator() + >>> annotated_frame = mask_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + ``` + + ![mask-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/mask-annotator-example.png) + """ + if detections.mask is None: + return scene + + for detection_idx in np.flip(np.argsort(detections.area)): + idx = resolve_color_idx( + detections=detections, + detection_idx=detection_idx, + color_map=self.color_map, + ) + color = resolve_color(color=self.color, idx=idx) + mask = detections.mask[detection_idx] + colored_mask = np.zeros_like(scene, dtype=np.uint8) + colored_mask[:] = color.as_bgr() + + scene = np.where( + np.expand_dims(mask, axis=-1), + np.uint8(self.opacity * colored_mask + (1 - self.opacity) * scene), + scene, + ) + return scene + + +class EllipseAnnotator(BaseAnnotator): + """ + A class for drawing ellipses on an image using provided detections. + """ + + def __init__( + self, + color: Union[Color, ColorPalette] = ColorPalette.default(), + thickness: int = 2, + start_angle: int = -45, + end_angle: int = 235, + color_map: str = "class", + ): + """ + Args: + color (Union[Color, ColorPalette]): The color or color palette to use for + annotating detections. + thickness (int): Thickness of the ellipse lines. + start_angle (int): Starting angle of the ellipse. + end_angle (int): Ending angle of the ellipse. + color_map (str): Strategy for mapping colors to annotations. + Options are `index`, `class`, or `track`. + """ + self.color: Union[Color, ColorPalette] = color + self.thickness: int = thickness + self.start_angle: int = start_angle + self.end_angle: int = end_angle + self.color_map: ColorMap = ColorMap(color_map) + + def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: + """ + Annotates the given scene with ellipses based on the provided detections. + + Args: + scene (np.ndarray): The image where ellipses will be drawn. + detections (Detections): Object detections to annotate. + + Returns: + np.ndarray: The annotated image. + + Example: + ```python + >>> import supervision as sv + + >>> image = ... + >>> detections = sv.Detections(...) + + >>> ellipse_annotator = sv.EllipseAnnotator() + >>> annotated_frame = ellipse_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + ``` + + ![ellipse-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/ellipse-annotator-example.png) + """ + for detection_idx in range(len(detections)): + x1, y1, x2, y2 = detections.xyxy[detection_idx].astype(int) + idx = resolve_color_idx( + detections=detections, + detection_idx=detection_idx, + color_map=self.color_map, + ) + color = resolve_color(color=self.color, idx=idx) + + center = (int((x1 + x2) / 2), y2) + width = x2 - x1 + cv2.ellipse( + scene, + center=center, + axes=(int(width), int(0.35 * width)), + angle=0.0, + startAngle=self.start_angle, + endAngle=self.end_angle, + color=color.as_bgr(), + thickness=self.thickness, + lineType=cv2.LINE_4, + ) + return scene + + +class BoxCornerAnnotator(BaseAnnotator): + """ + A class for drawing box corners on an image using provided detections. + """ + + def __init__( + self, + color: Union[Color, ColorPalette] = ColorPalette.default(), + thickness: int = 4, + corner_length: int = 25, + color_map: str = "class", + ): + """ + Args: + color (Union[Color, ColorPalette]): The color or color palette to use for + annotating detections. + thickness (int): Thickness of the corner lines. + corner_length (int): Length of each corner line. + color_map (str): Strategy for mapping colors to annotations. + Options are `index`, `class`, or `track`. + """ + self.color: Union[Color, ColorPalette] = color + self.thickness: int = thickness + self.corner_length: int = corner_length + self.color_map: ColorMap = ColorMap(color_map) + + def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: + """ + Annotates the given scene with box corners based on the provided detections. + + Args: + scene (np.ndarray): The image where box corners will be drawn. + detections (Detections): Object detections to annotate. + + Returns: + np.ndarray: The annotated image. + + Example: + ```python + >>> import supervision as sv + + >>> image = ... + >>> detections = sv.Detections(...) + + >>> corner_annotator = sv.BoxCornerAnnotator() + >>> annotated_frame = corner_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + ``` + + ![box-corner-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/box-corner-annotator-example.png) + """ + for detection_idx in range(len(detections)): + x1, y1, x2, y2 = detections.xyxy[detection_idx].astype(int) + idx = resolve_color_idx( + detections=detections, + detection_idx=detection_idx, + color_map=self.color_map, + ) + color = resolve_color(color=self.color, idx=idx) + corners = [(x1, y1), (x2, y1), (x1, y2), (x2, y2)] + + for x, y in corners: + x_end = x + self.corner_length if x == x1 else x - self.corner_length + cv2.line( + scene, (x, y), (x_end, y), color.as_bgr(), thickness=self.thickness + ) + + y_end = y + self.corner_length if y == y1 else y - self.corner_length + cv2.line( + scene, (x, y), (x, y_end), color.as_bgr(), thickness=self.thickness + ) + return scene + + +class LabelAnnotator: + """ + A class for annotating labels on an image using provided detections. + """ + + def __init__( + self, + color: Union[Color, ColorPalette] = ColorPalette.default(), + text_color: Color = Color.black(), + text_scale: float = 0.5, + text_thickness: int = 1, + text_padding: int = 10, + text_position: Position = Position.TOP_LEFT, + color_map: str = "class", + ): + """ + Args: + color (Union[Color, ColorPalette]): The color or color palette to use for + annotating the text background. + text_color (Color): The color to use for the text. + text_scale (float): Font scale for the text. + text_thickness (int): Thickness of the text characters. + text_padding (int): Padding around the text within its background box. + text_position (Position): Position of the text relative to the detection. + Possible values are defined in the `Position` enum. + color_map (str): Strategy for mapping colors to annotations. + Options are `index`, `class`, or `track`. + """ + self.color: Union[Color, ColorPalette] = color + self.text_color: Color = text_color + self.text_scale: float = text_scale + self.text_thickness: int = text_thickness + self.text_padding: int = text_padding + self.text_position: Position = text_position + self.color_map: ColorMap = ColorMap(color_map) + + @staticmethod + def resolve_text_background_xyxy( + detection_xyxy: Tuple[int, int, int, int], + text_wh: Tuple[int, int], + text_padding: int, + position: Position, + ) -> Tuple[int, int, int, int]: + padded_text_wh = (text_wh[0] + 2 * text_padding, text_wh[1] + 2 * text_padding) + x1, y1, x2, y2 = detection_xyxy + center_x = (x1 + x2) // 2 + center_y = (y1 + y2) // 2 + + if position == Position.TOP_LEFT: + return x1, y1 - padded_text_wh[1], x1 + padded_text_wh[0], y1 + elif position == Position.TOP_RIGHT: + return x2 - padded_text_wh[0], y1 - padded_text_wh[1], x2, y1 + elif position == Position.TOP_CENTER: + return ( + center_x - padded_text_wh[0] // 2, + y1 - padded_text_wh[1], + center_x + padded_text_wh[0] // 2, + y1, + ) + elif position == Position.CENTER: + return ( + center_x - padded_text_wh[0] // 2, + center_y - padded_text_wh[1] // 2, + center_x + padded_text_wh[0] // 2, + center_y + padded_text_wh[1] // 2, + ) + elif position == Position.BOTTOM_LEFT: + return x1, y2, x1 + padded_text_wh[0], y2 + padded_text_wh[1] + elif position == Position.BOTTOM_RIGHT: + return x2 - padded_text_wh[0], y2, x2, y2 + padded_text_wh[1] + elif position == Position.BOTTOM_CENTER: + return ( + center_x - padded_text_wh[0] // 2, + y2, + center_x + padded_text_wh[0] // 2, + y2 + padded_text_wh[1], + ) + + def annotate( + self, + scene: np.ndarray, + detections: Detections, + labels: List[str] = None, + ) -> np.ndarray: + """ + Annotates the given scene with labels based on the provided detections. + + Args: + scene (np.ndarray): The image where labels will be drawn. + detections (Detections): Object detections to annotate. + labels (List[str]): Optional. Custom labels for each detection. + + Returns: + np.ndarray: The annotated image. + + Example: + ```python + >>> import supervision as sv + + >>> image = ... + >>> detections = sv.Detections(...) + + >>> label_annotator = sv.LabelAnnotator(text_position=sv.Position.CENTER) + >>> annotated_frame = label_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + ``` + + ![label-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/label-annotator-example-2.png) + """ + font = cv2.FONT_HERSHEY_SIMPLEX + for detection_idx in range(len(detections)): + detection_xyxy = detections.xyxy[detection_idx].astype(int) + idx = resolve_color_idx( + detections=detections, + detection_idx=detection_idx, + color_map=self.color_map, + ) + color = resolve_color(color=self.color, idx=idx) + text = ( + f"{detections.class_id[detection_idx]}" + if (labels is None or len(detections) != len(labels)) + else labels[detection_idx] + ) + text_wh = cv2.getTextSize( + text=text, + fontFace=font, + fontScale=self.text_scale, + thickness=self.text_thickness, + )[0] + + text_background_xyxy = self.resolve_text_background_xyxy( + detection_xyxy=detection_xyxy, + text_wh=text_wh, + text_padding=self.text_padding, + position=self.text_position, + ) + + text_x = text_background_xyxy[0] + self.text_padding + text_y = text_background_xyxy[1] + self.text_padding + text_wh[1] + + cv2.rectangle( + img=scene, + pt1=(text_background_xyxy[0], text_background_xyxy[1]), + pt2=(text_background_xyxy[2], text_background_xyxy[3]), + color=color.as_bgr(), + thickness=cv2.FILLED, + ) + cv2.putText( + img=scene, + text=text, + org=(text_x, text_y), + fontFace=font, + fontScale=self.text_scale, + color=self.text_color.as_rgb(), + thickness=self.text_thickness, + lineType=cv2.LINE_AA, + ) + return scene diff --git a/supervision/detection/annotate.py b/supervision/detection/annotate.py index c84ca826c..83b6e0f89 100644 --- a/supervision/detection/annotate.py +++ b/supervision/detection/annotate.py @@ -147,64 +147,6 @@ def annotate( return scene -class MaskAnnotator: - """ - A class for overlaying masks on an image using detections provided. - - Attributes: - color (Union[Color, ColorPalette]): The color to fill the mask, - can be a single color or a color palette - """ - - def __init__( - self, - color: Union[Color, ColorPalette] = ColorPalette.default(), - ): - self.color: Union[Color, ColorPalette] = color - - def annotate( - self, scene: np.ndarray, detections: Detections, opacity: float = 0.5 - ) -> np.ndarray: - """ - Overlays the masks on the given image based on the provided detections, - with a specified opacity. - - Args: - scene (np.ndarray): The image on which the masks will be overlaid - detections (Detections): The detections for which the - masks will be overlaid - opacity (float): The opacity of the masks, between 0 and 1, default is 0.5 - - Returns: - np.ndarray: The image with the masks overlaid - """ - if detections.mask is None: - return scene - - for i in np.flip(np.argsort(detections.area)): - class_id = ( - detections.class_id[i] if detections.class_id is not None else None - ) - idx = class_id if class_id is not None else i - color = ( - self.color.by_idx(idx) - if isinstance(self.color, ColorPalette) - else self.color - ) - - mask = detections.mask[i] - colored_mask = np.zeros_like(scene, dtype=np.uint8) - colored_mask[:] = color.as_bgr() - - scene = np.where( - np.expand_dims(mask, axis=-1), - np.uint8(opacity * colored_mask + (1 - opacity) * scene), - scene, - ) - - return scene - - class Trace: def __init__( self, diff --git a/supervision/detection/core.py b/supervision/detection/core.py index a67eefbc5..f7f1bb5f7 100644 --- a/supervision/detection/core.py +++ b/supervision/detection/core.py @@ -644,15 +644,23 @@ def __all_not_none(item_list: List[Any]): def get_anchor_coordinates(self, anchor: Position) -> np.ndarray: """ - Returns the bounding box coordinates for a specific anchor. + Calculates and returns the coordinates of a specific anchor point + within the bounding boxes defined by the `xyxy` attribute. The anchor + point can be any of the predefined positions in the `Position` enum, + such as `CENTER`, `CENTER_LEFT`, `BOTTOM_RIGHT`, etc. Args: - anchor (Position): Position of bounding box anchor - for which to return the coordinates. + anchor (Position): An enum specifying the position of the anchor point + within the bounding box. Supported positions are defined in the + `Position` enum. Returns: - np.ndarray: An array of shape `(n, 2)` containing the bounding - box anchor coordinates in format `[x, y]`. + np.ndarray: An array of shape `(n, 2)`, where `n` is the number of bounding + boxes. Each row contains the `[x, y]` coordinates of the specified + anchor point for the corresponding bounding box. + + Raises: + ValueError: If the provided `anchor` is not supported. """ if anchor == Position.CENTER: return np.array( @@ -661,10 +669,36 @@ def get_anchor_coordinates(self, anchor: Position) -> np.ndarray: (self.xyxy[:, 1] + self.xyxy[:, 3]) / 2, ] ).transpose() + elif anchor == Position.CENTER_LEFT: + return np.array( + [ + self.xyxy[:, 0], + (self.xyxy[:, 1] + self.xyxy[:, 3]) / 2, + ] + ).transpose() + elif anchor == Position.CENTER_RIGHT: + return np.array( + [ + self.xyxy[:, 2], + (self.xyxy[:, 1] + self.xyxy[:, 3]) / 2, + ] + ).transpose() elif anchor == Position.BOTTOM_CENTER: return np.array( [(self.xyxy[:, 0] + self.xyxy[:, 2]) / 2, self.xyxy[:, 3]] ).transpose() + elif anchor == Position.BOTTOM_LEFT: + return np.array([self.xyxy[:, 0], self.xyxy[:, 3]]).transpose() + elif anchor == Position.BOTTOM_RIGHT: + return np.array([self.xyxy[:, 2], self.xyxy[:, 3]]).transpose() + elif anchor == Position.TOP_CENTER: + return np.array( + [(self.xyxy[:, 0] + self.xyxy[:, 2]) / 2, self.xyxy[:, 1]] + ).transpose() + elif anchor == Position.TOP_LEFT: + return np.array([self.xyxy[:, 0], self.xyxy[:, 1]]).transpose() + elif anchor == Position.TOP_RIGHT: + return np.array([self.xyxy[:, 2], self.xyxy[:, 1]]).transpose() raise ValueError(f"{anchor} is not supported.") diff --git a/supervision/geometry/core.py b/supervision/geometry/core.py index fc352f558..1771a356d 100644 --- a/supervision/geometry/core.py +++ b/supervision/geometry/core.py @@ -6,8 +6,19 @@ class Position(Enum): + """ + Enum representing the position of an anchor point. + """ + CENTER = "CENTER" + CENTER_LEFT = "CENTER_LEFT" + CENTER_RIGHT = "CENTER_RIGHT" + TOP_CENTER = "TOP_CENTER" + TOP_LEFT = "TOP_LEFT" + TOP_RIGHT = "TOP_RIGHT" + BOTTOM_LEFT = "BOTTOM_LEFT" BOTTOM_CENTER = "BOTTOM_CENTER" + BOTTOM_RIGHT = "BOTTOM_RIGHT" @classmethod def list(cls):	diff --git a/test/annotators/__init__.py b/test/annotators/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/test/annotators/test_base.py b/test/annotators/test_base.py new file mode 100644 index 000000000..73d5a147d --- /dev/null +++ b/test/annotators/test_base.py @@ -0,0 +1,94 @@ +from contextlib import ExitStack as DoesNotRaise +from test.utils import mock_detections +from typing import Optional + +import pytest + +from supervision.annotators.core import ColorMap, resolve_color_idx +from supervision.detection.core import Detections + + +@pytest.mark.parametrize( + "detections, detection_idx, color_map, expected_result, exception", + [ + ( + mock_detections( + xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]], + class_id=[5, 3], + tracker_id=[2, 6], + ), + 0, + ColorMap.INDEX, + 0, + DoesNotRaise(), + ), # multiple detections; index mapping + ( + mock_detections( + xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]], + class_id=[5, 3], + tracker_id=[2, 6], + ), + 0, + ColorMap.CLASS, + 5, + DoesNotRaise(), + ), # multiple detections; class mapping + ( + mock_detections( + xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]], + class_id=[5, 3], + tracker_id=[2, 6], + ), + 0, + ColorMap.TRACK, + 2, + DoesNotRaise(), + ), # multiple detections; track mapping + ( + Detections.empty(), + 0, + ColorMap.INDEX, + None, + pytest.raises(ValueError), + ), # no detections; index mapping; out of bounds + ( + mock_detections( + xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]], + class_id=[5, 3], + tracker_id=[2, 6], + ), + 2, + ColorMap.INDEX, + None, + pytest.raises(ValueError), + ), # multiple detections; index mapping; out of bounds + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + 0, + ColorMap.CLASS, + None, + pytest.raises(ValueError), + ), # multiple detections; class mapping; no class_id + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + 0, + ColorMap.TRACK, + None, + pytest.raises(ValueError), + ), # multiple detections; class mapping; no track_id + ], +) +def test_resolve_color_idx( + detections: Detections, + detection_idx: int, + color_map: ColorMap, + expected_result: Optional[int], + exception: Exception, +) -> None: + with exception: + result = resolve_color_idx( + detections=detections, + detection_idx=detection_idx, + color_map=color_map, + ) + assert result == expected_result diff --git a/test/detection/test_core.py b/test/detection/test_core.py index aaa1f236e..02595d973 100644 --- a/test/detection/test_core.py +++ b/test/detection/test_core.py @@ -5,7 +5,8 @@ import numpy as np import pytest -from supervision import Detections +from supervision.detection.core import Detections +from supervision.geometry.core import Position PREDICTIONS = np.array( [ @@ -190,3 +191,85 @@ def test_merge( with exception: result = Detections.merge(detections_list=detections_list) assert result == expected_result + + +@pytest.mark.parametrize( + "detections, anchor, expected_result, exception", + [ + ( + Detections.empty(), + Position.CENTER, + np.empty((0, 2), dtype=np.float32), + DoesNotRaise(), + ), # empty detections + ( + mock_detections(xyxy=[[10, 10, 20, 20]]), + Position.CENTER, + np.array([[15, 15]], dtype=np.float32), + DoesNotRaise(), + ), # single detection; center anchor + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + Position.CENTER, + np.array([[15, 15], [25, 25]], dtype=np.float32), + DoesNotRaise(), + ), # two detections; center anchor + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + Position.CENTER_LEFT, + np.array([[10, 15], [20, 25]], dtype=np.float32), + DoesNotRaise(), + ), # two detections; center left anchor + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + Position.CENTER_RIGHT, + np.array([[20, 15], [30, 25]], dtype=np.float32), + DoesNotRaise(), + ), # two detections; center right anchor + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + Position.TOP_CENTER, + np.array([[15, 10], [25, 20]], dtype=np.float32), + DoesNotRaise(), + ), # two detections; top center anchor + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + Position.TOP_LEFT, + np.array([[10, 10], [20, 20]], dtype=np.float32), + DoesNotRaise(), + ), # two detections; top left anchor + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + Position.TOP_RIGHT, + np.array([[20, 10], [30, 20]], dtype=np.float32), + DoesNotRaise(), + ), # two detections; top right anchor + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + Position.BOTTOM_CENTER, + np.array([[15, 20], [25, 30]], dtype=np.float32), + DoesNotRaise(), + ), # two detections; bottom center anchor + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + Position.BOTTOM_LEFT, + np.array([[10, 20], [20, 30]], dtype=np.float32), + DoesNotRaise(), + ), # two detections; bottom left anchor + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + Position.BOTTOM_RIGHT, + np.array([[20, 20], [30, 30]], dtype=np.float32), + DoesNotRaise(), + ), # two detections; bottom right anchor + ], +) +def test_get_anchor_coordinates( + detections: Detections, + anchor: Position, + expected_result: np.ndarray, + exception: Exception, +) -> None: + result = detections.get_anchor_coordinates(anchor) + with exception: + assert np.array_equal(result, expected_result)	diff --git a/docs/detection/annotate.md b/docs/detection/annotate.md index d37f14823..cc0be9fc1 100644 --- a/docs/detection/annotate.md +++ b/docs/detection/annotate.md @@ -1,11 +1,19 @@ -## BoxAnnotator +## BoundingBoxAnnotator -:::supervision.detection.annotate.BoxAnnotator +:::supervision.annotators.core.BoundingBoxAnnotator ## MaskAnnotator -:::supervision.detection.annotate.MaskAnnotator +:::supervision.annotators.core.MaskAnnotator -## TraceAnnotator +## EllipseAnnotator -:::supervision.detection.annotate.TraceAnnotator +:::supervision.annotators.core.EllipseAnnotator + +## BoxCornerAnnotator + +:::supervision.annotators.core.BoxCornerAnnotator + +## LabelAnnotator + +:::supervision.annotators.core.LabelAnnotator diff --git a/docs/geometry/core.md b/docs/geometry/core.md new file mode 100644 index 000000000..978ad2cf6 --- /dev/null +++ b/docs/geometry/core.md @@ -0,0 +1,3 @@ +## Position + +:::supervision.geometry.core.Position diff --git a/examples/traffic_analysis/requirements.txt b/examples/traffic_analysis/requirements.txt index 3103d0056..c793f725e 100644 --- a/examples/traffic_analysis/requirements.txt +++ b/examples/traffic_analysis/requirements.txt @@ -1,4 +1,4 @@ -supervision==0.15.0rc1 +supervision>=0.15.0rc1 tqdm ultralytics gdown	[ { "components": [ { "doc": "Enum for annotator color mapping.", "lines": [ 11, 18 ], "name": "ColorMap", "signature": "class ColorMap(Enum):", "type": "class" }, { "doc": "", "lines": [ 21, ...	[ "test/annotators/test_base.py::test_resolve_color_idx[detections0-0-ColorMap.INDEX-0-exception0]", "test/annotators/test_base.py::test_resolve_color_idx[detections1-0-ColorMap.CLASS-5-exception1]", "test/annotators/test_base.py::test_resolve_color_idx[detections2-0-ColorMap.TRACK-2-exception2]", "test/annotat...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> redesigned annotators This PR expands our range of Annotators and makes them more reusable. ![bounding-box-annotator-example](https://github.com/roboflow/supervision/assets/26109316/ba6943f8-3744-4dd7-898f-68a0fd570d5c) ![box-corner-annotator-example](https://github.com/roboflow/supervision/assets/26109316/f2f0e441-761b-42de-9b1f-64e45d21c594) ![ellipse-annotator-example](https://github.com/roboflow/supervision/assets/26109316/85bfcc10-5af9-45ab-b63e-e2e82dd93aa4) ![label-annotator-example-2](https://github.com/roboflow/supervision/assets/26109316/bc57a81d-87e8-4d22-91c8-dca9e6af8f7b) ![mask-annotator-example](https://github.com/roboflow/supervision/assets/26109316/30367bb4-c6ff-4319-b987-8357a6e27457) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in supervision/annotators/base.py] (definition of ColorMap:) class ColorMap(Enum): """Enum for annotator color mapping.""" (definition of resolve_color_idx:) def resolve_color_idx( detections: Detections, detection_idx: int, color_map: ColorMap = ColorMap.CLASS ) -> int: (definition of resolve_color:) def resolve_color(color: Union[Color, ColorPalette], idx: int) -> Color: (definition of BaseAnnotator:) class BaseAnnotator(ABC): @abstractmethod (definition of BaseAnnotator.annotate:) def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: [end of new definitions in supervision/annotators/base.py] [start of new definitions in supervision/annotators/core.py] (definition of BoundingBoxAnnotator:) class BoundingBoxAnnotator(BaseAnnotator): """A class for drawing bounding boxes on an image using provided detections.""" (definition of BoundingBoxAnnotator.__init__:) def __init__( self, color: Union[Color, ColorPalette] = ColorPalette.default(), thickness: int = 2, color_map: str = "class", ): """Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating detections. thickness (int): Thickness of the bounding box lines. color_map (str): Strategy for mapping colors to annotations. Options are `index`, `class`, or `track`.""" (definition of BoundingBoxAnnotator.annotate:) def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: """Annotates the given scene with bounding boxes based on the provided detections. Args: scene (np.ndarray): The image where bounding boxes will be drawn. detections (Detections): Object detections to annotate. Returns: np.ndarray: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> bounding_box_annotator = sv.BoundingBoxAnnotator() >>> annotated_frame = bounding_box_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![bounding-box-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/bounding-box-annotator-example.png)""" (definition of MaskAnnotator:) class MaskAnnotator(BaseAnnotator): """A class for drawing masks on an image using provided detections.""" (definition of MaskAnnotator.__init__:) def __init__( self, color: Union[Color, ColorPalette] = ColorPalette.default(), opacity: float = 0.5, color_map: str = "class", ): """Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating detections. opacity (float): Opacity of the overlay mask. Must be between `0` and `1`. color_map (str): Strategy for mapping colors to annotations. Options are `index`, `class`, or `track`.""" (definition of MaskAnnotator.annotate:) def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: """Annotates the given scene with masks based on the provided detections. Args: scene (np.ndarray): The image where masks will be drawn. detections (Detections): Object detections to annotate. Returns: np.ndarray: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> mask_annotator = sv.MaskAnnotator() >>> annotated_frame = mask_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![mask-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/mask-annotator-example.png)""" (definition of EllipseAnnotator:) class EllipseAnnotator(BaseAnnotator): """A class for drawing ellipses on an image using provided detections.""" (definition of EllipseAnnotator.__init__:) def __init__( self, color: Union[Color, ColorPalette] = ColorPalette.default(), thickness: int = 2, start_angle: int = -45, end_angle: int = 235, color_map: str = "class", ): """Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating detections. thickness (int): Thickness of the ellipse lines. start_angle (int): Starting angle of the ellipse. end_angle (int): Ending angle of the ellipse. color_map (str): Strategy for mapping colors to annotations. Options are `index`, `class`, or `track`.""" (definition of EllipseAnnotator.annotate:) def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: """Annotates the given scene with ellipses based on the provided detections. Args: scene (np.ndarray): The image where ellipses will be drawn. detections (Detections): Object detections to annotate. Returns: np.ndarray: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> ellipse_annotator = sv.EllipseAnnotator() >>> annotated_frame = ellipse_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![ellipse-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/ellipse-annotator-example.png)""" (definition of BoxCornerAnnotator:) class BoxCornerAnnotator(BaseAnnotator): """A class for drawing box corners on an image using provided detections.""" (definition of BoxCornerAnnotator.__init__:) def __init__( self, color: Union[Color, ColorPalette] = ColorPalette.default(), thickness: int = 4, corner_length: int = 25, color_map: str = "class", ): """Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating detections. thickness (int): Thickness of the corner lines. corner_length (int): Length of each corner line. color_map (str): Strategy for mapping colors to annotations. Options are `index`, `class`, or `track`.""" (definition of BoxCornerAnnotator.annotate:) def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: """Annotates the given scene with box corners based on the provided detections. Args: scene (np.ndarray): The image where box corners will be drawn. detections (Detections): Object detections to annotate. Returns: np.ndarray: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> corner_annotator = sv.BoxCornerAnnotator() >>> annotated_frame = corner_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![box-corner-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/box-corner-annotator-example.png)""" (definition of LabelAnnotator:) class LabelAnnotator: """A class for annotating labels on an image using provided detections.""" (definition of LabelAnnotator.__init__:) def __init__( self, color: Union[Color, ColorPalette] = ColorPalette.default(), text_color: Color = Color.black(), text_scale: float = 0.5, text_thickness: int = 1, text_padding: int = 10, text_position: Position = Position.TOP_LEFT, color_map: str = "class", ): """Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating the text background. text_color (Color): The color to use for the text. text_scale (float): Font scale for the text. text_thickness (int): Thickness of the text characters. text_padding (int): Padding around the text within its background box. text_position (Position): Position of the text relative to the detection. Possible values are defined in the `Position` enum. color_map (str): Strategy for mapping colors to annotations. Options are `index`, `class`, or `track`.""" (definition of LabelAnnotator.resolve_text_background_xyxy:) def resolve_text_background_xyxy( detection_xyxy: Tuple[int, int, int, int], text_wh: Tuple[int, int], text_padding: int, position: Position, ) -> Tuple[int, int, int, int]: (definition of LabelAnnotator.annotate:) def annotate( self, scene: np.ndarray, detections: Detections, labels: List[str] = None, ) -> np.ndarray: """Annotates the given scene with labels based on the provided detections. Args: scene (np.ndarray): The image where labels will be drawn. detections (Detections): Object detections to annotate. labels (List[str]): Optional. Custom labels for each detection. Returns: np.ndarray: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> label_annotator = sv.LabelAnnotator(text_position=sv.Position.CENTER) >>> annotated_frame = label_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![label-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/label-annotator-example-2.png)""" [end of new definitions in supervision/annotators/core.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		3eb5c0b024e3e46877b7fe4fd66e6177d1308ba0
scikit-learn__scikit-learn-26734	26,734	scikit-learn/scikit-learn	1.4	1fbf5fb317034e604d7ae71f368cd9e5b236ec0c	2023-06-29T21:37:42Z	diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 7f6f5c910a3fc..f4ae4ffbf8911 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -995,6 +995,8 @@ details. metrics.median_absolute_error metrics.mean_absolute_percentage_error metrics.r2_score + metrics.root_mean_squared_log_error + metrics.root_mean_squared_error metrics.mean_poisson_deviance metrics.mean_gamma_deviance metrics.mean_tweedie_deviance diff --git a/doc/modules/model_evaluation.rst b/doc/modules/model_evaluation.rst index c989f49c0fc7d..eac1cde567595 100644 --- a/doc/modules/model_evaluation.rst +++ b/doc/modules/model_evaluation.rst @@ -94,8 +94,9 @@ Scoring Function 'max_error' :func:`metrics.max_error` 'neg_mean_absolute_error' :func:`metrics.mean_absolute_error` 'neg_mean_squared_error' :func:`metrics.mean_squared_error` -'neg_root_mean_squared_error' :func:`metrics.mean_squared_error` +'neg_root_mean_squared_error' :func:`metrics.root_mean_squared_error` 'neg_mean_squared_log_error' :func:`metrics.mean_squared_log_error` +'neg_root_mean_squared_log_error' :func:`metrics.root_mean_squared_log_error` 'neg_median_absolute_error' :func:`metrics.median_absolute_error` 'r2' :func:`metrics.r2_score` 'neg_mean_poisson_deviance' :func:`metrics.mean_poisson_deviance` @@ -2310,6 +2311,10 @@ function:: for an example of mean squared error usage to evaluate gradient boosting regression. +Taking the square root of the MSE, called the root mean squared error (RMSE), is another +common metric that provides a measure in the same units as the target variable. RSME is +available through the :func:`root_mean_squared_error` function. + .. _mean_squared_log_error: Mean squared logarithmic error @@ -2347,6 +2352,9 @@ function:: >>> mean_squared_log_error(y_true, y_pred) 0.044... +The root mean squared logarithmic error (RMSLE) is available through the +:func:`root_mean_squared_log_error` function. + .. _mean_absolute_percentage_error: Mean absolute percentage error diff --git a/doc/whats_new/v1.4.rst b/doc/whats_new/v1.4.rst index 367315dc3c60d..8dbd867b0c9ba 100644 --- a/doc/whats_new/v1.4.rst +++ b/doc/whats_new/v1.4.rst @@ -238,6 +238,18 @@ Changelog - \|Enhancement\| :class:`preprocessing.TargetEncoder` now supports `target_type` 'multiclass'. :pr:`26674` by :user:`Lucy Liu <lucyleeow>`. +:mod:`sklearn.metrics` +...................... + +- \|API\| The `squared` parameter of :func:`metrics.mean_squared_error` and + :func:`metrics.mean_squared_log_error` is deprecated and will be removed in 1.6. + Use the new functions :func:`metrics.root_mean_squared_error` and + :func:`root_mean_squared_log_error` instead. + :pr:`26734` by :user:`Alejandro Martin Gil <101AlexMartin>`. + +- \|Enhancement\| Added `neg_root_mean_squared_log_error_scorer` as scorer + :pr:`26734` by :user:`Alejandro Martin Gil <101AlexMartin>`. + :mod:`sklearn.model_selection` .............................. diff --git a/sklearn/metrics/__init__.py b/sklearn/metrics/__init__.py index 488c776ae9a86..713c5fe651dbb 100644 --- a/sklearn/metrics/__init__.py +++ b/sklearn/metrics/__init__.py @@ -62,6 +62,8 @@ mean_tweedie_deviance, median_absolute_error, r2_score, + root_mean_squared_error, + root_mean_squared_log_error, ) from ._scorer import check_scoring, get_scorer, get_scorer_names, make_scorer from .cluster import ( @@ -166,6 +168,8 @@ "RocCurveDisplay", "roc_auc_score", "roc_curve", + "root_mean_squared_log_error", + "root_mean_squared_error", "get_scorer_names", "silhouette_samples", "silhouette_score", diff --git a/sklearn/metrics/_regression.py b/sklearn/metrics/_regression.py index a6dfacf30d3e1..77a93f4c17513 100644 --- a/sklearn/metrics/_regression.py +++ b/sklearn/metrics/_regression.py @@ -24,6 +24,7 @@ # Uttam kumar <bajiraouttamsinha@gmail.com> # Sylvain Marie <sylvain.marie@se.com> # Ohad Michel <ohadmich@gmail.com> +# Alejandro Martin Gil <almagil98@gmail.com> # License: BSD 3 clause import warnings @@ -33,7 +34,7 @@ from scipy.special import xlogy from ..exceptions import UndefinedMetricWarning -from ..utils._param_validation import Interval, StrOptions, validate_params +from ..utils._param_validation import Hidden, Interval, StrOptions, validate_params from ..utils.stats import _weighted_percentile from ..utils.validation import ( _check_sample_weight, @@ -52,6 +53,8 @@ "mean_absolute_percentage_error", "mean_pinball_loss", "r2_score", + "root_mean_squared_log_error", + "root_mean_squared_error", "explained_variance_score", "mean_tweedie_deviance", "mean_poisson_deviance", @@ -407,12 +410,17 @@ def mean_absolute_percentage_error( "y_pred": ["array-like"], "sample_weight": ["array-like", None], "multioutput": [StrOptions({"raw_values", "uniform_average"}), "array-like"], - "squared": ["boolean"], + "squared": [Hidden(StrOptions({"deprecated"})), "boolean"], }, prefer_skip_nested_validation=True, ) def mean_squared_error( - y_true, y_pred, , sample_weight=None, multioutput="uniform_average", squared=True + y_true, + y_pred, + , + sample_weight=None, + multioutput="uniform_average", + squared="deprecated", ): """Mean squared error regression loss. @@ -443,6 +451,11 @@ def mean_squared_error( squared : bool, default=True If True returns MSE value, if False returns RMSE value. + .. deprecated:: 1.4 + `squared` is deprecated in 1.4 and will be removed in 1.6. + Use :func:`~sklearn.metrics.root_mean_squared_error` + instead to calculate the root mean squared error. + Returns ------- loss : float or ndarray of floats @@ -456,29 +469,110 @@ def mean_squared_error( >>> y_pred = [2.5, 0.0, 2, 8] >>> mean_squared_error(y_true, y_pred) 0.375 - >>> y_true = [3, -0.5, 2, 7] - >>> y_pred = [2.5, 0.0, 2, 8] - >>> mean_squared_error(y_true, y_pred, squared=False) - 0.612... >>> y_true = [[0.5, 1],[-1, 1],[7, -6]] >>> y_pred = [[0, 2],[-1, 2],[8, -5]] >>> mean_squared_error(y_true, y_pred) 0.708... - >>> mean_squared_error(y_true, y_pred, squared=False) - 0.822... >>> mean_squared_error(y_true, y_pred, multioutput='raw_values') array([0.41666667, 1. ]) >>> mean_squared_error(y_true, y_pred, multioutput=[0.3, 0.7]) 0.825... """ + # TODO(1.6): remove + if squared != "deprecated": + warnings.warn( + ( + "'squared' is deprecated in version 1.4 and " + "will be removed in 1.6. To calculate the " + "root mean squared error, use the function" + "'root_mean_squared_error'." + ), + FutureWarning, + ) + if not squared: + return root_mean_squared_error( + y_true, y_pred, sample_weight=sample_weight, multioutput=multioutput + ) + y_type, y_true, y_pred, multioutput = _check_reg_targets( y_true, y_pred, multioutput ) check_consistent_length(y_true, y_pred, sample_weight) output_errors = np.average((y_true - y_pred) ** 2, axis=0, weights=sample_weight) - if not squared: - output_errors = np.sqrt(output_errors) + if isinstance(multioutput, str): + if multioutput == "raw_values": + return output_errors + elif multioutput == "uniform_average": + # pass None as weights to np.average: uniform mean + multioutput = None + + return np.average(output_errors, weights=multioutput) + + +@validate_params( + { + "y_true": ["array-like"], + "y_pred": ["array-like"], + "sample_weight": ["array-like", None], + "multioutput": [StrOptions({"raw_values", "uniform_average"}), "array-like"], + }, + prefer_skip_nested_validation=True, +) +def root_mean_squared_error( + y_true, y_pred, , sample_weight=None, multioutput="uniform_average" +): + """Root mean squared error regression loss. + + Read more in the :ref:`User Guide <mean_squared_error>`. + + .. versionadded:: 1.4 + + Parameters + ---------- + y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) + Ground truth (correct) target values. + + y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) + Estimated target values. + + sample_weight : array-like of shape (n_samples,), default=None + Sample weights. + + multioutput : {'raw_values', 'uniform_average'} or array-like of shape \ + (n_outputs,), default='uniform_average' + Defines aggregating of multiple output values. + Array-like value defines weights used to average errors. + + 'raw_values' : + Returns a full set of errors in case of multioutput input. + + 'uniform_average' : + Errors of all outputs are averaged with uniform weight. + + Returns + ------- + loss : float or ndarray of floats + A non-negative floating point value (the best value is 0.0), or an + array of floating point values, one for each individual target. + + Examples + -------- + >>> from sklearn.metrics import root_mean_squared_error + >>> y_true = [3, -0.5, 2, 7] + >>> y_pred = [2.5, 0.0, 2, 8] + >>> root_mean_squared_error(y_true, y_pred) + 0.612... + >>> y_true = [[0.5, 1],[-1, 1],[7, -6]] + >>> y_pred = [[0, 2],[-1, 2],[8, -5]] + >>> root_mean_squared_error(y_true, y_pred) + 0.822... + """ + output_errors = np.sqrt( + mean_squared_error( + y_true, y_pred, sample_weight=sample_weight, multioutput="raw_values" + ) + ) if isinstance(multioutput, str): if multioutput == "raw_values": @@ -496,12 +590,17 @@ def mean_squared_error( "y_pred": ["array-like"], "sample_weight": ["array-like", None], "multioutput": [StrOptions({"raw_values", "uniform_average"}), "array-like"], - "squared": ["boolean"], + "squared": [Hidden(StrOptions({"deprecated"})), "boolean"], }, prefer_skip_nested_validation=True, ) def mean_squared_log_error( - y_true, y_pred, , sample_weight=None, multioutput="uniform_average", squared=True + y_true, + y_pred, + , + sample_weight=None, + multioutput="uniform_average", + squared="deprecated", ): """Mean squared logarithmic error regression loss. @@ -530,10 +629,16 @@ def mean_squared_log_error( 'uniform_average' : Errors of all outputs are averaged with uniform weight. + squared : bool, default=True If True returns MSLE (mean squared log error) value. If False returns RMSLE (root mean squared log error) value. + .. deprecated:: 1.4 + `squared` is deprecated in 1.4 and will be removed in 1.6. + Use :func:`~sklearn.metrics.root_mean_squared_log_error` + instead to calculate the root mean squared logarithmic error. + Returns ------- loss : float or ndarray of floats @@ -547,8 +652,6 @@ def mean_squared_log_error( >>> y_pred = [2.5, 5, 4, 8] >>> mean_squared_log_error(y_true, y_pred) 0.039... - >>> mean_squared_log_error(y_true, y_pred, squared=False) - 0.199... >>> y_true = [[0.5, 1], [1, 2], [7, 6]] >>> y_pred = [[0.5, 2], [1, 2.5], [8, 8]] >>> mean_squared_log_error(y_true, y_pred) @@ -558,6 +661,22 @@ def mean_squared_log_error( >>> mean_squared_log_error(y_true, y_pred, multioutput=[0.3, 0.7]) 0.060... """ + # TODO(1.6): remove + if squared != "deprecated": + warnings.warn( + ( + "'squared' is deprecated in version 1.4 and " + "will be removed in 1.6. To calculate the " + "root mean squared logarithmic error, use the function" + "'root_mean_squared_log_error'." + ), + FutureWarning, + ) + if not squared: + return root_mean_squared_log_error( + y_true, y_pred, sample_weight=sample_weight, multioutput=multioutput + ) + y_type, y_true, y_pred, multioutput = _check_reg_targets( y_true, y_pred, multioutput ) @@ -574,7 +693,79 @@ def mean_squared_log_error( np.log1p(y_pred), sample_weight=sample_weight, multioutput=multioutput, - squared=squared, + ) + + +@validate_params( + { + "y_true": ["array-like"], + "y_pred": ["array-like"], + "sample_weight": ["array-like", None], + "multioutput": [StrOptions({"raw_values", "uniform_average"}), "array-like"], + }, + prefer_skip_nested_validation=True, +) +def root_mean_squared_log_error( + y_true, y_pred, , sample_weight=None, multioutput="uniform_average" +): + """Root mean squared logarithmic error regression loss. + + Read more in the :ref:`User Guide <mean_squared_log_error>`. + + .. versionadded:: 1.4 + + Parameters + ---------- + y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) + Ground truth (correct) target values. + + y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) + Estimated target values. + + sample_weight : array-like of shape (n_samples,), default=None + Sample weights. + + multioutput : {'raw_values', 'uniform_average'} or array-like of shape \ + (n_outputs,), default='uniform_average' + + Defines aggregating of multiple output values. + Array-like value defines weights used to average errors. + + 'raw_values' : + Returns a full set of errors when the input is of multioutput + format. + + 'uniform_average' : + Errors of all outputs are averaged with uniform weight. + + Returns + ------- + loss : float or ndarray of floats + A non-negative floating point value (the best value is 0.0), or an + array of floating point values, one for each individual target. + + Examples + -------- + >>> from sklearn.metrics import root_mean_squared_log_error + >>> y_true = [3, 5, 2.5, 7] + >>> y_pred = [2.5, 5, 4, 8] + >>> root_mean_squared_log_error(y_true, y_pred) + 0.199... + """ + _, y_true, y_pred, multioutput = _check_reg_targets(y_true, y_pred, multioutput) + check_consistent_length(y_true, y_pred, sample_weight) + + if (y_true < 0).any() or (y_pred < 0).any(): + raise ValueError( + "Root Mean Squared Logarithmic Error cannot be used when " + "targets contain negative values." + ) + + return root_mean_squared_error( + np.log1p(y_true), + np.log1p(y_pred), + sample_weight=sample_weight, + multioutput=multioutput, ) diff --git a/sklearn/metrics/_scorer.py b/sklearn/metrics/_scorer.py index 302831366aa54..50880080dd3cb 100644 --- a/sklearn/metrics/_scorer.py +++ b/sklearn/metrics/_scorer.py @@ -64,6 +64,8 @@ r2_score, recall_score, roc_auc_score, + root_mean_squared_error, + root_mean_squared_log_error, top_k_accuracy_score, ) from .cluster import ( @@ -762,7 +764,10 @@ def make_scorer( median_absolute_error, greater_is_better=False ) neg_root_mean_squared_error_scorer = make_scorer( - mean_squared_error, greater_is_better=False, squared=False + root_mean_squared_error, greater_is_better=False +) +neg_root_mean_squared_log_error_scorer = make_scorer( + root_mean_squared_log_error, greater_is_better=False ) neg_mean_poisson_deviance_scorer = make_scorer( mean_poisson_deviance, greater_is_better=False @@ -837,10 +842,11 @@ def negative_likelihood_ratio(y_true, y_pred): matthews_corrcoef=matthews_corrcoef_scorer, neg_median_absolute_error=neg_median_absolute_error_scorer, neg_mean_absolute_error=neg_mean_absolute_error_scorer, - neg_mean_absolute_percentage_error=neg_mean_absolute_percentage_error_scorer, # noqa + neg_mean_absolute_percentage_error=neg_mean_absolute_percentage_error_scorer, neg_mean_squared_error=neg_mean_squared_error_scorer, neg_mean_squared_log_error=neg_mean_squared_log_error_scorer, neg_root_mean_squared_error=neg_root_mean_squared_error_scorer, + neg_root_mean_squared_log_error=neg_root_mean_squared_log_error_scorer, neg_mean_poisson_deviance=neg_mean_poisson_deviance_scorer, neg_mean_gamma_deviance=neg_mean_gamma_deviance_scorer, accuracy=accuracy_scorer,	diff --git a/sklearn/metrics/tests/test_regression.py b/sklearn/metrics/tests/test_regression.py index f0486d1e942e6..29afac5cbc824 100644 --- a/sklearn/metrics/tests/test_regression.py +++ b/sklearn/metrics/tests/test_regression.py @@ -23,6 +23,8 @@ mean_tweedie_deviance, median_absolute_error, r2_score, + root_mean_squared_error, + root_mean_squared_log_error, ) from sklearn.metrics._regression import _check_reg_targets from sklearn.model_selection import GridSearchCV @@ -123,12 +125,12 @@ def test_regression_metrics(n_samples=50): ) -def test_mean_squared_error_multioutput_raw_value_squared(): +def test_root_mean_squared_error_multioutput_raw_value(): # non-regression test for # https://github.com/scikit-learn/scikit-learn/pull/16323 - mse1 = mean_squared_error([[1]], [[10]], multioutput="raw_values", squared=True) - mse2 = mean_squared_error([[1]], [[10]], multioutput="raw_values", squared=False) - assert np.sqrt(mse1) == pytest.approx(mse2) + mse = mean_squared_error([[1]], [[10]], multioutput="raw_values") + rmse = root_mean_squared_error([[1]], [[10]], multioutput="raw_values") + assert np.sqrt(mse) == pytest.approx(rmse) def test_multioutput_regression(): @@ -138,12 +140,15 @@ def test_multioutput_regression(): error = mean_squared_error(y_true, y_pred) assert_almost_equal(error, (1.0 / 3 + 2.0 / 3 + 2.0 / 3) / 4.0) - error = mean_squared_error(y_true, y_pred, squared=False) + error = root_mean_squared_error(y_true, y_pred) assert_almost_equal(error, 0.454, decimal=2) error = mean_squared_log_error(y_true, y_pred) assert_almost_equal(error, 0.200, decimal=2) + error = root_mean_squared_log_error(y_true, y_pred) + assert_almost_equal(error, 0.315, decimal=2) + # mean_absolute_error and mean_squared_error are equal because # it is a binary problem. error = mean_absolute_error(y_true, y_pred) @@ -219,7 +224,7 @@ def test_regression_metrics_at_limits(): # Single-sample case # Note: for r2 and d2_tweedie see also test_regression_single_sample assert_almost_equal(mean_squared_error([0.0], [0.0]), 0.0) - assert_almost_equal(mean_squared_error([0.0], [0.0], squared=False), 0.0) + assert_almost_equal(root_mean_squared_error([0.0], [0.0]), 0.0) assert_almost_equal(mean_squared_log_error([0.0], [0.0]), 0.0) assert_almost_equal(mean_absolute_error([0.0], [0.0]), 0.0) assert_almost_equal(mean_pinball_loss([0.0], [0.0]), 0.0) @@ -257,6 +262,12 @@ def test_regression_metrics_at_limits(): ) with pytest.raises(ValueError, match=msg): mean_squared_log_error([1.0, -2.0, 3.0], [1.0, 2.0, 3.0]) + msg = ( + "Root Mean Squared Logarithmic Error cannot be used when targets " + "contain negative values." + ) + with pytest.raises(ValueError, match=msg): + root_mean_squared_log_error([1.0, -2.0, 3.0], [1.0, 2.0, 3.0]) # Tweedie deviance error power = -1.2 @@ -438,7 +449,7 @@ def test_regression_custom_weights(): y_pred = [[1, 1], [2, -1], [5, 4], [5, 6.5]] msew = mean_squared_error(y_true, y_pred, multioutput=[0.4, 0.6]) - rmsew = mean_squared_error(y_true, y_pred, multioutput=[0.4, 0.6], squared=False) + rmsew = root_mean_squared_error(y_true, y_pred, multioutput=[0.4, 0.6]) maew = mean_absolute_error(y_true, y_pred, multioutput=[0.4, 0.6]) mapew = mean_absolute_percentage_error(y_true, y_pred, multioutput=[0.4, 0.6]) rw = r2_score(y_true, y_pred, multioutput=[0.4, 0.6]) @@ -611,3 +622,50 @@ def test_pinball_loss_relation_with_mae(): mean_absolute_error(y_true, y_pred) == mean_pinball_loss(y_true, y_pred, alpha=0.5) * 2 ) + + +# TODO(1.6): remove this test +@pytest.mark.parametrize("metric", [mean_squared_error, mean_squared_log_error]) +def test_mean_squared_deprecation_squared(metric): + """Check the deprecation warning of the squared parameter""" + depr_msg = "'squared' is deprecated in version 1.4 and will be removed in 1.6." + y_true, y_pred = np.arange(10), np.arange(1, 11) + with pytest.warns(FutureWarning, match=depr_msg): + metric(y_true, y_pred, squared=False) + + +# TODO(1.6): remove this test +@pytest.mark.filterwarnings("ignore:'squared' is deprecated") +@pytest.mark.parametrize( + "old_func, new_func", + [ + (mean_squared_error, root_mean_squared_error), + (mean_squared_log_error, root_mean_squared_log_error), + ], +) +def test_rmse_rmsle_parameter(old_func, new_func): + # Check that the new rmse/rmsle function is equivalent to + # the old mse/msle + squared=False function. + y_true = np.array([[1, 0, 0, 1], [0, 1, 1, 1], [1, 1, 0, 1]]) + y_pred = np.array([[0, 0, 0, 1], [1, 0, 1, 1], [0, 0, 0, 1]]) + y_true = np.array([[0.5, 1], [1, 2], [7, 6]]) + y_pred = np.array([[0.5, 2], [1, 2.5], [8, 8]]) + sw = np.arange(len(y_true)) + + expected = old_func(y_true, y_pred, squared=False) + actual = new_func(y_true, y_pred) + assert_allclose(expected, actual) + + expected = old_func(y_true, y_pred, sample_weight=sw, squared=False) + actual = new_func(y_true, y_pred, sample_weight=sw) + assert_allclose(expected, actual) + + expected = old_func(y_true, y_pred, multioutput="raw_values", squared=False) + actual = new_func(y_true, y_pred, multioutput="raw_values") + assert_allclose(expected, actual) + + expected = old_func( + y_true, y_pred, sample_weight=sw, multioutput="raw_values", squared=False + ) + actual = new_func(y_true, y_pred, sample_weight=sw, multioutput="raw_values") + assert_allclose(expected, actual) diff --git a/sklearn/metrics/tests/test_score_objects.py b/sklearn/metrics/tests/test_score_objects.py index 10d991c477f1b..0bd1def6a500d 100644 --- a/sklearn/metrics/tests/test_score_objects.py +++ b/sklearn/metrics/tests/test_score_objects.py @@ -73,6 +73,7 @@ "neg_mean_squared_log_error", "neg_median_absolute_error", "neg_root_mean_squared_error", + "neg_root_mean_squared_log_error", "mean_absolute_error", "mean_absolute_percentage_error", "mean_squared_error", diff --git a/sklearn/tests/test_public_functions.py b/sklearn/tests/test_public_functions.py index 20ac2e1e1615e..22e70b39e1c6f 100644 --- a/sklearn/tests/test_public_functions.py +++ b/sklearn/tests/test_public_functions.py @@ -295,6 +295,8 @@ def _check_function_param_validation( "sklearn.metrics.recall_score", "sklearn.metrics.roc_auc_score", "sklearn.metrics.roc_curve", + "sklearn.metrics.root_mean_squared_error", + "sklearn.metrics.root_mean_squared_log_error", "sklearn.metrics.top_k_accuracy_score", "sklearn.metrics.v_measure_score", "sklearn.metrics.zero_one_loss",	diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 7f6f5c910a3fc..f4ae4ffbf8911 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -995,6 +995,8 @@ details. metrics.median_absolute_error metrics.mean_absolute_percentage_error metrics.r2_score + metrics.root_mean_squared_log_error + metrics.root_mean_squared_error metrics.mean_poisson_deviance metrics.mean_gamma_deviance metrics.mean_tweedie_deviance diff --git a/doc/modules/model_evaluation.rst b/doc/modules/model_evaluation.rst index c989f49c0fc7d..eac1cde567595 100644 --- a/doc/modules/model_evaluation.rst +++ b/doc/modules/model_evaluation.rst @@ -94,8 +94,9 @@ Scoring Function 'max_error' :func:`metrics.max_error` 'neg_mean_absolute_error' :func:`metrics.mean_absolute_error` 'neg_mean_squared_error' :func:`metrics.mean_squared_error` -'neg_root_mean_squared_error' :func:`metrics.mean_squared_error` +'neg_root_mean_squared_error' :func:`metrics.root_mean_squared_error` 'neg_mean_squared_log_error' :func:`metrics.mean_squared_log_error` +'neg_root_mean_squared_log_error' :func:`metrics.root_mean_squared_log_error` 'neg_median_absolute_error' :func:`metrics.median_absolute_error` 'r2' :func:`metrics.r2_score` 'neg_mean_poisson_deviance' :func:`metrics.mean_poisson_deviance` @@ -2310,6 +2311,10 @@ function:: for an example of mean squared error usage to evaluate gradient boosting regression. +Taking the square root of the MSE, called the root mean squared error (RMSE), is another +common metric that provides a measure in the same units as the target variable. RSME is +available through the :func:`root_mean_squared_error` function. + .. _mean_squared_log_error: Mean squared logarithmic error @@ -2347,6 +2352,9 @@ function:: >>> mean_squared_log_error(y_true, y_pred) 0.044... +The root mean squared logarithmic error (RMSLE) is available through the +:func:`root_mean_squared_log_error` function. + .. _mean_absolute_percentage_error: Mean absolute percentage error diff --git a/doc/whats_new/v1.4.rst b/doc/whats_new/v1.4.rst index 367315dc3c60d..8dbd867b0c9ba 100644 --- a/doc/whats_new/v1.4.rst +++ b/doc/whats_new/v1.4.rst @@ -238,6 +238,18 @@ Changelog - \|Enhancement\| :class:`preprocessing.TargetEncoder` now supports `target_type` 'multiclass'. :pr:`26674` by :user:`Lucy Liu <lucyleeow>`. +:mod:`sklearn.metrics` +...................... + +- \|API\| The `squared` parameter of :func:`metrics.mean_squared_error` and + :func:`metrics.mean_squared_log_error` is deprecated and will be removed in 1.6. + Use the new functions :func:`metrics.root_mean_squared_error` and + :func:`root_mean_squared_log_error` instead. + :pr:`26734` by :user:`Alejandro Martin Gil <101AlexMartin>`. + +- \|Enhancement\| Added `neg_root_mean_squared_log_error_scorer` as scorer + :pr:`26734` by :user:`Alejandro Martin Gil <101AlexMartin>`. + :mod:`sklearn.model_selection` ..............................	[ { "components": [ { "doc": "Root mean squared error regression loss.\n\nRead more in the :ref:`User Guide <mean_squared_error>`.\n\n.. versionadded:: 1.4\n\nParameters\n----------\ny_true : array-like of shape (n_samples,) or (n_samples, n_outputs)\n Ground truth (correct) target values.\n\ny_p...	[ "sklearn/metrics/tests/test_regression.py::test_regression_metrics", "sklearn/metrics/tests/test_regression.py::test_root_mean_squared_error_multioutput_raw_value", "sklearn/metrics/tests/test_regression.py::test_multioutput_regression", "sklearn/metrics/tests/test_regression.py::test_regression_metrics_at_li...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> API replace mean_squared_error(square=False) by root_mean_squared_error <!-- Thanks for contributing a pull request! Please ensure you have taken a look at the contribution guidelines: https://github.com/scikit-learn/scikit-learn/blob/main/CONTRIBUTING.md --> #### Reference Issues/PRs <!-- Example: Fixes #1234. See also #3456. Please use keywords (e.g., Fixes) to create link to the issues or pull requests you resolved, so that they will automatically be closed when your pull request is merged. See https://github.com/blog/1506-closing-issues-via-pull-requests --> #### What does this implement/fix? Explain your changes. Create ad-hoc function to calculate RMSE #### Any other comments? As an external user of scikit-learn, I found it counter-intuitive to have a flag inside the MSE function to get RMSE. I think it is difficult to find. In fact, I'm not the only one: https://stackoverflow.com/questions/17197492/is-there-a-library-function-for-root-mean-square-error-rmse-in-python If you also think this PR might be worth it, I will further elaborate it, generating the tests and creating also an ad-hoc function for the root_mean_square_log_error. <!-- Please be aware that we are a loose team of volunteers so patience is necessary; assistance handling other issues is very welcome. We value all user contributions, no matter how minor they are. If we are slow to review, either the pull request needs some benchmarking, tinkering, convincing, etc. or more likely the reviewers are simply busy. In either case, we ask for your understanding during the review process. For more information, see our FAQ on this topic: http://scikit-learn.org/dev/faq.html#why-is-my-pull-request-not-getting-any-attention. Thanks for contributing! --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/metrics/_regression.py] (definition of root_mean_squared_error:) def root_mean_squared_error( y_true, y_pred, , sample_weight=None, multioutput="uniform_average" ): """Root mean squared error regression loss. Read more in the :ref:`User Guide <mean_squared_error>`. .. versionadded:: 1.4 Parameters ---------- y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. multioutput : {'raw_values', 'uniform_average'} or array-like of shape (n_outputs,), default='uniform_average' Defines aggregating of multiple output values. Array-like value defines weights used to average errors. 'raw_values' : Returns a full set of errors in case of multioutput input. 'uniform_average' : Errors of all outputs are averaged with uniform weight. Returns ------- loss : float or ndarray of floats A non-negative floating point value (the best value is 0.0), or an array of floating point values, one for each individual target. Examples -------- >>> from sklearn.metrics import root_mean_squared_error >>> y_true = [3, -0.5, 2, 7] >>> y_pred = [2.5, 0.0, 2, 8] >>> root_mean_squared_error(y_true, y_pred) 0.612... >>> y_true = [[0.5, 1],[-1, 1],[7, -6]] >>> y_pred = [[0, 2],[-1, 2],[8, -5]] >>> root_mean_squared_error(y_true, y_pred) 0.822...""" (definition of root_mean_squared_log_error:) def root_mean_squared_log_error( y_true, y_pred, , sample_weight=None, multioutput="uniform_average" ): """Root mean squared logarithmic error regression loss. Read more in the :ref:`User Guide <mean_squared_log_error>`. .. versionadded:: 1.4 Parameters ---------- y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. multioutput : {'raw_values', 'uniform_average'} or array-like of shape (n_outputs,), default='uniform_average' Defines aggregating of multiple output values. Array-like value defines weights used to average errors. 'raw_values' : Returns a full set of errors when the input is of multioutput format. 'uniform_average' : Errors of all outputs are averaged with uniform weight. Returns ------- loss : float or ndarray of floats A non-negative floating point value (the best value is 0.0), or an array of floating point values, one for each individual target. Examples -------- >>> from sklearn.metrics import root_mean_squared_log_error >>> y_true = [3, 5, 2.5, 7] >>> y_pred = [2.5, 5, 4, 8] >>> root_mean_squared_log_error(y_true, y_pred) 0.199...""" [end of new definitions in sklearn/metrics/_regression.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		ae2c80a21007d8295fb3ec3a927fce17b3d60ab8
snowflakedb__snowflake-connector-python-1621	1,621	snowflakedb/snowflake-connector-python	null	320dbcee525fd83847f8f059044a6bc645905a21	2023-06-28T23:57:22Z	diff --git a/DESCRIPTION.md b/DESCRIPTION.md index dd658ccacf..728e8ca54d 100644 --- a/DESCRIPTION.md +++ b/DESCRIPTION.md @@ -15,6 +15,7 @@ Source code is also available at: https://github.com/snowflakedb/snowflake-conne - Added a parameter `server_session_keep_alive` in `SnowflakeConnection` that skips session deletion when client connection closes. - Tightened our pinning of platformdirs, to prevent their new releases breaking us. - Fixed a bug where SFPlatformDirs would incorrectly append application_name/version to its path. + - Added retry reason for queries that are retried by the client. - Fixed a bug where `write_pandas` fails when user does not have the privilege to create stage or file format in the target schema, but has the right privilege for the current schema. - v3.0.4(May 23,2023) diff --git a/src/snowflake/connector/connection.py b/src/snowflake/connector/connection.py index e308db87c6..9d36a060ee 100644 --- a/src/snowflake/connector/connection.py +++ b/src/snowflake/connector/connection.py @@ -220,6 +220,10 @@ def DefaultConverterClass() -> type: False, bool, ), # Whether to keep session alive after connector shuts down + "enable_retry_reason_in_query_response": ( + True, + bool, + ), # Enable sending retryReason in response header for query-requests } APPLICATION_RE = re.compile(r"[\w\d_]+") diff --git a/src/snowflake/connector/errors.py b/src/snowflake/connector/errors.py index f31f3d6443..cb8757f15e 100644 --- a/src/snowflake/connector/errors.py +++ b/src/snowflake/connector/errors.py @@ -536,6 +536,19 @@ def __init__(self, kwargs) -> None: ) +class TooManyRequests(Error): + """Exception for 429 HTTP error for retry.""" + + def __init__(self, kwargs) -> None: + Error.__init__( + self, + msg=kwargs.get("msg") or "HTTP 429: Too Many Requests", + errno=kwargs.get("errno"), + sqlstate=kwargs.get("sqlstate"), + sfqid=kwargs.get("sfqid"), + ) + + class OtherHTTPRetryableError(Error): """Exception for other HTTP error for retry.""" diff --git a/src/snowflake/connector/network.py b/src/snowflake/connector/network.py index 566f32fe5f..a51955ec21 100644 --- a/src/snowflake/connector/network.py +++ b/src/snowflake/connector/network.py @@ -82,6 +82,7 @@ OtherHTTPRetryableError, ProgrammingError, ServiceUnavailableError, + TooManyRequests, ) from .sqlstate import ( SQLSTATE_CONNECTION_NOT_EXISTS, @@ -173,6 +174,7 @@ BAD_REQUEST: BadRequest, BAD_GATEWAY: BadGatewayError, METHOD_NOT_ALLOWED: MethodNotAllowed, + TOO_MANY_REQUESTS: TooManyRequests, } DEFAULT_AUTHENTICATOR = "SNOWFLAKE" # default authenticator name @@ -784,16 +786,32 @@ def fetch( """Carry out API request with session management.""" class RetryCtx: - def __init__(self, timeout, _include_retry_params: bool = False) -> None: + def __init__( + self, + timeout, + _include_retry_params: bool = False, + _include_retry_reason: bool = False, + ) -> None: self.total_timeout = timeout self.timeout = timeout self.cnt = 0 + self.reason = 0 self.sleeping_time = 1 self.start_time = get_time_millis() self._include_retry_params = _include_retry_params + self._include_retry_reason = _include_retry_reason # backoff between 1 and 16 seconds self._backoff = DecorrelateJitterBackoff(1, 16) + def increment_retry(self, reason: int = 0) -> None: + """Increment retry count and update the reason for retry + + Args: + reason: HTTP response code that caused retry. Defaults to 0. + """ + self.cnt += 1 + self.reason = reason + def next_sleep(self) -> int: self.sleeping_time = self._backoff.next_sleep( self.cnt, self.sleeping_time @@ -802,18 +820,23 @@ def next_sleep(self) -> int: def add_retry_params(self, full_url: str) -> str: if self._include_retry_params and self.cnt > 0: - suffix = urlencode( - {"clientStartTime": self.start_time, "retryCount": self.cnt} - ) + retry_params = { + "clientStartTime": self.start_time, + "retryCount": self.cnt, + } + if self._include_retry_reason: + retry_params.update({"retryReason": self.reason}) + suffix = urlencode(retry_params) sep = "&" if urlparse(full_url).query else "?" return full_url + sep + suffix else: return full_url + include_retry_reason = self._connection._enable_retry_reason_in_query_response include_retry_params = kwargs.pop("_include_retry_params", False) with self._use_requests_session(full_url) as session: - retry_ctx = RetryCtx(timeout, include_retry_params) + retry_ctx = RetryCtx(timeout, include_retry_params, include_retry_reason) while True: ret = self._request_exec_wrapper( session, method, full_url, headers, data, retry_ctx, **kwargs @@ -932,7 +955,8 @@ def _request_exec_wrapper( sleeping_time, ) time.sleep(sleeping_time) - retry_ctx.cnt += 1 + reason = getattr(cause, "errno", 0) + retry_ctx.increment_retry(reason) if retry_ctx.timeout is not None: retry_ctx.timeout -= sleeping_time return None # retry	diff --git a/test/unit/test_result_batch.py b/test/unit/test_result_batch.py index 3d3b86241a..315d8089d3 100644 --- a/test/unit/test_result_batch.py +++ b/test/unit/test_result_batch.py @@ -23,6 +23,7 @@ OK, REQUEST_TIMEOUT, SERVICE_UNAVAILABLE, + TOO_MANY_REQUESTS, UNAUTHORIZED, ) from snowflake.connector.errorcode import ( @@ -41,23 +42,21 @@ ) try: + from snowflake.connector.errors import TooManyRequests from snowflake.connector.result_batch import MAX_DOWNLOAD_RETRY, JSONResultBatch + from snowflake.connector.vendored import requests # NOQA + + REQUEST_MODULE_PATH = "snowflake.connector.vendored.requests" except ImportError: MAX_DOWNLOAD_RETRY = None JSONResultBatch = None + REQUEST_MODULE_PATH = "requests" + TooManyRequests = None from snowflake.connector.sqlstate import ( SQLSTATE_CONNECTION_REJECTED, SQLSTATE_CONNECTION_WAS_NOT_ESTABLISHED, ) -try: - from snowflake.connector.vendored import requests # NOQA - - REQUEST_MODULE_PATH = "snowflake.connector.vendored.requests" -except ImportError: - REQUEST_MODULE_PATH = "requests" - - MockRemoteChunkInfo = namedtuple("MockRemoteChunkInfo", "url") chunk_info = MockRemoteChunkInfo("http://www.chunk-url.com") result_batch = ( @@ -76,6 +75,7 @@ def test_ok_response_download(mock_get): assert response.status_code == 200 +@pytest.mark.skipolddriver @pytest.mark.parametrize( "errcode,error_class", [ @@ -83,6 +83,7 @@ def test_ok_response_download(mock_get): (FORBIDDEN, ForbiddenError), # 403 (METHOD_NOT_ALLOWED, MethodNotAllowed), # 405 (REQUEST_TIMEOUT, OtherHTTPRetryableError), # 408 + (TOO_MANY_REQUESTS, TooManyRequests), # 429 (INTERNAL_SERVER_ERROR, InternalServerError), # 500 (BAD_GATEWAY, BadGatewayError), # 502 (SERVICE_UNAVAILABLE, ServiceUnavailableError), # 503 diff --git a/test/unit/test_retry_network.py b/test/unit/test_retry_network.py index 236d9fb974..9939a7f2b8 100644 --- a/test/unit/test_retry_network.py +++ b/test/unit/test_retry_network.py @@ -6,14 +6,17 @@ from __future__ import annotations import errno +import json import logging import os import time -from unittest.mock import MagicMock, Mock, PropertyMock +from unittest.mock import MagicMock, Mock, PropertyMock, patch +from uuid import uuid4 import OpenSSL.SSL import pytest +import snowflake.connector from snowflake.connector.compat import ( BAD_GATEWAY, BAD_REQUEST, @@ -48,6 +51,116 @@ THIS_DIR = os.path.dirname(os.path.realpath(__file__)) +class Cnt: + def __init__(self): + self.c = 0 + + def set(self, cnt): + self.c = cnt + + def reset(self): + self.set(0) + + +def fake_connector() -> snowflake.connector.SnowflakeConnection: + return snowflake.connector.connect( + user="user", + account="account", + password="testpassword", + database="TESTDB", + warehouse="TESTWH", + ) + + +@patch("snowflake.connector.network.SnowflakeRestful._request_exec") +@patch("snowflake.connector.network.DecorrelateJitterBackoff.next_sleep") +def test_retry_reason(mockNextSleep, mockRequestExec): + url = "" + cnt = Cnt() + + def mock_exec(session, method, full_url, headers, data, token, **kwargs): + # take actions based on data["sqlText"] + nonlocal url + url = full_url + data = json.loads(data) + sql = data.get("sqlText", "default") + success_result = { + "success": True, + "message": None, + "data": { + "token": "TOKEN", + "masterToken": "MASTER_TOKEN", + "idToken": None, + "parameters": [{"name": "SERVICE_NAME", "value": "FAKE_SERVICE_NAME"}], + }, + } + cnt.c += 1 + if "retry" in sql: + # error = HTTP Error 429 + if cnt.c < 3: # retry twice for 429 error + raise RetryRequest(OtherHTTPRetryableError(errno=429)) + return success_result + elif "unknown error" in sql: + # Raise unknown http error + if cnt.c == 1: # retry once for 100 error + raise RetryRequest(OtherHTTPRetryableError(errno=100)) + return success_result + elif "flip" in sql: + if cnt.c == 1: # retry first with 100 + raise RetryRequest(OtherHTTPRetryableError(errno=100)) + elif cnt.c == 2: # then with 429 + raise RetryRequest(OtherHTTPRetryableError(errno=429)) + return success_result + + return success_result + + conn = fake_connector() + mockNextSleep.side_effect = lambda cnt, sleep: 0 + mockRequestExec.side_effect = mock_exec + + # ensure query requests don't have the retryReason if retryCount == 0 + cnt.reset() + conn.cmd_query("success", 0, uuid4()) + assert "retryReason" not in url + assert "retryCount" not in url + + # ensure query requests have correct retryReason when retry reason is sent by server + cnt.reset() + conn.cmd_query("retry", 0, uuid4()) + assert "retryReason=429" in url + assert "retryCount=2" in url + + cnt.reset() + conn.cmd_query("unknown error", 0, uuid4()) + assert "retryReason=100" in url + assert "retryCount=1" in url + + # ensure query requests have retryReason reset to 0 when no reason is given + cnt.reset() + conn.cmd_query("success", 0, uuid4()) + assert "retryReason" not in url + assert "retryCount" not in url + + # ensure query requests have retryReason gets updated with updated error code + cnt.reset() + conn.cmd_query("flip", 0, uuid4()) + assert "retryReason=429" in url + assert "retryCount=2" in url + + # ensure that disabling works and only suppresses retryReason + conn._enable_retry_reason_in_query_response = False + + cnt.reset() + conn.cmd_query("retry", 0, uuid4()) + assert "retryReason" not in url + assert "retryCount=2" in url + + cnt.reset() + conn.cmd_query("unknown error", 0, uuid4()) + assert "retryReason" not in url + assert "retryCount=1" in url + + def test_request_exec(): rest = SnowflakeRestful(host="testaccount.snowflakecomputing.com", port=443) @@ -164,16 +277,6 @@ def test_fetch(): host="testaccount.snowflakecomputing.com", port=443, connection=connection ) - class Cnt: - def __init__(self): - self.c = 0 - - def set(self, cnt): - self.c = cnt - - def reset(self): - self.set(0) - cnt = Cnt() default_parameters = { "method": "POST",	diff --git a/DESCRIPTION.md b/DESCRIPTION.md index dd658ccacf..728e8ca54d 100644 --- a/DESCRIPTION.md +++ b/DESCRIPTION.md @@ -15,6 +15,7 @@ Source code is also available at: https://github.com/snowflakedb/snowflake-conne - Added a parameter `server_session_keep_alive` in `SnowflakeConnection` that skips session deletion when client connection closes. - Tightened our pinning of platformdirs, to prevent their new releases breaking us. - Fixed a bug where SFPlatformDirs would incorrectly append application_name/version to its path. + - Added retry reason for queries that are retried by the client. - Fixed a bug where `write_pandas` fails when user does not have the privilege to create stage or file format in the target schema, but has the right privilege for the current schema. - v3.0.4(May 23,2023)	[ { "components": [ { "doc": "Exception for 429 HTTP error for retry.", "lines": [ 539, 548 ], "name": "TooManyRequests", "signature": "class TooManyRequests(Error):", "type": "class" }, { "doc": "", "lines": [ ...	[ "test/unit/test_result_batch.py::test_ok_response_download", "test/unit/test_result_batch.py::test_retryable_response_download[HTTPStatus.BAD_REQUEST-BadRequest]", "test/unit/test_result_batch.py::test_retryable_response_download[HTTPStatus.FORBIDDEN-ForbiddenError]", "test/unit/test_result_batch.py::test_ret...	[ "test/unit/test_retry_network.py::test_request_exec", "test/unit/test_retry_network.py::test_fetch", "test/unit/test_retry_network.py::test_secret_masking" ]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> SNOW-736326: Add retry reason for retried queries Please answer these questions before submitting your pull requests. Thanks! 1. What GitHub issue is this PR addressing? Make sure that there is an accompanying issue to your PR. Fixes #SNOW-736326 2. Fill out the following pre-review checklist: - [x] I am adding a new automated test(s) to verify correctness of my new code - [ ] I am adding new logging messages - [ ] I am adding a new telemetry message - [ ] I am modifying authorization mechanisms - [ ] I am adding new credentials - [ ] I am modifying OCSP code - [ ] I am adding a new dependency 3. Please describe how your code solves the related issue. Following requirements based on [this](https://docs.google.com/document/d/1aymRr14WJ-OF3Xgtlpt_Xkfq-TyCB-GK-YV-0i8if34/edit) spec. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/snowflake/connector/errors.py] (definition of TooManyRequests:) class TooManyRequests(Error): """Exception for 429 HTTP error for retry.""" (definition of TooManyRequests.__init__:) def __init__(self, **kwargs) -> None: [end of new definitions in src/snowflake/connector/errors.py] [start of new definitions in src/snowflake/connector/network.py] (definition of SnowflakeRestful.fetch.RetryCtx.increment_retry:) def increment_retry(self, reason: int = 0) -> None: """Increment retry count and update the reason for retry Args: reason: HTTP response code that caused retry. Defaults to 0.""" [end of new definitions in src/snowflake/connector/network.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		138241c3604e78fd35fe38a2c0bc55ebc2d47f66
tobymao__sqlglot-1847	1,847	tobymao/sqlglot	null	898f1a2ed4f575d11f7d8680c2d642c3d5b8320c	2023-06-28T17:03:05Z	diff --git a/sqlglot/dialects/bigquery.py b/sqlglot/dialects/bigquery.py index 94ea365f4f..d156d66b05 100644 --- a/sqlglot/dialects/bigquery.py +++ b/sqlglot/dialects/bigquery.py @@ -1,5 +1,6 @@ from __future__ import annotations +import logging import re import typing as t @@ -21,6 +22,8 @@ from sqlglot.helper import seq_get, split_num_words from sqlglot.tokens import TokenType +logger = logging.getLogger("sqlglot") + def _date_add_sql( data_type: str, kind: str @@ -104,6 +107,33 @@ def _unqualify_unnest(expression: exp.Expression) -> exp.Expression: return expression +def _pushdown_cte_column_names(expression: exp.Expression) -> exp.Expression: + """BigQuery doesn't allow column names when defining a CTE, so we try to push them down.""" + if isinstance(expression, exp.CTE) and expression.alias_column_names: + cte_query = expression.this + + if cte_query.is_star: + logger.warning( + "Can't push down CTE column names for star queries. Run the query through" + " the optimizer or use 'qualify' to expand the star projections first." + ) + return expression + + column_names = expression.alias_column_names + expression.args["alias"].set("columns", None) + + for name, select in zip(column_names, cte_query.selects): + to_replace = select + + if isinstance(select, exp.Alias): + select = select.this + + # Inner aliases are shadowed by the CTE column names + to_replace.replace(exp.alias_(select, name)) + + return expression + + class BigQuery(Dialect): UNNEST_COLUMN_ONLY = True @@ -309,6 +339,7 @@ class Generator(generator.Generator): "TIMESTAMP", self.func("DATETIME", e.this, e.args.get("zone")) ), exp.Cast: transforms.preprocess([transforms.remove_precision_parameterized_types]), + exp.CTE: transforms.preprocess([_pushdown_cte_column_names]), exp.DateAdd: _date_add_sql("DATE", "ADD"), exp.DateSub: _date_add_sql("DATE", "SUB"), exp.DatetimeAdd: _date_add_sql("DATETIME", "ADD"), @@ -486,6 +517,11 @@ class Generator(generator.Generator): "within", } + def cte_sql(self, expression: exp.CTE) -> str: + if expression.alias_column_names: + self.unsupported("Column names in CTE definition are not supported.") + return super().cte_sql(expression) + def array_sql(self, expression: exp.Array) -> str: first_arg = seq_get(expression.expressions, 0) if isinstance(first_arg, exp.Subqueryable):	diff --git a/tests/dialects/test_bigquery.py b/tests/dialects/test_bigquery.py index e2b655dffc..c4f364e631 100644 --- a/tests/dialects/test_bigquery.py +++ b/tests/dialects/test_bigquery.py @@ -1,3 +1,5 @@ +from unittest import mock + from sqlglot import ErrorLevel, ParseError, UnsupportedError, transpile from tests.dialects.test_dialect import Validator @@ -571,3 +573,34 @@ def test_rename_table(self): "bigquery": "ALTER TABLE db.t1 RENAME TO t2", }, ) + + @mock.patch("sqlglot.dialects.bigquery.logger") + def test_pushdown_cte_column_names(self, mock_logger): + with self.assertRaises(UnsupportedError): + transpile( + "WITH cte(foo) AS (SELECT * FROM tbl) SELECT foo FROM cte", + read="spark", + write="bigquery", + unsupported_level=ErrorLevel.RAISE, + ) + + self.validate_all( + "WITH cte AS (SELECT 1 AS foo) SELECT foo FROM cte", + read={"spark": "WITH cte(foo) AS (SELECT 1) SELECT foo FROM cte"}, + ) + self.validate_all( + "WITH cte AS (SELECT 1 AS foo) SELECT foo FROM cte", + read={"spark": "WITH cte(foo) AS (SELECT 1 AS bar) SELECT foo FROM cte"}, + ) + self.validate_all( + "WITH cte AS (SELECT 1 AS bar) SELECT bar FROM cte", + read={"spark": "WITH cte AS (SELECT 1 AS bar) SELECT bar FROM cte"}, + ) + self.validate_all( + "WITH cte AS (SELECT 1 AS foo, 2) SELECT foo FROM cte", + read={"postgres": "WITH cte(foo) AS (SELECT 1, 2) SELECT foo FROM cte"}, + ) + self.validate_all( + "WITH cte AS (SELECT 1 AS foo UNION ALL SELECT 2) SELECT foo FROM cte", + read={"postgres": "WITH cte(foo) AS (SELECT 1 UNION ALL SELECT 2) SELECT foo FROM cte"}, + )		[]	[ "tests/dialects/test_bigquery.py::TestBigQuery::test_pushdown_cte_column_names" ]	[ "tests/dialects/test_bigquery.py::TestBigQuery::test_bigquery", "tests/dialects/test_bigquery.py::TestBigQuery::test_group_concat", "tests/dialects/test_bigquery.py::TestBigQuery::test_merge", "tests/dialects/test_bigquery.py::TestBigQuery::test_remove_precision_parameterized_types", "tests/dialects/test_bi...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat(bigquery): pushdown CTE column names {} ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		ceb42fabad60312699e4b15936aeebac00e22e4d
pvlib__pvlib-python-1784	1,784	pvlib/pvlib-python	0.9	996361d56dce8d4f14b0a1f3484528b90eb50ace	2023-06-26T18:00:53Z	diff --git a/docs/sphinx/source/whatsnew/v0.10.2.rst b/docs/sphinx/source/whatsnew/v0.10.2.rst index 7259f6a566..dacfe27f53 100644 --- a/docs/sphinx/source/whatsnew/v0.10.2.rst +++ b/docs/sphinx/source/whatsnew/v0.10.2.rst @@ -15,6 +15,8 @@ Enhancements :py:func:`pvlib.iotools.get_pvgis_hourly`, :py:func:`pvlib.iotools.get_cams`, :py:func:`pvlib.iotools.get_bsrn`, and :py:func:`pvlib.iotools.read_midc_raw_data_from_nrel`. (:pull:`1800`) +* Added option to infer threshold values for + :py:func:`pvlib.clearsky.detect_clearsky` (:issue:`1808`, :pull:`1784`) Bug fixes @@ -39,4 +41,5 @@ Requirements Contributors ~~~~~~~~~~~~ * Adam R. Jensen (:ghuser:`AdamRJensen`) +* Abigail Jones (:ghuser:`ajonesr`) * Taos Transue (:ghuser:`reepoi`) diff --git a/pvlib/clearsky.py b/pvlib/clearsky.py index ffc7ac9b55..62318942da 100644 --- a/pvlib/clearsky.py +++ b/pvlib/clearsky.py @@ -644,8 +644,38 @@ def _clear_sample_index(clear_windows, samples_per_window, align, H): return clear_samples -def detect_clearsky(measured, clearsky, times=None, window_length=10, - mean_diff=75, max_diff=75, +def _clearsky_get_threshold(sample_interval): + """ + Returns threshold values for kwargs in detect_clearsky. See + Table 1 in [1]. + + References + ---------- + .. [1] Jordan, D.C. and C. Hansen, "Clear-sky detection for PV + degradation analysis using multiple regression", Renewable Energy, + v209, p. 393-400, 2023. + """ + + if (sample_interval < 1 or sample_interval > 30): + raise ValueError("`infer_limits=True` can only be used for inputs \ + with time step from 1 to 30 minutes") + + data_freq = np.array([1, 5, 15, 30]) + + window_length = np.interp(sample_interval, data_freq, [50, 60, 90, 120]) + mean_diff = np.interp(sample_interval, data_freq, [75, 75, 75, 75]) + max_diff = np.interp(sample_interval, data_freq, [60, 65, 75, 90]) + lower_line_length = np.interp(sample_interval, data_freq, [-45,-45,-45,-45]) + upper_line_length = np.interp(sample_interval, data_freq, [80, 80, 80, 80]) + var_diff = np.interp(sample_interval, data_freq, [0.005, 0.01, 0.032, 0.07]) + slope_dev = np.interp(sample_interval, data_freq, [50, 60, 75, 96]) + + return (window_length, mean_diff, max_diff, lower_line_length, + upper_line_length, var_diff, slope_dev) + + +def detect_clearsky(measured, clearsky, times=None, infer_limits=False, + window_length=10, mean_diff=75, max_diff=75, lower_line_length=-5, upper_line_length=10, var_diff=0.005, slope_dev=8, max_iterations=20, return_components=False): @@ -676,6 +706,9 @@ def detect_clearsky(measured, clearsky, times=None, window_length=10, times : DatetimeIndex or None, default None. Times of measured and clearsky values. If None the index of measured will be used. + infer_limits : bool, default False + If True, does not use passed in kwargs (or defaults), but instead + interpolates these values from Table 1 in [2]_. window_length : int, default 10 Length of sliding time window in minutes. Must be greater than 2 periods. @@ -731,6 +764,9 @@ def detect_clearsky(measured, clearsky, times=None, window_length=10, .. [1] Reno, M.J. and C.W. Hansen, "Identification of periods of clear sky irradiance in time series of GHI measurements" Renewable Energy, v90, p. 520-531, 2016. + .. [2] Jordan, D.C. and C. Hansen, "Clear-sky detection for PV + degradation analysis using multiple regression", Renewable Energy, + v209, p. 393-400, 2023. :doi:`10.1016/j.renene.2023.04.035` Notes ----- @@ -773,6 +809,21 @@ def detect_clearsky(measured, clearsky, times=None, window_length=10, sample_interval, samples_per_window = \ tools._get_sample_intervals(times, window_length) + # if infer_limits, find threshold values using the sample interval + if infer_limits: + window_length, mean_diff, max_diff, lower_line_length, \ + upper_line_length, var_diff, slope_dev = \ + _clearsky_get_threshold(sample_interval) + + # recalculate samples_per_window using returned window_length + _, samples_per_window = \ + tools._get_sample_intervals(times, window_length) + + # check that we have enough data to produce a nonempty hankel matrix + if len(times) < samples_per_window: + raise ValueError(f"times has only {len(times)} entries, but it must \ + have at least {samples_per_window} entries") + # generate matrix of integers for creating windows with indexing H = hankel(np.arange(samples_per_window), np.arange(samples_per_window-1, len(times))) @@ -826,7 +877,22 @@ def detect_clearsky(measured, clearsky, times=None, window_length=10, def rmse(alpha): return np.sqrt(np.mean((clear_meas - alphaclear_clear)2)) - alpha = minimize_scalar(rmse).x + optimize_result = minimize_scalar(rmse) + if not optimize_result.success: + try: + message = "Optimizer exited unsuccessfully: " \ + + optimize_result.message + except AttributeError: + message = "Optimizer exited unsuccessfully: \ + No message explaining the failure was returned. \ + If you would like to see this message, please \ + update your scipy version (try version 1.8.0 \ + or beyond)." + raise RuntimeError(message) + + else: + alpha = optimize_result.x + if round(alpha10000) == round(previous_alpha*10000): break else: diff --git a/pvlib/data/detect_clearsky_threshold_data.csv b/pvlib/data/detect_clearsky_threshold_data.csv new file mode 100644 index 0000000000..a36736b1a3 --- /dev/null +++ b/pvlib/data/detect_clearsky_threshold_data.csv @@ -0,0 +1,126 @@ +# latitude:35.04 +# longitude:-106.62 +# elevation:1619 +# window_length:10 +Time (UTC),GHI,Clear or not +4/1/2012 17:30,862.0935267144818,1 +4/1/2012 17:31,863.9568654037691,1 +4/1/2012 17:32,865.802767695237,1 +4/1/2012 17:33,867.6311939211416,1 +4/1/2012 17:34,869.4421084958154,1 +4/1/2012 17:35,871.2354749580768,1 +4/1/2012 17:36,873.0112572200139,1 +4/1/2012 17:37,874.7694195555663,1 +4/1/2012 17:38,876.5099266138993,1 +4/1/2012 17:39,878.2327434081394,1 +4/1/2012 17:40,879.9378353205582,1 +4/1/2012 17:41,881.6251681074431,1 +4/1/2012 17:42,500.0,0 +4/1/2012 17:43,300.0,0 +4/1/2012 17:44,400.0,0 +4/1/2012 17:45,888.1962370575133,1 +4/1/2012 17:46,889.7942734332919,1 +4/1/2012 17:47,891.3743529660121,1 +4/1/2012 17:48,892.9364440027008,1 +4/1/2012 17:49,894.4805152569894,1 +4/1/2012 17:50,896.0065358138269,1 +4/1/2012 17:51,897.514475133874,1 +4/1/2012 17:52,899.0043030438522,1 +4/1/2012 17:53,900.4759897479845,1 +4/1/2012 17:54,901.9295058184756,1 +4/1/2012 17:55,903.3648231563722,1 +4/1/2012 17:56,950.0,0 +4/1/2012 17:57,906.1807424805852,1 +4/1/2012 17:58,907.5612891914101,1 +4/1/2012 17:59,908.9235237269177,1 +4/1/2012 18:00,910.2674188971979,1 +4/1/2012 18:01,911.592947889838,1 +4/1/2012 18:02,912.9000842614388,1 +4/1/2012 18:03,914.1888019477013,1 +4/1/2012 18:04,915.4590752551169,1 +4/1/2012 18:05,916.7108788648916,1 +4/1/2012 18:06,917.9441886574208,1 +4/1/2012 18:07,919.1589784086842,1 +4/1/2012 18:08,920.3552247618425,1 +4/1/2012 18:09,921.5329038989687,1 +4/1/2012 18:10,922.691992377965,1 +4/1/2012 18:11,923.8324671359268,1 +4/1/2012 18:12,924.9543054818693,1 +4/1/2012 18:13,926.057485105408,1 +4/1/2012 18:14,927.141984069634,1 +4/1/2012 18:15,928.2077808145282,1 +4/1/2012 18:16,929.254854160055,1 +4/1/2012 18:17,930.2831839827653,1 +4/1/2012 18:18,931.2927484780441,1 +4/1/2012 18:19,932.2835282910601,1 +4/1/2012 18:20,933.2555037490038,1 +4/1/2012 18:21,934.2086555597849,1 +4/1/2012 18:22,935.1429648059466,1 +4/1/2012 18:23,936.058412951919,1 +4/1/2012 18:24,936.9549818381174,1 +4/1/2012 18:25,937.8326536837798,1 +4/1/2012 18:26,938.6914110895166,1 +4/1/2012 18:27,939.5312370318452,1 +4/1/2012 18:28,940.3521148697101,1 +4/1/2012 18:29,941.1540288705581,1 +4/1/2012 18:30,941.9369620746523,1 +4/1/2012 18:31,942.7008995238247,1 +4/1/2012 18:32,943.4458260928685,1 +4/1/2012 18:33,944.1717270394992,1 +4/1/2012 18:34,944.8785879996012,1 +4/1/2012 18:35,945.5663949895419,1 +4/1/2012 18:36,946.2351344081491,1 +4/1/2012 18:37,946.8847930330305,1 +4/1/2012 18:38,947.5153580226918,1 +4/1/2012 18:39,948.126816918376,1 +4/1/2012 18:40,948.7191580309192,1 +4/1/2012 18:41,949.2923688693852,1 +4/1/2012 18:42,949.8464385206038,1 +4/1/2012 18:43,950.3813560493355,1 +4/1/2012 18:44,950.8971109033968,1 +4/1/2012 18:45,951.3936929103834,1 +4/1/2012 18:46,951.8710922815745,1 +4/1/2012 18:47,952.3292996087865,1 +4/1/2012 18:48,952.7683058659376,1 +4/1/2012 18:49,953.1881024102506,1 +4/1/2012 18:50,953.5886809795984,1 +4/1/2012 18:51,953.9700339452911,1 +4/1/2012 18:52,954.3321532981175,1 +4/1/2012 18:53,954.6750321861093,1 +4/1/2012 18:54,954.9986638782349,1 +4/1/2012 18:55,955.3030420248847,1 +4/1/2012 18:56,955.5881606602495,1 +4/1/2012 18:57,955.8540142004646,1 +4/1/2012 18:58,956.1005974445337,1 +4/1/2012 18:59,956.3279055749699,1 +4/1/2012 19:00,956.5359341563872,1 +4/1/2012 19:01,956.7246791371283,1 +4/1/2012 19:02,956.8941369551687,1 +4/1/2012 19:03,957.0443040971436,1 +4/1/2012 19:04,957.175177780536,1 +4/1/2012 19:05,957.2867554853715,1 +4/1/2012 19:06,957.3790350752402,1 +4/1/2012 19:07,957.4520147966049,1 +4/1/2012 19:08,957.5056932791584,1 +4/1/2012 19:09,957.5400695359402,1 +4/1/2012 19:10,957.5551429630466,1 +4/1/2012 19:11,957.5509133398784,1 +4/1/2012 19:12,957.527380828979,1 +4/1/2012 19:13,957.4845459762313,1 +4/1/2012 19:14,957.4224096624041,1 +4/1/2012 19:15,957.3409732831614,1 +4/1/2012 19:16,957.2402384985319,1 +4/1/2012 19:17,957.1202073871192,1 +4/1/2012 19:18,956.9808824107419,1 +4/1/2012 19:19,956.8222664139458,1 +4/1/2012 19:20,956.6443626248492,1 +4/1/2012 19:21,956.4471746540574,1 +4/1/2012 19:22,956.2307064955613,1 +4/1/2012 19:23,955.9949625264852,1 +4/1/2012 19:24,955.7399475061342,1 +4/1/2012 19:25,955.4656663871413,1 +4/1/2012 19:26,955.1721250622959,1 +4/1/2012 19:27,954.8593292624192,1 +4/1/2012 19:28,954.5272852786308,1 +4/1/2012 19:29,954.175999783701,1 +4/1/2012 19:30,953.8054798341012,1	diff --git a/pvlib/tests/test_clearsky.py b/pvlib/tests/test_clearsky.py index 37b95dcdf9..c2ef607f0f 100644 --- a/pvlib/tests/test_clearsky.py +++ b/pvlib/tests/test_clearsky.py @@ -533,6 +533,49 @@ def detect_clearsky_data(): return expected, cs +@pytest.fixture +def detect_clearsky_threshold_data(): + # this is (roughly) just a 2 hour period of the same data in + # detect_clearsky_data (which only spans 30 minutes) + data_file = DATA_DIR / 'detect_clearsky_threshold_data.csv' + expected = pd.read_csv( + data_file, index_col=0, parse_dates=True, comment='#') + expected = expected.tz_localize('UTC').tz_convert('Etc/GMT+7') + metadata = {} + with data_file.open() as f: + for line in f: + if line.startswith('#'): + key, value = line.strip('# \n').split(':') + metadata[key] = float(value) + else: + break + metadata['window_length'] = int(metadata['window_length']) + loc = Location(metadata['latitude'], metadata['longitude'], + altitude=metadata['elevation']) + # specify turbidity to guard against future lookup changes + cs = loc.get_clearsky(expected.index, linke_turbidity=2.658197) + return expected, cs + + +def test_clearsky_get_threshold(): + out = clearsky._clearsky_get_threshold(4.5) + expected = (58.75, 75, 64.375, -45, 80.0, 0.009375, 58.75) + assert np.allclose(out, expected) + + +def test_clearsky_get_threshold_raises_error(): + with pytest.raises(ValueError, match='can only be used for inputs'): + clearsky._clearsky_get_threshold(0.5) + + +def test_detect_clearsky_calls_threshold(mocker, detect_clearsky_threshold_data): + threshold_spy = mocker.spy(clearsky, '_clearsky_get_threshold') + expected, cs = detect_clearsky_threshold_data + threshold_actual = clearsky.detect_clearsky(expected['GHI'], cs['ghi'], + infer_limits=True) + assert threshold_spy.call_count == 1 + + def test_detect_clearsky(detect_clearsky_data): expected, cs = detect_clearsky_data clear_samples = clearsky.detect_clearsky( @@ -629,6 +672,18 @@ def test_detect_clearsky_missing_index(detect_clearsky_data): clearsky.detect_clearsky(expected['GHI'].values, cs['ghi'].values) +def test_detect_clearsky_not_enough_data(detect_clearsky_data): + expected, cs = detect_clearsky_data + with pytest.raises(ValueError, match='have at least'): + clearsky.detect_clearsky(expected['GHI'], cs['ghi'], window_length=60) + + +def test_detect_clearsky_optimizer_failed(detect_clearsky_data): + expected, cs = detect_clearsky_data + with pytest.raises(RuntimeError, match='Optimizer exited unsuccessfully'): + clearsky.detect_clearsky(expected['GHI'], cs['ghi'], window_length=15) + + @pytest.fixture def detect_clearsky_helper_data(): samples_per_window = 3	diff --git a/docs/sphinx/source/whatsnew/v0.10.2.rst b/docs/sphinx/source/whatsnew/v0.10.2.rst index 7259f6a566..dacfe27f53 100644 --- a/docs/sphinx/source/whatsnew/v0.10.2.rst +++ b/docs/sphinx/source/whatsnew/v0.10.2.rst @@ -15,6 +15,8 @@ Enhancements :py:func:`pvlib.iotools.get_pvgis_hourly`, :py:func:`pvlib.iotools.get_cams`, :py:func:`pvlib.iotools.get_bsrn`, and :py:func:`pvlib.iotools.read_midc_raw_data_from_nrel`. (:pull:`1800`) +* Added option to infer threshold values for + :py:func:`pvlib.clearsky.detect_clearsky` (:issue:`1808`, :pull:`1784`) Bug fixes @@ -39,4 +41,5 @@ Requirements Contributors ~~~~~~~~~~~~ * Adam R. Jensen (:ghuser:`AdamRJensen`) +* Abigail Jones (:ghuser:`ajonesr`) * Taos Transue (:ghuser:`reepoi`) diff --git a/pvlib/data/detect_clearsky_threshold_data.csv b/pvlib/data/detect_clearsky_threshold_data.csv new file mode 100644 index 0000000000..a36736b1a3 --- /dev/null +++ b/pvlib/data/detect_clearsky_threshold_data.csv @@ -0,0 +1,126 @@ +# latitude:35.04 +# longitude:-106.62 +# elevation:1619 +# window_length:10 +Time (UTC),GHI,Clear or not +4/1/2012 17:30,862.0935267144818,1 +4/1/2012 17:31,863.9568654037691,1 +4/1/2012 17:32,865.802767695237,1 +4/1/2012 17:33,867.6311939211416,1 +4/1/2012 17:34,869.4421084958154,1 +4/1/2012 17:35,871.2354749580768,1 +4/1/2012 17:36,873.0112572200139,1 +4/1/2012 17:37,874.7694195555663,1 +4/1/2012 17:38,876.5099266138993,1 +4/1/2012 17:39,878.2327434081394,1 +4/1/2012 17:40,879.9378353205582,1 +4/1/2012 17:41,881.6251681074431,1 +4/1/2012 17:42,500.0,0 +4/1/2012 17:43,300.0,0 +4/1/2012 17:44,400.0,0 +4/1/2012 17:45,888.1962370575133,1 +4/1/2012 17:46,889.7942734332919,1 +4/1/2012 17:47,891.3743529660121,1 +4/1/2012 17:48,892.9364440027008,1 +4/1/2012 17:49,894.4805152569894,1 +4/1/2012 17:50,896.0065358138269,1 +4/1/2012 17:51,897.514475133874,1 +4/1/2012 17:52,899.0043030438522,1 +4/1/2012 17:53,900.4759897479845,1 +4/1/2012 17:54,901.9295058184756,1 +4/1/2012 17:55,903.3648231563722,1 +4/1/2012 17:56,950.0,0 +4/1/2012 17:57,906.1807424805852,1 +4/1/2012 17:58,907.5612891914101,1 +4/1/2012 17:59,908.9235237269177,1 +4/1/2012 18:00,910.2674188971979,1 +4/1/2012 18:01,911.592947889838,1 +4/1/2012 18:02,912.9000842614388,1 +4/1/2012 18:03,914.1888019477013,1 +4/1/2012 18:04,915.4590752551169,1 +4/1/2012 18:05,916.7108788648916,1 +4/1/2012 18:06,917.9441886574208,1 +4/1/2012 18:07,919.1589784086842,1 +4/1/2012 18:08,920.3552247618425,1 +4/1/2012 18:09,921.5329038989687,1 +4/1/2012 18:10,922.691992377965,1 +4/1/2012 18:11,923.8324671359268,1 +4/1/2012 18:12,924.9543054818693,1 +4/1/2012 18:13,926.057485105408,1 +4/1/2012 18:14,927.141984069634,1 +4/1/2012 18:15,928.2077808145282,1 +4/1/2012 18:16,929.254854160055,1 +4/1/2012 18:17,930.2831839827653,1 +4/1/2012 18:18,931.2927484780441,1 +4/1/2012 18:19,932.2835282910601,1 +4/1/2012 18:20,933.2555037490038,1 +4/1/2012 18:21,934.2086555597849,1 +4/1/2012 18:22,935.1429648059466,1 +4/1/2012 18:23,936.058412951919,1 +4/1/2012 18:24,936.9549818381174,1 +4/1/2012 18:25,937.8326536837798,1 +4/1/2012 18:26,938.6914110895166,1 +4/1/2012 18:27,939.5312370318452,1 +4/1/2012 18:28,940.3521148697101,1 +4/1/2012 18:29,941.1540288705581,1 +4/1/2012 18:30,941.9369620746523,1 +4/1/2012 18:31,942.7008995238247,1 +4/1/2012 18:32,943.4458260928685,1 +4/1/2012 18:33,944.1717270394992,1 +4/1/2012 18:34,944.8785879996012,1 +4/1/2012 18:35,945.5663949895419,1 +4/1/2012 18:36,946.2351344081491,1 +4/1/2012 18:37,946.8847930330305,1 +4/1/2012 18:38,947.5153580226918,1 +4/1/2012 18:39,948.126816918376,1 +4/1/2012 18:40,948.7191580309192,1 +4/1/2012 18:41,949.2923688693852,1 +4/1/2012 18:42,949.8464385206038,1 +4/1/2012 18:43,950.3813560493355,1 +4/1/2012 18:44,950.8971109033968,1 +4/1/2012 18:45,951.3936929103834,1 +4/1/2012 18:46,951.8710922815745,1 +4/1/2012 18:47,952.3292996087865,1 +4/1/2012 18:48,952.7683058659376,1 +4/1/2012 18:49,953.1881024102506,1 +4/1/2012 18:50,953.5886809795984,1 +4/1/2012 18:51,953.9700339452911,1 +4/1/2012 18:52,954.3321532981175,1 +4/1/2012 18:53,954.6750321861093,1 +4/1/2012 18:54,954.9986638782349,1 +4/1/2012 18:55,955.3030420248847,1 +4/1/2012 18:56,955.5881606602495,1 +4/1/2012 18:57,955.8540142004646,1 +4/1/2012 18:58,956.1005974445337,1 +4/1/2012 18:59,956.3279055749699,1 +4/1/2012 19:00,956.5359341563872,1 +4/1/2012 19:01,956.7246791371283,1 +4/1/2012 19:02,956.8941369551687,1 +4/1/2012 19:03,957.0443040971436,1 +4/1/2012 19:04,957.175177780536,1 +4/1/2012 19:05,957.2867554853715,1 +4/1/2012 19:06,957.3790350752402,1 +4/1/2012 19:07,957.4520147966049,1 +4/1/2012 19:08,957.5056932791584,1 +4/1/2012 19:09,957.5400695359402,1 +4/1/2012 19:10,957.5551429630466,1 +4/1/2012 19:11,957.5509133398784,1 +4/1/2012 19:12,957.527380828979,1 +4/1/2012 19:13,957.4845459762313,1 +4/1/2012 19:14,957.4224096624041,1 +4/1/2012 19:15,957.3409732831614,1 +4/1/2012 19:16,957.2402384985319,1 +4/1/2012 19:17,957.1202073871192,1 +4/1/2012 19:18,956.9808824107419,1 +4/1/2012 19:19,956.8222664139458,1 +4/1/2012 19:20,956.6443626248492,1 +4/1/2012 19:21,956.4471746540574,1 +4/1/2012 19:22,956.2307064955613,1 +4/1/2012 19:23,955.9949625264852,1 +4/1/2012 19:24,955.7399475061342,1 +4/1/2012 19:25,955.4656663871413,1 +4/1/2012 19:26,955.1721250622959,1 +4/1/2012 19:27,954.8593292624192,1 +4/1/2012 19:28,954.5272852786308,1 +4/1/2012 19:29,954.175999783701,1 +4/1/2012 19:30,953.8054798341012,1	[ { "components": [ { "doc": "Returns threshold values for kwargs in detect_clearsky. See\nTable 1 in [1].\n\nReferences\n----------\n.. [1] Jordan, D.C. and C. Hansen, \"Clear-sky detection for PV\n degradation analysis using multiple regression\", Renewable Energy,\n v209, p. 393-400, 2023.", ...	[ "pvlib/tests/test_clearsky.py::test_clearsky_get_threshold", "pvlib/tests/test_clearsky.py::test_clearsky_get_threshold_raises_error", "pvlib/tests/test_clearsky.py::test_detect_clearsky_calls_threshold", "pvlib/tests/test_clearsky.py::test_detect_clearsky_not_enough_data", "pvlib/tests/test_clearsky.py::te...	[ "pvlib/tests/test_clearsky.py::test_ineichen_series", "pvlib/tests/test_clearsky.py::test_ineichen_series_perez_enhancement", "pvlib/tests/test_clearsky.py::test_ineichen_scalar_input", "pvlib/tests/test_clearsky.py::test_ineichen_nans", "pvlib/tests/test_clearsky.py::test_ineichen_arrays", "pvlib/tests/t...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Infer thresholds for detect_clearsky - [x] Closes #1808 - [x] I am familiar with the [contributing guidelines](https://pvlib-python.readthedocs.io/en/latest/contributing.html) - [x] Tests added - ~~[ ] Updates entries in [`docs/sphinx/source/reference`](https://github.com/pvlib/pvlib-python/blob/main/docs/sphinx/source/reference) for API changes.~~ - [x] Adds description and name entries in the appropriate "what's new" file in [`docs/sphinx/source/whatsnew`](https://github.com/pvlib/pvlib-python/tree/main/docs/sphinx/source/whatsnew) for all changes. Includes link to the GitHub Issue with `` :issue:`num` `` or this Pull Request with `` :pull:`num` ``. Includes contributor name and/or GitHub username (link with `` :ghuser:`user` ``). - [x] New code is fully documented. Includes [numpydoc](https://numpydoc.readthedocs.io/en/latest/format.html) compliant docstrings, examples, and comments where necessary. - [x] Pull request is nearly complete and ready for detailed review. - [x] Maintainer: Appropriate GitHub Labels (including `remote-data`) and Milestone are assigned to the Pull Request and linked Issue. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pvlib/clearsky.py] (definition of _clearsky_get_threshold:) def _clearsky_get_threshold(sample_interval): """Returns threshold values for kwargs in detect_clearsky. See Table 1 in [1]. References ---------- .. [1] Jordan, D.C. and C. Hansen, "Clear-sky detection for PV degradation analysis using multiple regression", Renewable Energy, v209, p. 393-400, 2023.""" [end of new definitions in pvlib/clearsky.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Extend detect_clearsky for different data periods The threshold parameters for `pvlib.clearsky.detect_clearsky` were calibrated using data at 1 minute intervals. Recently, Jordan and Hansen [1] showed how to extend the `detect_clearsky` function for time-averaged data out to 30 minute intervals. The extension requires different data window length and different values for the threshold parameters, but doesn't require any change to the parameter calculations. Interestingly, the threshold values are linear functions of the data interval. Describe the solution you'd like Implement a helper function for `detect_clearsky` that infers the parameter values from the input data interval. Describe alternatives you've considered Leaving as-is. Additional context [1] Jordan, D.C. and C. Hansen, "Clear-sky detection for PV degradation analysis using multiple regression", Renewable Energy, v209, p. 393-400, 2023. ---------- -------------------- </issues>	d53f97e984bfdd268aa92f8bf482ced0edda0110
conan-io__conan-14169	14,169	conan-io/conan	null	ccdd94f2941060bf69b47536b4ccbc22da1288ac	2023-06-26T17:15:08Z	diff --git a/conan/tools/files/__init__.py b/conan/tools/files/__init__.py index f47cd2beffd..a697136753c 100644 --- a/conan/tools/files/__init__.py +++ b/conan/tools/files/__init__.py @@ -7,4 +7,4 @@ from conan.tools.files.packager import AutoPackager from conan.tools.files.symlinks import symlinks from conan.tools.files.copy_pattern import copy -from conan.tools.files.conandata import update_conandata +from conan.tools.files.conandata import update_conandata, trim_conandata diff --git a/conan/tools/files/conandata.py b/conan/tools/files/conandata.py index 43bd7a12d44..9e62288266d 100644 --- a/conan/tools/files/conandata.py +++ b/conan/tools/files/conandata.py @@ -31,3 +31,31 @@ def recursive_dict_update(d, u): recursive_dict_update(conandata, data) new_content = yaml.safe_dump(conandata) save(path, new_content) + + +def trim_conandata(conanfile): + """ + Tool to modify the ``conandata.yml`` once it is exported, to limit it to the current version + only + """ + if not hasattr(conanfile, "export_folder") or conanfile.export_folder is None: + raise ConanException("The 'trim_conandata()' can only be used in the 'export()' method") + path = os.path.join(conanfile.export_folder, "conandata.yml") + if not os.path.exists(path): + raise ConanException("conandata.yml file doesn't exist") + + conandata = load(path) + conandata = yaml.safe_load(conandata) + + version = str(conanfile.version) + result = {} + for k, v in conandata.items(): + if not isinstance(v, dict): + result[k] = v + continue # to allow user extra conandata, common to all versions + version_data = v.get(version) + if version_data is not None: + result[k] = {version: version_data} + + new_conandata_yml = yaml.safe_dump(result, default_flow_style=False) + save(path, new_conandata_yml)	diff --git a/conans/test/integration/conanfile/conan_data_test.py b/conans/test/integration/conanfile/conan_data_test.py index ff154c15cb3..47d773a252e 100644 --- a/conans/test/integration/conanfile/conan_data_test.py +++ b/conans/test/integration/conanfile/conan_data_test.py @@ -331,3 +331,53 @@ def export(self): c.save({"conanfile.py": conanfile}) c.run("export .") # It doesn't fail assert "pkg/0.1: Calling export()" in c.out + + +def test_conandata_trim(): + """ test the explict trim_conandata() helper + """ + c = TestClient() + conanfile = textwrap.dedent(""" + from conan import ConanFile + from conan.tools.files import trim_conandata + + class Pkg(ConanFile): + name = "pkg" + def export(self): + trim_conandata(self) + """) + conandata_yml = textwrap.dedent("""\ + sources: + "1.0": + url: "url1" + sha256: "sha1" + patches: + "1.0": + - patch_file: "patches/some_patch" + base_path: "source_subfolder" + something: else + """) + c.save({"conanfile.py": conanfile, + "conandata.yml": conandata_yml}) + c.run("export . 1.0@") + assert "pkg/1.0: Exported revision: 70612e15e4fc9af1123fe11731ac214f" in c.out + conandata_yml2 = textwrap.dedent("""\ + sources: + "1.0": + url: "url1" + sha256: "sha1" + "1.1": + url: "url2" + sha256: "sha2" + patches: + "1.1": + - patch_file: "patches/some_patch2" + base_path: "source_subfolder" + "1.0": + - patch_file: "patches/some_patch" + base_path: "source_subfolder" + something: else + """) + c.save({"conandata.yml": conandata_yml2}) + c.run("export . 1.0@") + assert "pkg/1.0: Exported revision: 70612e15e4fc9af1123fe11731ac214f" in c.out		[ { "components": [ { "doc": "Tool to modify the ``conandata.yml`` once it is exported, to limit it to the current version\nonly", "lines": [ 36, 61 ], "name": "trim_conandata", "signature": "def trim_conandata(conanfile):", "type": "functi...	[ "conans/test/integration/conanfile/conan_data_test.py::test_conandata_trim" ]	[ "conans/test/integration/conanfile/conan_data_test.py::ConanDataTest::test_conan_data_as_source", "conans/test/integration/conanfile/conan_data_test.py::ConanDataTest::test_conan_data_as_source_newtools", "conans/test/integration/conanfile/conan_data_test.py::ConanDataTest::test_conan_data_development_flow", ...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> trim_conandata() Changelog: Feature: New ``trim_conandata()`` function to make things explicit, not depend on hook. Docs: https://github.com/conan-io/docs/pull/3373 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conan/tools/files/conandata.py] (definition of trim_conandata:) def trim_conandata(conanfile): """Tool to modify the ``conandata.yml`` once it is exported, to limit it to the current version only""" [end of new definitions in conan/tools/files/conandata.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		4a5b19a75db9225316c8cb022a2dfb9705a2af34
scikit-learn__scikit-learn-26689	26,689	scikit-learn/scikit-learn	1.6	f6280bf4fd30627eeef7eb344f17d4fc05d37502	2023-06-23T17:50:45Z	diff --git a/doc/whats_new/upcoming_changes/sklearn.neighbors/26689.enhancement.rst b/doc/whats_new/upcoming_changes/sklearn.neighbors/26689.enhancement.rst new file mode 100644 index 0000000000000..ebc50d1bc6aaa --- /dev/null +++ b/doc/whats_new/upcoming_changes/sklearn.neighbors/26689.enhancement.rst @@ -0,0 +1,7 @@ +- Add :meth:`neighbors.NearestCentroid.decision_function`, + :meth:`neighbors.NearestCentroid.predict_proba` and + :meth:`neighbors.NearestCentroid.predict_log_proba` + to the :class:`neighbors.NearestCentroid` estimator class. + Support the case when `X` is sparse and `shrinking_threshold` + is not `None` in :class:`neighbors.NearestCentroid`. + By :user:`Matthew Ning <NoPenguinsLand>` diff --git a/sklearn/discriminant_analysis.py b/sklearn/discriminant_analysis.py index 69339491d214d..6a851c07dc896 100644 --- a/sklearn/discriminant_analysis.py +++ b/sklearn/discriminant_analysis.py @@ -168,6 +168,84 @@ def _class_cov(X, y, priors, shrinkage=None, covariance_estimator=None): return cov +class DiscriminantAnalysisPredictionMixin: + """Mixin class for QuadraticDiscriminantAnalysis and NearestCentroid.""" + + def decision_function(self, X): + """Apply decision function to an array of samples. + + Parameters + ---------- + X : {array-like, sparse matrix} of shape (n_samples, n_features) + Array of samples (test vectors). + + Returns + ------- + y_scores : ndarray of shape (n_samples,) or (n_samples, n_classes) + Decision function values related to each class, per sample. + In the two-class case, the shape is `(n_samples,)`, giving the + log likelihood ratio of the positive class. + """ + y_scores = self._decision_function(X) + if len(self.classes_) == 2: + return y_scores[:, 1] - y_scores[:, 0] + return y_scores + + def predict(self, X): + """Perform classification on an array of vectors `X`. + + Returns the class label for each sample. + + Parameters + ---------- + X : {array-like, sparse matrix} of shape (n_samples, n_features) + Input vectors, where `n_samples` is the number of samples and + `n_features` is the number of features. + + Returns + ------- + y_pred : ndarray of shape (n_samples,) + Class label for each sample. + """ + scores = self._decision_function(X) + return self.classes_.take(scores.argmax(axis=1)) + + def predict_proba(self, X): + """Estimate class probabilities. + + Parameters + ---------- + X : {array-like, sparse matrix} of shape (n_samples, n_features) + Input data. + + Returns + ------- + y_proba : ndarray of shape (n_samples, n_classes) + Probability estimate of the sample for each class in the + model, where classes are ordered as they are in `self.classes_`. + """ + return np.exp(self.predict_log_proba(X)) + + def predict_log_proba(self, X): + """Estimate log class probabilities. + + Parameters + ---------- + X : {array-like, sparse matrix} of shape (n_samples, n_features) + Input data. + + Returns + ------- + y_log_proba : ndarray of shape (n_samples, n_classes) + Estimated log probabilities. + """ + scores = self._decision_function(X) + log_likelihood = scores - scores.max(axis=1)[:, np.newaxis] + return log_likelihood - np.log( + np.exp(log_likelihood).sum(axis=1)[:, np.newaxis] + ) + + class LinearDiscriminantAnalysis( ClassNamePrefixFeaturesOutMixin, LinearClassifierMixin, @@ -744,9 +822,9 @@ def decision_function(self, X): Returns ------- - C : ndarray of shape (n_samples,) or (n_samples, n_classes) + y_scores : ndarray of shape (n_samples,) or (n_samples, n_classes) Decision function values related to each class, per sample. - In the two-class case, the shape is (n_samples,), giving the + In the two-class case, the shape is `(n_samples,)`, giving the log likelihood ratio of the positive class. """ # Only override for the doc @@ -758,7 +836,9 @@ def __sklearn_tags__(self): return tags -class QuadraticDiscriminantAnalysis(ClassifierMixin, BaseEstimator): +class QuadraticDiscriminantAnalysis( + DiscriminantAnalysisPredictionMixin, ClassifierMixin, BaseEstimator +): """Quadratic Discriminant Analysis. A classifier with a quadratic decision boundary, generated @@ -992,14 +1072,10 @@ def decision_function(self, X): ------- C : ndarray of shape (n_samples,) or (n_samples, n_classes) Decision function values related to each class, per sample. - In the two-class case, the shape is (n_samples,), giving the + In the two-class case, the shape is `(n_samples,)`, giving the log likelihood ratio of the positive class. """ - dec_func = self._decision_function(X) - # handle special case of two classes - if len(self.classes_) == 2: - return dec_func[:, 1] - dec_func[:, 0] - return dec_func + return super().decision_function(X) def predict(self, X): """Perform classification on an array of test vectors X. @@ -1017,9 +1093,7 @@ def predict(self, X): C : ndarray of shape (n_samples,) Estimated probabilities. """ - d = self._decision_function(X) - y_pred = self.classes_.take(d.argmax(1)) - return y_pred + return super().predict(X) def predict_proba(self, X): """Return posterior probabilities of classification. @@ -1034,12 +1108,9 @@ def predict_proba(self, X): C : ndarray of shape (n_samples, n_classes) Posterior probabilities of classification per class. """ - values = self._decision_function(X) # compute the likelihood of the underlying gaussian models # up to a multiplicative constant. - likelihood = np.exp(values - values.max(axis=1)[:, np.newaxis]) - # compute posterior probabilities - return likelihood / likelihood.sum(axis=1)[:, np.newaxis] + return super().predict_proba(X) def predict_log_proba(self, X): """Return log of posterior probabilities of classification. @@ -1055,5 +1126,4 @@ def predict_log_proba(self, X): Posterior log-probabilities of classification per class. """ # XXX : can do better to avoid precision overflows - probas_ = self.predict_proba(X) - return np.log(probas_) + return super().predict_log_proba(X) diff --git a/sklearn/neighbors/_nearest_centroid.py b/sklearn/neighbors/_nearest_centroid.py index f92ae68973741..cb8d1dbf7107f 100644 --- a/sklearn/neighbors/_nearest_centroid.py +++ b/sklearn/neighbors/_nearest_centroid.py @@ -5,21 +5,29 @@ # Authors: The scikit-learn developers # SPDX-License-Identifier: BSD-3-Clause +import warnings from numbers import Real import numpy as np from scipy import sparse as sp from ..base import BaseEstimator, ClassifierMixin, _fit_context -from ..metrics.pairwise import pairwise_distances_argmin +from ..discriminant_analysis import DiscriminantAnalysisPredictionMixin +from ..metrics.pairwise import ( + pairwise_distances, + pairwise_distances_argmin, +) from ..preprocessing import LabelEncoder +from ..utils._available_if import available_if from ..utils._param_validation import Interval, StrOptions from ..utils.multiclass import check_classification_targets from ..utils.sparsefuncs import csc_median_axis_0 from ..utils.validation import check_is_fitted, validate_data -class NearestCentroid(ClassifierMixin, BaseEstimator): +class NearestCentroid( + DiscriminantAnalysisPredictionMixin, ClassifierMixin, BaseEstimator +): """Nearest centroid classifier. Each class is represented by its centroid, with test samples classified to @@ -47,6 +55,13 @@ class is the arithmetic mean, which minimizes the sum of squared L1 distances. shrink_threshold : float, default=None Threshold for shrinking centroids to remove features. + priors : {"uniform", "empirical"} or array-like of shape (n_classes,), \ + default="uniform" + The class prior probabilities. By default, the class proportions are + inferred from the training data. + + .. versionadded:: 1.6 + Attributes ---------- centroids_ : array-like of shape (n_classes, n_features) @@ -66,6 +81,24 @@ class is the arithmetic mean, which minimizes the sum of squared L1 distances. .. versionadded:: 1.0 + deviations_ : ndarray of shape (n_classes, n_features) + Deviations (or shrinkages) of the centroids of each class from the + overall centroid. Equal to eq. (18.4) if `shrink_threshold=None`, + else (18.5) p. 653 of [2]. Can be used to identify features used + for classification. + + .. versionadded:: 1.6 + + within_class_std_dev_ : ndarray of shape (n_features,) + Pooled or within-class standard deviation of input data. + + .. versionadded:: 1.6 + + class_prior_ : ndarray of shape (n_classes,) + The class prior probabilities. + + .. versionadded:: 1.6 + See Also -------- KNeighborsClassifier : Nearest neighbors classifier. @@ -77,11 +110,14 @@ class is the arithmetic mean, which minimizes the sum of squared L1 distances. References ---------- - Tibshirani, R., Hastie, T., Narasimhan, B., & Chu, G. (2002). Diagnosis of + [1] Tibshirani, R., Hastie, T., Narasimhan, B., & Chu, G. (2002). Diagnosis of multiple cancer types by shrunken centroids of gene expression. Proceedings of the National Academy of Sciences of the United States of America, 99(10), 6567-6572. The National Academy of Sciences. + [2] Hastie, T., Tibshirani, R., Friedman, J. (2009). The Elements of Statistical + Learning Data Mining, Inference, and Prediction. 2nd Edition. New York, Springer. + Examples -------- >>> from sklearn.neighbors import NearestCentroid @@ -93,19 +129,24 @@ class is the arithmetic mean, which minimizes the sum of squared L1 distances. NearestCentroid() >>> print(clf.predict([[-0.8, -1]])) [1] - - For a more detailed example see: - :ref:`sphx_glr_auto_examples_neighbors_plot_nearest_centroid.py` """ _parameter_constraints: dict = { "metric": [StrOptions({"manhattan", "euclidean"})], "shrink_threshold": [Interval(Real, 0, None, closed="neither"), None], + "priors": ["array-like", StrOptions({"empirical", "uniform"})], } - def __init__(self, metric="euclidean", , shrink_threshold=None): + def __init__( + self, + metric="euclidean", + , + shrink_threshold=None, + priors="uniform", + ): self.metric = metric self.shrink_threshold = shrink_threshold + self.priors = priors @_fit_context(prefer_skip_nested_validation=True) def fit(self, X, y): @@ -133,8 +174,6 @@ def fit(self, X, y): else: X, y = validate_data(self, X, y, accept_sparse=["csr", "csc"]) is_X_sparse = sp.issparse(X) - if is_X_sparse and self.shrink_threshold: - raise ValueError("threshold shrinking not supported for sparse input") check_classification_targets(y) n_samples, n_features = X.shape @@ -148,8 +187,26 @@ def fit(self, X, y): % (n_classes) ) + if self.priors == "empirical": # estimate priors from sample + _, class_counts = np.unique(y, return_inverse=True) # non-negative ints + self.class_prior_ = np.bincount(class_counts) / float(len(y)) + elif self.priors == "uniform": + self.class_prior_ = np.asarray([1 / n_classes] * n_classes) + else: + self.class_prior_ = np.asarray(self.priors) + + if (self.class_prior_ < 0).any(): + raise ValueError("priors must be non-negative") + if not np.isclose(self.class_prior_.sum(), 1.0): + warnings.warn( + "The priors do not sum to 1. Normalizing such that it sums to one.", + UserWarning, + ) + self.class_prior_ = self.class_prior_ / self.class_prior_.sum() + # Mask mapping each class to its members. self.centroids_ = np.empty((n_classes, n_features), dtype=np.float64) + # Number of clusters in each class. nk = np.zeros(n_classes) @@ -168,30 +225,44 @@ def fit(self, X, y): else: # metric == "euclidean" self.centroids_[cur_class] = X[center_mask].mean(axis=0) + # Compute within-class std_dev with unshrunked centroids + variance = np.array(X - self.centroids_[y_ind], copy=False) ** 2 + self.within_class_std_dev_ = np.array( + np.sqrt(variance.sum(axis=0) / (n_samples - n_classes)), copy=False + ) + if any(self.within_class_std_dev_ == 0): + warnings.warn( + "self.within_class_std_dev_ has at least 1 zero standard deviation." + "Inputs within the same classes for at least 1 feature are identical." + ) + + err_msg = "All features have zero variance. Division by zero." + if is_X_sparse and np.all((X.max(axis=0) - X.min(axis=0)).toarray() == 0): + raise ValueError(err_msg) + elif not is_X_sparse and np.all(np.ptp(X, axis=0) == 0): + raise ValueError(err_msg) + + dataset_centroid_ = X.mean(axis=0) + # m parameter for determining deviation + m = np.sqrt((1.0 / nk) - (1.0 / n_samples)) + # Calculate deviation using the standard deviation of centroids. + # To deter outliers from affecting the results. + s = self.within_class_std_dev_ + np.median(self.within_class_std_dev_) + mm = m.reshape(len(m), 1) # Reshape to allow broadcasting. + ms = mm * s + self.deviations_ = np.array( + (self.centroids_ - dataset_centroid_) / ms, copy=False + ) + # Soft thresholding: if the deviation crosses 0 during shrinking, + # it becomes zero. if self.shrink_threshold: - if np.all(np.ptp(X, axis=0) == 0): - raise ValueError("All features have zero variance. Division by zero.") - dataset_centroid_ = np.mean(X, axis=0) - - # m parameter for determining deviation - m = np.sqrt((1.0 / nk) - (1.0 / n_samples)) - # Calculate deviation using the standard deviation of centroids. - variance = (X - self.centroids_[y_ind]) ** 2 - variance = variance.sum(axis=0) - s = np.sqrt(variance / (n_samples - n_classes)) - s += np.median(s) # To deter outliers from affecting the results. - mm = m.reshape(len(m), 1) # Reshape to allow broadcasting. - ms = mm * s - deviation = (self.centroids_ - dataset_centroid_) / ms - # Soft thresholding: if the deviation crosses 0 during shrinking, - # it becomes zero. - signs = np.sign(deviation) - deviation = np.abs(deviation) - self.shrink_threshold - np.clip(deviation, 0, None, out=deviation) - deviation = signs + signs = np.sign(self.deviations_) + self.deviations_ = np.abs(self.deviations_) - self.shrink_threshold + np.clip(self.deviations_, 0, None, out=self.deviations_) + self.deviations_ = signs # Now adjust the centroids using the deviation - msd = ms * deviation - self.centroids_ = dataset_centroid_[np.newaxis, :] + msd + msd = ms * self.deviations_ + self.centroids_ = np.array(dataset_centroid_ + msd, copy=False) return self def predict(self, X): @@ -202,16 +273,62 @@ def predict(self, X): Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) - Test samples. + Input data. Returns ------- - C : ndarray of shape (n_samples,) + y_pred : ndarray of shape (n_samples,) The predicted classes. """ check_is_fitted(self) + if np.isclose(self.class_prior_, 1 / len(self.classes_)).all(): + # `validate_data` is called here since we are not calling `super()` + X = validate_data(self, X, accept_sparse="csr", reset=False) + return self.classes_[ + pairwise_distances_argmin(X, self.centroids_, metric=self.metric) + ] + else: + return super().predict(X) + + def _decision_function(self, X): + # return discriminant scores, see eq. (18.2) p. 652 of the ESL. + check_is_fitted(self, "centroids_") + + X_normalized = validate_data( + self, X, copy=True, reset=False, accept_sparse="csr", dtype=np.float64 + ) + + discriminant_score = np.empty( + (X_normalized.shape[0], self.classes_.size), dtype=np.float64 + ) + + mask = self.within_class_std_dev_ != 0 + X_normalized[:, mask] /= self.within_class_std_dev_[mask] + centroids_normalized = self.centroids_.copy() + centroids_normalized[:, mask] /= self.within_class_std_dev_[mask] + + for class_idx in range(self.classes_.size): + distances = pairwise_distances( + X_normalized, centroids_normalized[[class_idx]], metric=self.metric + ).ravel() + distances *= 2 + discriminant_score[:, class_idx] = np.squeeze( + -distances + 2.0 np.log(self.class_prior_[class_idx]) + ) + + return discriminant_score + + def _check_euclidean_metric(self): + return self.metric == "euclidean" + + decision_function = available_if(_check_euclidean_metric)( + DiscriminantAnalysisPredictionMixin.decision_function + ) + + predict_proba = available_if(_check_euclidean_metric)( + DiscriminantAnalysisPredictionMixin.predict_proba + ) - X = validate_data(self, X, accept_sparse="csr", reset=False) - return self.classes_[ - pairwise_distances_argmin(X, self.centroids_, metric=self.metric) - ] + predict_log_proba = available_if(_check_euclidean_metric)( + DiscriminantAnalysisPredictionMixin.predict_log_proba + )	diff --git a/sklearn/neighbors/tests/test_nearest_centroid.py b/sklearn/neighbors/tests/test_nearest_centroid.py index 5ce792ac29d56..1aa9274cd28a8 100644 --- a/sklearn/neighbors/tests/test_nearest_centroid.py +++ b/sklearn/neighbors/tests/test_nearest_centroid.py @@ -4,10 +4,14 @@ import numpy as np import pytest -from numpy.testing import assert_array_equal from sklearn import datasets from sklearn.neighbors import NearestCentroid +from sklearn.utils._testing import ( + assert_allclose, + assert_array_almost_equal, + assert_array_equal, +) from sklearn.utils.fixes import CSR_CONTAINERS # toy sample @@ -15,6 +19,11 @@ y = [-1, -1, -1, 1, 1, 1] T = [[-1, -1], [2, 2], [3, 2]] true_result = [-1, 1, 1] +true_result_prior1 = [-1, 1, 1] + +true_discriminant_scores = [-32, 64, 80] +true_proba = [[1, 1.26642e-14], [1.60381e-28, 1], [1.80485e-35, 1]] + # also load the iris dataset # and randomly permute it @@ -31,9 +40,30 @@ def test_classification_toy(csr_container): X_csr = csr_container(X) T_csr = csr_container(T) + # Check classification on a toy dataset, including sparse versions. clf = NearestCentroid() clf.fit(X, y) assert_array_equal(clf.predict(T), true_result) + assert_array_almost_equal(clf.decision_function(T), true_discriminant_scores) + assert_array_almost_equal(clf.predict_proba(T), true_proba) + + # Test uniform priors + clf = NearestCentroid(priors="uniform") + clf.fit(X, y) + assert_array_equal(clf.predict(T), true_result) + assert_array_almost_equal(clf.decision_function(T), true_discriminant_scores) + assert_array_almost_equal(clf.predict_proba(T), true_proba) + + clf = NearestCentroid(priors="empirical") + clf.fit(X, y) + assert_array_equal(clf.predict(T), true_result) + assert_array_almost_equal(clf.decision_function(T), true_discriminant_scores) + assert_array_almost_equal(clf.predict_proba(T), true_proba) + + # Test custom priors + clf = NearestCentroid(priors=[0.25, 0.75]) + clf.fit(X, y) + assert_array_equal(clf.predict(T), true_result_prior1) # Same test, but with a sparse matrix to fit and test. clf = NearestCentroid() @@ -159,3 +189,49 @@ def test_features_zero_var(): clf = NearestCentroid(shrink_threshold=0.1) with pytest.raises(ValueError): clf.fit(X, y) + + +def test_negative_priors_error(): + """Check that we raise an error when the user-defined priors are negative.""" + clf = NearestCentroid(priors=[-2, 4]) + with pytest.raises(ValueError, match="priors must be non-negative"): + clf.fit(X, y) + + +def test_warn_non_normalized_priors(): + """Check that we raise a warning and normalize the user-defined priors when they + don't sum to 1. + """ + priors = [2, 4] + clf = NearestCentroid(priors=priors) + with pytest.warns( + UserWarning, + match="The priors do not sum to 1. Normalizing such that it sums to one.", + ): + clf.fit(X, y) + + assert_allclose(clf.class_prior_, np.asarray(priors) / np.asarray(priors).sum()) + + +@pytest.mark.parametrize( + "response_method", ["decision_function", "predict_proba", "predict_log_proba"] +) +def test_method_not_available_with_manhattan(response_method): + """Check that we raise an AttributeError with Manhattan metric when trying + to call a non-thresholded response method. + """ + clf = NearestCentroid(metric="manhattan").fit(X, y) + with pytest.raises(AttributeError): + getattr(clf, response_method)(T) + + +@pytest.mark.parametrize("array_constructor", [np.array] + CSR_CONTAINERS) +def test_error_zero_variances(array_constructor): + """Check that we raise an error when the variance for all features is zero.""" + X = np.ones((len(y), 2)) + X[:, 1] *= 2 + X = array_constructor(X) + + clf = NearestCentroid() + with pytest.raises(ValueError, match="All features have zero variance"): + clf.fit(X, y)	diff --git a/doc/whats_new/upcoming_changes/sklearn.neighbors/26689.enhancement.rst b/doc/whats_new/upcoming_changes/sklearn.neighbors/26689.enhancement.rst new file mode 100644 index 0000000000000..ebc50d1bc6aaa --- /dev/null +++ b/doc/whats_new/upcoming_changes/sklearn.neighbors/26689.enhancement.rst @@ -0,0 +1,7 @@ +- Add :meth:`neighbors.NearestCentroid.decision_function`, + :meth:`neighbors.NearestCentroid.predict_proba` and + :meth:`neighbors.NearestCentroid.predict_log_proba` + to the :class:`neighbors.NearestCentroid` estimator class. + Support the case when `X` is sparse and `shrinking_threshold` + is not `None` in :class:`neighbors.NearestCentroid`. + By :user:`Matthew Ning <NoPenguinsLand>`	[ { "components": [ { "doc": "Mixin class for QuadraticDiscriminantAnalysis and NearestCentroid.", "lines": [ 171, 245 ], "name": "DiscriminantAnalysisPredictionMixin", "signature": "class DiscriminantAnalysisPredictionMixin:", "type": "cla...	[ "sklearn/neighbors/tests/test_nearest_centroid.py::test_classification_toy[csr_matrix]", "sklearn/neighbors/tests/test_nearest_centroid.py::test_classification_toy[csr_array]", "sklearn/neighbors/tests/test_nearest_centroid.py::test_negative_priors_error", "sklearn/neighbors/tests/test_nearest_centroid.py::te...	[ "sklearn/neighbors/tests/test_nearest_centroid.py::test_iris", "sklearn/neighbors/tests/test_nearest_centroid.py::test_iris_shrinkage", "sklearn/neighbors/tests/test_nearest_centroid.py::test_pickle", "sklearn/neighbors/tests/test_nearest_centroid.py::test_shrinkage_correct", "sklearn/neighbors/tests/test_n...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> ENH Add decision_function, predict_proba and predict_log_proba for NearestCentroid estimator #### Reference Issues/PRs closes #17711 and #26659 supersede #17711 #### What does this implement/fix? Explain your changes. Add `decision_function`, `predict_proba` and `predict_log_proba` methods for NearestCentroid estimator class for usage with `roc_curve` function. The NearestCentroid class constructor now has an additional parameter called _priors_. By default, _priors_ is set to `None`. When _priors_ is set to `None`, class _priors_ will be estimated using the sample data _X_. Thus, it is not backward compatible with the old version of NearestCentroid. The old and new NearestCentroid estimators will yield different results because the old NearestCentroid estimator assumed equal class _priors_. #### Any other comments? I try to keep the design as consistent as possible with the LinearDiscriminantAnalysis estimator. So, the _priors_ parameter in both classes are the same. Open to feedback and advise. #### References Tibshirani, R., Hastie, T., Narasimhan, B., & Chu, G. (2002). Class Prediction by Nearest Shrunken Centroids, with Applications to DNA Microaarrays. Statistical Science 18(1), p. 104-117. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/discriminant_analysis.py] (definition of DiscriminantAnalysisPredictionMixin:) class DiscriminantAnalysisPredictionMixin: """Mixin class for QuadraticDiscriminantAnalysis and NearestCentroid.""" (definition of DiscriminantAnalysisPredictionMixin.decision_function:) def decision_function(self, X): """Apply decision function to an array of samples. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Array of samples (test vectors). Returns ------- y_scores : ndarray of shape (n_samples,) or (n_samples, n_classes) Decision function values related to each class, per sample. In the two-class case, the shape is `(n_samples,)`, giving the log likelihood ratio of the positive class.""" (definition of DiscriminantAnalysisPredictionMixin.predict:) def predict(self, X): """Perform classification on an array of vectors `X`. Returns the class label for each sample. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Input vectors, where `n_samples` is the number of samples and `n_features` is the number of features. Returns ------- y_pred : ndarray of shape (n_samples,) Class label for each sample.""" (definition of DiscriminantAnalysisPredictionMixin.predict_proba:) def predict_proba(self, X): """Estimate class probabilities. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Input data. Returns ------- y_proba : ndarray of shape (n_samples, n_classes) Probability estimate of the sample for each class in the model, where classes are ordered as they are in `self.classes_`.""" (definition of DiscriminantAnalysisPredictionMixin.predict_log_proba:) def predict_log_proba(self, X): """Estimate log class probabilities. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Input data. Returns ------- y_log_proba : ndarray of shape (n_samples, n_classes) Estimated log probabilities.""" [end of new definitions in sklearn/discriminant_analysis.py] [start of new definitions in sklearn/neighbors/_nearest_centroid.py] (definition of NearestCentroid._decision_function:) def _decision_function(self, X): (definition of NearestCentroid._check_euclidean_metric:) def _check_euclidean_metric(self): [end of new definitions in sklearn/neighbors/_nearest_centroid.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Implement probability estimates for NearestCentroid classifier #### Reference Issues/PRs There are no related issues or PRs. #### What does this implement/fix? Explain your changes. This contribution implements the .predict_proba() method for the NearestCentroid() classifier based on the contribution of _Tibshirani, R., Hastie, T., Narasimhan, B., & Chu, G. (2002). Class Prediction by Nearest Shrunken Centroids, with Applications to DNA Microaarrays. Statistical Science 18(1), p. 104-117._ #### Any other comments? Currently, the estimation of probabilities is optional and has to be enabled at the instantiation of the classifier. However, this is a design decision and any advise is welcome. ---------- @kempa-liehr Are you able to complete this PR. Otherwise, I would close it and open a new issue with the necessary information such that a new contributor can takeover. @adrnjalali. @glemaitre Thanks for catching up. I'll be able to continue working on the PR next week. Sorry, for the delay. @kempa-liehr would you like to finish this or leave it to a new contributor? -------------------- </issues>	18dc8630a7cbe1b591c12774949058b12157a39a
astropy__astropy-14979	14,979	astropy/astropy	5.2	9e3d8361e8b047a13d6279693f169476882e38f9	2023-06-22T19:53:15Z	diff --git a/astropy/cosmology/_io/yaml.py b/astropy/cosmology/_io/yaml.py index abdf8f73749e..71bf1a5bda1e 100644 --- a/astropy/cosmology/_io/yaml.py +++ b/astropy/cosmology/_io/yaml.py @@ -200,9 +200,6 @@ def to_yaml(cosmology, *args): # =================================================================== # Register -for cosmo_cls in _COSMOLOGY_CLASSES.values(): - register_cosmology_yaml(cosmo_cls) - convert_registry.register_reader("yaml", Cosmology, from_yaml) convert_registry.register_writer("yaml", Cosmology, to_yaml) # convert_registry.register_identifier("yaml", Cosmology, yaml_identify) diff --git a/astropy/cosmology/core.py b/astropy/cosmology/core.py index 3036dc40d2ea..98f635b80e3c 100644 --- a/astropy/cosmology/core.py +++ b/astropy/cosmology/core.py @@ -70,12 +70,16 @@ class Cosmology(metaclass=abc.ABCMeta): Notes ----- - Class instances are static -- you cannot (and should not) change the values - of the parameters. That is, all of the above attributes (except meta) are - read only. + Class instances are static -- you cannot (and should not) change the + values of the parameters. That is, all of the above attributes + (except meta) are read only. For details on how to create performant custom subclasses, see the documentation on :ref:`astropy-cosmology-fast-integrals`. + + Cosmology subclasses are automatically registered in a global registry + and with various I/O methods. To turn off or change this registration, + override the ``_register_cls`` classmethod in the subclass. """ meta = MetaData() @@ -125,8 +129,9 @@ def __init_subclass__(cls): cls.__all_parameters__ = cls.__parameters__ + tuple(derived_parameters) # ------------------- - # register as a Cosmology subclass - _COSMOLOGY_CLASSES[cls.__qualname__] = cls + # Registration + + cls._register_cls() @classproperty(lazy=True) def _init_signature(cls): @@ -136,6 +141,16 @@ def _init_signature(cls): sig = sig.replace(parameters=list(sig.parameters.values())[1:]) return sig + @classmethod + def _register_cls(cls): + # register class + _COSMOLOGY_CLASSES[cls.__qualname__] = cls + + # register to YAML + from astropy.cosmology._io.yaml import register_cosmology_yaml + + register_cosmology_yaml(cls) + # --------------------------------------------------------------- def __init__(self, name=None, meta=None):	diff --git a/astropy/cosmology/tests/test_core.py b/astropy/cosmology/tests/test_core.py index ba4c6ad19c8b..bd484a942248 100644 --- a/astropy/cosmology/tests/test_core.py +++ b/astropy/cosmology/tests/test_core.py @@ -141,6 +141,9 @@ def cosmo(self, cosmo_cls): def test_init_subclass(self, cosmo_cls): """Test creating subclasses registers classes and manages Parameters.""" + # ----------------------------------------------------------- + # Normal subclass creation + class InitSubclassTest(cosmo_cls): pass @@ -151,6 +154,18 @@ class InitSubclassTest(cosmo_cls): registrant = _COSMOLOGY_CLASSES.pop(InitSubclassTest.__qualname__) assert registrant is InitSubclassTest + # ----------------------------------------------------------- + # Skip + + class UnRegisteredSubclassTest(cosmo_cls): + @classmethod + def _register_cls(cls): + """Override to not register.""" + pass + + assert UnRegisteredSubclassTest.__parameters__ == cosmo_cls.__parameters__ + assert UnRegisteredSubclassTest.__qualname__ not in _COSMOLOGY_CLASSES + def test_init_signature(self, cosmo_cls, cosmo): """Test class-property ``_init_signature``.""" # test presence		[ { "components": [ { "doc": "", "lines": [ 145, 152 ], "name": "Cosmology._register_cls", "signature": "def _register_cls(cls):", "type": "function" } ], "file": "astropy/cosmology/core.py" } ]	[ "astropy/cosmology/tests/test_core.py::TestCosmology::test_to_yaml", "astropy/cosmology/tests/test_core.py::TestCosmology::test_from_yaml_default", "astropy/cosmology/tests/test_core.py::TestCosmology::test_from_yaml_autoidentify", "astropy/cosmology/tests/test_core.py::TestCosmology::test_is_equivalent_to_ya...	[ "astropy/cosmology/tests/test_core.py::TestCosmology::test_to_table_bad_index", "astropy/cosmology/tests/test_core.py::TestCosmology::test_to_table_failed_cls", "astropy/cosmology/tests/test_core.py::TestCosmology::test_to_table_cls[QTable]", "astropy/cosmology/tests/test_core.py::TestCosmology::test_to_table...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Register YAML on class creation Auto-registration of Cosmology classes with YAML. Optionally turn off the registration for e.g. temporary classes. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in astropy/cosmology/core.py] (definition of Cosmology._register_cls:) def _register_cls(cls): [end of new definitions in astropy/cosmology/core.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		32bd0ffb6898c6a57b9ec1a55c13c7a0efe8d273
softlayer__softlayer-python-1999	1,999	softlayer/softlayer-python	null	36d7c19ae40ca3bec8d7c07454a60ee3d8cd9a9e	2023-06-21T13:56:06Z	diff --git a/SoftLayer/CLI/loadbal/protocol_add.py b/SoftLayer/CLI/loadbal/protocol_add.py new file mode 100644 index 000000000..dd5a4f60f --- /dev/null +++ b/SoftLayer/CLI/loadbal/protocol_add.py @@ -0,0 +1,66 @@ +"""Add a new load balancer protocol.""" +import click + +import SoftLayer +from SoftLayer.CLI import environment +from SoftLayer.CLI import exceptions +from SoftLayer.CLI import formatting + + +# pylint: disable=unused-argument +def parse_proto(ctx, param, value): + """Parses the frontend and backend cli options""" + proto = {'protocol': 'HTTP', 'port': 80} + splitout = value.split(':') + if len(splitout) != 2: + raise exceptions.ArgumentError("{}={} is not properly formatted.".format(param, value)) + proto['protocol'] = splitout[0] + proto['port'] = int(splitout[1]) + return proto + + +@click.command(cls=SoftLayer.CLI.command.SLCommand, ) +@click.argument('identifier') +@click.option('--frontend', '-f', required=True, default='HTTP:80', show_default=True, callback=parse_proto, + help='PROTOCOL:PORT string for incoming internet connections.') +@click.option('--backend', '-b', required=True, default='HTTP:80', show_default=True, callback=parse_proto, + help='PROTOCOL:PORT string for connecting to backend servers.') +@click.option('--method', '-m', help="Balancing Method.", default='ROUNDROBIN', show_default=True, + type=click.Choice(['ROUNDROBIN', 'LEASTCONNECTION', 'WEIGHTED_RR'])) +@click.option('--session', '-s', required=True, + help="Session stickiness type. Valid values are SOURCE_IP or HTTP_COOKIE ") +@click.option('--max', help="Max Connections setting", type=int) +@environment.pass_env +def cli(env, identifier, args): + """Add a new load balancer protocol.""" + + mgr = SoftLayer.LoadBalancerManager(env.client) + + uuid = mgr.get_lb_uuid(identifier) + + backend = args.get('backend') + frontend = args.get('frontend') + protocols = [ + { + "backendPort": backend.get('port'), + "backendProtocol": backend.get('protocol'), + "frontendPort": frontend.get('port'), + "frontendProtocol": frontend.get('protocol'), + "loadBalancingMethod": args.get('method'), + "sessionType": args.get('session'), + "maxConn": args.get('max') + } + ] + + protocol = mgr.add_protocols(uuid, protocols) + + table = formatting.KeyValueTable(['name', 'value']) + table.align['name'] = 'r' + table.align['value'] = 'l' + table.add_row(['Id', protocol.get('id')]) + table.add_row(['UUI', protocol.get('uuid')]) + table.add_row(['Address', protocol.get('address')]) + table.add_row(['Type', mgr.get_lb_type(protocol.get('type'))]) + table.add_row(['Description', protocol.get('description')]) + + env.fout(table) diff --git a/SoftLayer/CLI/loadbal/protocol_delete.py b/SoftLayer/CLI/loadbal/protocol_delete.py new file mode 100644 index 000000000..105b585bf --- /dev/null +++ b/SoftLayer/CLI/loadbal/protocol_delete.py @@ -0,0 +1,31 @@ +"""Delete load balancer protocol.""" +import click + +import SoftLayer +from SoftLayer.CLI import environment +from SoftLayer.CLI import formatting + + +@click.command(cls=SoftLayer.CLI.command.SLCommand, ) +@click.argument('identifier') +@click.option('--uuid', help="Load Balancer Uuid.") +@environment.pass_env +def cli(env, identifier, uuid): + """delete a load balancer protocol.""" + + mgr = SoftLayer.LoadBalancerManager(env.client) + + uuid_lb = mgr.get_lb(identifier)['uuid'] + + protocol = mgr.delete_protocol(uuid_lb, uuid) + + table = formatting.KeyValueTable(['name', 'value']) + table.align['name'] = 'r' + table.align['value'] = 'l' + table.add_row(['Id', protocol.get('id')]) + table.add_row(['UUI', protocol.get('uuid')]) + table.add_row(['Address', protocol.get('address')]) + table.add_row(['Type', SoftLayer.LoadBalancerManager.TYPE.get(protocol.get('type'))]) + table.add_row(['Description', protocol.get('description')]) + + env.fout(table) diff --git a/SoftLayer/CLI/loadbal/protocol_edit.py b/SoftLayer/CLI/loadbal/protocol_edit.py new file mode 100644 index 000000000..d0f1a685b --- /dev/null +++ b/SoftLayer/CLI/loadbal/protocol_edit.py @@ -0,0 +1,67 @@ +"""Add a new load balancer protocol.""" +import click + +import SoftLayer +from SoftLayer.CLI import environment +from SoftLayer.CLI import exceptions +from SoftLayer.CLI import formatting + + +# pylint: disable=unused-argument +def parse_proto(ctx, param, value): + """Parses the frontend and backend cli options""" + proto = {'protocol': 'HTTP', 'port': 80} + splitout = value.split(':') + if len(splitout) != 2: + raise exceptions.ArgumentError("{}={} is not properly formatted.".format(param, value)) + proto['protocol'] = splitout[0] + proto['port'] = int(splitout[1]) + return proto + + +@click.command(cls=SoftLayer.CLI.command.SLCommand, ) +@click.argument('identifier') +@click.option('--uuid', help="Load Balancer Uuid.") +@click.option('--frontend', '-f', required=True, default='HTTP:80', show_default=True, callback=parse_proto, + help='PROTOCOL:PORT string for incoming internet connections.') +@click.option('--backend', '-b', required=True, default='HTTP:80', show_default=True, callback=parse_proto, + help='PROTOCOL:PORT string for connecting to backend servers.') +@click.option('--method', '-m', help="Balancing Method.", default='ROUNDROBIN', show_default=True, + type=click.Choice(['ROUNDROBIN', 'LEASTCONNECTION', 'WEIGHTED_RR'])) +@click.option('--session', '-s', required=True, + help="Session stickiness type. Valid values are SOURCE_IP or HTTP_COOKIE ") +@click.option('--max', help="Max Connections setting", type=int) +@environment.pass_env +def cli(env, identifier, args): + """Edit a load balancer protocol.""" + + mgr = SoftLayer.LoadBalancerManager(env.client) + + uuid = mgr.get_lb_uuid(identifier) + + backend = args.get('backend') + frontend = args.get('frontend') + protocol_configurations = [ + { + "backendPort": backend.get('port'), + "backendProtocol": backend.get('protocol'), + "frontendPort": frontend.get('port'), + "frontendProtocol": frontend.get('protocol'), + "loadBalancingMethod": args.get('method'), + "sessionType": args.get('session'), + "maxConn": args.get('max') + } + ] + protocol_configurations[0]['listenerUuid'] = args.get('uuid') + protocol = mgr.add_protocols(uuid, protocol_configurations) + + table = formatting.KeyValueTable(['name', 'value']) + table.align['name'] = 'r' + table.align['value'] = 'l' + table.add_row(['Id', protocol.get('id')]) + table.add_row(['UUI', protocol.get('uuid')]) + table.add_row(['Address', protocol.get('address')]) + table.add_row(['Type', mgr.get_lb_type(protocol.get('type'))]) + table.add_row(['Description', protocol.get('description')]) + + env.fout(table) diff --git a/SoftLayer/CLI/routes.py b/SoftLayer/CLI/routes.py index e0558b626..15d1e98ce 100644 --- a/SoftLayer/CLI/routes.py +++ b/SoftLayer/CLI/routes.py @@ -244,6 +244,9 @@ ('loadbal:order', 'SoftLayer.CLI.loadbal.order:order'), ('loadbal:order-options', 'SoftLayer.CLI.loadbal.order:order_options'), ('loadbal:cancel', 'SoftLayer.CLI.loadbal.order:cancel'), + ('loadbal:protocol-add', 'SoftLayer.CLI.loadbal.protocol_add:cli'), + ('loadbal:protocol-edit', 'SoftLayer.CLI.loadbal.protocol_edit:cli'), + ('loadbal:protocol-delete', 'SoftLayer.CLI.loadbal.protocol_delete:cli'), ('loadbal:ns-detail', 'SoftLayer.CLI.loadbal.ns_detail:cli'), ('loadbal:ns-list', 'SoftLayer.CLI.loadbal.ns_list:cli'), diff --git a/SoftLayer/managers/load_balancer.py b/SoftLayer/managers/load_balancer.py index ecd48dd59..2e7fc75a1 100644 --- a/SoftLayer/managers/load_balancer.py +++ b/SoftLayer/managers/load_balancer.py @@ -5,6 +5,7 @@ :license: MIT, see LICENSE for more details. """ +import SoftLayer from SoftLayer import exceptions from SoftLayer.managers import ordering from SoftLayer import utils @@ -70,7 +71,7 @@ def get_lb(self, identifier, mask=None): :returns: SoftLayer_Network_LBaaS_LoadBalancer """ if mask is None: - mask = "mask[healthMonitors, l7Pools, members, sslCiphers, " \ + mask = "mask[healthMonitors, l7Pools, uuid, members, sslCiphers, " \ "listeners[defaultPool[healthMonitor, members, sessionAffinity],l7Policies]]" this_lb = self.lbaas.getObject(id=identifier, mask=mask) @@ -275,3 +276,38 @@ def cancel_lbaas(self, uuid): """ return self.lbaas.cancelLoadBalancer(uuid) + + def add_protocols(self, uuid, protocols): + """This sample shows how to add protocols to the LBaaS. + + https://softlayer.github.io/reference/services/SoftLayer_Network_LBaaS_Listener/updateLoadBalancerProtocols/ + :param uuid string: UUID of the LBaaS instance to add a new protocol + :param protocols SoftLayer_Network_LBaaS_LoadBalancerProtocolConfiguration[]: protocol configurations + """ + return self.client.call('SoftLayer_Network_LBaaS_Listener', 'updateLoadBalancerProtocols', + uuid, protocols) + + def delete_protocol(self, uuid_lb, uuid): + """This sample shows how to delete protocols to the LBaaS. + + https://softlayer.github.io/reference/services/SoftLayer_Network_LBaaS_Listener/updateLoadBalancerProtocols/ + :param uuid string: UUID of the LBaaS instance to add a new protocol + :param protocols SoftLayer_Network_LBaaS_LoadBalancerProtocolConfiguration[]: protocol configurations + """ + return self.client.call('SoftLayer_Network_LBaaS_Listener', 'deleteLoadBalancerProtocols', + uuid_lb, [uuid]) + + def get_lb_uuid(self, identifier): + """this sample show the uuid from loadbalancer. + + :param identifier int: loadbalancer identifier. + """ + load_balancer = self.lbaas.getObject(id=identifier, mask="mask[id,uuid]") + return load_balancer.get('uuid') + + def get_lb_type(self, lb_type): + """return the loadbalancer type. + + :param lb_type: load balancer type + """ + return SoftLayer.LoadBalancerManager.TYPE.get(lb_type) diff --git a/docs/cli/loadbal.rst b/docs/cli/loadbal.rst index e019e2aa0..3ba20f9ee 100644 --- a/docs/cli/loadbal.rst +++ b/docs/cli/loadbal.rst @@ -52,6 +52,15 @@ LBaaS Commands .. click:: SoftLayer.CLI.loadbal.order:cancel :prog: loadbal cancel :show-nested: +.. click:: SoftLayer.CLI.loadbal.protocol_add:cli + :prog: loadbal protocol-add + :show-nested: +.. click:: SoftLayer.CLI.loadbal.protocol_edit:cli + :prog: loadbal protocol-edit + :show-nested: +.. click:: SoftLayer.CLI.loadbal.protocol_delete:cli + :prog: loadbal protocol-delete + :show-nested: NetScaler Commands	diff --git a/tests/CLI/modules/loadbal_tests.py b/tests/CLI/modules/loadbal_tests.py index cbba6266c..dabfa8891 100644 --- a/tests/CLI/modules/loadbal_tests.py +++ b/tests/CLI/modules/loadbal_tests.py @@ -315,3 +315,23 @@ def test_ns_detail(self): result = self.run_command(['loadbal', 'ns-detail', '11111']) self.assert_no_fail(result) + + def test_lb_protocol_add(self): + result = self.run_command(['lb', 'protocol-add', '1111111', '--backend', 'HTTP:216', + '--frontend', 'HTTP:217', '--method', 'ROUNDROBIN', '-s', 'SOURCE_IP', + '--max', '190']) + self.assert_no_fail(result) + + def test_lb_protocol_edit(self): + result = self.run_command(['lb', 'protocol-edit', '1111111', + '--uuid', '4d088a44-8c42-4f24-a437-9461ff4c9851', '--backend', 'HTTP:216', + '--frontend', 'HTTP:217', '--method', 'ROUNDROBIN', '-s', 'SOURCE_IP', + '--max', '190']) + + self.assert_no_fail(result) + + def test_lb_protocol_delete(self): + result = self.run_command(['lb', 'protocol-delete', '1111111', + '--uuid', '4d088a44-8c42-4f24-a437-9461ff4c9851']) + + self.assert_no_fail(result) diff --git a/tests/managers/loadbal_tests.py b/tests/managers/loadbal_tests.py index fd231be78..4dfbe1d29 100644 --- a/tests/managers/loadbal_tests.py +++ b/tests/managers/loadbal_tests.py @@ -9,6 +9,7 @@ """ import SoftLayer from SoftLayer import exceptions +from SoftLayer import fixtures from SoftLayer.fixtures import SoftLayer_Network_LBaaS_LoadBalancer from SoftLayer import testing @@ -209,3 +210,26 @@ def test_get_lbaas_by_name_fails(self): load_bal_mock.return_value = [] name = 'test' self.assertRaises(exceptions.SoftLayerError, self.lb_mgr.get_lbaas_by_name, name) + + def test_lbaas_update_protocol(self): + uuid = '1a1aa111-4474-4e16-9f02-4de959229b85' + protocol_configurations = [ + { + "backendPort": 52, + "backendProtocol": 'HTTP', + "frontendPort": 216, + "frontendProtocol": 'HTTP', + "loadBalancingMethod": 'ROUNDROBIN', + "sessionType": 'SOURCE_IP', + "maxConn": 50 + } + ] + result = self.lb_mgr.add_protocols(uuid, protocol_configurations) + self.assertEqual(fixtures.SoftLayer_Network_LBaaS_Listener.updateLoadBalancerProtocols, result) + + def test_lbaas_delete_protocol(self): + uuid = '1a1aa111-4474-4e16-9f02-4de959229b85' + uuid_delete = 'abba-aabb-cc' + + result = self.lb_mgr.delete_protocol(uuid, uuid_delete) + self.assertEqual(fixtures.SoftLayer_Network_LBaaS_Listener.deleteLoadBalancerProtocols, result)	diff --git a/docs/cli/loadbal.rst b/docs/cli/loadbal.rst index e019e2aa0..3ba20f9ee 100644 --- a/docs/cli/loadbal.rst +++ b/docs/cli/loadbal.rst @@ -52,6 +52,15 @@ LBaaS Commands .. click:: SoftLayer.CLI.loadbal.order:cancel :prog: loadbal cancel :show-nested: +.. click:: SoftLayer.CLI.loadbal.protocol_add:cli + :prog: loadbal protocol-add + :show-nested: +.. click:: SoftLayer.CLI.loadbal.protocol_edit:cli + :prog: loadbal protocol-edit + :show-nested: +.. click:: SoftLayer.CLI.loadbal.protocol_delete:cli + :prog: loadbal protocol-delete + :show-nested: NetScaler Commands	[ { "components": [ { "doc": "Parses the frontend and backend cli options", "lines": [ 11, 19 ], "name": "parse_proto", "signature": "def parse_proto(ctx, param, value):", "type": "function" }, { "doc": "Add a new load b...	[ "tests/CLI/modules/loadbal_tests.py::LoadBalancerTests::test_lb_protocol_add", "tests/CLI/modules/loadbal_tests.py::LoadBalancerTests::test_lb_protocol_delete", "tests/CLI/modules/loadbal_tests.py::LoadBalancerTests::test_lb_protocol_edit", "tests/managers/loadbal_tests.py::LoadBalancerTests::test_lbaas_delet...	[ "tests/CLI/modules/loadbal_tests.py::LoadBalancerTests::test_add_7p", "tests/CLI/modules/loadbal_tests.py::LoadBalancerTests::test_add_7p_fail", "tests/CLI/modules/loadbal_tests.py::LoadBalancerTests::test_add_7p_server", "tests/CLI/modules/loadbal_tests.py::LoadBalancerTests::test_add_7p_server_fail", "tes...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> LB protocol features [#issue1986](https://github.com/softlayer/softlayer-python/issues/1986) protocol-add ![image](https://github.com/softlayer/softlayer-python/assets/22535437/55115e08-c377-44e7-bf07-4dc14847ab50) protocol-edit ![image](https://github.com/softlayer/softlayer-python/assets/22535437/7690f563-a0e3-40b6-b2cb-d386e61be07d) protocol-delete ![image](https://github.com/softlayer/softlayer-python/assets/22535437/5e9d601a-b010-4a06-a344-5a48b8ff3f64) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in SoftLayer/CLI/loadbal/protocol_add.py] (definition of parse_proto:) def parse_proto(ctx, param, value): """Parses the frontend and backend cli options""" (definition of cli:) def cli(env, identifier, args): """Add a new load balancer protocol.""" [end of new definitions in SoftLayer/CLI/loadbal/protocol_add.py] [start of new definitions in SoftLayer/CLI/loadbal/protocol_delete.py] (definition of cli:) def cli(env, identifier, uuid): """delete a load balancer protocol.""" [end of new definitions in SoftLayer/CLI/loadbal/protocol_delete.py] [start of new definitions in SoftLayer/CLI/loadbal/protocol_edit.py] (definition of parse_proto:) def parse_proto(ctx, param, value): """Parses the frontend and backend cli options""" (definition of cli:) def cli(env, identifier, args): """Edit a load balancer protocol.""" [end of new definitions in SoftLayer/CLI/loadbal/protocol_edit.py] [start of new definitions in SoftLayer/managers/load_balancer.py] (definition of LoadBalancerManager.add_protocols:) def add_protocols(self, uuid, protocols): """This sample shows how to add protocols to the LBaaS. https://softlayer.github.io/reference/services/SoftLayer_Network_LBaaS_Listener/updateLoadBalancerProtocols/ :param uuid string: UUID of the LBaaS instance to add a new protocol :param protocols SoftLayer_Network_LBaaS_LoadBalancerProtocolConfiguration[]: protocol configurations""" (definition of LoadBalancerManager.delete_protocol:) def delete_protocol(self, uuid_lb, uuid): """This sample shows how to delete protocols to the LBaaS. https://softlayer.github.io/reference/services/SoftLayer_Network_LBaaS_Listener/updateLoadBalancerProtocols/ :param uuid string: UUID of the LBaaS instance to add a new protocol :param protocols SoftLayer_Network_LBaaS_LoadBalancerProtocolConfiguration[]: protocol configurations""" (definition of LoadBalancerManager.get_lb_uuid:) def get_lb_uuid(self, identifier): """this sample show the uuid from loadbalancer. :param identifier int: loadbalancer identifier.""" (definition of LoadBalancerManager.get_lb_type:) def get_lb_type(self, lb_type): """return the loadbalancer type. :param lb_type: load balancer type""" [end of new definitions in SoftLayer/managers/load_balancer.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		bd1ecce1ec4313b9ceefd3cfea52d1b9274fef9d

conan-io__conan-15415

15,415

conan-io/conan

null

4f0533c8075ad86f116a6e2c71ab1df69373378a

2024-01-08T16:20:33Z

diff --git a/conans/model/settings.py b/conans/model/settings.py index 189bb71185d..d55e0f37452 100644 --- a/conans/model/settings.py +++ b/conans/model/settings.py @@ -106,6 +106,11 @@ def _get_child(self, item): raise undefined_field(self._name, item, None, self._value) if self._value is None: raise ConanException("'%s' value not defined" % self._name) + return self._get_definition() + + def _get_definition(self): + if self._value not in self._definition and "ANY" in self._definition: + return self._definition["ANY"] return self._definition[self._value] def __getattr__(self, item): @@ -142,7 +147,7 @@ def values_list(self): partial_name = ".".join(self._name.split(".")[1:]) result.append((partial_name, self._value)) if isinstance(self._definition, dict): - sub_config_dict = self._definition[self._value] + sub_config_dict = self._get_definition() result.extend(sub_config_dict.values_list) return result @@ -150,7 +155,7 @@ def validate(self): if self._value is None and None not in self._definition: raise ConanException("'%s' value not defined" % self._name) if isinstance(self._definition, dict): - self._definition[self._value].validate() + self._get_definition().validate() def possible_values(self): if isinstance(self._definition, list):

diff --git a/conans/test/unittests/model/settings_test.py b/conans/test/unittests/model/settings_test.py index b80904ff3f6..94d4a44673c 100644 --- a/conans/test/unittests/model/settings_test.py +++ b/conans/test/unittests/model/settings_test.py @@ -1,3 +1,4 @@ +import textwrap import unittest import pytest @@ -48,6 +49,32 @@ def test_none_any(self): self.assertTrue(settings.os == "Windows") self.assertEqual("os=Windows", settings.dumps()) + def test_nested_any(self): + yml = textwrap.dedent("""\ + os: + ANY: + version: [null, ANY] + Ubuntu: + version: ["18.04", "20.04"] + """) + settings = Settings.loads(yml) + settings.os = "Windows" + settings.validate() + self.assertTrue(settings.os == "Windows") + self.assertIn("os=Windows", settings.dumps()) + settings.os.version = 2 + self.assertTrue(settings.os == "Windows") + self.assertEqual("os=Windows\nos.version=2", settings.dumps()) + settings.os = "Ubuntu" + with self.assertRaisesRegex(ConanException, "'settings.os.version' value not defined"): + settings.validate() + with self.assertRaisesRegex(ConanException, + "Invalid setting '3' is not a valid 'settings.os.version'"): + settings.os.version = 3 + settings.os.version = "20.04" + self.assertEqual("os=Ubuntu\nos.version=20.04", settings.dumps()) + self.assertTrue(settings.os.version == "20.04") + def test_getattr_none(self): yml = "os: [None, Windows]" settings = Settings.loads(yml)

[ { "components": [ { "doc": "", "lines": [ 111, 114 ], "name": "SettingsItem._get_definition", "signature": "def _get_definition(self):", "type": "function" } ], "file": "conans/model/settings.py" } ]

[ "conans/test/unittests/model/settings_test.py::SettingsLoadsTest::test_nested_any" ]

[ "conans/test/unittests/model/settings_test.py::SettingsLoadsTest::test_any", "conans/test/unittests/model/settings_test.py::SettingsLoadsTest::test_get_safe", "conans/test/unittests/model/settings_test.py::SettingsLoadsTest::test_getattr_none", "conans/test/unittests/model/settings_test.py::SettingsLoadsTest:...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> explore nested ANY settings.yml Changelog: Feature: Allow nested "ANY" definitions in ``settings.yml``. Docs: https://github.com/conan-io/docs/pull/3546 Close https://github.com/conan-io/conan/issues/15414 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conans/model/settings.py] (definition of SettingsItem._get_definition:) def _get_definition(self): [end of new definitions in conans/model/settings.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

4a5b19a75db9225316c8cb022a2dfb9705a2af34

pyro-ppl__pyro-3311

3,311

pyro-ppl/pyro

null

5d920aabaaf80b7bb86e53f5a0dc11251bbdffa5

2024-01-04T17:04:23Z

diff --git a/docs/source/pyro.infer.mcmc.txt b/docs/source/pyro.infer.mcmc.txt index 0f51191474..0684a97b99 100644 --- a/docs/source/pyro.infer.mcmc.txt +++ b/docs/source/pyro.infer.mcmc.txt @@ -37,6 +37,14 @@ NUTS :undoc-members: :show-inheritance: +RandomWalkKernel +---------------- + +.. autoclass:: pyro.infer.mcmc.RandomWalkKernel + :members: + :undoc-members: + :show-inheritance: + BlockMassMatrix --------------- diff --git a/pyro/infer/__init__.py b/pyro/infer/__init__.py index 5485b7476e..c0f3a26c3f 100644 --- a/pyro/infer/__init__.py +++ b/pyro/infer/__init__.py @@ -11,6 +11,7 @@ from pyro.infer.mcmc.api import MCMC from pyro.infer.mcmc.hmc import HMC from pyro.infer.mcmc.nuts import NUTS +from pyro.infer.mcmc.rwkernel import RandomWalkKernel from pyro.infer.predictive import Predictive from pyro.infer.renyi_elbo import RenyiELBO from pyro.infer.rws import ReweightedWakeSleep @@ -45,6 +46,7 @@ "MCMC", "NUTS", "Predictive", + "RandomWalkKernel", "RBFSteinKernel", "RenyiELBO", "ReweightedWakeSleep", diff --git a/pyro/infer/mcmc/__init__.py b/pyro/infer/mcmc/__init__.py index 7be4bae99c..749af47b1a 100644 --- a/pyro/infer/mcmc/__init__.py +++ b/pyro/infer/mcmc/__init__.py @@ -5,6 +5,7 @@ from pyro.infer.mcmc.api import MCMC, StreamingMCMC from pyro.infer.mcmc.hmc import HMC from pyro.infer.mcmc.nuts import NUTS +from pyro.infer.mcmc.rwkernel import RandomWalkKernel __all__ = [ "ArrowheadMassMatrix", @@ -12,5 +13,6 @@ "HMC", "MCMC", "NUTS", + "RandomWalkKernel", "StreamingMCMC", ] diff --git a/pyro/infer/mcmc/rwkernel.py b/pyro/infer/mcmc/rwkernel.py new file mode 100644 index 0000000000..4c3da325df --- /dev/null +++ b/pyro/infer/mcmc/rwkernel.py @@ -0,0 +1,143 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +import math +from collections import OrderedDict + +import torch + +import pyro +import pyro.distributions as dist +from pyro.infer.mcmc.mcmc_kernel import MCMCKernel +from pyro.infer.mcmc.util import initialize_model + + +class RandomWalkKernel(MCMCKernel): + r""" + Simple gradient-free kernel that utilizes an isotropic gaussian random walk in the unconstrained + latent space of the model. The step size that controls the variance of the kernel is adapted during + warm-up with a simple adaptation scheme that targets a user-provided acceptance probability. + + :param model: Python callable containing Pyro primitives. + :param float init_step_size: A positive float that controls the initial step size. Defaults to 0.1. + :param float target_accept_prob: The target acceptance probability used during adaptation of + the step size. Defaults to 0.234. + + Example: + + >>> true_coefs = torch.tensor([1., 2., 3.]) + >>> data = torch.randn(2000, 3) + >>> dim = 3 + >>> labels = dist.Bernoulli(logits=(true_coefs * data).sum(-1)).sample() + >>> + >>> def model(data): + ... coefs_mean = torch.zeros(dim) + ... coefs = pyro.sample('beta', dist.Normal(coefs_mean, torch.ones(3))) + ... y = pyro.sample('y', dist.Bernoulli(logits=(coefs * data).sum(-1)), obs=labels) + ... return y + >>> + >>> hmc_kernel = RandomWalkKernel(model, init_step_size=0.2) + >>> mcmc = MCMC(hmc_kernel, num_samples=200, warmup_steps=100) + >>> mcmc.run(data) + >>> mcmc.get_samples()['beta'].mean(0) # doctest: +SKIP + tensor([ 0.9819, 1.9258, 2.9737]) + """ + + def __init__( + self, model, init_step_size: float = 0.1, target_accept_prob: float = 0.234 + ): + if not isinstance(init_step_size, float) or init_step_size <= 0.0: + raise ValueError("init_step_size must be a positive float.") + + if ( + not isinstance(target_accept_prob, float) + or target_accept_prob <= 0.0 + or target_accept_prob >= 1.0 + ): + raise ValueError( + "target_accept_prob must be a float in the interval (0, 1)." + ) + + self.model = model + self.init_step_size = init_step_size + self.target_accept_prob = target_accept_prob + + self._t = 0 + self._log_step_size = math.log(init_step_size) + self._accept_cnt = 0 + self._mean_accept_prob = 0.0 + super().__init__() + + def setup(self, warmup_steps, *args, **kwargs): + self._warmup_steps = warmup_steps + ( + self._initial_params, + self.potential_fn, + self.transforms, + self._prototype_trace, + ) = initialize_model( + self.model, + model_args=args, + model_kwargs=kwargs, + ) + self._energy_last = self.potential_fn(self._initial_params) + + def sample(self, params): + step_size = math.exp(self._log_step_size) + new_params = { + k: v + step_size * torch.randn(v.shape, dtype=v.dtype, device=v.device) + for k, v in params.items() + } + energy_proposal = self.potential_fn(new_params) + delta_energy = energy_proposal - self._energy_last + + accept_prob = (-delta_energy).exp().clamp(max=1.0).item() + rand = pyro.sample( + "rand_t={}".format(self._t), + dist.Uniform(0.0, 1.0), + ) + accepted = False + if rand < accept_prob: + accepted = True + params = new_params + self._energy_last = energy_proposal + + if self._t <= self._warmup_steps: + adaptation_speed = max(0.001, 0.1 / math.sqrt(1 + self._t)) + self._log_step_size += adaptation_speed * ( + accept_prob - self.target_accept_prob + ) + + self._t += 1 + + if self._t > self._warmup_steps: + n = self._t - self._warmup_steps + if accepted: + self._accept_cnt += 1 + else: + n = self._t + + self._mean_accept_prob += (accept_prob - self._mean_accept_prob) / n + + return params.copy() + + @property + def initial_params(self): + return self._initial_params + + @initial_params.setter + def initial_params(self, params): + self._initial_params = params + + def logging(self): + return OrderedDict( + [ + ("step size", "{:.2e}".format(math.exp(self._log_step_size))), + ("acc. prob", "{:.3f}".format(self._mean_accept_prob)), + ] + ) + + def diagnostics(self): + return { + "acceptance rate": self._accept_cnt / (self._t - self._warmup_steps), + }

diff --git a/tests/infer/mcmc/test_rwkernel.py b/tests/infer/mcmc/test_rwkernel.py new file mode 100644 index 0000000000..08490703e6 --- /dev/null +++ b/tests/infer/mcmc/test_rwkernel.py @@ -0,0 +1,40 @@ +# Copyright (c) 2017-2019 Uber Technologies, Inc. +# SPDX-License-Identifier: Apache-2.0 + +import torch + +import pyro +import pyro.distributions as dist +from pyro.infer.mcmc.api import MCMC +from pyro.infer.mcmc.rwkernel import RandomWalkKernel +from tests.common import assert_equal + + +def test_beta_bernoulli(): + alpha = torch.tensor([1.1, 2.2]) + beta = torch.tensor([1.1, 2.2]) + + def model(data): + p_latent = pyro.sample("p_latent", dist.Beta(alpha, beta)) + with pyro.plate("data", data.shape[0], dim=-2): + pyro.sample("obs", dist.Bernoulli(p_latent), obs=data) + + num_data = 5 + true_probs = torch.tensor([0.9, 0.1]) + data = dist.Bernoulli(true_probs).sample(sample_shape=(torch.Size((num_data,)))) + + kernel = RandomWalkKernel(model) + mcmc = MCMC(kernel, num_samples=2000, warmup_steps=500) + mcmc.run(data) + samples = mcmc.get_samples() + + data_sum = data.sum(0) + alpha_post = alpha + data_sum + beta_post = beta + num_data - data_sum + expected_mean = alpha_post / (alpha_post + beta_post) + expected_var = ( + expected_mean.pow(2) * beta_post / (alpha_post * (1 + alpha_post + beta_post)) + ) + + assert_equal(samples["p_latent"].mean(0), expected_mean, prec=0.03) + assert_equal(samples["p_latent"].var(0), expected_var, prec=0.005)

diff --git a/docs/source/pyro.infer.mcmc.txt b/docs/source/pyro.infer.mcmc.txt index 0f51191474..0684a97b99 100644 --- a/docs/source/pyro.infer.mcmc.txt +++ b/docs/source/pyro.infer.mcmc.txt @@ -37,6 +37,14 @@ NUTS :undoc-members: :show-inheritance: +RandomWalkKernel +---------------- + +.. autoclass:: pyro.infer.mcmc.RandomWalkKernel + :members: + :undoc-members: + :show-inheritance: + BlockMassMatrix ---------------

[ { "components": [ { "doc": "Simple gradient-free kernel that utilizes an isotropic gaussian random walk in the unconstrained\nlatent space of the model. The step size that controls the variance of the kernel is adapted during\nwarm-up with a simple adaptation scheme that targets a user-provided ac...

[ "tests/infer/mcmc/test_rwkernel.py::test_beta_bernoulli" ]

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add simple RandomWalkKernel Add a simple gradient-free kernel to complements HMC/NUTS. - isotropic gaussian proposal - simple adaptation scheme to adapt step size ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pyro/infer/mcmc/rwkernel.py] (definition of RandomWalkKernel:) class RandomWalkKernel(MCMCKernel): """Simple gradient-free kernel that utilizes an isotropic gaussian random walk in the unconstrained latent space of the model. The step size that controls the variance of the kernel is adapted during warm-up with a simple adaptation scheme that targets a user-provided acceptance probability. :param model: Python callable containing Pyro primitives. :param float init_step_size: A positive float that controls the initial step size. Defaults to 0.1. :param float target_accept_prob: The target acceptance probability used during adaptation of the step size. Defaults to 0.234. Example: >>> true_coefs = torch.tensor([1., 2., 3.]) >>> data = torch.randn(2000, 3) >>> dim = 3 >>> labels = dist.Bernoulli(logits=(true_coefs * data).sum(-1)).sample() >>> >>> def model(data): ... coefs_mean = torch.zeros(dim) ... coefs = pyro.sample('beta', dist.Normal(coefs_mean, torch.ones(3))) ... y = pyro.sample('y', dist.Bernoulli(logits=(coefs * data).sum(-1)), obs=labels) ... return y >>> >>> hmc_kernel = RandomWalkKernel(model, init_step_size=0.2) >>> mcmc = MCMC(hmc_kernel, num_samples=200, warmup_steps=100) >>> mcmc.run(data) >>> mcmc.get_samples()['beta'].mean(0) # doctest: +SKIP tensor([ 0.9819, 1.9258, 2.9737])""" (definition of RandomWalkKernel.__init__:) def __init__( self, model, init_step_size: float = 0.1, target_accept_prob: float = 0.234 ): (definition of RandomWalkKernel.setup:) def setup(self, warmup_steps, *args, **kwargs): (definition of RandomWalkKernel.sample:) def sample(self, params): (definition of RandomWalkKernel.initial_params:) def initial_params(self): (definition of RandomWalkKernel.initial_params:) def initial_params(self, params): (definition of RandomWalkKernel.logging:) def logging(self): (definition of RandomWalkKernel.diagnostics:) def diagnostics(self): [end of new definitions in pyro/infer/mcmc/rwkernel.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

64e71eee1c14dc926d5cbc5e762b6337bb4750a6

conan-io__conan-15382

15,382

conan-io/conan

null

e2a65483d2e294d604d4bae9ede883958c583f75

2024-01-03T16:56:11Z

diff --git a/conan/cli/commands/build.py b/conan/cli/commands/build.py index 2212e5f79ac..bf1543a8681 100644 --- a/conan/cli/commands/build.py +++ b/conan/cli/commands/build.py @@ -23,7 +23,8 @@ def build(conan_api, parser, *args): parser.add_argument("-of", "--output-folder", help='The root output folder for generated and build files') parser.add_argument("-d", "--deployer", action="append", - help='Deploy using the provided deployer to the output folder') + help="Deploy using the provided deployer to the output folder. " + "Built-in deployers: 'full_deploy', 'direct_deploy', 'runtime_deploy'") parser.add_argument("--deployer-folder", help="Deployer output folder, base build folder by default if not set") parser.add_argument("--build-require", action='store_true', default=False, diff --git a/conan/cli/commands/graph.py b/conan/cli/commands/graph.py index c5fb5f168bd..85d7cb510ec 100644 --- a/conan/cli/commands/graph.py +++ b/conan/cli/commands/graph.py @@ -175,7 +175,10 @@ def graph_info(conan_api, parser, subparser, *args): subparser.add_argument("--package-filter", action="append", help='Print information only for packages that match the patterns') subparser.add_argument("-d", "--deployer", action="append", - help='Deploy using the provided deployer to the output folder') + help="Deploy using the provided deployer to the output folder. " + "Built-in deployers: 'full_deploy', 'direct_deploy'. Deployers " + "will only deploy recipes, as 'conan graph info' do not retrieve " + "binaries") subparser.add_argument("-df", "--deployer-folder", help="Deployer output folder, base build folder by default if not set") subparser.add_argument("--build-require", action='store_true', default=False, diff --git a/conan/cli/commands/install.py b/conan/cli/commands/install.py index cad3168a543..703e022ea0f 100644 --- a/conan/cli/commands/install.py +++ b/conan/cli/commands/install.py @@ -30,7 +30,8 @@ def install(conan_api, parser, *args): parser.add_argument("-of", "--output-folder", help='The root output folder for generated and build files') parser.add_argument("-d", "--deployer", action="append", - help='Deploy using the provided deployer to the output folder') + help="Deploy using the provided deployer to the output folder. " + "Built-in deployers: 'full_deploy', 'direct_deploy', 'runtime_deploy'") parser.add_argument("--deployer-folder", help="Deployer output folder, base build folder by default if not set") parser.add_argument("--deployer-package", action="append", diff --git a/conan/internal/deploy.py b/conan/internal/deploy.py index 9631645ffdd..d5f04693d20 100644 --- a/conan/internal/deploy.py +++ b/conan/internal/deploy.py @@ -1,3 +1,4 @@ +import filecmp import os import shutil @@ -31,7 +32,8 @@ def _load(path): if os.path.isfile(cache_path): return _load(cache_path) builtin_deploy = {"full_deploy.py": full_deploy, - "direct_deploy.py": direct_deploy}.get(d) + "direct_deploy.py": direct_deploy, + "runtime_deploy.py": runtime_deploy}.get(d) if builtin_deploy is not None: return builtin_deploy raise ConanException(f"Cannot find deployer '{d}'") @@ -87,6 +89,75 @@ def full_deploy(graph, output_folder): _deploy_single(dep, conanfile, output_folder, folder_name) +def runtime_deploy(graph, output_folder): + """ + Deploy all the shared libraries and the executables of the dependencies in a flat directory. + """ + conanfile = graph.root.conanfile + output = ConanOutput(scope="runtime_deploy") + output.info(f"Deploying dependencies runtime to folder: {output_folder}") + output.warning("This deployer is experimental and subject to change. " + "Please give feedback at https://github.com/conan-io/conan/issues") + mkdir(output_folder) + symlinks = conanfile.conf.get("tools.deployer:symlinks", check_type=bool, default=True) + for _, dep in conanfile.dependencies.host.items(): + if dep.package_folder is None: + output.warning(f"{dep.ref} does not have any package folder, skipping binary") + continue + count = 0 + cpp_info = dep.cpp_info.aggregated_components() + for bindir in cpp_info.bindirs: + if not os.path.isdir(bindir): + output.warning(f"{dep.ref} {bindir} does not exist") + continue + count += _flatten_directory(dep, bindir, output_folder, symlinks) + + for libdir in cpp_info.libdirs: + if not os.path.isdir(libdir): + output.warning(f"{dep.ref} {libdir} does not exist") + continue + count += _flatten_directory(dep, libdir, output_folder, symlinks, [".dylib", ".so"]) + + output.info(f"Copied {count} files from {dep.ref}") + conanfile.output.success(f"Runtime deployed to folder: {output_folder}") + + +def _flatten_directory(dep, src_dir, output_dir, symlinks, extension_filter=None): + """ + Copy all the files from the source directory in a flat output directory. + An optional string, named extension_filter, can be set to copy only the files with + the listed extensions. + """ + file_count = 0 + + output = ConanOutput(scope="runtime_deploy") + for src_dirpath, _, src_filenames in os.walk(src_dir, followlinks=symlinks): + for src_filename in src_filenames: + if extension_filter and not any(src_filename.endswith(ext) for ext in extension_filter): + continue + + src_filepath = os.path.join(src_dirpath, src_filename) + dest_filepath = os.path.join(output_dir, src_filename) + if os.path.exists(dest_filepath): + if filecmp.cmp(src_filepath, dest_filepath): # Be efficient, do not copy + output.verbose(f"{dest_filepath} exists with same contents, skipping copy") + continue + else: + output.warning(f"{dest_filepath} exists and will be overwritten") + + try: + file_count += 1 + shutil.copy2(src_filepath, dest_filepath, follow_symlinks=symlinks) + output.verbose(f"Copied {src_filepath} into {output_dir}") + except Exception as e: + if "WinError 1314" in str(e): + ConanOutput().error("runtime_deploy: Windows symlinks require admin privileges " + "or 'Developer mode = ON'", error_type="exception") + raise ConanException(f"runtime_deploy: Copy of '{dep}' files failed: {e}.\nYou can " + f"use 'tools.deployer:symlinks' conf to disable symlinks") + return file_count + + def _deploy_single(dep, conanfile, output_folder, folder_name): new_folder = os.path.join(output_folder, folder_name) rmdir(new_folder)

diff --git a/test/functional/command/test_install_deploy.py b/test/functional/command/test_install_deploy.py index 24bb1bd63ba..1967e4b4836 100644 --- a/test/functional/command/test_install_deploy.py +++ b/test/functional/command/test_install_deploy.py @@ -435,3 +435,57 @@ def package_info(self): env = c.load("conanbuildenv-release-x86_64.sh") assert f'export MYPATH="{some_abs_path}/mypath"' in env + + +class TestRuntimeDeployer: + def test_runtime_deploy(self): + c = TestClient() + conanfile = textwrap.dedent(""" + from conan import ConanFile + from conan.tools.files import copy + class Pkg(ConanFile): + def package(self): + copy(self, "*.so", src=self.build_folder, dst=self.package_folder) + copy(self, "*.dll", src=self.build_folder, dst=self.package_folder) + """) + c.save({"pkga/conanfile.py": conanfile, + "pkga/lib/pkga.so": "", + "pkga/bin/pkga.dll": "", + "pkgb/conanfile.py": conanfile, + "pkgb/lib/pkgb.so": ""}) + c.run("export-pkg pkga --name=pkga --version=1.0") + c.run("export-pkg pkgb --name=pkgb --version=1.0") + c.run("install --requires=pkga/1.0 --requires=pkgb/1.0 --deployer=runtime_deploy " + "--deployer-folder=myruntime -vvv") + + expected = sorted(["pkga.so", "pkgb.so", "pkga.dll"]) + assert sorted(os.listdir(os.path.join(c.current_folder, "myruntime"))) == expected + + def test_runtime_deploy_components(self): + c = TestClient() + conanfile = textwrap.dedent(""" + import os + from conan import ConanFile + from conan.tools.files import copy + class Pkg(ConanFile): + def package(self): + copy(self, "*.so", src=self.build_folder, + dst=os.path.join(self.package_folder, "a")) + copy(self, "*.dll", src=self.build_folder, + dst=os.path.join(self.package_folder, "b")) + def package_info(self): + self.cpp_info.components["a"].libdirs = ["a"] + self.cpp_info.components["b"].bindirs = ["b"] + """) + c.save({"pkga/conanfile.py": conanfile, + "pkga/lib/pkga.so": "", + "pkga/bin/pkga.dll": "", + "pkgb/conanfile.py": conanfile, + "pkgb/lib/pkgb.so": ""}) + c.run("export-pkg pkga --name=pkga --version=1.0") + c.run("export-pkg pkgb --name=pkgb --version=1.0") + c.run("install --requires=pkga/1.0 --requires=pkgb/1.0 --deployer=runtime_deploy " + "--deployer-folder=myruntime -vvv") + + expected = sorted(["pkga.so", "pkgb.so", "pkga.dll"]) + assert sorted(os.listdir(os.path.join(c.current_folder, "myruntime"))) == expected

[ { "components": [ { "doc": "Deploy all the shared libraries and the executables of the dependencies in a flat directory.", "lines": [ 92, 122 ], "name": "runtime_deploy", "signature": "def runtime_deploy(graph, output_folder):", "type": "...

[ "test/functional/command/test_install_deploy.py::TestRuntimeDeployer::test_runtime_deploy", "test/functional/command/test_install_deploy.py::TestRuntimeDeployer::test_runtime_deploy_components" ]

[ "test/functional/command/test_install_deploy.py::test_copy_files_deploy", "test/functional/command/test_install_deploy.py::test_multi_deploy", "test/functional/command/test_install_deploy.py::test_deploy_local_import", "test/functional/command/test_install_deploy.py::test_builtin_full_deploy", "test/functio...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add built in runtime deployer Changelog: Feature: Add built in `runtime_deploy` deployer. Docs: https://github.com/conan-io/docs/pull/3789 Fix https://github.com/conan-io/conan/issues/15381 This PR is currently a draft, only tested manually on windows with: ``` conan install --requires=zlib/1.3 --requires=cmake/3.28.1 -of C:\Users\florian.degaulejac\tmp\zlib-cmake --deployer runtime_deploy.py -vtrace --deployer-folder C:\Users\florian.degaulejac\tmp\zlib-cmake\deploy -o "zlib/*:shared=True" ``` Remaining tasks that I won't have the time to complete: - [ ] write autotest instead of manual test - [ ] test other env (linux, apple...) - [ ] symbolic links - [ ] test with deep hierarchy and check it is flatten And a weird behavior I observed: dep.cpp_info.bindirs and dep.cpp_info.libdirs are populated with absolute paths instead of relative path like described in the documentation. Docs: https://github.com/conan-io/docs/pull/XXXX - [x] Refer to the issue that supports this Pull Request. - [x] If the issue has missing info, explain the purpose/use case/pain/need that covers this Pull Request. - [x] I've read the [Contributing guide](https://github.com/conan-io/conan/blob/develop/.github/CONTRIBUTING.md). - [ ] I've followed the PEP8 style guides for Python code. - [ ] I've opened another PR in the Conan docs repo to the ``develop`` branch, documenting this one. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conan/internal/deploy.py] (definition of runtime_deploy:) def runtime_deploy(graph, output_folder): """Deploy all the shared libraries and the executables of the dependencies in a flat directory.""" (definition of _flatten_directory:) def _flatten_directory(dep, src_dir, output_dir, symlinks, extension_filter=None): """Copy all the files from the source directory in a flat output directory. An optional string, named extension_filter, can be set to copy only the files with the listed extensions.""" [end of new definitions in conan/internal/deploy.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

4a5b19a75db9225316c8cb022a2dfb9705a2af34

deepset-ai__haystack-6676

6,676

deepset-ai/haystack

null

1336456b4f94e47ea1cf0d45835e5eef4349530d

2024-01-02T13:34:32Z

diff --git a/haystack/components/embedders/__init__.py b/haystack/components/embedders/__init__.py index d2005877a3..5a6730e5be 100644 --- a/haystack/components/embedders/__init__.py +++ b/haystack/components/embedders/__init__.py @@ -4,6 +4,8 @@ from haystack.components.embedders.sentence_transformers_document_embedder import SentenceTransformersDocumentEmbedder from haystack.components.embedders.openai_document_embedder import OpenAIDocumentEmbedder from haystack.components.embedders.openai_text_embedder import OpenAITextEmbedder +from haystack.components.embedders.azure_text_embedder import AzureOpenAITextEmbedder +from haystack.components.embedders.azure_document_embedder import AzureOpenAIDocumentEmbedder __all__ = [ "HuggingFaceTEITextEmbedder", @@ -12,4 +14,6 @@ "SentenceTransformersDocumentEmbedder", "OpenAITextEmbedder", "OpenAIDocumentEmbedder", + "AzureOpenAITextEmbedder", + "AzureOpenAIDocumentEmbedder", ] diff --git a/haystack/components/embedders/azure_document_embedder.py b/haystack/components/embedders/azure_document_embedder.py new file mode 100644 index 0000000000..9d98eab1ff --- /dev/null +++ b/haystack/components/embedders/azure_document_embedder.py @@ -0,0 +1,178 @@ +import os +from typing import List, Optional, Dict, Any, Tuple + +from openai.lib.azure import AzureADTokenProvider, AzureOpenAI +from tqdm import tqdm + +from haystack import component, Document, default_to_dict + + +@component +class AzureOpenAIDocumentEmbedder: + """ + A component for computing Document embeddings using OpenAI models. + The embedding of each Document is stored in the `embedding` field of the Document. + + Usage example: + ```python + from haystack import Document + from haystack.components.embedders import AzureOpenAIDocumentEmbedder + + doc = Document(content="I love pizza!") + + document_embedder = AzureOpenAIDocumentEmbedder() + + result = document_embedder.run([doc]) + print(result['documents'][0].embedding) + + # [0.017020374536514282, -0.023255806416273117, ...] + ``` + """ + + def __init__( + self, + azure_endpoint: Optional[str] = None, + api_version: Optional[str] = "2023-05-15", + azure_deployment: str = "text-embedding-ada-002", + api_key: Optional[str] = None, + azure_ad_token: Optional[str] = None, + azure_ad_token_provider: Optional[AzureADTokenProvider] = None, + organization: Optional[str] = None, + prefix: str = "", + suffix: str = "", + batch_size: int = 32, + progress_bar: bool = True, + meta_fields_to_embed: Optional[List[str]] = None, + embedding_separator: str = "\n", + ): + """ + Create an AzureOpenAITextEmbedder component. + + :param azure_endpoint: The endpoint of the deployed model, e.g. `https://example-resource.azure.openai.com/` + :param api_version: The version of the API to use. Defaults to 2023-05-15 + :param azure_deployment: The deployment of the model, usually the model name. + :param api_key: The API key to use for authentication. + :param azure_ad_token: Azure Active Directory token, see https://www.microsoft.com/en-us/security/business/identity-access/microsoft-entra-id + :param azure_ad_token_provider: A function that returns an Azure Active Directory token, will be invoked + on every request. + :param organization: The Organization ID, defaults to `None`. See + [production best practices](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization). + :param prefix: A string to add to the beginning of each text. + :param suffix: A string to add to the end of each text. + :param batch_size: Number of Documents to encode at once. + :param progress_bar: Whether to show a progress bar or not. Can be helpful to disable in production deployments + to keep the logs clean. + :param meta_fields_to_embed: List of meta fields that should be embedded along with the Document text. + :param embedding_separator: Separator used to concatenate the meta fields to the Document text. + """ + # if not provided as a parameter, azure_endpoint is read from the env var AZURE_OPENAI_ENDPOINT + azure_endpoint = azure_endpoint or os.environ.get("AZURE_OPENAI_ENDPOINT") + if not azure_endpoint: + raise ValueError("Please provide an Azure endpoint or set the environment variable AZURE_OPENAI_ENDPOINT.") + + self.api_version = api_version + self.azure_endpoint = azure_endpoint + self.azure_deployment = azure_deployment + self.organization = organization + self.prefix = prefix + self.suffix = suffix + self.batch_size = batch_size + self.progress_bar = progress_bar + self.meta_fields_to_embed = meta_fields_to_embed or [] + self.embedding_separator = embedding_separator + + self._client = AzureOpenAI( + api_version=api_version, + azure_endpoint=azure_endpoint, + azure_deployment=azure_deployment, + api_key=api_key, + azure_ad_token=azure_ad_token, + azure_ad_token_provider=azure_ad_token_provider, + organization=organization, + ) + + def _get_telemetry_data(self) -> Dict[str, Any]: + """ + Data that is sent to Posthog for usage analytics. + """ + return {"model": self.azure_deployment} + + def to_dict(self) -> Dict[str, Any]: + """ + This method overrides the default serializer in order to avoid leaking the `api_key` value passed + to the constructor. + """ + return default_to_dict( + self, + azure_endpoint=self.azure_endpoint, + azure_deployment=self.azure_deployment, + organization=self.organization, + api_version=self.api_version, + prefix=self.prefix, + suffix=self.suffix, + batch_size=self.batch_size, + progress_bar=self.progress_bar, + meta_fields_to_embed=self.meta_fields_to_embed, + embedding_separator=self.embedding_separator, + ) + + def _prepare_texts_to_embed(self, documents: List[Document]) -> List[str]: + """ + Prepare the texts to embed by concatenating the Document text with the metadata fields to embed. + """ + texts_to_embed = [] + for doc in documents: + meta_values_to_embed = [ + str(doc.meta[key]) for key in self.meta_fields_to_embed if key in doc.meta and doc.meta[key] is not None + ] + + text_to_embed = ( + self.prefix + self.embedding_separator.join(meta_values_to_embed + [doc.content or ""]) + self.suffix + ).replace("\n", " ") + + texts_to_embed.append(text_to_embed) + return texts_to_embed + + def _embed_batch(self, texts_to_embed: List[str], batch_size: int) -> Tuple[List[List[float]], Dict[str, Any]]: + """ + Embed a list of texts in batches. + """ + + all_embeddings: List[List[float]] = [] + meta: Dict[str, Any] = {"model": "", "usage": {"prompt_tokens": 0, "total_tokens": 0}} + for i in tqdm(range(0, len(texts_to_embed), batch_size), desc="Embedding Texts"): + batch = texts_to_embed[i : i + batch_size] + response = self._client.embeddings.create(model=self.azure_deployment, input=batch) + + # Append embeddings to the list + all_embeddings.extend(el.embedding for el in response.data) + + # Update the meta information only once if it's empty + if not meta["model"]: + meta["model"] = response.model + meta["usage"] = dict(response.usage) + else: + # Update the usage tokens + meta["usage"]["prompt_tokens"] += response.usage.prompt_tokens + meta["usage"]["total_tokens"] += response.usage.total_tokens + + return all_embeddings, meta + + @component.output_types(documents=List[Document], meta=Dict[str, Any]) + def run(self, documents: List[Document]): + """ + Embed a list of Documents. The embedding of each Document is stored in the `embedding` field of the Document. + + :param documents: A list of Documents to embed. + """ + if not (isinstance(documents, list) and all(isinstance(doc, Document) for doc in documents)): + raise TypeError("Input must be a list of Document instances. For strings, use AzureOpenAITextEmbedder.") + + texts_to_embed = self._prepare_texts_to_embed(documents=documents) + embeddings, meta = self._embed_batch(texts_to_embed=texts_to_embed, batch_size=self.batch_size) + + # Assign the corresponding embeddings to each document + for doc, emb in zip(documents, embeddings): + doc.embedding = emb + + return {"documents": documents, "meta": meta} diff --git a/haystack/components/embedders/azure_text_embedder.py b/haystack/components/embedders/azure_text_embedder.py new file mode 100644 index 0000000000..58ca3ba851 --- /dev/null +++ b/haystack/components/embedders/azure_text_embedder.py @@ -0,0 +1,123 @@ +import os +from typing import List, Optional, Dict, Any + +from openai.lib.azure import AzureADTokenProvider, AzureOpenAI + +from haystack import component, default_to_dict, Document + + +@component +class AzureOpenAITextEmbedder: + """ + A component for embedding strings using OpenAI models. + + Usage example: + ```python + from haystack.components.embedders import AzureOpenAITextEmbedder + + text_to_embed = "I love pizza!" + + text_embedder = AzureOpenAITextEmbedder() + + print(text_embedder.run(text_to_embed)) + + # {'embedding': [0.017020374536514282, -0.023255806416273117, ...], + # 'meta': {'model': 'text-embedding-ada-002-v2', + # 'usage': {'prompt_tokens': 4, 'total_tokens': 4}}} + ``` + """ + + def __init__( + self, + azure_endpoint: Optional[str] = None, + api_version: Optional[str] = "2023-05-15", + azure_deployment: str = "text-embedding-ada-002", + api_key: Optional[str] = None, + azure_ad_token: Optional[str] = None, + azure_ad_token_provider: Optional[AzureADTokenProvider] = None, + organization: Optional[str] = None, + prefix: str = "", + suffix: str = "", + ): + """ + Create an AzureOpenAITextEmbedder component. + + :param azure_endpoint: The endpoint of the deployed model, e.g. `https://example-resource.azure.openai.com/` + :param api_version: The version of the API to use. Defaults to 2023-05-15 + :param azure_deployment: The deployment of the model, usually the model name. + :param api_key: The API key to use for authentication. + :param azure_ad_token: Azure Active Directory token, see https://www.microsoft.com/en-us/security/business/identity-access/microsoft-entra-id + :param azure_ad_token_provider: A function that returns an Azure Active Directory token, will be invoked + on every request. + :param organization: The Organization ID, defaults to `None`. See + [production best practices](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization). + :param prefix: A string to add to the beginning of each text. + :param suffix: A string to add to the end of each text. + """ + # Why is this here? + # AzureOpenAI init is forcing us to use an init method that takes either base_url or azure_endpoint as not + # None init parameters. This way we accommodate the use case where env var AZURE_OPENAI_ENDPOINT is set instead + # of passing it as a parameter. + azure_endpoint = azure_endpoint or os.environ.get("AZURE_OPENAI_ENDPOINT") + if not azure_endpoint: + raise ValueError("Please provide an Azure endpoint or set the environment variable AZURE_OPENAI_ENDPOINT.") + + self.api_version = api_version + self.azure_endpoint = azure_endpoint + self.azure_deployment = azure_deployment + self.organization = organization + self.prefix = prefix + self.suffix = suffix + + self._client = AzureOpenAI( + api_version=api_version, + azure_endpoint=azure_endpoint, + azure_deployment=azure_deployment, + api_key=api_key, + azure_ad_token=azure_ad_token, + azure_ad_token_provider=azure_ad_token_provider, + organization=organization, + ) + + def _get_telemetry_data(self) -> Dict[str, Any]: + """ + Data that is sent to Posthog for usage analytics. + """ + return {"model": self.azure_deployment} + + def to_dict(self) -> Dict[str, Any]: + """ + Serialize this component to a dictionary. + :return: The serialized component as a dictionary. + """ + return default_to_dict( + self, + azure_endpoint=self.azure_endpoint, + azure_deployment=self.azure_deployment, + organization=self.organization, + api_version=self.api_version, + prefix=self.prefix, + suffix=self.suffix, + ) + + @component.output_types(embedding=List[float], meta=Dict[str, Any]) + def run(self, text: str): + """Embed a string using AzureOpenAITextEmbedder.""" + if not isinstance(text, str): + # Check if input is a list and all elements are instances of Document + if isinstance(text, list) and all(isinstance(elem, Document) for elem in text): + error_message = "Input must be a string. Use AzureOpenAIDocumentEmbedder for a list of Documents." + else: + error_message = "Input must be a string." + raise TypeError(error_message) + + # Preprocess the text by adding prefixes/suffixes + # finally, replace newlines as recommended by OpenAI docs + processed_text = f"{self.prefix}{text}{self.suffix}".replace("\n", " ") + + response = self._client.embeddings.create(model=self.azure_deployment, input=processed_text) + + return { + "embedding": response.data[0].embedding, + "meta": {"model": response.model, "usage": dict(response.usage)}, + } diff --git a/releasenotes/notes/add-azure-embedders-fd5f4fbcab0e1c48.yaml b/releasenotes/notes/add-azure-embedders-fd5f4fbcab0e1c48.yaml new file mode 100644 index 0000000000..d66d3207d2 --- /dev/null +++ b/releasenotes/notes/add-azure-embedders-fd5f4fbcab0e1c48.yaml @@ -0,0 +1,5 @@ +--- +features: + - | + Adds AzureOpenAIDocumentEmbedder and AzureOpenAITextEmbedder as new embedders. These embedders are very similar to + their OpenAI counterparts, but they use the Azure API instead of the OpenAI API.

diff --git a/test/components/embedders/test_azure_document_embedder.py b/test/components/embedders/test_azure_document_embedder.py new file mode 100644 index 0000000000..b5625e71dd --- /dev/null +++ b/test/components/embedders/test_azure_document_embedder.py @@ -0,0 +1,76 @@ +import os + +import pytest + +from haystack import Document +from haystack.components.embedders import AzureOpenAIDocumentEmbedder + + +class TestAzureOpenAIDocumentEmbedder: + def test_init_default(self, monkeypatch): + monkeypatch.setenv("AZURE_OPENAI_API_KEY", "fake-api-key") + embedder = AzureOpenAIDocumentEmbedder(azure_endpoint="https://example-resource.azure.openai.com/") + assert embedder.azure_deployment == "text-embedding-ada-002" + assert embedder.organization is None + assert embedder.prefix == "" + assert embedder.suffix == "" + assert embedder.batch_size == 32 + assert embedder.progress_bar is True + assert embedder.meta_fields_to_embed == [] + assert embedder.embedding_separator == "\n" + + def test_to_dict(self): + component = AzureOpenAIDocumentEmbedder( + api_key="fake-api-key", azure_endpoint="https://example-resource.azure.openai.com/" + ) + data = component.to_dict() + assert data == { + "type": "haystack.components.embedders.azure_document_embedder.AzureOpenAIDocumentEmbedder", + "init_parameters": { + "api_version": "2023-05-15", + "azure_deployment": "text-embedding-ada-002", + "azure_endpoint": "https://example-resource.azure.openai.com/", + "organization": None, + "prefix": "", + "suffix": "", + "batch_size": 32, + "progress_bar": True, + "meta_fields_to_embed": [], + "embedding_separator": "\n", + }, + } + + @pytest.mark.integration + @pytest.mark.skipif( + not os.environ.get("AZURE_OPENAI_API_KEY", None) and not os.environ.get("AZURE_OPENAI_ENDPOINT", None), + reason=( + "Please export env variables called AZURE_OPENAI_API_KEY containing " + "the Azure OpenAI key, AZURE_OPENAI_ENDPOINT containing " + "the Azure OpenAI endpoint URL to run this test." + ), + ) + def test_run(self): + docs = [ + Document(content="I love cheese", meta={"topic": "Cuisine"}), + Document(content="A transformer is a deep learning architecture", meta={"topic": "ML"}), + ] + # the default model is text-embedding-ada-002 even if we don't specify it, but let's be explicit + embedder = AzureOpenAIDocumentEmbedder( + azure_deployment="text-embedding-ada-002", + meta_fields_to_embed=["topic"], + embedding_separator=" | ", + organization="HaystackCI", + ) + + result = embedder.run(documents=docs) + documents_with_embeddings = result["documents"] + metadata = result["meta"] + + assert isinstance(documents_with_embeddings, list) + assert len(documents_with_embeddings) == len(docs) + for doc in documents_with_embeddings: + assert isinstance(doc, Document) + assert isinstance(doc.embedding, list) + assert len(doc.embedding) == 1536 + assert all(isinstance(x, float) for x in doc.embedding) + assert metadata == {"model": "ada", "usage": {"prompt_tokens": 15, "total_tokens": 15}} diff --git a/test/components/embedders/test_azure_text_embedder.py b/test/components/embedders/test_azure_text_embedder.py new file mode 100644 index 0000000000..8afcd5d3d6 --- /dev/null +++ b/test/components/embedders/test_azure_text_embedder.py @@ -0,0 +1,54 @@ +import os + +import pytest + +from haystack.components.embedders import AzureOpenAITextEmbedder + + +class TestAzureOpenAITextEmbedder: + def test_init_default(self, monkeypatch): + monkeypatch.setenv("AZURE_OPENAI_API_KEY", "fake-api-key") + embedder = AzureOpenAITextEmbedder(azure_endpoint="https://example-resource.azure.openai.com/") + + assert embedder._client.api_key == "fake-api-key" + assert embedder.azure_deployment == "text-embedding-ada-002" + assert embedder.organization is None + assert embedder.prefix == "" + assert embedder.suffix == "" + + def test_to_dict(self): + component = AzureOpenAITextEmbedder( + api_key="fake-api-key", azure_endpoint="https://example-resource.azure.openai.com/" + ) + data = component.to_dict() + assert data == { + "type": "haystack.components.embedders.azure_text_embedder.AzureOpenAITextEmbedder", + "init_parameters": { + "azure_deployment": "text-embedding-ada-002", + "organization": None, + "azure_endpoint": "https://example-resource.azure.openai.com/", + "api_version": "2023-05-15", + "prefix": "", + "suffix": "", + }, + } + + @pytest.mark.integration + @pytest.mark.skipif( + not os.environ.get("AZURE_OPENAI_API_KEY", None) and not os.environ.get("AZURE_OPENAI_ENDPOINT", None), + reason=( + "Please export env variables called AZURE_OPENAI_API_KEY containing " + "the Azure OpenAI key, AZURE_OPENAI_ENDPOINT containing " + "the Azure OpenAI endpoint URL to run this test." + ), + ) + def test_run(self): + # the default model is text-embedding-ada-002 even if we don't specify it, but let's be explicit + embedder = AzureOpenAITextEmbedder( + azure_deployment="text-embedding-ada-002", prefix="prefix ", suffix=" suffix", organization="HaystackCI" + ) + result = embedder.run(text="The food was delicious") + + assert len(result["embedding"]) == 1536 + assert all(isinstance(x, float) for x in result["embedding"]) + assert result["meta"] == {"model": "ada", "usage": {"prompt_tokens": 6, "total_tokens": 6}}

diff --git a/releasenotes/notes/add-azure-embedders-fd5f4fbcab0e1c48.yaml b/releasenotes/notes/add-azure-embedders-fd5f4fbcab0e1c48.yaml new file mode 100644 index 0000000000..d66d3207d2 --- /dev/null +++ b/releasenotes/notes/add-azure-embedders-fd5f4fbcab0e1c48.yaml @@ -0,0 +1,5 @@ +--- +features: + - | + Adds AzureOpenAIDocumentEmbedder and AzureOpenAITextEmbedder as new embedders. These embedders are very similar to + their OpenAI counterparts, but they use the Azure API instead of the OpenAI API.

[ { "components": [ { "doc": "A component for computing Document embeddings using OpenAI models.\nThe embedding of each Document is stored in the `embedding` field of the Document.\n\nUsage example:\n```python\nfrom haystack import Document\nfrom haystack.components.embedders import AzureOpenAIDocum...

[ "test/components/embedders/test_azure_document_embedder.py::TestAzureOpenAIDocumentEmbedder::test_init_default", "test/components/embedders/test_azure_document_embedder.py::TestAzureOpenAIDocumentEmbedder::test_to_dict", "test/components/embedders/test_azure_text_embedder.py::TestAzureOpenAITextEmbedder::test_i...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat: Add Azure embedders support ### Why: Add new embedding components that leverage Azure's cognitive services for text and document embedding. These new components are intended to provide users with more embedding options and utilize Azure's models. ### What: The main changes introduced in the `azure_embedders` branch include: 1. **Addition of Azure Embedders**: The `AzureOpenAITextEmbedder` and `AzureOpenAIDocumentEmbedder` classes have been added. These are similar to their OpenAI counterparts but use Azure API for embedding texts and documents. 2. **Modifications in `__init__.py`**: The `__init__.py` file within the embedders directory has been modified to include the newly added Azure embedder classes. 3. **Unit Tests**: New unit tests have been added for both the `AzureOpenAITextEmbedder` and `AzureOpenAIDocumentEmbedder` to ensure they work as expected and handle various inputs correctly. 4. **Release Notes**: A release note has been added to document the inclusion of new Azure embedders. ### How can it be used: The new Azure embedders can be used in the Haystack framework for tasks that involve text and document embedding. Users can utilize these embedders to convert texts or documents into vectors using Azure's cognitive services. This can be particularly useful for tasks involving semantic search, text clustering, or any application that requires understanding the semantic content of texts. ### How did you test it: 1. **Unit Tests**: New tests were added to verify the functionality of the Azure embedders. These tests check if the embedders correctly initialize with default and custom parameters and if they return expected embeddings for given texts and documents. 2. **Integration Testing**: The embedders were tested in an integrated environment to ensure they interact correctly with the Azure API and the rest of the haystack components. This includes testing with actual text inputs and verifying the embeddings' quality and format. ### Notes for the reviewer: - Review the implementation of the Azure embedders to ensure they align with the project's standards and efficiently utilize Azure's cognitive services. - Consider the unit tests' coverage and whether any additional scenarios need to be tested. - As the embedders rely on external services (Azure), consider the latency, cost, and availability implications when using these components in production environments. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in haystack/components/embedders/azure_document_embedder.py] (definition of AzureOpenAIDocumentEmbedder:) class AzureOpenAIDocumentEmbedder: """A component for computing Document embeddings using OpenAI models. The embedding of each Document is stored in the `embedding` field of the Document. Usage example: ```python from haystack import Document from haystack.components.embedders import AzureOpenAIDocumentEmbedder doc = Document(content="I love pizza!") document_embedder = AzureOpenAIDocumentEmbedder() result = document_embedder.run([doc]) print(result['documents'][0].embedding) # [0.017020374536514282, -0.023255806416273117, ...] ```""" (definition of AzureOpenAIDocumentEmbedder.__init__:) def __init__( self, azure_endpoint: Optional[str] = None, api_version: Optional[str] = "2023-05-15", azure_deployment: str = "text-embedding-ada-002", api_key: Optional[str] = None, azure_ad_token: Optional[str] = None, azure_ad_token_provider: Optional[AzureADTokenProvider] = None, organization: Optional[str] = None, prefix: str = "", suffix: str = "", batch_size: int = 32, progress_bar: bool = True, meta_fields_to_embed: Optional[List[str]] = None, embedding_separator: str = "\n", ): """Create an AzureOpenAITextEmbedder component. :param azure_endpoint: The endpoint of the deployed model, e.g. `https://example-resource.azure.openai.com/` :param api_version: The version of the API to use. Defaults to 2023-05-15 :param azure_deployment: The deployment of the model, usually the model name. :param api_key: The API key to use for authentication. :param azure_ad_token: Azure Active Directory token, see https://www.microsoft.com/en-us/security/business/identity-access/microsoft-entra-id :param azure_ad_token_provider: A function that returns an Azure Active Directory token, will be invoked on every request. :param organization: The Organization ID, defaults to `None`. See [production best practices](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization). :param prefix: A string to add to the beginning of each text. :param suffix: A string to add to the end of each text. :param batch_size: Number of Documents to encode at once. :param progress_bar: Whether to show a progress bar or not. Can be helpful to disable in production deployments to keep the logs clean. :param meta_fields_to_embed: List of meta fields that should be embedded along with the Document text. :param embedding_separator: Separator used to concatenate the meta fields to the Document text.""" (definition of AzureOpenAIDocumentEmbedder._get_telemetry_data:) def _get_telemetry_data(self) -> Dict[str, Any]: """Data that is sent to Posthog for usage analytics.""" (definition of AzureOpenAIDocumentEmbedder.to_dict:) def to_dict(self) -> Dict[str, Any]: """This method overrides the default serializer in order to avoid leaking the `api_key` value passed to the constructor.""" (definition of AzureOpenAIDocumentEmbedder._prepare_texts_to_embed:) def _prepare_texts_to_embed(self, documents: List[Document]) -> List[str]: """Prepare the texts to embed by concatenating the Document text with the metadata fields to embed.""" (definition of AzureOpenAIDocumentEmbedder._embed_batch:) def _embed_batch(self, texts_to_embed: List[str], batch_size: int) -> Tuple[List[List[float]], Dict[str, Any]]: """Embed a list of texts in batches.""" (definition of AzureOpenAIDocumentEmbedder.run:) def run(self, documents: List[Document]): """Embed a list of Documents. The embedding of each Document is stored in the `embedding` field of the Document. :param documents: A list of Documents to embed.""" [end of new definitions in haystack/components/embedders/azure_document_embedder.py] [start of new definitions in haystack/components/embedders/azure_text_embedder.py] (definition of AzureOpenAITextEmbedder:) class AzureOpenAITextEmbedder: """A component for embedding strings using OpenAI models. Usage example: ```python from haystack.components.embedders import AzureOpenAITextEmbedder text_to_embed = "I love pizza!" text_embedder = AzureOpenAITextEmbedder() print(text_embedder.run(text_to_embed)) # {'embedding': [0.017020374536514282, -0.023255806416273117, ...], # 'meta': {'model': 'text-embedding-ada-002-v2', # 'usage': {'prompt_tokens': 4, 'total_tokens': 4}}} ```""" (definition of AzureOpenAITextEmbedder.__init__:) def __init__( self, azure_endpoint: Optional[str] = None, api_version: Optional[str] = "2023-05-15", azure_deployment: str = "text-embedding-ada-002", api_key: Optional[str] = None, azure_ad_token: Optional[str] = None, azure_ad_token_provider: Optional[AzureADTokenProvider] = None, organization: Optional[str] = None, prefix: str = "", suffix: str = "", ): """Create an AzureOpenAITextEmbedder component. :param azure_endpoint: The endpoint of the deployed model, e.g. `https://example-resource.azure.openai.com/` :param api_version: The version of the API to use. Defaults to 2023-05-15 :param azure_deployment: The deployment of the model, usually the model name. :param api_key: The API key to use for authentication. :param azure_ad_token: Azure Active Directory token, see https://www.microsoft.com/en-us/security/business/identity-access/microsoft-entra-id :param azure_ad_token_provider: A function that returns an Azure Active Directory token, will be invoked on every request. :param organization: The Organization ID, defaults to `None`. See [production best practices](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization). :param prefix: A string to add to the beginning of each text. :param suffix: A string to add to the end of each text.""" (definition of AzureOpenAITextEmbedder._get_telemetry_data:) def _get_telemetry_data(self) -> Dict[str, Any]: """Data that is sent to Posthog for usage analytics.""" (definition of AzureOpenAITextEmbedder.to_dict:) def to_dict(self) -> Dict[str, Any]: """Serialize this component to a dictionary. :return: The serialized component as a dictionary.""" (definition of AzureOpenAITextEmbedder.run:) def run(self, text: str): """Embed a string using AzureOpenAITextEmbedder.""" [end of new definitions in haystack/components/embedders/azure_text_embedder.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

f4d9c2bb917be0ffe132dffcc2ad4f1b0fcc5967

joke2k__faker-1968

1,968

joke2k/faker

null

b2df6408867310874d85bcad47348eb1fc802f0d

2023-12-28T18:51:45Z

diff --git a/faker/providers/bank/cs_CZ/__init__.py b/faker/providers/bank/cs_CZ/__init__.py new file mode 100644 index 0000000000..7ea79ab21e --- /dev/null +++ b/faker/providers/bank/cs_CZ/__init__.py @@ -0,0 +1,11 @@ +from .. import Provider as BankProvider + + +class Provider(BankProvider): + """Implement bank provider for ``cs_CZ`` locale. + + https://www.mbank.cz/informace-k-produktum/info/ucty/cislo-uctu-iban.html + """ + + bban_format = "####################" + country_code = "CZ"

diff --git a/tests/providers/test_bank.py b/tests/providers/test_bank.py index cf065af3ce..d373a4ced7 100644 --- a/tests/providers/test_bank.py +++ b/tests/providers/test_bank.py @@ -4,6 +4,7 @@ from faker.providers.bank import Provider as BankProvider from faker.providers.bank.az_AZ import Provider as AzAzBankProvider +from faker.providers.bank.cs_CZ import Provider as CsCZBankProvider from faker.providers.bank.de_CH import Provider as DeChBankProvider from faker.providers.bank.el_GR import Provider as ElGrBankProvider from faker.providers.bank.en_GB import Provider as EnGbBankProvider @@ -56,6 +57,21 @@ def test_bank(self, faker, num_samples): bank = faker.bank() assert bank in AzAzBankProvider.banks +class TestCsCz: + """Test cs_CZ bank provider""" + + def test_bban(self, faker, num_samples): + for _ in range(num_samples): + assert re.fullmatch(r"\d{20}", faker.bban()) + + def test_iban(self, faker, num_samples): + for _ in range(num_samples): + iban = faker.iban() + assert is_valid_iban(iban) + assert iban[:2] == CsCZBankProvider.country_code + assert re.fullmatch(r"\d{2}\d{20}", iban[2:]) + + class TestNoNo: """Test no_NO bank provider"""

[ { "components": [ { "doc": "Implement bank provider for ``cs_CZ`` locale.\n\nhttps://www.mbank.cz/informace-k-produktum/info/ucty/cislo-uctu-iban.html", "lines": [ 4, 11 ], "name": "Provider", "signature": "class Provider(BankProvider):", ...

[ "tests/providers/test_bank.py::TestAzAz::test_bban", "tests/providers/test_bank.py::TestAzAz::test_iban", "tests/providers/test_bank.py::TestAzAz::test_bank", "tests/providers/test_bank.py::TestCsCz::test_bban", "tests/providers/test_bank.py::TestCsCz::test_iban", "tests/providers/test_bank.py::TestNoNo::...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add bank provider for cs_CZ ### What does this change Add bank provider for cs_CZ ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in faker/providers/bank/cs_CZ/__init__.py] (definition of Provider:) class Provider(BankProvider): """Implement bank provider for ``cs_CZ`` locale. https://www.mbank.cz/informace-k-produktum/info/ucty/cislo-uctu-iban.html""" [end of new definitions in faker/providers/bank/cs_CZ/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

6edfdbf6ae90b0153309e3bf066aa3b2d16494a7

pypa__hatch-1178

1,178

pypa/hatch

null

a4ceb972aaba40d624b18363b95bafa339294ee8

2023-12-26T17:52:54Z

diff --git a/docs/history/hatch.md b/docs/history/hatch.md index 25a1f0a3a..5a8a9dd17 100644 --- a/docs/history/hatch.md +++ b/docs/history/hatch.md @@ -8,6 +8,21 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), ## Unreleased +***Added:*** + +- Add the following methods to the `environment` interface for complete control over output during life cycle management: + - app_status_creation + - app_status_pre_installation + - app_status_post_installation + - app_status_project_installation + - app_status_dependency_state_check + - app_status_dependency_installation_check + - app_status_dependency_synchronization + +***Fixed:*** + +- When projects derive dependencies from metadata hooks, there is now by default a status indicator for when the hooks are executed for better responsiveness + ## [1.9.1](https://github.com/pypa/hatch/releases/tag/hatch-v1.9.1) - 2023-12-25 ## {: #hatch-v1.9.1 } ***Fixed:*** diff --git a/docs/plugins/environment/reference.md b/docs/plugins/environment/reference.md index 374f02492..c310a2b89 100644 --- a/docs/plugins/environment/reference.md +++ b/docs/plugins/environment/reference.md @@ -42,6 +42,26 @@ All environment types should [offer support](#hatch.env.plugin.interface.Environ options: members: - PLUGIN_NAME + - find + - create + - remove + - exists + - install_project + - install_project_dev_mode + - dependencies_in_sync + - sync_dependencies + - dependency_hash + - build_environment + - build_environment_exists + - activate + - deactivate + - app_status_creation + - app_status_pre_installation + - app_status_post_installation + - app_status_project_installation + - app_status_dependency_state_check + - app_status_dependency_installation_check + - app_status_dependency_synchronization - app - root - name @@ -58,19 +78,6 @@ All environment types should [offer support](#hatch.env.plugin.interface.Environ - skip_install - dev_mode - description - - activate - - deactivate - - find - - create - - remove - - exists - - install_project - - install_project_dev_mode - - dependencies_in_sync - - sync_dependencies - - dependency_hash - - build_environment - - build_environment_exists - run_builder - construct_build_command - command_context diff --git a/src/hatch/cli/application.py b/src/hatch/cli/application.py index 198df6f0c..ec22f2566 100644 --- a/src/hatch/cli/application.py +++ b/src/hatch/cli/application.py @@ -85,33 +85,34 @@ def prepare_environment(self, environment: EnvironmentInterface): if not environment.exists(): self.env_metadata.reset(environment) - with self.status(f'Creating environment: {environment.name}'): + with environment.app_status_creation(): environment.create() if not environment.skip_install: if environment.pre_install_commands: - with self.status('Running pre-installation commands'): + with environment.app_status_pre_installation(): self.run_shell_commands(environment, environment.pre_install_commands, source='pre-install') - if environment.dev_mode: - with self.status('Installing project in development mode'): + with environment.app_status_project_installation(): + if environment.dev_mode: environment.install_project_dev_mode() - else: - with self.status('Installing project'): + else: environment.install_project() if environment.post_install_commands: - with self.status('Running post-installation commands'): + with environment.app_status_post_installation(): self.run_shell_commands(environment, environment.post_install_commands, source='post-install') - new_dep_hash = environment.dependency_hash() + with environment.app_status_dependency_state_check(): + new_dep_hash = environment.dependency_hash() + current_dep_hash = self.env_metadata.dependency_hash(environment) if new_dep_hash != current_dep_hash: - with self.status('Checking dependencies'): + with environment.app_status_dependency_installation_check(): dependencies_in_sync = environment.dependencies_in_sync() if not dependencies_in_sync: - with self.status('Syncing dependencies'): + with environment.app_status_dependency_synchronization(): environment.sync_dependencies() new_dep_hash = environment.dependency_hash() diff --git a/src/hatch/env/plugin/interface.py b/src/hatch/env/plugin/interface.py index 849dbbc94..1be90afed 100644 --- a/src/hatch/env/plugin/interface.py +++ b/src/hatch/env/plugin/interface.py @@ -659,6 +659,71 @@ def dependency_hash(self): return hash_dependencies(self.dependencies_complex) + @contextmanager + def app_status_creation(self): + """ + See the [life cycle of environments](reference.md#life-cycle). + """ + with self.app.status(f'Creating environment: {self.name}'): + yield + + @contextmanager + def app_status_pre_installation(self): + """ + See the [life cycle of environments](reference.md#life-cycle). + """ + with self.app.status('Running pre-installation commands'): + yield + + @contextmanager + def app_status_post_installation(self): + """ + See the [life cycle of environments](reference.md#life-cycle). + """ + with self.app.status('Running post-installation commands'): + yield + + @contextmanager + def app_status_project_installation(self): + """ + See the [life cycle of environments](reference.md#life-cycle). + """ + if self.dev_mode: + with self.app.status('Installing project in development mode'): + yield + else: + with self.app.status('Installing project'): + yield + + @contextmanager + def app_status_dependency_state_check(self): + """ + See the [life cycle of environments](reference.md#life-cycle). + """ + if not self.skip_install and ( + 'dependencies' in self.metadata.dynamic or 'optional-dependencies' in self.metadata.dynamic + ): + with self.app.status('Polling dependency state'): + yield + else: + yield + + @contextmanager + def app_status_dependency_installation_check(self): + """ + See the [life cycle of environments](reference.md#life-cycle). + """ + with self.app.status('Checking dependencies'): + yield + + @contextmanager + def app_status_dependency_synchronization(self): + """ + See the [life cycle of environments](reference.md#life-cycle). + """ + with self.app.status('Syncing dependencies'): + yield + @contextmanager def build_environment( self,

diff --git a/tests/cli/env/test_create.py b/tests/cli/env/test_create.py index 358cdbfa5..fed313a3f 100644 --- a/tests/cli/env/test_create.py +++ b/tests/cli/env/test_create.py @@ -1359,6 +1359,7 @@ def update(self, metadata): Creating environment: test Installing project in development mode Running post-installation commands + Polling dependency state Checking dependencies Syncing dependencies """

diff --git a/docs/history/hatch.md b/docs/history/hatch.md index 25a1f0a3a..5a8a9dd17 100644 --- a/docs/history/hatch.md +++ b/docs/history/hatch.md @@ -8,6 +8,21 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), ## Unreleased +***Added:*** + +- Add the following methods to the `environment` interface for complete control over output during life cycle management: + - app_status_creation + - app_status_pre_installation + - app_status_post_installation + - app_status_project_installation + - app_status_dependency_state_check + - app_status_dependency_installation_check + - app_status_dependency_synchronization + +***Fixed:*** + +- When projects derive dependencies from metadata hooks, there is now by default a status indicator for when the hooks are executed for better responsiveness + ## [1.9.1](https://github.com/pypa/hatch/releases/tag/hatch-v1.9.1) - 2023-12-25 ## {: #hatch-v1.9.1 } ***Fixed:*** diff --git a/docs/plugins/environment/reference.md b/docs/plugins/environment/reference.md index 374f02492..c310a2b89 100644 --- a/docs/plugins/environment/reference.md +++ b/docs/plugins/environment/reference.md @@ -42,6 +42,26 @@ All environment types should [offer support](#hatch.env.plugin.interface.Environ options: members: - PLUGIN_NAME + - find + - create + - remove + - exists + - install_project + - install_project_dev_mode + - dependencies_in_sync + - sync_dependencies + - dependency_hash + - build_environment + - build_environment_exists + - activate + - deactivate + - app_status_creation + - app_status_pre_installation + - app_status_post_installation + - app_status_project_installation + - app_status_dependency_state_check + - app_status_dependency_installation_check + - app_status_dependency_synchronization - app - root - name @@ -58,19 +78,6 @@ All environment types should [offer support](#hatch.env.plugin.interface.Environ - skip_install - dev_mode - description - - activate - - deactivate - - find - - create - - remove - - exists - - install_project - - install_project_dev_mode - - dependencies_in_sync - - sync_dependencies - - dependency_hash - - build_environment - - build_environment_exists - run_builder - construct_build_command - command_context

[ { "components": [ { "doc": "See the [life cycle of environments](reference.md#life-cycle).", "lines": [ 663, 668 ], "name": "EnvironmentInterface.app_status_creation", "signature": "def app_status_creation(self):", "type": "function" ...

[ "tests/cli/env/test_create.py::test_sync_dynamic_dependencies" ]

[ "tests/cli/env/test_create.py::test_undefined", "tests/cli/env/test_create.py::test_unknown_type", "tests/cli/env/test_create.py::test_new", "tests/cli/env/test_create.py::test_selected_absolute_directory", "tests/cli/env/test_create.py::test_option_absolute_directory", "tests/cli/env/test_create.py::test...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add life cycle messaging methods to the `environment` interface @juftin Curious your thoughts on this ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/hatch/env/plugin/interface.py] (definition of EnvironmentInterface.app_status_creation:) def app_status_creation(self): """See the [life cycle of environments](reference.md#life-cycle).""" (definition of EnvironmentInterface.app_status_pre_installation:) def app_status_pre_installation(self): """See the [life cycle of environments](reference.md#life-cycle).""" (definition of EnvironmentInterface.app_status_post_installation:) def app_status_post_installation(self): """See the [life cycle of environments](reference.md#life-cycle).""" (definition of EnvironmentInterface.app_status_project_installation:) def app_status_project_installation(self): """See the [life cycle of environments](reference.md#life-cycle).""" (definition of EnvironmentInterface.app_status_dependency_state_check:) def app_status_dependency_state_check(self): """See the [life cycle of environments](reference.md#life-cycle).""" (definition of EnvironmentInterface.app_status_dependency_installation_check:) def app_status_dependency_installation_check(self): """See the [life cycle of environments](reference.md#life-cycle).""" (definition of EnvironmentInterface.app_status_dependency_synchronization:) def app_status_dependency_synchronization(self): """See the [life cycle of environments](reference.md#life-cycle).""" [end of new definitions in src/hatch/env/plugin/interface.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c06c820d722667306f39bda956c58cf4c48d0728

deepset-ai__haystack-6648

6,648

deepset-ai/haystack

null

9c08f3d9c7f0888d29deec98373d536b8f61e4b8

2023-12-26T15:48:58Z

diff --git a/haystack/components/generators/__init__.py b/haystack/components/generators/__init__.py index a9251b9336..73818abfbb 100644 --- a/haystack/components/generators/__init__.py +++ b/haystack/components/generators/__init__.py @@ -1,5 +1,12 @@ from haystack.components.generators.hugging_face_local import HuggingFaceLocalGenerator from haystack.components.generators.hugging_face_tgi import HuggingFaceTGIGenerator from haystack.components.generators.openai import OpenAIGenerator, GPTGenerator +from haystack.components.generators.azure import AzureOpenAIGenerator -__all__ = ["HuggingFaceLocalGenerator", "HuggingFaceTGIGenerator", "OpenAIGenerator", "GPTGenerator"] +__all__ = [ + "HuggingFaceLocalGenerator", + "HuggingFaceTGIGenerator", + "OpenAIGenerator", + "GPTGenerator", + "AzureOpenAIGenerator", +] diff --git a/haystack/components/generators/azure.py b/haystack/components/generators/azure.py new file mode 100644 index 0000000000..fd38b5b140 --- /dev/null +++ b/haystack/components/generators/azure.py @@ -0,0 +1,158 @@ +import logging +import os +from typing import Optional, Callable, Dict, Any + +# pylint: disable=import-error +from openai.lib.azure import AzureADTokenProvider, AzureOpenAI + +from haystack import default_to_dict, default_from_dict +from haystack.components.generators import OpenAIGenerator +from haystack.components.generators.utils import serialize_callback_handler, deserialize_callback_handler +from haystack.dataclasses import StreamingChunk + +logger = logging.getLogger(__name__) + + +class AzureOpenAIGenerator(OpenAIGenerator): + """ + Enables text generation using OpenAI's large language models (LLMs) on Azure. It supports gpt-4 and gpt-3.5-turbo + family of models. + + Users can pass any text generation parameters valid for the `openai.ChatCompletion.create` method + directly to this component via the `**generation_kwargs` parameter in __init__ or the `**generation_kwargs` + parameter in `run` method. + + For more details on OpenAI models deployed on Azure, refer to the Microsoft + [documentation](https://learn.microsoft.com/en-us/azure/ai-services/openai/). + + + ```python + from haystack.components.generators import AzureOpenAIGenerator + client = AzureOpenAIGenerator(azure_endpoint="<Your Azure endpoint e.g. `https://your-company.azure.openai.com/>", + api_key="<you api key>", + azure_deployment="<this a model name, e.g. gpt-35-turbo>") + response = client.run("What's Natural Language Processing? Be brief.") + print(response) + + >> {'replies': ['Natural Language Processing (NLP) is a branch of artificial intelligence that focuses on + >> the interaction between computers and human language. It involves enabling computers to understand, interpret, + >> and respond to natural human language in a way that is both meaningful and useful.'], 'meta': [{'model': + >> 'gpt-3.5-turbo-0613', 'index': 0, 'finish_reason': 'stop', 'usage': {'prompt_tokens': 16, + >> 'completion_tokens': 49, 'total_tokens': 65}}]} + ``` + + Key Features and Compatibility: + - **Primary Compatibility**: Designed to work seamlessly with gpt-4, gpt-3.5-turbo family of models. + - **Streaming Support**: Supports streaming responses from the OpenAI API. + - **Customizability**: Supports all parameters supported by the OpenAI API. + + Input and Output Format: + - **String Format**: This component uses the strings for both input and output. + """ + + # pylint: disable=super-init-not-called + def __init__( + self, + azure_endpoint: Optional[str] = None, + api_version: Optional[str] = "2023-05-15", + azure_deployment: Optional[str] = "gpt-35-turbo", + api_key: Optional[str] = None, + azure_ad_token: Optional[str] = None, + azure_ad_token_provider: Optional[AzureADTokenProvider] = None, + organization: Optional[str] = None, + streaming_callback: Optional[Callable[[StreamingChunk], None]] = None, + system_prompt: Optional[str] = None, + generation_kwargs: Optional[Dict[str, Any]] = None, + ): + """ + :param azure_endpoint: The endpoint of the deployed model, e.g. `https://example-resource.azure.openai.com/` + :param api_version: The version of the API to use. Defaults to 2023-05-15 + :param azure_deployment: The deployment of the model, usually the model name. + :param api_key: The API key to use for authentication. + :param azure_ad_token: Azure Active Directory token, see https://www.microsoft.com/en-us/security/business/identity-access/microsoft-entra-id + :param azure_ad_token_provider: A function that returns an Azure Active Directory token, will be invoked + on every request. + :param organization: The Organization ID, defaults to `None`. See + [production best practices](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization). + :param streaming_callback: A callback function that is called when a new token is received from the stream. + The callback function accepts StreamingChunk as an argument. + :param system_prompt: The prompt to use for the system. If not provided, the system prompt will be + :param generation_kwargs: Other parameters to use for the model. These parameters are all sent directly to + the OpenAI endpoint. See OpenAI [documentation](https://platform.openai.com/docs/api-reference/chat) for + more details. + Some of the supported parameters: + - `max_tokens`: The maximum number of tokens the output text can have. + - `temperature`: What sampling temperature to use. Higher values mean the model will take more risks. + Try 0.9 for more creative applications and 0 (argmax sampling) for ones with a well-defined answer. + - `top_p`: An alternative to sampling with temperature, called nucleus sampling, where the model + considers the results of the tokens with top_p probability mass. So 0.1 means only the tokens + comprising the top 10% probability mass are considered. + - `n`: How many completions to generate for each prompt. For example, if the LLM gets 3 prompts and n is 2, + it will generate two completions for each of the three prompts, ending up with 6 completions in total. + - `stop`: One or more sequences after which the LLM should stop generating tokens. + - `presence_penalty`: What penalty to apply if a token is already present at all. Bigger values mean + the model will be less likely to repeat the same token in the text. + - `frequency_penalty`: What penalty to apply if a token has already been generated in the text. + Bigger values mean the model will be less likely to repeat the same token in the text. + - `logit_bias`: Add a logit bias to specific tokens. The keys of the dictionary are tokens, and the + values are the bias to add to that token. + """ + # We intentionally do not call super().__init__ here because we only need to instantiate the client to interact + # with the API. + + # Why is this here? + # AzureOpenAI init is forcing us to use an init method that takes either base_url or azure_endpoint as not + # None init parameters. This way we accommodate the use case where env var AZURE_OPENAI_ENDPOINT is set instead + # of passing it as a parameter. + azure_endpoint = azure_endpoint or os.environ.get("AZURE_OPENAI_ENDPOINT") + if not azure_endpoint: + raise ValueError("Please provide an Azure endpoint or set the environment variable AZURE_OPENAI_ENDPOINT.") + + self.generation_kwargs = generation_kwargs or {} + self.system_prompt = system_prompt + self.streaming_callback = streaming_callback + self.api_version = api_version + self.azure_endpoint = azure_endpoint + self.azure_deployment = azure_deployment + self.organization = organization + self.model_name: str = azure_deployment or "gpt-35-turbo" + + self.client = AzureOpenAI( + api_version=api_version, + azure_endpoint=azure_endpoint, + azure_deployment=azure_deployment, + api_key=api_key, + azure_ad_token=azure_ad_token, + azure_ad_token_provider=azure_ad_token_provider, + organization=organization, + ) + + def to_dict(self) -> Dict[str, Any]: + """ + Serialize this component to a dictionary. + :return: The serialized component as a dictionary. + """ + callback_name = serialize_callback_handler(self.streaming_callback) if self.streaming_callback else None + return default_to_dict( + self, + azure_endpoint=self.azure_endpoint, + azure_deployment=self.azure_deployment, + organization=self.organization, + api_version=self.api_version, + streaming_callback=callback_name, + generation_kwargs=self.generation_kwargs, + system_prompt=self.system_prompt, + ) + + @classmethod + def from_dict(cls, data: Dict[str, Any]) -> "AzureOpenAIGenerator": + """ + Deserialize this component from a dictionary. + :param data: The dictionary representation of this component. + :return: The deserialized component instance. + """ + init_params = data.get("init_parameters", {}) + serialized_callback_handler = init_params.get("streaming_callback") + if serialized_callback_handler: + data["init_parameters"]["streaming_callback"] = deserialize_callback_handler(serialized_callback_handler) + return default_from_dict(cls, data) diff --git a/haystack/components/generators/chat/__init__.py b/haystack/components/generators/chat/__init__.py index 3227e50bfa..028389a568 100644 --- a/haystack/components/generators/chat/__init__.py +++ b/haystack/components/generators/chat/__init__.py @@ -1,4 +1,5 @@ from haystack.components.generators.chat.hugging_face_tgi import HuggingFaceTGIChatGenerator from haystack.components.generators.chat.openai import OpenAIChatGenerator, GPTChatGenerator +from haystack.components.generators.chat.azure import AzureOpenAIChatGenerator -__all__ = ["HuggingFaceTGIChatGenerator", "OpenAIChatGenerator", "GPTChatGenerator"] +__all__ = ["HuggingFaceTGIChatGenerator", "OpenAIChatGenerator", "GPTChatGenerator", "AzureOpenAIChatGenerator"] diff --git a/haystack/components/generators/chat/azure.py b/haystack/components/generators/chat/azure.py new file mode 100644 index 0000000000..7b1f4513f6 --- /dev/null +++ b/haystack/components/generators/chat/azure.py @@ -0,0 +1,161 @@ +import logging +import os +from typing import Optional, Callable, Dict, Any + +# pylint: disable=import-error +from openai.lib.azure import AzureADTokenProvider, AzureOpenAI + +from haystack import default_to_dict, default_from_dict +from haystack.components.generators.chat import OpenAIChatGenerator +from haystack.components.generators.utils import serialize_callback_handler, deserialize_callback_handler +from haystack.dataclasses import StreamingChunk + +logger = logging.getLogger(__name__) + + +class AzureOpenAIChatGenerator(OpenAIChatGenerator): + """ + Enables text generation using OpenAI's large language models (LLMs) on Azure. It supports gpt-4 and gpt-3.5-turbo + family of models accessed through the chat completions API endpoint. + + Users can pass any text generation parameters valid for the `openai.ChatCompletion.create` method + directly to this component via the `**generation_kwargs` parameter in __init__ or the `**generation_kwargs` + parameter in `run` method. + + For more details on OpenAI models deployed on Azure, refer to the Microsoft + [documentation](https://learn.microsoft.com/en-us/azure/ai-services/openai/). + + ```python + from haystack.components.generators.chat import AzureOpenAIGenerator + from haystack.dataclasses import ChatMessage + + messages = [ChatMessage.from_user("What's Natural Language Processing?")] + + client = AzureOpenAIGenerator(azure_endpoint="<Your Azure endpoint e.g. `https://your-company.azure.openai.com/>", + api_key="<you api key>", + azure_deployment="<this a model name, e.g. gpt-35-turbo>") + response = client.run(messages) + print(response) + + >>{'replies': [ChatMessage(content='Natural Language Processing (NLP) is a branch of artificial intelligence + >>that focuses on enabling computers to understand, interpret, and generate human language in a way that is + >>meaningful and useful.', role=<ChatRole.ASSISTANT: 'assistant'>, name=None, + >>meta={'model': 'gpt-3.5-turbo-0613', 'index': 0, 'finish_reason': 'stop', + >>'usage': {'prompt_tokens': 15, 'completion_tokens': 36, 'total_tokens': 51}})]} + + ``` + + Key Features and Compatibility: + - **Primary Compatibility**: Designed to work seamlessly with the OpenAI API Chat Completion endpoint + and gpt-4 and gpt-3.5-turbo family of models. + - **Streaming Support**: Supports streaming responses from the OpenAI API Chat Completion endpoint. + - **Customizability**: Supports all parameters supported by the OpenAI API Chat Completion endpoint. + + Input and Output Format: + - **ChatMessage Format**: This component uses the ChatMessage format for structuring both input and output, + ensuring coherent and contextually relevant responses in chat-based text generation scenarios. Details on the + ChatMessage format can be found at: https://github.com/openai/openai-python/blob/main/chatml.md. + """ + + # pylint: disable=super-init-not-called + def __init__( + self, + azure_endpoint: Optional[str] = None, + api_version: Optional[str] = "2023-05-15", + azure_deployment: Optional[str] = "gpt-35-turbo", + api_key: Optional[str] = None, + azure_ad_token: Optional[str] = None, + azure_ad_token_provider: Optional[AzureADTokenProvider] = None, + organization: Optional[str] = None, + streaming_callback: Optional[Callable[[StreamingChunk], None]] = None, + generation_kwargs: Optional[Dict[str, Any]] = None, + ): + """ + :param azure_endpoint: The endpoint of the deployed model, e.g. `https://example-resource.azure.openai.com/` + :param api_version: The version of the API to use. Defaults to 2023-05-15 + :param azure_deployment: The deployment of the model, usually the model name. + :param api_key: The API key to use for authentication. + :param azure_ad_token: Azure Active Directory token, see https://www.microsoft.com/en-us/security/business/identity-access/microsoft-entra-id + :param azure_ad_token_provider: A function that returns an Azure Active Directory token, will be invoked + on every request. + :param organization: The Organization ID, defaults to `None`. See + [production best practices](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization). + :param streaming_callback: A callback function that is called when a new token is received from the stream. + The callback function accepts StreamingChunk as an argument. + :param generation_kwargs: Other parameters to use for the model. These parameters are all sent directly to + the OpenAI endpoint. See OpenAI [documentation](https://platform.openai.com/docs/api-reference/chat) for + more details. + Some of the supported parameters: + - `max_tokens`: The maximum number of tokens the output text can have. + - `temperature`: What sampling temperature to use. Higher values mean the model will take more risks. + Try 0.9 for more creative applications and 0 (argmax sampling) for ones with a well-defined answer. + - `top_p`: An alternative to sampling with temperature, called nucleus sampling, where the model + considers the results of the tokens with top_p probability mass. So 0.1 means only the tokens + comprising the top 10% probability mass are considered. + - `n`: How many completions to generate for each prompt. For example, if the LLM gets 3 prompts and n is 2, + it will generate two completions for each of the three prompts, ending up with 6 completions in total. + - `stop`: One or more sequences after which the LLM should stop generating tokens. + - `presence_penalty`: What penalty to apply if a token is already present at all. Bigger values mean + the model will be less likely to repeat the same token in the text. + - `frequency_penalty`: What penalty to apply if a token has already been generated in the text. + Bigger values mean the model will be less likely to repeat the same token in the text. + - `logit_bias`: Add a logit bias to specific tokens. The keys of the dictionary are tokens, and the + values are the bias to add to that token. + """ + # We intentionally do not call super().__init__ here because we only need to instantiate the client to interact + # with the API. + + # Why is this here? + # AzureOpenAI init is forcing us to use an init method that takes either base_url or azure_endpoint as not + # None init parameters. This way we accommodate the use case where env var AZURE_OPENAI_ENDPOINT is set instead + # of passing it as a parameter. + azure_endpoint = azure_endpoint or os.environ.get("AZURE_OPENAI_ENDPOINT") + if not azure_endpoint: + raise ValueError("Please provide an Azure endpoint or set the environment variable AZURE_OPENAI_ENDPOINT.") + + self.generation_kwargs = generation_kwargs or {} + self.streaming_callback = streaming_callback + self.api_version = api_version + self.azure_endpoint = azure_endpoint + self.azure_deployment = azure_deployment + self.organization = organization + self.model_name = azure_deployment or "gpt-35-turbo" + + self.client = AzureOpenAI( + api_version=api_version, + azure_endpoint=azure_endpoint, + azure_deployment=azure_deployment, + api_key=api_key, + azure_ad_token=azure_ad_token, + azure_ad_token_provider=azure_ad_token_provider, + organization=organization, + ) + + def to_dict(self) -> Dict[str, Any]: + """ + Serialize this component to a dictionary. + :return: The serialized component as a dictionary. + """ + callback_name = serialize_callback_handler(self.streaming_callback) if self.streaming_callback else None + return default_to_dict( + self, + azure_endpoint=self.azure_endpoint, + azure_deployment=self.azure_deployment, + organization=self.organization, + api_version=self.api_version, + streaming_callback=callback_name, + generation_kwargs=self.generation_kwargs, + ) + + @classmethod + def from_dict(cls, data: Dict[str, Any]) -> "AzureOpenAIChatGenerator": + """ + Deserialize this component from a dictionary. + :param data: The dictionary representation of this component. + :return: The deserialized component instance. + """ + init_params = data.get("init_parameters", {}) + serialized_callback_handler = init_params.get("streaming_callback") + if serialized_callback_handler: + data["init_parameters"]["streaming_callback"] = deserialize_callback_handler(serialized_callback_handler) + return default_from_dict(cls, data) diff --git a/releasenotes/notes/add-azure-generators-a30c786204b22e48.yaml b/releasenotes/notes/add-azure-generators-a30c786204b22e48.yaml new file mode 100644 index 0000000000..2a3422cfeb --- /dev/null +++ b/releasenotes/notes/add-azure-generators-a30c786204b22e48.yaml @@ -0,0 +1,4 @@ +--- +features: + - | + Adds support for Azure OpenAI models with AzureOpenAIGenerator and AzureOpenAIChatGenerator components.

diff --git a/test/components/generators/chat/test_azure.py b/test/components/generators/chat/test_azure.py new file mode 100644 index 0000000000..2a9f900f7d --- /dev/null +++ b/test/components/generators/chat/test_azure.py @@ -0,0 +1,89 @@ +import os + +import pytest +from openai import OpenAIError + +from haystack.components.generators.chat import AzureOpenAIChatGenerator +from haystack.components.generators.utils import default_streaming_callback +from haystack.dataclasses import ChatMessage + + +class TestOpenAIChatGenerator: + def test_init_default(self): + component = AzureOpenAIChatGenerator(azure_endpoint="some-non-existing-endpoint", api_key="test-api-key") + assert component.client.api_key == "test-api-key" + assert component.azure_deployment == "gpt-35-turbo" + assert component.streaming_callback is None + assert not component.generation_kwargs + + def test_init_fail_wo_api_key(self, monkeypatch): + monkeypatch.delenv("AZURE_OPENAI_API_KEY", raising=False) + with pytest.raises(OpenAIError): + AzureOpenAIChatGenerator(azure_endpoint="some-non-existing-endpoint") + + def test_init_with_parameters(self): + component = AzureOpenAIChatGenerator( + azure_endpoint="some-non-existing-endpoint", + api_key="test-api-key", + streaming_callback=default_streaming_callback, + generation_kwargs={"max_tokens": 10, "some_test_param": "test-params"}, + ) + assert component.client.api_key == "test-api-key" + assert component.azure_deployment == "gpt-35-turbo" + assert component.streaming_callback is default_streaming_callback + assert component.generation_kwargs == {"max_tokens": 10, "some_test_param": "test-params"} + + def test_to_dict_default(self): + component = AzureOpenAIChatGenerator(api_key="test-api-key", azure_endpoint="some-non-existing-endpoint") + data = component.to_dict() + assert data == { + "type": "haystack.components.generators.chat.azure.AzureOpenAIChatGenerator", + "init_parameters": { + "api_version": "2023-05-15", + "azure_endpoint": "some-non-existing-endpoint", + "azure_deployment": "gpt-35-turbo", + "organization": None, + "streaming_callback": None, + "generation_kwargs": {}, + }, + } + + def test_to_dict_with_parameters(self): + component = AzureOpenAIChatGenerator( + api_key="test-api-key", + azure_endpoint="some-non-existing-endpoint", + generation_kwargs={"max_tokens": 10, "some_test_param": "test-params"}, + ) + data = component.to_dict() + assert data == { + "type": "haystack.components.generators.chat.azure.AzureOpenAIChatGenerator", + "init_parameters": { + "api_version": "2023-05-15", + "azure_endpoint": "some-non-existing-endpoint", + "azure_deployment": "gpt-35-turbo", + "organization": None, + "streaming_callback": None, + "generation_kwargs": {"max_tokens": 10, "some_test_param": "test-params"}, + }, + } + + @pytest.mark.integration + @pytest.mark.skipif( + not os.environ.get("AZURE_OPENAI_API_KEY", None) and not os.environ.get("AZURE_OPENAI_ENDPOINT", None), + reason=( + "Please export env variables called AZURE_OPENAI_API_KEY containing " + "the Azure OpenAI key, AZURE_OPENAI_ENDPOINT containing " + "the Azure OpenAI endpoint URL to run this test." + ), + ) + def test_live_run(self): + chat_messages = [ChatMessage.from_user("What's the capital of France")] + component = AzureOpenAIChatGenerator(organization="HaystackCI") + results = component.run(chat_messages) + assert len(results["replies"]) == 1 + message: ChatMessage = results["replies"][0] + assert "Paris" in message.content + assert "gpt-35-turbo" in message.meta["model"] + assert message.meta["finish_reason"] == "stop" + + # additional tests intentionally omitted as they are covered by test_openai.py diff --git a/test/components/generators/test_azure.py b/test/components/generators/test_azure.py new file mode 100644 index 0000000000..816afb9a51 --- /dev/null +++ b/test/components/generators/test_azure.py @@ -0,0 +1,99 @@ +import os + +import pytest +from openai import OpenAIError + +from haystack.components.generators import AzureOpenAIGenerator +from haystack.components.generators.utils import default_streaming_callback + + +class TestAzureOpenAIGenerator: + def test_init_default(self): + component = AzureOpenAIGenerator(api_key="test-api-key", azure_endpoint="some-non-existing-endpoint") + assert component.client.api_key == "test-api-key" + assert component.azure_deployment == "gpt-35-turbo" + assert component.streaming_callback is None + assert not component.generation_kwargs + + def test_init_fail_wo_api_key(self, monkeypatch): + monkeypatch.delenv("AZURE_OPENAI_API_KEY", raising=False) + with pytest.raises(OpenAIError): + AzureOpenAIGenerator(azure_endpoint="some-non-existing-endpoint") + + def test_init_with_parameters(self): + component = AzureOpenAIGenerator( + api_key="test-api-key", + azure_endpoint="some-non-existing-endpoint", + azure_deployment="gpt-35-turbo", + streaming_callback=default_streaming_callback, + generation_kwargs={"max_tokens": 10, "some_test_param": "test-params"}, + ) + assert component.client.api_key == "test-api-key" + assert component.azure_deployment == "gpt-35-turbo" + assert component.streaming_callback is default_streaming_callback + assert component.generation_kwargs == {"max_tokens": 10, "some_test_param": "test-params"} + + def test_to_dict_default(self): + component = AzureOpenAIGenerator(api_key="test-api-key", azure_endpoint="some-non-existing-endpoint") + data = component.to_dict() + assert data == { + "type": "haystack.components.generators.azure.AzureOpenAIGenerator", + "init_parameters": { + "azure_deployment": "gpt-35-turbo", + "api_version": "2023-05-15", + "streaming_callback": None, + "azure_endpoint": "some-non-existing-endpoint", + "organization": None, + "system_prompt": None, + "generation_kwargs": {}, + }, + } + + def test_to_dict_with_parameters(self): + component = AzureOpenAIGenerator( + api_key="test-api-key", + azure_endpoint="some-non-existing-endpoint", + generation_kwargs={"max_tokens": 10, "some_test_param": "test-params"}, + ) + + data = component.to_dict() + assert data == { + "type": "haystack.components.generators.azure.AzureOpenAIGenerator", + "init_parameters": { + "azure_deployment": "gpt-35-turbo", + "api_version": "2023-05-15", + "streaming_callback": None, + "azure_endpoint": "some-non-existing-endpoint", + "organization": None, + "system_prompt": None, + "generation_kwargs": {"max_tokens": 10, "some_test_param": "test-params"}, + }, + } + + @pytest.mark.integration + @pytest.mark.skipif( + not os.environ.get("AZURE_OPENAI_API_KEY", None) and not os.environ.get("AZURE_OPENAI_ENDPOINT", None), + reason=( + "Please export env variables called AZURE_OPENAI_API_KEY containing " + "the Azure OpenAI key, AZURE_OPENAI_ENDPOINT containing " + "the Azure OpenAI endpoint URL to run this test." + ), + ) + def test_live_run(self): + component = AzureOpenAIGenerator(organization="HaystackCI") + results = component.run("What's the capital of France?") + assert len(results["replies"]) == 1 + assert len(results["meta"]) == 1 + response: str = results["replies"][0] + assert "Paris" in response + + metadata = results["meta"][0] + assert "gpt-35-turbo" in metadata["model"] + assert metadata["finish_reason"] == "stop" + + assert "usage" in metadata + assert "prompt_tokens" in metadata["usage"] and metadata["usage"]["prompt_tokens"] > 0 + assert "completion_tokens" in metadata["usage"] and metadata["usage"]["completion_tokens"] > 0 + assert "total_tokens" in metadata["usage"] and metadata["usage"]["total_tokens"] > 0 + + # additional tests intentionally omitted as they are covered by test_openai.py

diff --git a/releasenotes/notes/add-azure-generators-a30c786204b22e48.yaml b/releasenotes/notes/add-azure-generators-a30c786204b22e48.yaml new file mode 100644 index 0000000000..2a3422cfeb --- /dev/null +++ b/releasenotes/notes/add-azure-generators-a30c786204b22e48.yaml @@ -0,0 +1,4 @@ +--- +features: + - | + Adds support for Azure OpenAI models with AzureOpenAIGenerator and AzureOpenAIChatGenerator components.

[ { "components": [ { "doc": "Enables text generation using OpenAI's large language models (LLMs) on Azure. It supports gpt-4 and gpt-3.5-turbo\nfamily of models.\n\nUsers can pass any text generation parameters valid for the `openai.ChatCompletion.create` method\ndirectly to this component via the ...

[ "test/components/generators/chat/test_azure.py::TestOpenAIChatGenerator::test_init_default", "test/components/generators/chat/test_azure.py::TestOpenAIChatGenerator::test_init_fail_wo_api_key", "test/components/generators/chat/test_azure.py::TestOpenAIChatGenerator::test_init_with_parameters", "test/component...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat: Add AzureOpenAIGenerator and AzureOpenAIChatGenerator ### Why: Add support for OpenAI LLMs like GPT-3.5 and GPT-4, which are available through Azure's services. ### What: Two main components have been added: 1. **AzureGenerator**: This class extends the capabilities of the `OpenAIGenerator` to use Azure's deployment of OpenAI's models. It involves numerous parameters and methods that facilitate text generation with customizable settings tailored to Azure's API structure and authentication mechanisms. 2. **AzureChatGenerator**: Similar to `AzureGenerator`, this class is tailored for chat-based applications, providing functionalities to utilize Azure's deployment of OpenAI models in chatbots or other conversational AI applications. Additionally, both components are registered in their respective `__init__.py` files. ### How can it be used: Developers and researchers can use these components to integrate Azure's powerful language models into their applications for a variety of tasks, including but not limited to: - Generating text based on prompts - Building conversational agents - Automating content creation These generators provide easy access to advanced NLP capabilities and can be customized with different parameters to suit specific needs, such as adjusting the model's creativity or response length. ### How did you test it: Manually. Unit tests were not added as we use the already tested OpenAIGenerator and OpenAIChatGenerator ### Notes for the reviewer: - **Omission of super init call**: Azure generators intentionally omit super init call to parent components. This is intentional, see if that is the best approach possible. - **Understanding Azure**: As these changes involve integration with Azure, understanding the Azure environment, its authentication mechanisms, and how it hosts OpenAI models is crucial. - **Reviewing Dependencies**: Changes include imports specific to Azure's SDK (`openai.lib.azure`) and other related utilities, which should be reviewed for compatibility and stability. - **Considerations for Deployment**: Ensure that the addition of these new components aligns with the overall architecture and does not introduce any issues or conflicts with existing functionalities. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in haystack/components/generators/azure.py] (definition of AzureOpenAIGenerator:) class AzureOpenAIGenerator(OpenAIGenerator): """Enables text generation using OpenAI's large language models (LLMs) on Azure. It supports gpt-4 and gpt-3.5-turbo family of models. Users can pass any text generation parameters valid for the `openai.ChatCompletion.create` method directly to this component via the `**generation_kwargs` parameter in __init__ or the `**generation_kwargs` parameter in `run` method. For more details on OpenAI models deployed on Azure, refer to the Microsoft [documentation](https://learn.microsoft.com/en-us/azure/ai-services/openai/). ```python from haystack.components.generators import AzureOpenAIGenerator client = AzureOpenAIGenerator(azure_endpoint="<Your Azure endpoint e.g. `https://your-company.azure.openai.com/>", api_key="<you api key>", azure_deployment="<this a model name, e.g. gpt-35-turbo>") response = client.run("What's Natural Language Processing? Be brief.") print(response) >> {'replies': ['Natural Language Processing (NLP) is a branch of artificial intelligence that focuses on >> the interaction between computers and human language. It involves enabling computers to understand, interpret, >> and respond to natural human language in a way that is both meaningful and useful.'], 'meta': [{'model': >> 'gpt-3.5-turbo-0613', 'index': 0, 'finish_reason': 'stop', 'usage': {'prompt_tokens': 16, >> 'completion_tokens': 49, 'total_tokens': 65}}]} ``` Key Features and Compatibility: - **Primary Compatibility**: Designed to work seamlessly with gpt-4, gpt-3.5-turbo family of models. - **Streaming Support**: Supports streaming responses from the OpenAI API. - **Customizability**: Supports all parameters supported by the OpenAI API. Input and Output Format: - **String Format**: This component uses the strings for both input and output.""" (definition of AzureOpenAIGenerator.__init__:) def __init__( self, azure_endpoint: Optional[str] = None, api_version: Optional[str] = "2023-05-15", azure_deployment: Optional[str] = "gpt-35-turbo", api_key: Optional[str] = None, azure_ad_token: Optional[str] = None, azure_ad_token_provider: Optional[AzureADTokenProvider] = None, organization: Optional[str] = None, streaming_callback: Optional[Callable[[StreamingChunk], None]] = None, system_prompt: Optional[str] = None, generation_kwargs: Optional[Dict[str, Any]] = None, ): """:param azure_endpoint: The endpoint of the deployed model, e.g. `https://example-resource.azure.openai.com/` :param api_version: The version of the API to use. Defaults to 2023-05-15 :param azure_deployment: The deployment of the model, usually the model name. :param api_key: The API key to use for authentication. :param azure_ad_token: Azure Active Directory token, see https://www.microsoft.com/en-us/security/business/identity-access/microsoft-entra-id :param azure_ad_token_provider: A function that returns an Azure Active Directory token, will be invoked on every request. :param organization: The Organization ID, defaults to `None`. See [production best practices](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization). :param streaming_callback: A callback function that is called when a new token is received from the stream. The callback function accepts StreamingChunk as an argument. :param system_prompt: The prompt to use for the system. If not provided, the system prompt will be :param generation_kwargs: Other parameters to use for the model. These parameters are all sent directly to the OpenAI endpoint. See OpenAI [documentation](https://platform.openai.com/docs/api-reference/chat) for more details. Some of the supported parameters: - `max_tokens`: The maximum number of tokens the output text can have. - `temperature`: What sampling temperature to use. Higher values mean the model will take more risks. Try 0.9 for more creative applications and 0 (argmax sampling) for ones with a well-defined answer. - `top_p`: An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass. So 0.1 means only the tokens comprising the top 10% probability mass are considered. - `n`: How many completions to generate for each prompt. For example, if the LLM gets 3 prompts and n is 2, it will generate two completions for each of the three prompts, ending up with 6 completions in total. - `stop`: One or more sequences after which the LLM should stop generating tokens. - `presence_penalty`: What penalty to apply if a token is already present at all. Bigger values mean the model will be less likely to repeat the same token in the text. - `frequency_penalty`: What penalty to apply if a token has already been generated in the text. Bigger values mean the model will be less likely to repeat the same token in the text. - `logit_bias`: Add a logit bias to specific tokens. The keys of the dictionary are tokens, and the values are the bias to add to that token.""" (definition of AzureOpenAIGenerator.to_dict:) def to_dict(self) -> Dict[str, Any]: """Serialize this component to a dictionary. :return: The serialized component as a dictionary.""" (definition of AzureOpenAIGenerator.from_dict:) def from_dict(cls, data: Dict[str, Any]) -> "AzureOpenAIGenerator": """Deserialize this component from a dictionary. :param data: The dictionary representation of this component. :return: The deserialized component instance.""" [end of new definitions in haystack/components/generators/azure.py] [start of new definitions in haystack/components/generators/chat/azure.py] (definition of AzureOpenAIChatGenerator:) class AzureOpenAIChatGenerator(OpenAIChatGenerator): """Enables text generation using OpenAI's large language models (LLMs) on Azure. It supports gpt-4 and gpt-3.5-turbo family of models accessed through the chat completions API endpoint. Users can pass any text generation parameters valid for the `openai.ChatCompletion.create` method directly to this component via the `**generation_kwargs` parameter in __init__ or the `**generation_kwargs` parameter in `run` method. For more details on OpenAI models deployed on Azure, refer to the Microsoft [documentation](https://learn.microsoft.com/en-us/azure/ai-services/openai/). ```python from haystack.components.generators.chat import AzureOpenAIGenerator from haystack.dataclasses import ChatMessage messages = [ChatMessage.from_user("What's Natural Language Processing?")] client = AzureOpenAIGenerator(azure_endpoint="<Your Azure endpoint e.g. `https://your-company.azure.openai.com/>", api_key="<you api key>", azure_deployment="<this a model name, e.g. gpt-35-turbo>") response = client.run(messages) print(response) >>{'replies': [ChatMessage(content='Natural Language Processing (NLP) is a branch of artificial intelligence >>that focuses on enabling computers to understand, interpret, and generate human language in a way that is >>meaningful and useful.', role=<ChatRole.ASSISTANT: 'assistant'>, name=None, >>meta={'model': 'gpt-3.5-turbo-0613', 'index': 0, 'finish_reason': 'stop', >>'usage': {'prompt_tokens': 15, 'completion_tokens': 36, 'total_tokens': 51}})]} ``` Key Features and Compatibility: - **Primary Compatibility**: Designed to work seamlessly with the OpenAI API Chat Completion endpoint and gpt-4 and gpt-3.5-turbo family of models. - **Streaming Support**: Supports streaming responses from the OpenAI API Chat Completion endpoint. - **Customizability**: Supports all parameters supported by the OpenAI API Chat Completion endpoint. Input and Output Format: - **ChatMessage Format**: This component uses the ChatMessage format for structuring both input and output, ensuring coherent and contextually relevant responses in chat-based text generation scenarios. Details on the ChatMessage format can be found at: https://github.com/openai/openai-python/blob/main/chatml.md.""" (definition of AzureOpenAIChatGenerator.__init__:) def __init__( self, azure_endpoint: Optional[str] = None, api_version: Optional[str] = "2023-05-15", azure_deployment: Optional[str] = "gpt-35-turbo", api_key: Optional[str] = None, azure_ad_token: Optional[str] = None, azure_ad_token_provider: Optional[AzureADTokenProvider] = None, organization: Optional[str] = None, streaming_callback: Optional[Callable[[StreamingChunk], None]] = None, generation_kwargs: Optional[Dict[str, Any]] = None, ): """:param azure_endpoint: The endpoint of the deployed model, e.g. `https://example-resource.azure.openai.com/` :param api_version: The version of the API to use. Defaults to 2023-05-15 :param azure_deployment: The deployment of the model, usually the model name. :param api_key: The API key to use for authentication. :param azure_ad_token: Azure Active Directory token, see https://www.microsoft.com/en-us/security/business/identity-access/microsoft-entra-id :param azure_ad_token_provider: A function that returns an Azure Active Directory token, will be invoked on every request. :param organization: The Organization ID, defaults to `None`. See [production best practices](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization). :param streaming_callback: A callback function that is called when a new token is received from the stream. The callback function accepts StreamingChunk as an argument. :param generation_kwargs: Other parameters to use for the model. These parameters are all sent directly to the OpenAI endpoint. See OpenAI [documentation](https://platform.openai.com/docs/api-reference/chat) for more details. Some of the supported parameters: - `max_tokens`: The maximum number of tokens the output text can have. - `temperature`: What sampling temperature to use. Higher values mean the model will take more risks. Try 0.9 for more creative applications and 0 (argmax sampling) for ones with a well-defined answer. - `top_p`: An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass. So 0.1 means only the tokens comprising the top 10% probability mass are considered. - `n`: How many completions to generate for each prompt. For example, if the LLM gets 3 prompts and n is 2, it will generate two completions for each of the three prompts, ending up with 6 completions in total. - `stop`: One or more sequences after which the LLM should stop generating tokens. - `presence_penalty`: What penalty to apply if a token is already present at all. Bigger values mean the model will be less likely to repeat the same token in the text. - `frequency_penalty`: What penalty to apply if a token has already been generated in the text. Bigger values mean the model will be less likely to repeat the same token in the text. - `logit_bias`: Add a logit bias to specific tokens. The keys of the dictionary are tokens, and the values are the bias to add to that token.""" (definition of AzureOpenAIChatGenerator.to_dict:) def to_dict(self) -> Dict[str, Any]: """Serialize this component to a dictionary. :return: The serialized component as a dictionary.""" (definition of AzureOpenAIChatGenerator.from_dict:) def from_dict(cls, data: Dict[str, Any]) -> "AzureOpenAIChatGenerator": """Deserialize this component from a dictionary. :param data: The dictionary representation of this component. :return: The deserialized component instance.""" [end of new definitions in haystack/components/generators/chat/azure.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

f4d9c2bb917be0ffe132dffcc2ad4f1b0fcc5967

pvlib__pvlib-python-1940

1,940

pvlib/pvlib-python

0.9

6bb149fa8c933ea32a060198864a12887dc5c538

2023-12-22T21:20:00Z

diff --git a/docs/sphinx/source/reference/pv_modeling/system_models.rst b/docs/sphinx/source/reference/pv_modeling/system_models.rst index c2c55d2580..55e01f437e 100644 --- a/docs/sphinx/source/reference/pv_modeling/system_models.rst +++ b/docs/sphinx/source/reference/pv_modeling/system_models.rst @@ -47,3 +47,11 @@ ADR model pvarray.pvefficiency_adr pvarray.fit_pvefficiency_adr + +PVGIS model +^^^^^^^^^^^ + +.. autosummary:: + :toctree: ../generated/ + + pvarray.huld diff --git a/docs/sphinx/source/whatsnew/v0.10.4.rst b/docs/sphinx/source/whatsnew/v0.10.4.rst index df73d68e98..adb9c3e251 100644 --- a/docs/sphinx/source/whatsnew/v0.10.4.rst +++ b/docs/sphinx/source/whatsnew/v0.10.4.rst @@ -7,6 +7,7 @@ v0.10.4 (Anticipated March, 2024) Enhancements ~~~~~~~~~~~~ +* Added the Huld PV model used by PVGIS (:pull:`1940`) Bug fixes @@ -28,4 +29,5 @@ Requirements Contributors ~~~~~~~~~~~~ +* Cliff Hansen (:ghuser:`cwhanse`) * :ghuser:`matsuobasho` diff --git a/pvlib/pvarray.py b/pvlib/pvarray.py index e8968886e1..a8bbd36eb3 100644 --- a/pvlib/pvarray.py +++ b/pvlib/pvarray.py @@ -223,3 +223,128 @@ def adr_wrapper(xdata, *params): return dict(zip(P_NAMES, popt)) else: return popt + + +def _infer_k_huld(cell_type, pdc0): + # from PVGIS documentation, "PVGIS data sources & calculation methods", + # Section 5.2.3, accessed 12/22/2023 + # The parameters in PVGIS' documentation are for a version of Huld's + # equation that has factored Pdc0 out of the polynomial: + # P = G/1000 * Pdc0 * (1 + k1 log(Geff) + ...) so these parameters are + # multiplied by pdc0 + huld_params = {'csi': (-0.017237, -0.040465, -0.004702, 0.000149, + 0.000170, 0.000005), + 'cis': (-0.005554, -0.038724, -0.003723, -0.000905, + -0.001256, 0.000001), + 'cdte': (-0.046689, -0.072844, -0.002262, 0.000276, + 0.000159, -0.000006)} + k = tuple([x*pdc0 for x in huld_params[cell_type.lower()]]) + return k + + +def huld(effective_irradiance, temp_mod, pdc0, k=None, cell_type=None): + r""" + Power (DC) using the Huld model. + + The Huld model [1]_ is used by PVGIS and is given by + + + .. math:: + + P_{dc} &= G' ( P_{dc0} + k_1 \log(G') + k_2 \log^2 (G') + k_3 T' + + k_4 T' \log(G') + k_5 T' \log^2 (G') + k_6 T'^2) + + G' &= \frac{G_{poa eff}}{1000} + + T' &= T_{mod} - 25^{\circ}C + + + Parameters + ---------- + effective_irradiance : numeric + The irradiance that is converted to photocurrent. [:math:`W/m^2`] + temp_mod: numeric + Module back-surface temperature. [C] + pdc0: numeric + Power of the modules at reference conditions 1000 :math:`W/m^2` + and :math:`25^{\circ}C`. [W] + k : tuple, optional + Empirical coefficients used in the power model. Length 6. If ``k`` is + not provided, ``cell_type`` must be specified. + cell_type : str, optional + If provided, must be one of ``'cSi'``, ``'CIS'``, or ``'CdTe'``. + Used to look up default values for ``k`` if ``k`` is not specified. + + Returns + ------- + pdc: numeric + DC power. [W] + + Raises + ------ + ValueError + If neither ``k`` nor ``cell_type`` are specified. + + Notes + ----- + The equation for :math:`P_{dc}` is from [1]_. The expression used in PVGIS + documentation differs by factoring :math:`P_{dc0}` out of the + polynomial: + + .. math:: + + P_{dc} = G' P_{dc0} (1 + k'_1 \log(G') + k'_2 \log^2 (G') + k'_3 T' + + k'_4 T' \log(G') + k'_5 T' \log^2 (G') + k'_6 T'^2) + + + PVGIS documentation shows a table of default parameters :math:`k'` for + different cell types. The parameters :math:`k'` differ from the parameters + :math:`k` for :py:func:`huld` by the factor ``pdc0``, that is, + + .. math:: + + k = P_{dc0} k' + + With default values for :math:`k`, at very low irradiance, i.e., + :math:`G' < 20 W/m^2`, :math:`P_{dc}` may be negative + due to the terms involving :math:`\log(G')`. + + :py:func:`huld` is a component of the PV performance model implemented in + PVGIS. Among other components, the full PVGIS model includes: + - the Faiman model for module temperature + :py:func:`pvlib.temperature.faiman` + - the Martin and Ruiz model for the incidence angle modifier (IAM) + :py:func:`pvlib.iam.martin_ruiz` + - a custom model for a spectral adjustment factor + The PVGIS API (see :py:func:`pvlib.iotools.get_pvgis_hourly`) returns + broadband plane-of-array irradiance (``poa_global``) and DC power (``P``). + ``poa_global`` is irradiance before applying the IAM and spectral + adjustments. In contrast the ``effective_irradiance`` for :py:func:`huld` + should have the IAM and spectral adjustments. Users comparing output of + :py:func:`huld` to PVGIS' ``P`` values should expect differences unless + ``effective_irradiance`` is computed in the same way as done by PVGIS. + + References + ---------- + .. [1] T. Huld, G. Friesen, A. Skoczek, R. Kenny, T. Sample, M. Field, + E. Dunlop. A power-rating model for crystalline silicon PV modules. + Solar Energy Materials and Solar Cells 95, (2011), pp. 3359-3369. + :doi:`10.1016/j.solmat.2011.07.026`. + """ + if k is None: + if cell_type is not None: + k = _infer_k_huld(cell_type, pdc0) + else: + raise ValueError('Either k or cell_type must be specified') + + gprime = effective_irradiance / 1000 + tprime = temp_mod - 25 + # accomodate gprime<=0 + with np.errstate(divide='ignore'): + logGprime = np.log(gprime, out=np.zeros_like(gprime), + where=np.array(gprime > 0)) + # Eq. 1 in [1] + pdc = gprime * (pdc0 + k[0] * logGprime + k[1] * logGprime**2 + + k[2] * tprime + k[3] * tprime * logGprime + + k[4] * tprime * logGprime**2 + k[5] * tprime**2) + return pdc

diff --git a/pvlib/tests/test_pvarray.py b/pvlib/tests/test_pvarray.py index 6dcacdefe1..693ef78b2a 100644 --- a/pvlib/tests/test_pvarray.py +++ b/pvlib/tests/test_pvarray.py @@ -1,5 +1,8 @@ import numpy as np +import pandas as pd from numpy.testing import assert_allclose +from .conftest import assert_series_equal +import pytest from pvlib import pvarray @@ -44,3 +47,25 @@ def test_pvefficiency_adr_round_trip(): params = pvarray.fit_pvefficiency_adr(g, t, eta, dict_output=False) result = pvarray.pvefficiency_adr(g, t, *params) assert_allclose(result, eta, atol=1e-6) + + +def test_huld(): + pdc0 = 100 + res = pvarray.huld(1000, 25, pdc0, cell_type='cSi') + assert np.isclose(res, pdc0) + exp_sum = np.exp(1) * (np.sum(pvarray._infer_k_huld('cSi', pdc0)) + pdc0) + res = pvarray.huld(1000*np.exp(1), 26, pdc0, cell_type='cSi') + assert np.isclose(res, exp_sum) + res = pvarray.huld(100, 30, pdc0, k=(1, 1, 1, 1, 1, 1)) + exp_100 = 0.1 * (pdc0 + np.log(0.1) + np.log(0.1)**2 + 5 + 5*np.log(0.1) + + 5*np.log(0.1)**2 + 25) + assert np.isclose(res, exp_100) + # Series input, and irradiance = 0 + eff_irr = pd.Series([1000, 100, 0]) + tm = pd.Series([25, 30, 30]) + expected = pd.Series([pdc0, exp_100, 0]) + res = pvarray.huld(eff_irr, tm, pdc0, k=(1, 1, 1, 1, 1, 1)) + assert_series_equal(res, expected) + with pytest.raises(ValueError, + match='Either k or cell_type must be specified'): + res = pvarray.huld(1000, 25, 100) diff --git a/pvlib/tests/test_pvsystem.py b/pvlib/tests/test_pvsystem.py index 6557d77e10..ebc59a838a 100644 --- a/pvlib/tests/test_pvsystem.py +++ b/pvlib/tests/test_pvsystem.py @@ -12,7 +12,6 @@ import unittest.mock as mock from pvlib import inverter, pvsystem -from pvlib import atmosphere from pvlib import iam as _iam from pvlib import irradiance from pvlib import spectrum

diff --git a/docs/sphinx/source/reference/pv_modeling/system_models.rst b/docs/sphinx/source/reference/pv_modeling/system_models.rst index c2c55d2580..55e01f437e 100644 --- a/docs/sphinx/source/reference/pv_modeling/system_models.rst +++ b/docs/sphinx/source/reference/pv_modeling/system_models.rst @@ -47,3 +47,11 @@ ADR model pvarray.pvefficiency_adr pvarray.fit_pvefficiency_adr + +PVGIS model +^^^^^^^^^^^ + +.. autosummary:: + :toctree: ../generated/ + + pvarray.huld diff --git a/docs/sphinx/source/whatsnew/v0.10.4.rst b/docs/sphinx/source/whatsnew/v0.10.4.rst index df73d68e98..adb9c3e251 100644 --- a/docs/sphinx/source/whatsnew/v0.10.4.rst +++ b/docs/sphinx/source/whatsnew/v0.10.4.rst @@ -7,6 +7,7 @@ v0.10.4 (Anticipated March, 2024) Enhancements ~~~~~~~~~~~~ +* Added the Huld PV model used by PVGIS (:pull:`1940`) Bug fixes @@ -28,4 +29,5 @@ Requirements Contributors ~~~~~~~~~~~~ +* Cliff Hansen (:ghuser:`cwhanse`) * :ghuser:`matsuobasho`

[ { "components": [ { "doc": "", "lines": [ 228, 242 ], "name": "_infer_k_huld", "signature": "def _infer_k_huld(cell_type, pdc0):", "type": "function" }, { "doc": "Power (DC) using the Huld model.\n\nThe Huld model [1]_...

[ "pvlib/tests/test_pvarray.py::test_huld" ]

[ "pvlib/tests/test_pvarray.py::test_pvefficiency_adr", "pvlib/tests/test_pvarray.py::test_fit_pvefficiency_adr", "pvlib/tests/test_pvarray.py::test_pvefficiency_adr_round_trip", "pvlib/tests/test_pvsystem.py::test_PVSystem_get_iam[ashrae-model_params0]", "pvlib/tests/test_pvsystem.py::test_PVSystem_get_iam[p...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add Huld PV model ~~- [ ] Closes #xxxx~~ - [x] I am familiar with the [contributing guidelines](https://pvlib-python.readthedocs.io/en/latest/contributing.html) - [x] Tests added - [x] Updates entries in [`docs/sphinx/source/reference`](https://github.com/pvlib/pvlib-python/blob/main/docs/sphinx/source/reference) for API changes. - [x] Adds description and name entries in the appropriate "what's new" file in [`docs/sphinx/source/whatsnew`](https://github.com/pvlib/pvlib-python/tree/main/docs/sphinx/source/whatsnew) for all changes. Includes link to the GitHub Issue with `` :issue:`num` `` or this Pull Request with `` :pull:`num` ``. Includes contributor name and/or GitHub username (link with `` :ghuser:`user` ``). - [x] New code is fully documented. Includes [numpydoc](https://numpydoc.readthedocs.io/en/latest/format.html) compliant docstrings, examples, and comments where necessary. - [x] Pull request is nearly complete and ready for detailed review. - [x] Maintainer: Appropriate GitHub Labels (including `remote-data`) and Milestone are assigned to the Pull Request and linked Issue. Adds Huld's model for DC power. This model is used in PVGIS. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pvlib/pvarray.py] (definition of _infer_k_huld:) def _infer_k_huld(cell_type, pdc0): (definition of huld:) def huld(effective_irradiance, temp_mod, pdc0, k=None, cell_type=None): """Power (DC) using the Huld model. The Huld model [1]_ is used by PVGIS and is given by .. math:: P_{dc} &= G' ( P_{dc0} + k_1 \log(G') + k_2 \log^2 (G') + k_3 T' + k_4 T' \log(G') + k_5 T' \log^2 (G') + k_6 T'^2) G' &= \frac{G_{poa eff}}{1000} T' &= T_{mod} - 25^{\circ}C Parameters ---------- effective_irradiance : numeric The irradiance that is converted to photocurrent. [:math:`W/m^2`] temp_mod: numeric Module back-surface temperature. [C] pdc0: numeric Power of the modules at reference conditions 1000 :math:`W/m^2` and :math:`25^{\circ}C`. [W] k : tuple, optional Empirical coefficients used in the power model. Length 6. If ``k`` is not provided, ``cell_type`` must be specified. cell_type : str, optional If provided, must be one of ``'cSi'``, ``'CIS'``, or ``'CdTe'``. Used to look up default values for ``k`` if ``k`` is not specified. Returns ------- pdc: numeric DC power. [W] Raises ------ ValueError If neither ``k`` nor ``cell_type`` are specified. Notes ----- The equation for :math:`P_{dc}` is from [1]_. The expression used in PVGIS documentation differs by factoring :math:`P_{dc0}` out of the polynomial: .. math:: P_{dc} = G' P_{dc0} (1 + k'_1 \log(G') + k'_2 \log^2 (G') + k'_3 T' + k'_4 T' \log(G') + k'_5 T' \log^2 (G') + k'_6 T'^2) PVGIS documentation shows a table of default parameters :math:`k'` for different cell types. The parameters :math:`k'` differ from the parameters :math:`k` for :py:func:`huld` by the factor ``pdc0``, that is, .. math:: k = P_{dc0} k' With default values for :math:`k`, at very low irradiance, i.e., :math:`G' < 20 W/m^2`, :math:`P_{dc}` may be negative due to the terms involving :math:`\log(G')`. :py:func:`huld` is a component of the PV performance model implemented in PVGIS. Among other components, the full PVGIS model includes: - the Faiman model for module temperature :py:func:`pvlib.temperature.faiman` - the Martin and Ruiz model for the incidence angle modifier (IAM) :py:func:`pvlib.iam.martin_ruiz` - a custom model for a spectral adjustment factor The PVGIS API (see :py:func:`pvlib.iotools.get_pvgis_hourly`) returns broadband plane-of-array irradiance (``poa_global``) and DC power (``P``). ``poa_global`` is irradiance before applying the IAM and spectral adjustments. In contrast the ``effective_irradiance`` for :py:func:`huld` should have the IAM and spectral adjustments. Users comparing output of :py:func:`huld` to PVGIS' ``P`` values should expect differences unless ``effective_irradiance`` is computed in the same way as done by PVGIS. References ---------- .. [1] T. Huld, G. Friesen, A. Skoczek, R. Kenny, T. Sample, M. Field, E. Dunlop. A power-rating model for crystalline silicon PV modules. Solar Energy Materials and Solar Cells 95, (2011), pp. 3359-3369. :doi:`10.1016/j.solmat.2011.07.026`.""" [end of new definitions in pvlib/pvarray.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

d53f97e984bfdd268aa92f8bf482ced0edda0110

deepset-ai__haystack-6592

6,592

deepset-ai/haystack

null

f877704839dc585cf47305d97fd5011be367b907

2023-12-19T13:28:08Z

diff --git a/haystack/components/others/__init__.py b/haystack/components/others/__init__.py new file mode 100644 index 0000000000..cac8782cd1 --- /dev/null +++ b/haystack/components/others/__init__.py @@ -0,0 +1,3 @@ +from haystack.components.others.multiplexer import Multiplexer + +__all__ = ["Multiplexer"] diff --git a/haystack/components/others/multiplexer.py b/haystack/components/others/multiplexer.py new file mode 100644 index 0000000000..8c69172185 --- /dev/null +++ b/haystack/components/others/multiplexer.py @@ -0,0 +1,69 @@ +import sys +import logging +from typing import Any, Dict + +from haystack.core.component.types import Variadic +from haystack import component, default_to_dict, default_from_dict +from haystack.components.routers.conditional_router import serialize_type, deserialize_type + +if sys.version_info < (3, 10): + from typing_extensions import TypeAlias +else: + from typing import TypeAlias + + +logger = logging.getLogger(__name__) + + +@component +class Multiplexer: + """ + This component is used to distribute a single value to many components that may need it. + It can take such value from different sources (the user's input, or another component), so + it's only input is of Variadic type. + + The type of the expected input (and therefore of the output as well) must be given at init time. + + Example usage: + + ```python + >>> mp = Multiplexer(str) + >>> mp.run(value=["hello"]) + {"value" : "hello"} + + >>> mp = Multiplexer(int) + >>> mp.run(value=[3]) + {"value": 3} + ``` + + This component won't handle several inputs at the same time: it always only expects one. + If more than one input is received when run is invoked, it will raise a ValueError. + + ```python + >>> mp = Multiplexer(int) + >>> mp.run([2, 4]) + ValueError: Multiplexer expects only one input, but 2 were received. + + >>> mp = Multiplexer(int) + >>> mp.run([2, None]) + ValueError: Multiplexer expects only one input, but 2 were received. + ``` + """ + + def __init__(self, type_: TypeAlias): + self.type_ = type_ + component.set_input_types(self, value=Variadic[type_]) + component.set_output_types(self, value=type_) + + def to_dict(self): + return default_to_dict(self, type_=serialize_type(self.type_)) + + @classmethod + def from_dict(cls, data: Dict[str, Any]) -> "Multiplexer": + data["init_parameters"]["type_"] = deserialize_type(data["init_parameters"]["type_"]) + return default_from_dict(cls, data) + + def run(self, **kwargs): + if (inputs_count := len(kwargs["value"])) != 1: + raise ValueError(f"Multiplexer expects only one input, but {inputs_count} were received.") + return {"value": kwargs["value"][0]} diff --git a/releasenotes/notes/multiplexer-a7b1259bd20c144c.yaml b/releasenotes/notes/multiplexer-a7b1259bd20c144c.yaml new file mode 100644 index 0000000000..2ef1fbaa42 --- /dev/null +++ b/releasenotes/notes/multiplexer-a7b1259bd20c144c.yaml @@ -0,0 +1,3 @@ +features: + - | + Add `Multiplexer`. For an example of its usage, see https://github.com/deepset-ai/haystack/pull/6420.

diff --git a/test/components/others/test_multiplexer.py b/test/components/others/test_multiplexer.py new file mode 100644 index 0000000000..3488b61c28 --- /dev/null +++ b/test/components/others/test_multiplexer.py @@ -0,0 +1,32 @@ +import pytest + +from haystack.components.others import Multiplexer + + +class TestMultiplexer: + def test_one_value(self): + multiplexer = Multiplexer(int) + output = multiplexer.run(value=[2]) + assert output == {"value": 2} + + def test_one_value_of_wrong_type(self): + # Multiplexer does not type check the input + multiplexer = Multiplexer(int) + output = multiplexer.run(value=["hello"]) + assert output == {"value": "hello"} + + def test_one_value_of_none_type(self): + # Multiplexer does not type check the input + multiplexer = Multiplexer(int) + output = multiplexer.run(value=[None]) + assert output == {"value": None} + + def test_more_values_of_expected_type(self): + multiplexer = Multiplexer(int) + with pytest.raises(ValueError, match="Multiplexer expects only one input, but 3 were received."): + multiplexer.run(value=[2, 3, 4]) + + def test_no_values(self): + multiplexer = Multiplexer(int) + with pytest.raises(ValueError, match="Multiplexer expects only one input, but 0 were received."): + multiplexer.run(value=[])

diff --git a/releasenotes/notes/multiplexer-a7b1259bd20c144c.yaml b/releasenotes/notes/multiplexer-a7b1259bd20c144c.yaml new file mode 100644 index 0000000000..2ef1fbaa42 --- /dev/null +++ b/releasenotes/notes/multiplexer-a7b1259bd20c144c.yaml @@ -0,0 +1,3 @@ +features: + - | + Add `Multiplexer`. For an example of its usage, see https://github.com/deepset-ai/haystack/pull/6420.

[ { "components": [ { "doc": "This component is used to distribute a single value to many components that may need it.\nIt can take such value from different sources (the user's input, or another component), so\nit's only input is of Variadic type.\n\nThe type of the expected input (and therefore of...

[ "test/components/others/test_multiplexer.py::TestMultiplexer::test_one_value", "test/components/others/test_multiplexer.py::TestMultiplexer::test_one_value_of_wrong_type", "test/components/others/test_multiplexer.py::TestMultiplexer::test_one_value_of_none_type", "test/components/others/test_multiplexer.py::T...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat: `Multiplexer` ### Related Issues - See https://github.com/deepset-ai/haystack/pull/6420 ### Proposed Changes: Introduces a `Multiplexer` component that takes an arbitrary number of input connections, but expects only one value from them. This value is then redirected to the output, unchanged. Components like `Multiplexer` come very handy in looping pipelines such as https://github.com/deepset-ai/haystack/pull/6420, where the input is guaranteed to only come from one input connection, but several need to be made to the same component. They can also help simplify the input of a pipeline, as they can distribute a single input value to several components on behalf of the user. ### How did you test it? Local tests, CI ### Notes for the reviewer n/a ### Checklist - I have read the [contributors guidelines](https://github.com/deepset-ai/haystack/blob/main/CONTRIBUTING.md) and the [code of conduct](https://github.com/deepset-ai/haystack/blob/main/code_of_conduct.txt) - I have updated the related issue with new insights and changes - I added unit tests and updated the docstrings - I've used one of the [conventional commit types](https://www.conventionalcommits.org/en/v1.0.0/) for my PR title: `fix:`, `feat:`, `build:`, `chore:`, `ci:`, `docs:`, `style:`, `refactor:`, `perf:`, `test:`. - I documented my code - I ran [pre-commit hooks](https://github.com/deepset-ai/haystack/blob/main/CONTRIBUTING.md#installation) and fixed any issue ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in haystack/components/others/multiplexer.py] (definition of Multiplexer:) class Multiplexer: """This component is used to distribute a single value to many components that may need it. It can take such value from different sources (the user's input, or another component), so it's only input is of Variadic type. The type of the expected input (and therefore of the output as well) must be given at init time. Example usage: ```python >>> mp = Multiplexer(str) >>> mp.run(value=["hello"]) {"value" : "hello"} >>> mp = Multiplexer(int) >>> mp.run(value=[3]) {"value": 3} ``` This component won't handle several inputs at the same time: it always only expects one. If more than one input is received when run is invoked, it will raise a ValueError. ```python >>> mp = Multiplexer(int) >>> mp.run([2, 4]) ValueError: Multiplexer expects only one input, but 2 were received. >>> mp = Multiplexer(int) >>> mp.run([2, None]) ValueError: Multiplexer expects only one input, but 2 were received. ```""" (definition of Multiplexer.__init__:) def __init__(self, type_: TypeAlias): (definition of Multiplexer.to_dict:) def to_dict(self): (definition of Multiplexer.from_dict:) def from_dict(cls, data: Dict[str, Any]) -> "Multiplexer": (definition of Multiplexer.run:) def run(self, **kwargs): [end of new definitions in haystack/components/others/multiplexer.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

f4d9c2bb917be0ffe132dffcc2ad4f1b0fcc5967

deepset-ai__haystack-6582

6,582

deepset-ai/haystack

null

0ac1bdc6a0a741a18bde9d44321142c4efa91ad6

2023-12-18T10:07:47Z

diff --git a/haystack/components/converters/html.py b/haystack/components/converters/html.py index 71475aea5d..859f62fed9 100644 --- a/haystack/components/converters/html.py +++ b/haystack/components/converters/html.py @@ -1,6 +1,6 @@ import logging from pathlib import Path -from typing import Any, Dict, List, Optional, Union +from typing import Any, Dict, List, Optional, Union, Literal from boilerpy3 import extractors from haystack import Document, component @@ -28,6 +28,27 @@ class HTMLToDocument: """ + def __init__( + self, + extractor_type: Literal[ + "DefaultExtractor", + "ArticleExtractor", + "ArticleSentencesExtractor", + "LargestContentExtractor", + "CanolaExtractor", + "KeepEverythingExtractor", + "NumWordsRulesExtractor", + ] = "DefaultExtractor", + ): + """ + Create an HTMLToDocument component. + + :param extractor_type: The type of boilerpy3 extractor to use. Defaults to `DefaultExtractor`. + For more information on the different types of extractors, + see [boilerpy3 documentation](https://github.com/jmriebold/BoilerPy3?tab=readme-ov-file#extractors). + """ + self.extractor_type = extractor_type + @component.output_types(documents=List[Document]) def run(self, sources: List[Union[str, Path, ByteStream]], meta: Optional[List[Dict[str, Any]]] = None): """ @@ -46,7 +67,8 @@ def run(self, sources: List[Union[str, Path, ByteStream]], meta: Optional[List[D elif len(sources) != len(meta): raise ValueError("The length of the metadata list must match the number of sources.") - extractor = extractors.ArticleExtractor(raise_on_failure=False) + extractor_class = getattr(extractors, self.extractor_type) + extractor = extractor_class(raise_on_failure=False) for source, metadata in zip(sources, meta): try: diff --git a/releasenotes/notes/htmlconverter-allow-extractor-customizability-730ae129db17327a.yaml b/releasenotes/notes/htmlconverter-allow-extractor-customizability-730ae129db17327a.yaml new file mode 100644 index 0000000000..a77b947505 --- /dev/null +++ b/releasenotes/notes/htmlconverter-allow-extractor-customizability-730ae129db17327a.yaml @@ -0,0 +1,7 @@ +--- +enhancements: + - | + The `HTMLToDocument` converter now allows choosing the boilerpy3 extractor + to extract the content from the HTML document. + The default extractor has been changed to `DefaultExtractor`, which is better + for generic use cases than the previous default (`ArticleExtractor`).

diff --git a/test/components/converters/test_html_to_document.py b/test/components/converters/test_html_to_document.py index 437ab9e616..1cdb478127 100644 --- a/test/components/converters/test_html_to_document.py +++ b/test/components/converters/test_html_to_document.py @@ -18,6 +18,20 @@ def test_run(self, test_files_path): assert len(docs) == 1 assert "Haystack" in docs[0].content + def test_run_different_extractors(self, test_files_path): + """ + Test if the component runs correctly with different boilrepy3 extractors. + """ + sources = [test_files_path / "html" / "what_is_haystack.html"] + + converter_article = HTMLToDocument(extractor_type="ArticleExtractor") + converter_keep_everything = HTMLToDocument(extractor_type="KeepEverythingExtractor") + + doc_article = converter_article.run(sources=sources)["documents"][0] + doc_keep_everything = converter_keep_everything.run(sources=sources)["documents"][0] + + assert len(doc_keep_everything.content) > len(doc_article.content) + def test_run_doc_metadata(self, test_files_path): """ Test if the component runs correctly when metadata is supplied by the user.

diff --git a/releasenotes/notes/htmlconverter-allow-extractor-customizability-730ae129db17327a.yaml b/releasenotes/notes/htmlconverter-allow-extractor-customizability-730ae129db17327a.yaml new file mode 100644 index 0000000000..a77b947505 --- /dev/null +++ b/releasenotes/notes/htmlconverter-allow-extractor-customizability-730ae129db17327a.yaml @@ -0,0 +1,7 @@ +--- +enhancements: + - | + The `HTMLToDocument` converter now allows choosing the boilerpy3 extractor + to extract the content from the HTML document. + The default extractor has been changed to `DefaultExtractor`, which is better + for generic use cases than the previous default (`ArticleExtractor`).

[ { "components": [ { "doc": "Create an HTMLToDocument component.\n\n:param extractor_type: The type of boilerpy3 extractor to use. Defaults to `DefaultExtractor`.\n For more information on the different types of extractors,\n see [boilerpy3 documentation](https://github.com/jmriebold/BoilerPy3?ta...

[ "test/components/converters/test_html_to_document.py::TestHTMLToDocument::test_run_different_extractors" ]

[ "[", "test/components/converters/test_html_to_document.py::TestHTMLToDocument::test_run", "test/components/converters/test_html_to_document.py::TestHTMLToDocument::test_run_doc_metadata", "test/components/converters/test_html_to_document.py::TestHTMLToDocument::test_incorrect_meta", "test/components/convert...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat!: `HTMLToDocument` - allow choosing the boilerpy3 extractor ### Related Issues - fixes #6579 ### Proposed Changes: - allow choosing the boilerpy3 extractor to extract the content from the HTML document - change the default extractor to `DefaultExtractor`, which is better for generic use cases than the previous default (`ArticleExtractor`). ### How did you test it? CI, new test. ### Checklist - I have read the [contributors guidelines](https://github.com/deepset-ai/haystack/blob/main/CONTRIBUTING.md) and the [code of conduct](https://github.com/deepset-ai/haystack/blob/main/code_of_conduct.txt) - I have updated the related issue with new insights and changes - I added unit tests and updated the docstrings - I've used one of the [conventional commit types](https://www.conventionalcommits.org/en/v1.0.0/) for my PR title: `fix:`, `feat:`, `build:`, `chore:`, `ci:`, `docs:`, `style:`, `refactor:`, `perf:`, `test:`. - I documented my code - I ran [pre-commit hooks](https://github.com/deepset-ai/haystack/blob/main/CONTRIBUTING.md#installation) and fixed any issue ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in haystack/components/converters/html.py] (definition of HTMLToDocument.__init__:) def __init__( self, extractor_type: Literal[ "DefaultExtractor", "ArticleExtractor", "ArticleSentencesExtractor", "LargestContentExtractor", "CanolaExtractor", "KeepEverythingExtractor", "NumWordsRulesExtractor", ] = "DefaultExtractor", ): """Create an HTMLToDocument component. :param extractor_type: The type of boilerpy3 extractor to use. Defaults to `DefaultExtractor`. For more information on the different types of extractors, see [boilerpy3 documentation](https://github.com/jmriebold/BoilerPy3?tab=readme-ov-file#extractors).""" [end of new definitions in haystack/components/converters/html.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> `HTMLToDocument` sometimes skips some relevant text **Describe the bug** `HTMLToDocument` uses `ArticleExtractor` from [boilerpy3](https://github.com/jmriebold/BoilerPy3). This extractor is tuned towards news articles and sometimes skips some relevant text. **To Reproduce** ```python from haystack.components.fetchers import LinkContentFetcher from haystack.components.converters import HTMLToDocument lc = LinkContentFetcher() hd = HTMLToDocument() out=lc.run(urls=["https://www.rainforest-alliance.org/species/capybara/"]) print('largest rodents' in str(out['streams'][0])) # True doc=hd.run(sources=out['streams'])['documents'][0] print('largest rodents' in doc.content) # False ``` **Expected behavior** - I would like to configure the best [boilerpy3 extractor](https://github.com/jmriebold/BoilerPy3?tab=readme-ov-file#extractors) for my use case - The default extractor should probably be more generic (e.g., `DefaultExtractor`) **System:** - Haystack version (commit or version number): 2.0.0b3 ---------- -------------------- </issues>

f4d9c2bb917be0ffe132dffcc2ad4f1b0fcc5967

conan-io__conan-15284

15,284

conan-io/conan

null

98d8f6aaa074b2bf6b827a359daf415f447a86a3

2023-12-16T10:42:15Z

diff --git a/conan/api/subapi/lockfile.py b/conan/api/subapi/lockfile.py index e9fc4daf337..7e4bf7de760 100644 --- a/conan/api/subapi/lockfile.py +++ b/conan/api/subapi/lockfile.py @@ -88,6 +88,12 @@ def add_lockfile(lockfile=None, requires=None, build_requires=None, python_requi python_requires=python_requires) return lockfile + @staticmethod + def remove_lockfile(lockfile, requires=None, build_requires=None, python_requires=None): + lockfile.remove(requires=requires, build_requires=build_requires, + python_requires=python_requires) + return lockfile + @staticmethod def save_lockfile(lockfile, lockfile_out, path=None): if lockfile_out is not None: diff --git a/conan/cli/commands/lock.py b/conan/cli/commands/lock.py index 9831337c29c..31630863a43 100644 --- a/conan/cli/commands/lock.py +++ b/conan/cli/commands/lock.py @@ -6,7 +6,6 @@ from conan.cli import make_abs_path from conan.cli.args import common_graph_args, validate_common_graph_args from conan.cli.printers.graph import print_graph_packages, print_graph_basic -from conans.client.cache.cache import ClientCache from conans.model.graph_lock import Lockfile, LOCKFILE from conans.model.recipe_ref import RecipeReference @@ -124,3 +123,27 @@ def _parse_requires(reqs): python_requires=python_requires, build_requires=build_requires) conan_api.lockfile.save_lockfile(lockfile, args.lockfile_out) + + +@conan_subcommand() +def lock_remove(conan_api, parser, subparser, *args): + """ + Remove requires, build-requires or python-requires from an existing or new lockfile. + References can be supplied with and without revisions like "--requires=pkg/version", + """ + subparser.add_argument('--requires', action="append", help='Remove references to lockfile.') + subparser.add_argument('--build-requires', action="append", + help='Remove build-requires from lockfile') + subparser.add_argument('--python-requires', action="append", + help='Remove python-requires from lockfile') + subparser.add_argument("--lockfile-out", action=OnceArgument, default=LOCKFILE, + help="Filename of the created lockfile") + subparser.add_argument("--lockfile", action=OnceArgument, help="Filename of the input lockfile") + args = parser.parse_args(*args) + + lockfile = conan_api.lockfile.get_lockfile(lockfile=args.lockfile, partial=True) + lockfile = conan_api.lockfile.remove_lockfile(lockfile, + requires=args.requires, + python_requires=args.python_requires, + build_requires=args.build_requires) + conan_api.lockfile.save_lockfile(lockfile, args.lockfile_out) diff --git a/conans/model/graph_lock.py b/conans/model/graph_lock.py index 789bb081824..3786beb07d5 100644 --- a/conans/model/graph_lock.py +++ b/conans/model/graph_lock.py @@ -1,3 +1,4 @@ +import fnmatch import json import os from collections import OrderedDict @@ -6,6 +7,7 @@ from conans.client.graph.graph import RECIPE_VIRTUAL, RECIPE_CONSUMER, CONTEXT_BUILD, Overrides from conans.errors import ConanException from conans.model.recipe_ref import RecipeReference +from conans.model.version_range import VersionRange from conans.util.files import load, save LOCKFILE = "conan.lock" @@ -64,6 +66,23 @@ def add(self, ref, package_ids=None): raise ConanException(f"Cannot add {ref} to lockfile, already exists") self._requires[ref] = package_ids + def remove(self, pattern): + ref = RecipeReference.loads(pattern) + version = str(ref.version) + remove = [] + if version.startswith("[") and version.endswith("]"): + version_range = VersionRange(version[1:-1]) + for k, v in self._requires.items(): + if fnmatch.fnmatch(k.name, ref.name) and version_range.contains(k.version, None): + new_pattern = f"{k.name}/*@{ref.user or ''}" + new_pattern += f"/{ref.channel}" if ref.channel else "" + if k.matches(new_pattern, False): + remove.append(k) + else: + remove = [k for k in self._requires if k.matches(pattern, False)] + self._requires = OrderedDict((k, v) for k, v in self._requires.items() if k not in remove) + return remove + def sort(self): self._requires = OrderedDict(reversed(sorted(self._requires.items()))) @@ -171,6 +190,19 @@ def add(self, requires=None, build_requires=None, python_requires=None): self._python_requires.add(r) self._python_requires.sort() + def remove(self, requires=None, build_requires=None, python_requires=None): + def _remove(reqs, self_reqs, name): + if reqs: + removed = [] + for r in reqs: + removed.extend(self_reqs.remove(r)) + for d in removed: + ConanOutput().info(f"Removed locked {name}: {d.repr_notime()}") + + _remove(requires, self._requires, "require") + _remove(build_requires, self._build_requires, "build_require") + _remove(python_requires, self._python_requires, "python_require") + @staticmethod def deserialize(data): """ constructs a GraphLock from a json like dict

diff --git a/conans/test/integration/lockfile/test_user_overrides.py b/conans/test/integration/lockfile/test_user_overrides.py index f37a91c4259..53648a5c6c2 100644 --- a/conans/test/integration/lockfile/test_user_overrides.py +++ b/conans/test/integration/lockfile/test_user_overrides.py @@ -1,4 +1,7 @@ import json +import textwrap + +import pytest from conans.test.assets.genconanfile import GenConanfile from conans.test.utils.tools import TestClient @@ -211,3 +214,106 @@ def test_lock_add_error(): c = TestClient() c.run(f"lock add --requires=math/1.0:pid1", assert_error=True) assert "ERROR: Invalid recipe reference 'math/1.0:pid1' is a package reference" in c.out + + +class TestLockRemove: + @pytest.mark.parametrize("args, removed", [ + ("--requires=math/*", ["math"]), + ("--requires=math/2.0", []), + ("--build-requires=cmake/1.0", ["cmake"]), + # Not valid ("--build-requires=*", ["cmake", "ninja"]), + ("--build-requires=*/*", ["cmake", "ninja"]), # But this is valid + ("--python-requires=mytool/*", ["mytool"]), + ("--python-requires=*tool/*", ["mytool", "othertool"]), + # With version ranges + ('--requires="math/[>=1.0 <2]"', ["math"]), + ('--requires="math/[>1.0]"', []), + ('--requires="*/[>=1.0 <2]"', ["math", "engine"]) + ]) + def test_lock_remove(self, args, removed): + c = TestClient() + lock = textwrap.dedent("""\ + { + "version": "0.5", + "requires": [ + "math/1.0#85d927a4a067a531b1a9c7619522c015%1702683583.3411012", + "math/1.0#12345%1702683584.3411012", + "engine/1.0#fd2b006646a54397c16a1478ac4111ac%1702683583.3544693" + ], + "build_requires": [ + "cmake/1.0#85d927a4a067a531b1a9c7619522c015%1702683583.3411012", + "ninja/1.0#fd2b006646a54397c16a1478ac4111ac%1702683583.3544693" + ], + "python_requires": [ + "mytool/1.0#85d927a4a067a531b1a9c7619522c015%1702683583.3411012", + "othertool/1.0#fd2b006646a54397c16a1478ac4111ac%1702683583.3544693" + ] + } + """) + c.save({"conan.lock": lock}) + c.run(f"lock remove {args}") + lock = c.load("conan.lock") + for remove in removed: + assert remove not in lock + for pkg in {"math", "engine", "cmake", "ninja", "mytool", "othertool"}.difference(removed): + assert pkg in lock + + @pytest.mark.parametrize("args, removed", [ + ("--requires=math/1.0#12345*", ["math/1.0#123456789abcdef"]), + ("--requires=math/1.0#*", ["math/1.0#123456789abcdef", + "math/1.0#85d927a4a067a531b1a9c7619522c015"]), + ]) + def test_lock_remove_revisions(self, args, removed): + c = TestClient() + lock = textwrap.dedent("""\ + { + "version": "0.5", + "requires": [ + "math/1.0#123456789abcdef%1702683584.3411012", + "math/1.0#85d927a4a067a531b1a9c7619522c015%1702683583.3411012", + "engine/1.0#fd2b006646a54397c16a1478ac4111ac%1702683583.3544693" + ] + } + """) + c.save({"conan.lock": lock}) + c.run(f"lock remove {args}") + lock = c.load("conan.lock") + for remove in removed: + assert remove not in lock + for pkg in {"math/1.0#123456789abcdef", + "math/1.0#85d927a4a067a531b1a9c7619522c015", + "engine/1.0#fd2b006646a54397c16a1478ac4111ac"}.difference(removed): + assert pkg in lock + + @pytest.mark.parametrize("args, removed", [ + ("--requires=*/*@team", ["pkg/1.0@team"]), + ("--requires=*/*@team*", ["pkg/1.0@team", "math/2.0@team/stable"]), + ("--requires=*/*@user", ["math/1.0@user", "other/1.0@user"]), + ("--requires=*/*@", ["engine/1.0"]), # Remove those without user + # with version ranges + ("--requires=math/[*]@user", ["math/1.0@user"]), + ("--requires=math/[*]@team*", ["math/2.0@team/stable"]), + ]) + def test_lock_remove_user_channel(self, args, removed): + c = TestClient() + lock = textwrap.dedent("""\ + { + "version": "0.5", + "requires": [ + "math/1.0@user#123456789abcdef%1702683584.3411012", + "math/2.0@team/stable#123456789abcdef%1702683584.3411012", + "other/1.0@user#85d927a4a067a531b1a9c7619522c015%1702683583.3411012", + "pkg/1.0@team#85d927a4a067a531b1a9c7619522c015%1702683583.3411012", + "engine/1.0#fd2b006646a54397c16a1478ac4111ac%1702683583.3544693" + ] + } + """) + c.save({"conan.lock": lock}) + c.run(f"lock remove {args}") + lock = c.load("conan.lock") + for remove in removed: + assert remove not in lock + rest = {"math/1.0@user", "math/2.0@team/stable", + "other/1.0@user", "pkg/1.0@team", "engine/1.0"}.difference(removed) + for pkg in rest: + assert pkg in lock

[ { "components": [ { "doc": "", "lines": [ 92, 95 ], "name": "LockfileAPI.remove_lockfile", "signature": "def remove_lockfile(lockfile, requires=None, build_requires=None, python_requires=None):", "type": "function" } ], "fil...

[ "conans/test/integration/lockfile/test_user_overrides.py::TestLockRemove::test_lock_remove[--requires=math/*-removed0]", "conans/test/integration/lockfile/test_user_overrides.py::TestLockRemove::test_lock_remove[--requires=math/2.0-removed1]", "conans/test/integration/lockfile/test_user_overrides.py::TestLockRe...

[ "conans/test/integration/lockfile/test_user_overrides.py::test_user_overrides", "conans/test/integration/lockfile/test_user_overrides.py::test_user_build_overrides", "conans/test/integration/lockfile/test_user_overrides.py::test_user_python_overrides", "conans/test/integration/lockfile/test_user_overrides.py:...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> new lock remove command Changelog: Feature: New ``conan lock remove`` command to remove requires from lockfiles. Docs: https://github.com/conan-io/docs/pull/3496 I am proposing this PR to close: Close https://github.com/conan-io/conan/issues/14523 Close https://github.com/conan-io/conan/issues/14524 The idea is that updates are equivalent to something like: ```bash $ conan remove --requires=zlib/* && conan add --requires=zlib/1.2.11 ``` But it will allow us to first iterate and learn about the logic of removal of versions from lockfiles, because ``conan remove`` makes sense in isolation, even without ``lock update`` or ``lock add``, like for example using it before resolving it to latest with ``--lockfile-partial``. When we have clear what is the UX and UI for the removal, we can do a single command ``conan update`` or ``conan add`` with extra arguments ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conan/api/subapi/lockfile.py] (definition of LockfileAPI.remove_lockfile:) def remove_lockfile(lockfile, requires=None, build_requires=None, python_requires=None): [end of new definitions in conan/api/subapi/lockfile.py] [start of new definitions in conan/cli/commands/lock.py] (definition of lock_remove:) def lock_remove(conan_api, parser, subparser, *args): """Remove requires, build-requires or python-requires from an existing or new lockfile. References can be supplied with and without revisions like "--requires=pkg/version",""" [end of new definitions in conan/cli/commands/lock.py] [start of new definitions in conans/model/graph_lock.py] (definition of _LockRequires.remove:) def remove(self, pattern): (definition of Lockfile.remove:) def remove(self, requires=None, build_requires=None, python_requires=None): (definition of Lockfile.remove._remove:) def _remove(reqs, self_reqs, name): [end of new definitions in conans/model/graph_lock.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

4a5b19a75db9225316c8cb022a2dfb9705a2af34

astropy__astropy-15737

15,737

astropy/astropy

v5.3

f87e75d967fcf0ede5a1fe9f1326e4b84e333f94

2023-12-14T19:52:14Z

diff --git a/astropy/coordinates/baseframe.py b/astropy/coordinates/baseframe.py index 88a525feb8ff..7be15424b799 100644 --- a/astropy/coordinates/baseframe.py +++ b/astropy/coordinates/baseframe.py @@ -26,11 +26,12 @@ from astropy.utils.exceptions import AstropyWarning from . import representation as r -from .angles import Angle +from .angles import Angle, position_angle from .attributes import Attribute from .transformations import TransformGraph if TYPE_CHECKING: + from astropy.coordinates import Latitude, Longitude, SkyCoord from astropy.units import Unit @@ -1765,6 +1766,50 @@ def __eq__(self, value): def __ne__(self, value): return np.logical_not(self == value) + def _prepare_unit_sphere_coords( + self, other: BaseCoordinateFrame | SkyCoord + ) -> tuple[Longitude, Latitude, Longitude, Latitude]: + self_sph = self.represent_as(r.UnitSphericalRepresentation) + other_sph = ( + getattr(other, "frame", other) + .transform_to(self) + .represent_as(r.UnitSphericalRepresentation) + ) + return self_sph.lon, self_sph.lat, other_sph.lon, other_sph.lat + + def position_angle(self, other: BaseCoordinateFrame | SkyCoord) -> Angle: + """Compute the on-sky position angle to another coordinate. + + Parameters + ---------- + other : `~astropy.coordinates.BaseCoordinateFrame` or `~astropy.coordinates.SkyCoord` + The other coordinate to compute the position angle to. It is + treated as the "head" of the vector of the position angle. + + Returns + ------- + `~astropy.coordinates.Angle` + The (positive) position angle of the vector pointing from ``self`` + to ``other``, measured East from North. If either ``self`` or + ``other`` contain arrays, this will be an array following the + appropriate `numpy` broadcasting rules. + + Examples + -------- + >>> from astropy import units as u + >>> from astropy.coordinates import ICRS, SkyCoord + >>> c1 = SkyCoord(0*u.deg, 0*u.deg) + >>> c2 = ICRS(1*u.deg, 0*u.deg) + >>> c1.position_angle(c2).degree + 90.0 + >>> c2.position_angle(c1).degree + 270.0 + >>> c3 = SkyCoord(1*u.deg, 1*u.deg) + >>> c1.position_angle(c3).degree # doctest: +FLOAT_CMP + 44.995636455344844 + """ + return position_angle(*self._prepare_unit_sphere_coords(other)) + def separation(self, other): """ Computes on-sky separation between this coordinate and another. @@ -1800,18 +1845,9 @@ def separation(self, other): """ from .angles import Angle, angular_separation - self_unit_sph = self.represent_as(r.UnitSphericalRepresentation) - other_unit_sph = ( - getattr(other, "frame", other) - .transform_to(self) - .represent_as(r.UnitSphericalRepresentation) - ) - - # Get the separation as a Quantity, convert to Angle in degrees - sep = angular_separation( - self_unit_sph.lon, self_unit_sph.lat, other_unit_sph.lon, other_unit_sph.lat + return Angle( + angular_separation(*self._prepare_unit_sphere_coords(other)), unit=u.degree ) - return Angle(sep, unit=u.degree) def separation_3d(self, other): """ diff --git a/astropy/coordinates/sky_coordinate.py b/astropy/coordinates/sky_coordinate.py index 027d65e0d6f3..e446c4d272da 100644 --- a/astropy/coordinates/sky_coordinate.py +++ b/astropy/coordinates/sky_coordinate.py @@ -295,6 +295,7 @@ class name that allow for creating a |SkyCoord| object and transforming info = SkyCoordInfo() # Methods implemented by the underlying frame + position_angle: Callable[[BaseCoordinateFrame | SkyCoord], Angle] separation: Callable[[BaseCoordinateFrame | SkyCoord], Angle] separation_3d: Callable[[BaseCoordinateFrame | SkyCoord], Distance] @@ -1182,7 +1183,7 @@ def spherical_offsets_to(self, tocoord): -------- :meth:`~astropy.coordinates.BaseCoordinateFrame.separation` : for the *total* angular offset (not broken out into components). - position_angle : + :meth:`~astropy.coordinates.BaseCoordinateFrame.position_angle` : for the direction of the offset. """ @@ -1255,8 +1256,7 @@ def directional_offset_by(self, position_angle, separation): ------- newpoints : `~astropy.coordinates.SkyCoord` The coordinates for the location that corresponds to offsetting by - the given `position_angle` and - :meth:`~astropy.coordinates.BaseCoordinateFrame.separation`. + the given ``position_angle`` and ``separation``. Notes ----- @@ -1273,8 +1273,10 @@ def directional_offset_by(self, position_angle, separation): See Also -------- - position_angle : inverse operation for the ``position_angle`` component - :meth:`~astropy.coordinates.BaseCoordinateFrame.separation` : inverse operation for the ``separation`` component + :meth:`~astropy.coordinates.BaseCoordinateFrame.position_angle` : + inverse operation for the ``position_angle`` component + :meth:`~astropy.coordinates.BaseCoordinateFrame.separation` : + inverse operation for the ``separation`` component """ from .angles import offset_by @@ -1541,53 +1543,6 @@ def search_around_3d(self, searcharoundcoords, distlimit): searcharoundcoords, self, distlimit, storekdtree="_kdtree_3d" ) - def position_angle(self, other): - """ - Computes the on-sky position angle (East of North) between this - SkyCoord and another. - - Parameters - ---------- - other : |SkyCoord| - The other coordinate to compute the position angle to. It is - treated as the "head" of the vector of the position angle. - - Returns - ------- - pa : `~astropy.coordinates.Angle` - The (positive) position angle of the vector pointing from ``self`` - to ``other``. If either ``self`` or ``other`` contain arrays, this - will be an array following the appropriate `numpy` broadcasting - rules. - - Examples - -------- - >>> c1 = SkyCoord(0*u.deg, 0*u.deg) - >>> c2 = SkyCoord(1*u.deg, 0*u.deg) - >>> c1.position_angle(c2).degree - 90.0 - >>> c3 = SkyCoord(1*u.deg, 1*u.deg) - >>> c1.position_angle(c3).degree # doctest: +FLOAT_CMP - 44.995636455344844 - """ - from .angles import position_angle - - if not self.is_equivalent_frame(other): - try: - other = other.transform_to(self, merge_attributes=False) - except TypeError: - raise TypeError( - "Can only get position_angle to another " - "SkyCoord or a coordinate frame with data" - ) - - slat = self.represent_as(UnitSphericalRepresentation).lat - slon = self.represent_as(UnitSphericalRepresentation).lon - olat = other.represent_as(UnitSphericalRepresentation).lat - olon = other.represent_as(UnitSphericalRepresentation).lon - - return position_angle(slon, slat, olon, olat) - def skyoffset_frame(self, rotation=None): """ Returns the sky offset frame with this SkyCoord at the origin. diff --git a/docs/changes/coordinates/15737.feature.rst b/docs/changes/coordinates/15737.feature.rst new file mode 100644 index 000000000000..fd33dd6a78b8 --- /dev/null +++ b/docs/changes/coordinates/15737.feature.rst @@ -0,0 +1,2 @@ +``BaseCoordinateFrame`` now has a ``position_angle()`` method, which is the +same as the ``position_angle`` method of ``SkyCoord`` instances. diff --git a/docs/coordinates/matchsep.rst b/docs/coordinates/matchsep.rst index fdf2f1b140d9..209f373c7ef5 100644 --- a/docs/coordinates/matchsep.rst +++ b/docs/coordinates/matchsep.rst @@ -68,8 +68,8 @@ rather than the single scalar angular offset of a separation. offsets encountered in astronomy. The first piece of such functionality is the -:meth:`~astropy.coordinates.SkyCoord.position_angle` method. This method -computes the position angle between one +:meth:`~astropy.coordinates.BaseCoordinateFrame.position_angle` method. +This method computes the position angle between one |SkyCoord| instance and another (passed as the argument) following the astronomy convention (positive angles East of North):: @@ -79,8 +79,9 @@ astronomy convention (positive angles East of North):: <Angle 44.97818294 deg> The combination of :meth:`~astropy.coordinates.BaseCoordinateFrame.separation` -and :meth:`~astropy.coordinates.SkyCoord.position_angle` thus give a set of -directional offsets. To do the inverse operation — determining the new +and :meth:`~astropy.coordinates.BaseCoordinateFrame.position_angle` thus give a +set of directional offsets. +To do the inverse operation — determining the new "destination" coordinate given a separation and position angle — the :meth:`~astropy.coordinates.SkyCoord.directional_offset_by` method is provided:: diff --git a/docs/coordinates/skycoord.rst b/docs/coordinates/skycoord.rst index f73a1727e8ec..ff1914d32eaf 100644 --- a/docs/coordinates/skycoord.rst +++ b/docs/coordinates/skycoord.rst @@ -1256,7 +1256,7 @@ the available docstrings below: - `~astropy.coordinates.SkyCoord.match_to_catalog_sky`, - `~astropy.coordinates.SkyCoord.match_to_catalog_3d`, -- `~astropy.coordinates.SkyCoord.position_angle`, +- `~astropy.coordinates.BaseCoordinateFrame.position_angle`, - `~astropy.coordinates.BaseCoordinateFrame.separation`, - `~astropy.coordinates.BaseCoordinateFrame.separation_3d` - `~astropy.coordinates.SkyCoord.apply_space_motion`

diff --git a/astropy/coordinates/tests/test_frame_skycoord_common_methods.py b/astropy/coordinates/tests/test_frame_skycoord_common_methods.py new file mode 100644 index 000000000000..29fc2b5853be --- /dev/null +++ b/astropy/coordinates/tests/test_frame_skycoord_common_methods.py @@ -0,0 +1,39 @@ +# Licensed under a 3-clause BSD style license - see LICENSE.rst + +""" +Tests for methods that are implemented in `BaseCoordinateFrame`, +but are also exposed by `SkyCoord` instances. +""" + +import pytest + +from astropy import units as u +from astropy.coordinates import FK5, ICRS, SkyCoord +from astropy.tests.helper import assert_quantity_allclose + + +@pytest.mark.parametrize("self_class", [SkyCoord, ICRS]) +@pytest.mark.parametrize("other_class", [SkyCoord, ICRS]) +def test_position_angle_array(self_class, other_class): + c1 = self_class(0 * u.deg, [0, 1, 2] * u.deg) + c2 = other_class([-1, -2, -3] * u.deg, [0.1, 1.1, 2.1] * u.deg) + assert_quantity_allclose( + c1.position_angle(c2), [275.710887, 272.880921, 271.963607] * u.deg + ) + + +@pytest.mark.parametrize("self_class", [SkyCoord, ICRS]) +@pytest.mark.parametrize( + "other_coord,value", + [ + (SkyCoord(1 * u.deg, 0 * u.deg), 90 * u.deg), + (SkyCoord(1 * u.deg, 0.1 * u.deg), 84.289113 * u.deg), + (SkyCoord(1 * u.deg, 1 * u.deg), 44.995636455344844 * u.deg), + (ICRS(0 * u.deg, 1 * u.deg), 0 * u.deg), + (FK5(1 * u.deg, 0 * u.deg), 90.000139 * u.deg), + ], +) +def test_position_angle_scalar(self_class, other_coord, value): + assert_quantity_allclose( + self_class(0 * u.deg, 0 * u.deg).position_angle(other_coord), value + ) diff --git a/astropy/coordinates/tests/test_sky_coord.py b/astropy/coordinates/tests/test_sky_coord.py index 8e433d63618e..db5eb11b74e7 100644 --- a/astropy/coordinates/tests/test_sky_coord.py +++ b/astropy/coordinates/tests/test_sky_coord.py @@ -853,33 +853,6 @@ def test_none_transform(): npt.assert_array_equal(sc_arr5.ra, sc_arr2.transform_to("fk5").ra) -def test_position_angle(): - c1 = SkyCoord(0 * u.deg, 0 * u.deg) - - c2 = SkyCoord(1 * u.deg, 0 * u.deg) - assert_allclose(c1.position_angle(c2) - 90.0 * u.deg, 0 * u.deg) - - c3 = SkyCoord(1 * u.deg, 0.1 * u.deg) - assert c1.position_angle(c3) < 90 * u.deg - - c4 = SkyCoord(0 * u.deg, 1 * u.deg) - assert_allclose(c1.position_angle(c4), 0 * u.deg) - - carr1 = SkyCoord(0 * u.deg, [0, 1, 2] * u.deg) - carr2 = SkyCoord([-1, -2, -3] * u.deg, [0.1, 1.1, 2.1] * u.deg) - - res = carr1.position_angle(carr2) - assert res.shape == (3,) - assert np.all(res < 360 * u.degree) - assert np.all(res > 270 * u.degree) - - cicrs = SkyCoord(0 * u.deg, 0 * u.deg, frame="icrs") - cfk5 = SkyCoord(1 * u.deg, 0 * u.deg, frame="fk5") - # because of the frame transform, it's just a *bit* more than 90 degrees - assert cicrs.position_angle(cfk5) > 90.0 * u.deg - assert cicrs.position_angle(cfk5) < 91.0 * u.deg - - def test_position_angle_directly(): """Regression check for #3800: position_angle should accept floats.""" from astropy.coordinates import position_angle

diff --git a/docs/changes/coordinates/15737.feature.rst b/docs/changes/coordinates/15737.feature.rst new file mode 100644 index 000000000000..fd33dd6a78b8 --- /dev/null +++ b/docs/changes/coordinates/15737.feature.rst @@ -0,0 +1,2 @@ +``BaseCoordinateFrame`` now has a ``position_angle()`` method, which is the +same as the ``position_angle`` method of ``SkyCoord`` instances. diff --git a/docs/coordinates/matchsep.rst b/docs/coordinates/matchsep.rst index fdf2f1b140d9..209f373c7ef5 100644 --- a/docs/coordinates/matchsep.rst +++ b/docs/coordinates/matchsep.rst @@ -68,8 +68,8 @@ rather than the single scalar angular offset of a separation. offsets encountered in astronomy. The first piece of such functionality is the -:meth:`~astropy.coordinates.SkyCoord.position_angle` method. This method -computes the position angle between one +:meth:`~astropy.coordinates.BaseCoordinateFrame.position_angle` method. +This method computes the position angle between one |SkyCoord| instance and another (passed as the argument) following the astronomy convention (positive angles East of North):: @@ -79,8 +79,9 @@ astronomy convention (positive angles East of North):: <Angle 44.97818294 deg> The combination of :meth:`~astropy.coordinates.BaseCoordinateFrame.separation` -and :meth:`~astropy.coordinates.SkyCoord.position_angle` thus give a set of -directional offsets. To do the inverse operation — determining the new +and :meth:`~astropy.coordinates.BaseCoordinateFrame.position_angle` thus give a +set of directional offsets. +To do the inverse operation — determining the new "destination" coordinate given a separation and position angle — the :meth:`~astropy.coordinates.SkyCoord.directional_offset_by` method is provided:: diff --git a/docs/coordinates/skycoord.rst b/docs/coordinates/skycoord.rst index f73a1727e8ec..ff1914d32eaf 100644 --- a/docs/coordinates/skycoord.rst +++ b/docs/coordinates/skycoord.rst @@ -1256,7 +1256,7 @@ the available docstrings below: - `~astropy.coordinates.SkyCoord.match_to_catalog_sky`, - `~astropy.coordinates.SkyCoord.match_to_catalog_3d`, -- `~astropy.coordinates.SkyCoord.position_angle`, +- `~astropy.coordinates.BaseCoordinateFrame.position_angle`, - `~astropy.coordinates.BaseCoordinateFrame.separation`, - `~astropy.coordinates.BaseCoordinateFrame.separation_3d` - `~astropy.coordinates.SkyCoord.apply_space_motion`

[ { "components": [ { "doc": "", "lines": [ 1769, 1778 ], "name": "BaseCoordinateFrame._prepare_unit_sphere_coords", "signature": "def _prepare_unit_sphere_coords( self, other: BaseCoordinateFrame | SkyCoord ) -> tuple[Longitude, Latitude, Longitud...

[ "astropy/coordinates/tests/test_frame_skycoord_common_methods.py::test_position_angle_array[SkyCoord-ICRS]", "astropy/coordinates/tests/test_frame_skycoord_common_methods.py::test_position_angle_array[ICRS-ICRS]", "astropy/coordinates/tests/test_frame_skycoord_common_methods.py::test_position_angle_scalar[other...

[ "astropy/coordinates/tests/test_frame_skycoord_common_methods.py::test_position_angle_array[SkyCoord-SkyCoord]", "astropy/coordinates/tests/test_frame_skycoord_common_methods.py::test_position_angle_array[ICRS-SkyCoord]", "astropy/coordinates/tests/test_frame_skycoord_common_methods.py::test_position_angle_scal...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Move `position_angle()` from `SkyCoord` to `BaseCoordinateFrame` ### Description The first commit implements a new private method in `BaseCoordinateFrame` that simplifies the implementation of `separation()` and `position_angle()` methods. The second commit moves `position_angle()` from `SkyCoord` to `BaseCoordinateFrame`. The method remains accessible for `SkyCoord` instances because they have access to methods defined both in `SkyCoord` and in their underlying frame. I felt it appropriate to create a new file for testing methods that are implemented in `BaseCoordinateFrame`, but are exposed also by `SkyCoord` instances. That file should also include tests for `separation()` and `separation_3d()`, but moving those tests over would be beyond the scope of this pull request, which is large enough as it is.  - [x] By checking this box, the PR author has requested that maintainers do **NOT** use the "Squash and Merge" button. Maintainers should respect this when possible; however, the final decision is at the discretion of the maintainer that merges the PR. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in astropy/coordinates/baseframe.py] (definition of BaseCoordinateFrame._prepare_unit_sphere_coords:) def _prepare_unit_sphere_coords( self, other: BaseCoordinateFrame | SkyCoord ) -> tuple[Longitude, Latitude, Longitude, Latitude]: (definition of BaseCoordinateFrame.position_angle:) def position_angle(self, other: BaseCoordinateFrame | SkyCoord) -> Angle: """Compute the on-sky position angle to another coordinate. Parameters ---------- other : `~astropy.coordinates.BaseCoordinateFrame` or `~astropy.coordinates.SkyCoord` The other coordinate to compute the position angle to. It is treated as the "head" of the vector of the position angle. Returns ------- `~astropy.coordinates.Angle` The (positive) position angle of the vector pointing from ``self`` to ``other``, measured East from North. If either ``self`` or ``other`` contain arrays, this will be an array following the appropriate `numpy` broadcasting rules. Examples -------- >>> from astropy import units as u >>> from astropy.coordinates import ICRS, SkyCoord >>> c1 = SkyCoord(0*u.deg, 0*u.deg) >>> c2 = ICRS(1*u.deg, 0*u.deg) >>> c1.position_angle(c2).degree 90.0 >>> c2.position_angle(c1).degree 270.0 >>> c3 = SkyCoord(1*u.deg, 1*u.deg) >>> c1.position_angle(c3).degree # doctest: +FLOAT_CMP 44.995636455344844""" [end of new definitions in astropy/coordinates/baseframe.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

2d281019494aaebf522f6626c0dae37510c16688

googleapis__python-aiplatform-3105

3,105

googleapis/python-aiplatform

null

f54048ac67a4d4e3b8fc607f6321b3b4d48588d7

2023-12-13T23:04:29Z

diff --git a/google/cloud/aiplatform/jobs.py b/google/cloud/aiplatform/jobs.py index 653d31f73a..188b671b5c 100644 --- a/google/cloud/aiplatform/jobs.py +++ b/google/cloud/aiplatform/jobs.py @@ -252,6 +252,14 @@ def _block_until_complete(self): else: _LOGGER.log_action_completed_against_resource("run", "completed", self) + def wait_for_completion(self) -> None: + """Waits for job to complete. + + Raises: + RuntimeError: If job failed or cancelled. + """ + self._block_until_complete() + @classmethod def list( cls, @@ -609,6 +617,530 @@ def create( (jobs.BatchPredictionJob): Instantiated representation of the created batch prediction job. """ + return cls._submit_impl( + job_display_name=job_display_name, + model_name=model_name, + instances_format=instances_format, + predictions_format=predictions_format, + gcs_source=gcs_source, + bigquery_source=bigquery_source, + gcs_destination_prefix=gcs_destination_prefix, + bigquery_destination_prefix=bigquery_destination_prefix, + model_parameters=model_parameters, + machine_type=machine_type, + accelerator_type=accelerator_type, + accelerator_count=accelerator_count, + starting_replica_count=starting_replica_count, + max_replica_count=max_replica_count, + generate_explanation=generate_explanation, + explanation_metadata=explanation_metadata, + explanation_parameters=explanation_parameters, + labels=labels, + project=project, + location=location, + credentials=credentials, + encryption_spec_key_name=encryption_spec_key_name, + sync=sync, + create_request_timeout=create_request_timeout, + batch_size=batch_size, + model_monitoring_objective_config=model_monitoring_objective_config, + model_monitoring_alert_config=model_monitoring_alert_config, + analysis_instance_schema_uri=analysis_instance_schema_uri, + service_account=service_account, + # Main distinction of `create` vs `submit`: + wait_for_completion=True, + ) + + @classmethod + def submit( + cls, + *, + job_display_name: Optional[str] = None, + model_name: Union[str, "aiplatform.Model"], + instances_format: str = "jsonl", + predictions_format: str = "jsonl", + gcs_source: Optional[Union[str, Sequence[str]]] = None, + bigquery_source: Optional[str] = None, + gcs_destination_prefix: Optional[str] = None, + bigquery_destination_prefix: Optional[str] = None, + model_parameters: Optional[Dict] = None, + machine_type: Optional[str] = None, + accelerator_type: Optional[str] = None, + accelerator_count: Optional[int] = None, + starting_replica_count: Optional[int] = None, + max_replica_count: Optional[int] = None, + generate_explanation: Optional[bool] = False, + explanation_metadata: Optional["aiplatform.explain.ExplanationMetadata"] = None, + explanation_parameters: Optional[ + "aiplatform.explain.ExplanationParameters" + ] = None, + labels: Optional[Dict[str, str]] = None, + project: Optional[str] = None, + location: Optional[str] = None, + credentials: Optional[auth_credentials.Credentials] = None, + encryption_spec_key_name: Optional[str] = None, + create_request_timeout: Optional[float] = None, + batch_size: Optional[int] = None, + model_monitoring_objective_config: Optional[ + "aiplatform.model_monitoring.ObjectiveConfig" + ] = None, + model_monitoring_alert_config: Optional[ + "aiplatform.model_monitoring.AlertConfig" + ] = None, + analysis_instance_schema_uri: Optional[str] = None, + service_account: Optional[str] = None, + ) -> "BatchPredictionJob": + """Sumbit a batch prediction job (not waiting for completion). + + Args: + job_display_name (str): + Required. The user-defined name of the BatchPredictionJob. + The name can be up to 128 characters long and can be consist + of any UTF-8 characters. + model_name (Union[str, aiplatform.Model]): + Required. A fully-qualified model resource name or model ID. + Example: "projects/123/locations/us-central1/models/456" or + "456" when project and location are initialized or passed. + May optionally contain a version ID or alias in + {model_name}@{version} form. + + Or an instance of aiplatform.Model. + instances_format (str): + Required. The format in which instances are provided. Must be one + of the formats listed in `Model.supported_input_storage_formats`. + Default is "jsonl" when using `gcs_source`. If a `bigquery_source` + is provided, this is overridden to "bigquery". + predictions_format (str): + Required. The format in which Vertex AI outputs the + predictions, must be one of the formats specified in + `Model.supported_output_storage_formats`. + Default is "jsonl" when using `gcs_destination_prefix`. If a + `bigquery_destination_prefix` is provided, this is overridden to + "bigquery". + gcs_source (Optional[Sequence[str]]): + Google Cloud Storage URI(-s) to your instances to run + batch prediction on. They must match `instances_format`. + + bigquery_source (Optional[str]): + BigQuery URI to a table, up to 2000 characters long. For example: + `bq://projectId.bqDatasetId.bqTableId` + gcs_destination_prefix (Optional[str]): + The Google Cloud Storage location of the directory where the + output is to be written to. In the given directory a new + directory is created. Its name is + ``prediction-<model-display-name>-<job-create-time>``, where + timestamp is in YYYY-MM-DDThh:mm:ss.sssZ ISO-8601 format. + Inside of it files ``predictions_0001.<extension>``, + ``predictions_0002.<extension>``, ..., + ``predictions_N.<extension>`` are created where + ``<extension>`` depends on chosen ``predictions_format``, + and N may equal 0001 and depends on the total number of + successfully predicted instances. If the Model has both + ``instance`` and ``prediction`` schemata defined then each such + file contains predictions as per the ``predictions_format``. + If prediction for any instance failed (partially or + completely), then an additional ``errors_0001.<extension>``, + ``errors_0002.<extension>``,..., ``errors_N.<extension>`` + files are created (N depends on total number of failed + predictions). These files contain the failed instances, as + per their schema, followed by an additional ``error`` field + which as value has ```google.rpc.Status`` <Status>`__ + containing only ``code`` and ``message`` fields. + bigquery_destination_prefix (Optional[str]): + The BigQuery project or dataset location where the output is + to be written to. If project is provided, a new dataset is + created with name + ``prediction_<model-display-name>_<job-create-time>`` where + is made BigQuery-dataset-name compatible (for example, most + special characters become underscores), and timestamp is in + YYYY_MM_DDThh_mm_ss_sssZ "based on ISO-8601" format. In the + dataset two tables will be created, ``predictions``, and + ``errors``. If the Model has both + [instance][google.cloud.aiplatform.v1.PredictSchemata.instance_schema_uri] + and + [prediction][google.cloud.aiplatform.v1.PredictSchemata.parameters_schema_uri] + schemata defined then the tables have columns as follows: + The ``predictions`` table contains instances for which the + prediction succeeded, it has columns as per a concatenation + of the Model's instance and prediction schemata. The + ``errors`` table contains rows for which the prediction has + failed, it has instance columns, as per the instance schema, + followed by a single "errors" column, which as values has + [google.rpc.Status][google.rpc.Status] represented as a + STRUCT, and containing only ``code`` and ``message``. + model_parameters (Optional[Dict]): + The parameters that govern the predictions. The schema of + the parameters may be specified via the Model's `parameters_schema_uri`. + machine_type (Optional[str]): + The type of machine for running batch prediction on + dedicated resources. Not specifying machine type will result in + batch prediction job being run with automatic resources. + accelerator_type (Optional[str]): + The type of accelerator(s) that may be attached + to the machine as per `accelerator_count`. Only used if + `machine_type` is set. + accelerator_count (Optional[int]): + The number of accelerators to attach to the + `machine_type`. Only used if `machine_type` is set. + starting_replica_count (Optional[int]): + The number of machine replicas used at the start of the batch + operation. If not set, Vertex AI decides starting number, not + greater than `max_replica_count`. Only used if `machine_type` is + set. + max_replica_count (Optional[int]): + The maximum number of machine replicas the batch operation may + be scaled to. Only used if `machine_type` is set. + Default is 10. + generate_explanation (bool): + Optional. Generate explanation along with the batch prediction + results. This will cause the batch prediction output to include + explanations based on the `prediction_format`: + - `bigquery`: output includes a column named `explanation`. The value + is a struct that conforms to the [aiplatform.gapic.Explanation] object. + - `jsonl`: The JSON objects on each line include an additional entry + keyed `explanation`. The value of the entry is a JSON object that + conforms to the [aiplatform.gapic.Explanation] object. + - `csv`: Generating explanations for CSV format is not supported. + explanation_metadata (aiplatform.explain.ExplanationMetadata): + Optional. Explanation metadata configuration for this BatchPredictionJob. + Can be specified only if `generate_explanation` is set to `True`. + + This value overrides the value of `Model.explanation_metadata`. + All fields of `explanation_metadata` are optional in the request. If + a field of the `explanation_metadata` object is not populated, the + corresponding field of the `Model.explanation_metadata` object is inherited. + For more details, see `Ref docs <http://tinyurl.com/1igh60kt>` + explanation_parameters (aiplatform.explain.ExplanationParameters): + Optional. Parameters to configure explaining for Model's predictions. + Can be specified only if `generate_explanation` is set to `True`. + + This value overrides the value of `Model.explanation_parameters`. + All fields of `explanation_parameters` are optional in the request. If + a field of the `explanation_parameters` object is not populated, the + corresponding field of the `Model.explanation_parameters` object is inherited. + For more details, see `Ref docs <http://tinyurl.com/1an4zake>` + labels (Dict[str, str]): + Optional. The labels with user-defined metadata to organize your + BatchPredictionJobs. Label keys and values can be no longer than + 64 characters (Unicode codepoints), can only contain lowercase + letters, numeric characters, underscores and dashes. + International characters are allowed. See https://goo.gl/xmQnxf + for more information and examples of labels. + credentials (Optional[auth_credentials.Credentials]): + Custom credentials to use to create this batch prediction + job. Overrides credentials set in aiplatform.init. + encryption_spec_key_name (Optional[str]): + Optional. The Cloud KMS resource identifier of the customer + managed encryption key used to protect the job. Has the + form: + ``projects/my-project/locations/my-region/keyRings/my-kr/cryptoKeys/my-key``. + The key needs to be in the same region as where the compute + resource is created. + + If this is set, then all + resources created by the BatchPredictionJob will + be encrypted with the provided encryption key. + + Overrides encryption_spec_key_name set in aiplatform.init. + create_request_timeout (float): + Optional. The timeout for the create request in seconds. + batch_size (int): + Optional. The number of the records (e.g. instances) of the operation given in each batch + to a machine replica. Machine type, and size of a single record should be considered + when setting this parameter, higher value speeds up the batch operation's execution, + but too high value will result in a whole batch not fitting in a machine's memory, + and the whole operation will fail. + The default value is 64. + model_monitoring_objective_config (aiplatform.model_monitoring.ObjectiveConfig): + Optional. The objective config for model monitoring. Passing this parameter enables + monitoring on the model associated with this batch prediction job. + model_monitoring_alert_config (aiplatform.model_monitoring.EmailAlertConfig): + Optional. Configures how model monitoring alerts are sent to the user. Right now + only email alert is supported. + analysis_instance_schema_uri (str): + Optional. Only applicable if model_monitoring_objective_config is also passed. + This parameter specifies the YAML schema file uri describing the format of a single + instance that you want Tensorflow Data Validation (TFDV) to + analyze. If this field is empty, all the feature data types are + inferred from predict_instance_schema_uri, meaning that TFDV + will use the data in the exact format as prediction request/response. + If there are any data type differences between predict instance + and TFDV instance, this field can be used to override the schema. + For models trained with Vertex AI, this field must be set as all the + fields in predict instance formatted as string. + service_account (str): + Optional. Specifies the service account for workload run-as account. + Users submitting jobs must have act-as permission on this run-as account. + Returns: + (jobs.BatchPredictionJob): + Instantiated representation of the created batch prediction job. + """ + return cls._submit_impl( + job_display_name=job_display_name, + model_name=model_name, + instances_format=instances_format, + predictions_format=predictions_format, + gcs_source=gcs_source, + bigquery_source=bigquery_source, + gcs_destination_prefix=gcs_destination_prefix, + bigquery_destination_prefix=bigquery_destination_prefix, + model_parameters=model_parameters, + machine_type=machine_type, + accelerator_type=accelerator_type, + accelerator_count=accelerator_count, + starting_replica_count=starting_replica_count, + max_replica_count=max_replica_count, + generate_explanation=generate_explanation, + explanation_metadata=explanation_metadata, + explanation_parameters=explanation_parameters, + labels=labels, + project=project, + location=location, + credentials=credentials, + encryption_spec_key_name=encryption_spec_key_name, + create_request_timeout=create_request_timeout, + batch_size=batch_size, + model_monitoring_objective_config=model_monitoring_objective_config, + model_monitoring_alert_config=model_monitoring_alert_config, + analysis_instance_schema_uri=analysis_instance_schema_uri, + service_account=service_account, + # Main distinction of `create` vs `submit`: + wait_for_completion=False, + sync=True, + ) + + @classmethod + def _submit_impl( + cls, + *, + job_display_name: Optional[str] = None, + model_name: Union[str, "aiplatform.Model"], + instances_format: str = "jsonl", + predictions_format: str = "jsonl", + gcs_source: Optional[Union[str, Sequence[str]]] = None, + bigquery_source: Optional[str] = None, + gcs_destination_prefix: Optional[str] = None, + bigquery_destination_prefix: Optional[str] = None, + model_parameters: Optional[Dict] = None, + machine_type: Optional[str] = None, + accelerator_type: Optional[str] = None, + accelerator_count: Optional[int] = None, + starting_replica_count: Optional[int] = None, + max_replica_count: Optional[int] = None, + generate_explanation: Optional[bool] = False, + explanation_metadata: Optional["aiplatform.explain.ExplanationMetadata"] = None, + explanation_parameters: Optional[ + "aiplatform.explain.ExplanationParameters" + ] = None, + labels: Optional[Dict[str, str]] = None, + project: Optional[str] = None, + location: Optional[str] = None, + credentials: Optional[auth_credentials.Credentials] = None, + encryption_spec_key_name: Optional[str] = None, + sync: bool = True, + create_request_timeout: Optional[float] = None, + batch_size: Optional[int] = None, + model_monitoring_objective_config: Optional[ + "aiplatform.model_monitoring.ObjectiveConfig" + ] = None, + model_monitoring_alert_config: Optional[ + "aiplatform.model_monitoring.AlertConfig" + ] = None, + analysis_instance_schema_uri: Optional[str] = None, + service_account: Optional[str] = None, + wait_for_completion: bool = False, + ) -> "BatchPredictionJob": + """Create a batch prediction job. + + Args: + job_display_name (str): + Required. The user-defined name of the BatchPredictionJob. + The name can be up to 128 characters long and can be consist + of any UTF-8 characters. + model_name (Union[str, aiplatform.Model]): + Required. A fully-qualified model resource name or model ID. + Example: "projects/123/locations/us-central1/models/456" or + "456" when project and location are initialized or passed. + May optionally contain a version ID or alias in + {model_name}@{version} form. + + Or an instance of aiplatform.Model. + instances_format (str): + Required. The format in which instances are provided. Must be one + of the formats listed in `Model.supported_input_storage_formats`. + Default is "jsonl" when using `gcs_source`. If a `bigquery_source` + is provided, this is overridden to "bigquery". + predictions_format (str): + Required. The format in which Vertex AI outputs the + predictions, must be one of the formats specified in + `Model.supported_output_storage_formats`. + Default is "jsonl" when using `gcs_destination_prefix`. If a + `bigquery_destination_prefix` is provided, this is overridden to + "bigquery". + gcs_source (Optional[Sequence[str]]): + Google Cloud Storage URI(-s) to your instances to run + batch prediction on. They must match `instances_format`. + + bigquery_source (Optional[str]): + BigQuery URI to a table, up to 2000 characters long. For example: + `bq://projectId.bqDatasetId.bqTableId` + gcs_destination_prefix (Optional[str]): + The Google Cloud Storage location of the directory where the + output is to be written to. In the given directory a new + directory is created. Its name is + ``prediction-<model-display-name>-<job-create-time>``, where + timestamp is in YYYY-MM-DDThh:mm:ss.sssZ ISO-8601 format. + Inside of it files ``predictions_0001.<extension>``, + ``predictions_0002.<extension>``, ..., + ``predictions_N.<extension>`` are created where + ``<extension>`` depends on chosen ``predictions_format``, + and N may equal 0001 and depends on the total number of + successfully predicted instances. If the Model has both + ``instance`` and ``prediction`` schemata defined then each such + file contains predictions as per the ``predictions_format``. + If prediction for any instance failed (partially or + completely), then an additional ``errors_0001.<extension>``, + ``errors_0002.<extension>``,..., ``errors_N.<extension>`` + files are created (N depends on total number of failed + predictions). These files contain the failed instances, as + per their schema, followed by an additional ``error`` field + which as value has ```google.rpc.Status`` <Status>`__ + containing only ``code`` and ``message`` fields. + bigquery_destination_prefix (Optional[str]): + The BigQuery project or dataset location where the output is + to be written to. If project is provided, a new dataset is + created with name + ``prediction_<model-display-name>_<job-create-time>`` where + is made BigQuery-dataset-name compatible (for example, most + special characters become underscores), and timestamp is in + YYYY_MM_DDThh_mm_ss_sssZ "based on ISO-8601" format. In the + dataset two tables will be created, ``predictions``, and + ``errors``. If the Model has both + [instance][google.cloud.aiplatform.v1.PredictSchemata.instance_schema_uri] + and + [prediction][google.cloud.aiplatform.v1.PredictSchemata.parameters_schema_uri] + schemata defined then the tables have columns as follows: + The ``predictions`` table contains instances for which the + prediction succeeded, it has columns as per a concatenation + of the Model's instance and prediction schemata. The + ``errors`` table contains rows for which the prediction has + failed, it has instance columns, as per the instance schema, + followed by a single "errors" column, which as values has + [google.rpc.Status][google.rpc.Status] represented as a + STRUCT, and containing only ``code`` and ``message``. + model_parameters (Optional[Dict]): + The parameters that govern the predictions. The schema of + the parameters may be specified via the Model's `parameters_schema_uri`. + machine_type (Optional[str]): + The type of machine for running batch prediction on + dedicated resources. Not specifying machine type will result in + batch prediction job being run with automatic resources. + accelerator_type (Optional[str]): + The type of accelerator(s) that may be attached + to the machine as per `accelerator_count`. Only used if + `machine_type` is set. + accelerator_count (Optional[int]): + The number of accelerators to attach to the + `machine_type`. Only used if `machine_type` is set. + starting_replica_count (Optional[int]): + The number of machine replicas used at the start of the batch + operation. If not set, Vertex AI decides starting number, not + greater than `max_replica_count`. Only used if `machine_type` is + set. + max_replica_count (Optional[int]): + The maximum number of machine replicas the batch operation may + be scaled to. Only used if `machine_type` is set. + Default is 10. + generate_explanation (bool): + Optional. Generate explanation along with the batch prediction + results. This will cause the batch prediction output to include + explanations based on the `prediction_format`: + - `bigquery`: output includes a column named `explanation`. The value + is a struct that conforms to the [aiplatform.gapic.Explanation] object. + - `jsonl`: The JSON objects on each line include an additional entry + keyed `explanation`. The value of the entry is a JSON object that + conforms to the [aiplatform.gapic.Explanation] object. + - `csv`: Generating explanations for CSV format is not supported. + explanation_metadata (aiplatform.explain.ExplanationMetadata): + Optional. Explanation metadata configuration for this BatchPredictionJob. + Can be specified only if `generate_explanation` is set to `True`. + + This value overrides the value of `Model.explanation_metadata`. + All fields of `explanation_metadata` are optional in the request. If + a field of the `explanation_metadata` object is not populated, the + corresponding field of the `Model.explanation_metadata` object is inherited. + For more details, see `Ref docs <http://tinyurl.com/1igh60kt>` + explanation_parameters (aiplatform.explain.ExplanationParameters): + Optional. Parameters to configure explaining for Model's predictions. + Can be specified only if `generate_explanation` is set to `True`. + + This value overrides the value of `Model.explanation_parameters`. + All fields of `explanation_parameters` are optional in the request. If + a field of the `explanation_parameters` object is not populated, the + corresponding field of the `Model.explanation_parameters` object is inherited. + For more details, see `Ref docs <http://tinyurl.com/1an4zake>` + labels (Dict[str, str]): + Optional. The labels with user-defined metadata to organize your + BatchPredictionJobs. Label keys and values can be no longer than + 64 characters (Unicode codepoints), can only contain lowercase + letters, numeric characters, underscores and dashes. + International characters are allowed. See https://goo.gl/xmQnxf + for more information and examples of labels. + credentials (Optional[auth_credentials.Credentials]): + Custom credentials to use to create this batch prediction + job. Overrides credentials set in aiplatform.init. + encryption_spec_key_name (Optional[str]): + Optional. The Cloud KMS resource identifier of the customer + managed encryption key used to protect the job. Has the + form: + ``projects/my-project/locations/my-region/keyRings/my-kr/cryptoKeys/my-key``. + The key needs to be in the same region as where the compute + resource is created. + + If this is set, then all + resources created by the BatchPredictionJob will + be encrypted with the provided encryption key. + + Overrides encryption_spec_key_name set in aiplatform.init. + sync (bool): + Whether to execute this method synchronously. If False, this method + will be executed in concurrent Future and any downstream object will + be immediately returned and synced when the Future has completed. + create_request_timeout (float): + Optional. The timeout for the create request in seconds. + batch_size (int): + Optional. The number of the records (e.g. instances) of the operation given in each batch + to a machine replica. Machine type, and size of a single record should be considered + when setting this parameter, higher value speeds up the batch operation's execution, + but too high value will result in a whole batch not fitting in a machine's memory, + and the whole operation will fail. + The default value is 64. + model_monitoring_objective_config (aiplatform.model_monitoring.ObjectiveConfig): + Optional. The objective config for model monitoring. Passing this parameter enables + monitoring on the model associated with this batch prediction job. + model_monitoring_alert_config (aiplatform.model_monitoring.EmailAlertConfig): + Optional. Configures how model monitoring alerts are sent to the user. Right now + only email alert is supported. + analysis_instance_schema_uri (str): + Optional. Only applicable if model_monitoring_objective_config is also passed. + This parameter specifies the YAML schema file uri describing the format of a single + instance that you want Tensorflow Data Validation (TFDV) to + analyze. If this field is empty, all the feature data types are + inferred from predict_instance_schema_uri, meaning that TFDV + will use the data in the exact format as prediction request/response. + If there are any data type differences between predict instance + and TFDV instance, this field can be used to override the schema. + For models trained with Vertex AI, this field must be set as all the + fields in predict instance formatted as string. + service_account (str): + Optional. Specifies the service account for workload run-as account. + Users submitting jobs must have act-as permission on this run-as account. + wait_for_completion (bool): + Whether to wait for the job completion. + Returns: + (jobs.BatchPredictionJob): + Instantiated representation of the created batch prediction job. + """ # TODO(b/242108750): remove temporary logic once model monitoring for batch prediction is GA if model_monitoring_objective_config: from google.cloud.aiplatform.compat.types import ( @@ -802,18 +1334,19 @@ def create( gapic_batch_prediction_job.model_monitoring_config = gapic_mm_config # TODO(b/242108750): remove temporary logic once model monitoring for batch prediction is GA - return cls._create( + return cls._submit_and_optionally_wait_with_sync_support( empty_batch_prediction_job=empty_batch_prediction_job, model_or_model_name=model_name, gca_batch_prediction_job=gapic_batch_prediction_job, generate_explanation=generate_explanation, sync=sync, create_request_timeout=create_request_timeout, + wait_for_completion=wait_for_completion, ) @classmethod @base.optional_sync(return_input_arg="empty_batch_prediction_job") - def _create( + def _submit_and_optionally_wait_with_sync_support( cls, empty_batch_prediction_job: "BatchPredictionJob", model_or_model_name: Union[str, "aiplatform.Model"], @@ -821,6 +1354,7 @@ def _create( generate_explanation: bool, sync: bool = True, create_request_timeout: Optional[float] = None, + wait_for_completion: bool = True, ) -> "BatchPredictionJob": """Create a batch prediction job. @@ -839,6 +1373,8 @@ def _create( results. create_request_timeout (float): Optional. The timeout for the create request in seconds. + wait_for_completion (bool): + Whether to wait for the job completion. Returns: (jobs.BatchPredictionJob): Instantiated representation of the created batch prediction job. @@ -882,8 +1418,8 @@ def _create( _LOGGER.info( "View Batch Prediction Job:\n%s" % batch_prediction_job._dashboard_uri() ) - - batch_prediction_job._block_until_complete() + if wait_for_completion: + batch_prediction_job._block_until_complete() return batch_prediction_job

diff --git a/tests/unit/aiplatform/test_jobs.py b/tests/unit/aiplatform/test_jobs.py index 7f1cd8288e..79f99ea7e0 100644 --- a/tests/unit/aiplatform/test_jobs.py +++ b/tests/unit/aiplatform/test_jobs.py @@ -877,6 +877,34 @@ def test_batch_predict_job_done_create(self, create_batch_prediction_job_mock): assert batch_prediction_job.done() is True + @mock.patch.object(jobs, "_JOB_WAIT_TIME", 1) + @mock.patch.object(jobs, "_LOG_WAIT_TIME", 1) + @pytest.mark.usefixtures("get_batch_prediction_job_mock") + def test_batch_predict_job_submit(self, create_batch_prediction_job_mock): + aiplatform.init(project=_TEST_PROJECT, location=_TEST_LOCATION) + + # Make SDK batch_predict method call + batch_prediction_job = jobs.BatchPredictionJob._submit_impl( + model_name=_TEST_MODEL_NAME, + job_display_name=_TEST_BATCH_PREDICTION_JOB_DISPLAY_NAME, + gcs_source=_TEST_BATCH_PREDICTION_GCS_SOURCE, + gcs_destination_prefix=_TEST_BATCH_PREDICTION_GCS_DEST_PREFIX, + service_account=_TEST_SERVICE_ACCOUNT, + ) + + batch_prediction_job.wait_for_resource_creation() + assert batch_prediction_job.done() is False + assert ( + batch_prediction_job.state + != jobs.gca_job_state.JobState.JOB_STATE_SUCCEEDED + ) + + batch_prediction_job.wait_for_completion() + assert ( + batch_prediction_job.state + == jobs.gca_job_state.JobState.JOB_STATE_SUCCEEDED + ) + @mock.patch.object(jobs, "_JOB_WAIT_TIME", 1) @mock.patch.object(jobs, "_LOG_WAIT_TIME", 1) @pytest.mark.parametrize("sync", [True, False])

[ { "components": [ { "doc": "Waits for job to complete.\n\nRaises:\n RuntimeError: If job failed or cancelled.", "lines": [ 255, 261 ], "name": "_Job.wait_for_completion", "signature": "def wait_for_completion(self) -> None:", "type": "...

[ "tests/unit/aiplatform/test_jobs.py::TestBatchPredictionJob::test_batch_predict_job_submit" ]

[ "tests/unit/aiplatform/test_jobs.py::TestJob::test_init_job_class", "tests/unit/aiplatform/test_jobs.py::TestJob::test_cancel_mock_job", "tests/unit/aiplatform/test_jobs.py::TestBatchPredictionJob::test_init_batch_prediction_job", "tests/unit/aiplatform/test_jobs.py::TestBatchPredictionJob::test_batch_predict...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat: Added the `BatchPredictionJob.submit` method - a non-blocking version of `BatchPredictionJob.create` feat: Added the `BatchPredictionJob.submit` method - a non-blocking version of `BatchPredictionJob.create` ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in google/cloud/aiplatform/jobs.py] (definition of _Job.wait_for_completion:) def wait_for_completion(self) -> None: """Waits for job to complete. Raises: RuntimeError: If job failed or cancelled.""" (definition of BatchPredictionJob.submit:) def submit( cls, *, job_display_name: Optional[str] = None, model_name: Union[str, "aiplatform.Model"], instances_format: str = "jsonl", predictions_format: str = "jsonl", gcs_source: Optional[Union[str, Sequence[str]]] = None, bigquery_source: Optional[str] = None, gcs_destination_prefix: Optional[str] = None, bigquery_destination_prefix: Optional[str] = None, model_parameters: Optional[Dict] = None, machine_type: Optional[str] = None, accelerator_type: Optional[str] = None, accelerator_count: Optional[int] = None, starting_replica_count: Optional[int] = None, max_replica_count: Optional[int] = None, generate_explanation: Optional[bool] = False, explanation_metadata: Optional["aiplatform.explain.ExplanationMetadata"] = None, explanation_parameters: Optional[ "aiplatform.explain.ExplanationParameters" ] = None, labels: Optional[Dict[str, str]] = None, project: Optional[str] = None, location: Optional[str] = None, credentials: Optional[auth_credentials.Credentials] = None, encryption_spec_key_name: Optional[str] = None, create_request_timeout: Optional[float] = None, batch_size: Optional[int] = None, model_monitoring_objective_config: Optional[ "aiplatform.model_monitoring.ObjectiveConfig" ] = None, model_monitoring_alert_config: Optional[ "aiplatform.model_monitoring.AlertConfig" ] = None, analysis_instance_schema_uri: Optional[str] = None, service_account: Optional[str] = None, ) -> "BatchPredictionJob": """Sumbit a batch prediction job (not waiting for completion). Args: job_display_name (str): Required. The user-defined name of the BatchPredictionJob. The name can be up to 128 characters long and can be consist of any UTF-8 characters. model_name (Union[str, aiplatform.Model]): Required. A fully-qualified model resource name or model ID. Example: "projects/123/locations/us-central1/models/456" or "456" when project and location are initialized or passed. May optionally contain a version ID or alias in {model_name}@{version} form. Or an instance of aiplatform.Model. instances_format (str): Required. The format in which instances are provided. Must be one of the formats listed in `Model.supported_input_storage_formats`. Default is "jsonl" when using `gcs_source`. If a `bigquery_source` is provided, this is overridden to "bigquery". predictions_format (str): Required. The format in which Vertex AI outputs the predictions, must be one of the formats specified in `Model.supported_output_storage_formats`. Default is "jsonl" when using `gcs_destination_prefix`. If a `bigquery_destination_prefix` is provided, this is overridden to "bigquery". gcs_source (Optional[Sequence[str]]): Google Cloud Storage URI(-s) to your instances to run batch prediction on. They must match `instances_format`. bigquery_source (Optional[str]): BigQuery URI to a table, up to 2000 characters long. For example: `bq://projectId.bqDatasetId.bqTableId` gcs_destination_prefix (Optional[str]): The Google Cloud Storage location of the directory where the output is to be written to. In the given directory a new directory is created. Its name is ``prediction-<model-display-name>-<job-create-time>``, where timestamp is in YYYY-MM-DDThh:mm:ss.sssZ ISO-8601 format. Inside of it files ``predictions_0001.<extension>``, ``predictions_0002.<extension>``, ..., ``predictions_N.<extension>`` are created where ``<extension>`` depends on chosen ``predictions_format``, and N may equal 0001 and depends on the total number of successfully predicted instances. If the Model has both ``instance`` and ``prediction`` schemata defined then each such file contains predictions as per the ``predictions_format``. If prediction for any instance failed (partially or completely), then an additional ``errors_0001.<extension>``, ``errors_0002.<extension>``,..., ``errors_N.<extension>`` files are created (N depends on total number of failed predictions). These files contain the failed instances, as per their schema, followed by an additional ``error`` field which as value has ```google.rpc.Status`` <Status>`__ containing only ``code`` and ``message`` fields. bigquery_destination_prefix (Optional[str]): The BigQuery project or dataset location where the output is to be written to. If project is provided, a new dataset is created with name ``prediction_<model-display-name>_<job-create-time>`` where is made BigQuery-dataset-name compatible (for example, most special characters become underscores), and timestamp is in YYYY_MM_DDThh_mm_ss_sssZ "based on ISO-8601" format. In the dataset two tables will be created, ``predictions``, and ``errors``. If the Model has both [instance][google.cloud.aiplatform.v1.PredictSchemata.instance_schema_uri] and [prediction][google.cloud.aiplatform.v1.PredictSchemata.parameters_schema_uri] schemata defined then the tables have columns as follows: The ``predictions`` table contains instances for which the prediction succeeded, it has columns as per a concatenation of the Model's instance and prediction schemata. The ``errors`` table contains rows for which the prediction has failed, it has instance columns, as per the instance schema, followed by a single "errors" column, which as values has [google.rpc.Status][google.rpc.Status] represented as a STRUCT, and containing only ``code`` and ``message``. model_parameters (Optional[Dict]): The parameters that govern the predictions. The schema of the parameters may be specified via the Model's `parameters_schema_uri`. machine_type (Optional[str]): The type of machine for running batch prediction on dedicated resources. Not specifying machine type will result in batch prediction job being run with automatic resources. accelerator_type (Optional[str]): The type of accelerator(s) that may be attached to the machine as per `accelerator_count`. Only used if `machine_type` is set. accelerator_count (Optional[int]): The number of accelerators to attach to the `machine_type`. Only used if `machine_type` is set. starting_replica_count (Optional[int]): The number of machine replicas used at the start of the batch operation. If not set, Vertex AI decides starting number, not greater than `max_replica_count`. Only used if `machine_type` is set. max_replica_count (Optional[int]): The maximum number of machine replicas the batch operation may be scaled to. Only used if `machine_type` is set. Default is 10. generate_explanation (bool): Optional. Generate explanation along with the batch prediction results. This will cause the batch prediction output to include explanations based on the `prediction_format`: - `bigquery`: output includes a column named `explanation`. The value is a struct that conforms to the [aiplatform.gapic.Explanation] object. - `jsonl`: The JSON objects on each line include an additional entry keyed `explanation`. The value of the entry is a JSON object that conforms to the [aiplatform.gapic.Explanation] object. - `csv`: Generating explanations for CSV format is not supported. explanation_metadata (aiplatform.explain.ExplanationMetadata): Optional. Explanation metadata configuration for this BatchPredictionJob. Can be specified only if `generate_explanation` is set to `True`. This value overrides the value of `Model.explanation_metadata`. All fields of `explanation_metadata` are optional in the request. If a field of the `explanation_metadata` object is not populated, the corresponding field of the `Model.explanation_metadata` object is inherited. For more details, see `Ref docs <http://tinyurl.com/1igh60kt>` explanation_parameters (aiplatform.explain.ExplanationParameters): Optional. Parameters to configure explaining for Model's predictions. Can be specified only if `generate_explanation` is set to `True`. This value overrides the value of `Model.explanation_parameters`. All fields of `explanation_parameters` are optional in the request. If a field of the `explanation_parameters` object is not populated, the corresponding field of the `Model.explanation_parameters` object is inherited. For more details, see `Ref docs <http://tinyurl.com/1an4zake>` labels (Dict[str, str]): Optional. The labels with user-defined metadata to organize your BatchPredictionJobs. Label keys and values can be no longer than 64 characters (Unicode codepoints), can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. See https://goo.gl/xmQnxf for more information and examples of labels. credentials (Optional[auth_credentials.Credentials]): Custom credentials to use to create this batch prediction job. Overrides credentials set in aiplatform.init. encryption_spec_key_name (Optional[str]): Optional. The Cloud KMS resource identifier of the customer managed encryption key used to protect the job. Has the form: ``projects/my-project/locations/my-region/keyRings/my-kr/cryptoKeys/my-key``. The key needs to be in the same region as where the compute resource is created. If this is set, then all resources created by the BatchPredictionJob will be encrypted with the provided encryption key. Overrides encryption_spec_key_name set in aiplatform.init. create_request_timeout (float): Optional. The timeout for the create request in seconds. batch_size (int): Optional. The number of the records (e.g. instances) of the operation given in each batch to a machine replica. Machine type, and size of a single record should be considered when setting this parameter, higher value speeds up the batch operation's execution, but too high value will result in a whole batch not fitting in a machine's memory, and the whole operation will fail. The default value is 64. model_monitoring_objective_config (aiplatform.model_monitoring.ObjectiveConfig): Optional. The objective config for model monitoring. Passing this parameter enables monitoring on the model associated with this batch prediction job. model_monitoring_alert_config (aiplatform.model_monitoring.EmailAlertConfig): Optional. Configures how model monitoring alerts are sent to the user. Right now only email alert is supported. analysis_instance_schema_uri (str): Optional. Only applicable if model_monitoring_objective_config is also passed. This parameter specifies the YAML schema file uri describing the format of a single instance that you want Tensorflow Data Validation (TFDV) to analyze. If this field is empty, all the feature data types are inferred from predict_instance_schema_uri, meaning that TFDV will use the data in the exact format as prediction request/response. If there are any data type differences between predict instance and TFDV instance, this field can be used to override the schema. For models trained with Vertex AI, this field must be set as all the fields in predict instance formatted as string. service_account (str): Optional. Specifies the service account for workload run-as account. Users submitting jobs must have act-as permission on this run-as account. Returns: (jobs.BatchPredictionJob): Instantiated representation of the created batch prediction job.""" (definition of BatchPredictionJob._submit_impl:) def _submit_impl( cls, *, job_display_name: Optional[str] = None, model_name: Union[str, "aiplatform.Model"], instances_format: str = "jsonl", predictions_format: str = "jsonl", gcs_source: Optional[Union[str, Sequence[str]]] = None, bigquery_source: Optional[str] = None, gcs_destination_prefix: Optional[str] = None, bigquery_destination_prefix: Optional[str] = None, model_parameters: Optional[Dict] = None, machine_type: Optional[str] = None, accelerator_type: Optional[str] = None, accelerator_count: Optional[int] = None, starting_replica_count: Optional[int] = None, max_replica_count: Optional[int] = None, generate_explanation: Optional[bool] = False, explanation_metadata: Optional["aiplatform.explain.ExplanationMetadata"] = None, explanation_parameters: Optional[ "aiplatform.explain.ExplanationParameters" ] = None, labels: Optional[Dict[str, str]] = None, project: Optional[str] = None, location: Optional[str] = None, credentials: Optional[auth_credentials.Credentials] = None, encryption_spec_key_name: Optional[str] = None, sync: bool = True, create_request_timeout: Optional[float] = None, batch_size: Optional[int] = None, model_monitoring_objective_config: Optional[ "aiplatform.model_monitoring.ObjectiveConfig" ] = None, model_monitoring_alert_config: Optional[ "aiplatform.model_monitoring.AlertConfig" ] = None, analysis_instance_schema_uri: Optional[str] = None, service_account: Optional[str] = None, wait_for_completion: bool = False, ) -> "BatchPredictionJob": """Create a batch prediction job. Args: job_display_name (str): Required. The user-defined name of the BatchPredictionJob. The name can be up to 128 characters long and can be consist of any UTF-8 characters. model_name (Union[str, aiplatform.Model]): Required. A fully-qualified model resource name or model ID. Example: "projects/123/locations/us-central1/models/456" or "456" when project and location are initialized or passed. May optionally contain a version ID or alias in {model_name}@{version} form. Or an instance of aiplatform.Model. instances_format (str): Required. The format in which instances are provided. Must be one of the formats listed in `Model.supported_input_storage_formats`. Default is "jsonl" when using `gcs_source`. If a `bigquery_source` is provided, this is overridden to "bigquery". predictions_format (str): Required. The format in which Vertex AI outputs the predictions, must be one of the formats specified in `Model.supported_output_storage_formats`. Default is "jsonl" when using `gcs_destination_prefix`. If a `bigquery_destination_prefix` is provided, this is overridden to "bigquery". gcs_source (Optional[Sequence[str]]): Google Cloud Storage URI(-s) to your instances to run batch prediction on. They must match `instances_format`. bigquery_source (Optional[str]): BigQuery URI to a table, up to 2000 characters long. For example: `bq://projectId.bqDatasetId.bqTableId` gcs_destination_prefix (Optional[str]): The Google Cloud Storage location of the directory where the output is to be written to. In the given directory a new directory is created. Its name is ``prediction-<model-display-name>-<job-create-time>``, where timestamp is in YYYY-MM-DDThh:mm:ss.sssZ ISO-8601 format. Inside of it files ``predictions_0001.<extension>``, ``predictions_0002.<extension>``, ..., ``predictions_N.<extension>`` are created where ``<extension>`` depends on chosen ``predictions_format``, and N may equal 0001 and depends on the total number of successfully predicted instances. If the Model has both ``instance`` and ``prediction`` schemata defined then each such file contains predictions as per the ``predictions_format``. If prediction for any instance failed (partially or completely), then an additional ``errors_0001.<extension>``, ``errors_0002.<extension>``,..., ``errors_N.<extension>`` files are created (N depends on total number of failed predictions). These files contain the failed instances, as per their schema, followed by an additional ``error`` field which as value has ```google.rpc.Status`` <Status>`__ containing only ``code`` and ``message`` fields. bigquery_destination_prefix (Optional[str]): The BigQuery project or dataset location where the output is to be written to. If project is provided, a new dataset is created with name ``prediction_<model-display-name>_<job-create-time>`` where is made BigQuery-dataset-name compatible (for example, most special characters become underscores), and timestamp is in YYYY_MM_DDThh_mm_ss_sssZ "based on ISO-8601" format. In the dataset two tables will be created, ``predictions``, and ``errors``. If the Model has both [instance][google.cloud.aiplatform.v1.PredictSchemata.instance_schema_uri] and [prediction][google.cloud.aiplatform.v1.PredictSchemata.parameters_schema_uri] schemata defined then the tables have columns as follows: The ``predictions`` table contains instances for which the prediction succeeded, it has columns as per a concatenation of the Model's instance and prediction schemata. The ``errors`` table contains rows for which the prediction has failed, it has instance columns, as per the instance schema, followed by a single "errors" column, which as values has [google.rpc.Status][google.rpc.Status] represented as a STRUCT, and containing only ``code`` and ``message``. model_parameters (Optional[Dict]): The parameters that govern the predictions. The schema of the parameters may be specified via the Model's `parameters_schema_uri`. machine_type (Optional[str]): The type of machine for running batch prediction on dedicated resources. Not specifying machine type will result in batch prediction job being run with automatic resources. accelerator_type (Optional[str]): The type of accelerator(s) that may be attached to the machine as per `accelerator_count`. Only used if `machine_type` is set. accelerator_count (Optional[int]): The number of accelerators to attach to the `machine_type`. Only used if `machine_type` is set. starting_replica_count (Optional[int]): The number of machine replicas used at the start of the batch operation. If not set, Vertex AI decides starting number, not greater than `max_replica_count`. Only used if `machine_type` is set. max_replica_count (Optional[int]): The maximum number of machine replicas the batch operation may be scaled to. Only used if `machine_type` is set. Default is 10. generate_explanation (bool): Optional. Generate explanation along with the batch prediction results. This will cause the batch prediction output to include explanations based on the `prediction_format`: - `bigquery`: output includes a column named `explanation`. The value is a struct that conforms to the [aiplatform.gapic.Explanation] object. - `jsonl`: The JSON objects on each line include an additional entry keyed `explanation`. The value of the entry is a JSON object that conforms to the [aiplatform.gapic.Explanation] object. - `csv`: Generating explanations for CSV format is not supported. explanation_metadata (aiplatform.explain.ExplanationMetadata): Optional. Explanation metadata configuration for this BatchPredictionJob. Can be specified only if `generate_explanation` is set to `True`. This value overrides the value of `Model.explanation_metadata`. All fields of `explanation_metadata` are optional in the request. If a field of the `explanation_metadata` object is not populated, the corresponding field of the `Model.explanation_metadata` object is inherited. For more details, see `Ref docs <http://tinyurl.com/1igh60kt>` explanation_parameters (aiplatform.explain.ExplanationParameters): Optional. Parameters to configure explaining for Model's predictions. Can be specified only if `generate_explanation` is set to `True`. This value overrides the value of `Model.explanation_parameters`. All fields of `explanation_parameters` are optional in the request. If a field of the `explanation_parameters` object is not populated, the corresponding field of the `Model.explanation_parameters` object is inherited. For more details, see `Ref docs <http://tinyurl.com/1an4zake>` labels (Dict[str, str]): Optional. The labels with user-defined metadata to organize your BatchPredictionJobs. Label keys and values can be no longer than 64 characters (Unicode codepoints), can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. See https://goo.gl/xmQnxf for more information and examples of labels. credentials (Optional[auth_credentials.Credentials]): Custom credentials to use to create this batch prediction job. Overrides credentials set in aiplatform.init. encryption_spec_key_name (Optional[str]): Optional. The Cloud KMS resource identifier of the customer managed encryption key used to protect the job. Has the form: ``projects/my-project/locations/my-region/keyRings/my-kr/cryptoKeys/my-key``. The key needs to be in the same region as where the compute resource is created. If this is set, then all resources created by the BatchPredictionJob will be encrypted with the provided encryption key. Overrides encryption_spec_key_name set in aiplatform.init. sync (bool): Whether to execute this method synchronously. If False, this method will be executed in concurrent Future and any downstream object will be immediately returned and synced when the Future has completed. create_request_timeout (float): Optional. The timeout for the create request in seconds. batch_size (int): Optional. The number of the records (e.g. instances) of the operation given in each batch to a machine replica. Machine type, and size of a single record should be considered when setting this parameter, higher value speeds up the batch operation's execution, but too high value will result in a whole batch not fitting in a machine's memory, and the whole operation will fail. The default value is 64. model_monitoring_objective_config (aiplatform.model_monitoring.ObjectiveConfig): Optional. The objective config for model monitoring. Passing this parameter enables monitoring on the model associated with this batch prediction job. model_monitoring_alert_config (aiplatform.model_monitoring.EmailAlertConfig): Optional. Configures how model monitoring alerts are sent to the user. Right now only email alert is supported. analysis_instance_schema_uri (str): Optional. Only applicable if model_monitoring_objective_config is also passed. This parameter specifies the YAML schema file uri describing the format of a single instance that you want Tensorflow Data Validation (TFDV) to analyze. If this field is empty, all the feature data types are inferred from predict_instance_schema_uri, meaning that TFDV will use the data in the exact format as prediction request/response. If there are any data type differences between predict instance and TFDV instance, this field can be used to override the schema. For models trained with Vertex AI, this field must be set as all the fields in predict instance formatted as string. service_account (str): Optional. Specifies the service account for workload run-as account. Users submitting jobs must have act-as permission on this run-as account. wait_for_completion (bool): Whether to wait for the job completion. Returns: (jobs.BatchPredictionJob): Instantiated representation of the created batch prediction job.""" (definition of BatchPredictionJob._submit_and_optionally_wait_with_sync_support:) def _submit_and_optionally_wait_with_sync_support( cls, empty_batch_prediction_job: "BatchPredictionJob", model_or_model_name: Union[str, "aiplatform.Model"], gca_batch_prediction_job: gca_bp_job_compat.BatchPredictionJob, generate_explanation: bool, sync: bool = True, create_request_timeout: Optional[float] = None, wait_for_completion: bool = True, ) -> "BatchPredictionJob": """Create a batch prediction job. Args: empty_batch_prediction_job (BatchPredictionJob): Required. BatchPredictionJob without _gca_resource populated. model_or_model_name (Union[str, aiplatform.Model]): Required. Required. A fully-qualified model resource name or an instance of aiplatform.Model. If a resource name, it may optionally contain a version ID or alias in {model_name}@{version} form. gca_batch_prediction_job (gca_bp_job.BatchPredictionJob): Required. a batch prediction job proto for creating a batch prediction job on Vertex AI. generate_explanation (bool): Required. Generate explanation along with the batch prediction results. create_request_timeout (float): Optional. The timeout for the create request in seconds. wait_for_completion (bool): Whether to wait for the job completion. Returns: (jobs.BatchPredictionJob): Instantiated representation of the created batch prediction job. Raises: ValueError: If no or multiple source or destinations are provided. Also, if provided instances_format or predictions_format are not supported by Vertex AI.""" [end of new definitions in google/cloud/aiplatform/jobs.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

67358fa6a830eb842f6b52d09061af4a41b54af6

conan-io__conan-15270

15,270

conan-io/conan

null

98d68db7f3a7d6eec4dc463a24839af542fb70cc

2023-12-13T22:43:40Z

diff --git a/conan/cli/commands/graph.py b/conan/cli/commands/graph.py index d9c773a00f5..d8babfefa96 100644 --- a/conan/cli/commands/graph.py +++ b/conan/cli/commands/graph.py @@ -56,6 +56,8 @@ def graph_build_order(conan_api, parser, subparser, *args): Compute the build order of a dependency graph. """ common_graph_args(subparser) + subparser.add_argument("--order", choices=['recipe', 'configuration'], default="recipe", + help='Select which order method') args = parser.parse_args(*args) # parameter validation @@ -93,7 +95,7 @@ def graph_build_order(conan_api, parser, subparser, *args): out = ConanOutput() out.title("Computing the build order") - install_graph = InstallGraph(deps_graph) + install_graph = InstallGraph(deps_graph, order=args.order) install_order_serialized = install_graph.install_build_order() lockfile = conan_api.lockfile.update_lockfile(lockfile, deps_graph, args.lockfile_packages, @@ -110,11 +112,12 @@ def graph_build_order_merge(conan_api, parser, subparser, *args): """ subparser.add_argument("--file", nargs="?", action="append", help="Files to be merged") args = parser.parse_args(*args) + if not args.file or len(args.file) < 2: + raise ConanException("At least 2 files are needed to be merged") - result = InstallGraph() - for f in args.file: - f = make_abs_path(f) - install_graph = InstallGraph.load(f) + result = InstallGraph.load(make_abs_path(args.file[0])) + for f in args.file[1:]: + install_graph = InstallGraph.load(make_abs_path(f)) result.merge(install_graph) install_order_serialized = result.install_build_order() diff --git a/conans/client/graph/install_graph.py b/conans/client/graph/install_graph.py index ab39d8dc283..e34c525bf03 100644 --- a/conans/client/graph/install_graph.py +++ b/conans/client/graph/install_graph.py @@ -193,13 +193,123 @@ def deserialize(data, filename): return result +class _InstallConfiguration: + """ Represents a single, unique PackageReference to be downloaded, built, etc. + Same PREF should only be built or downloaded once, but it is possible to have multiple + nodes in the DepsGraph that share the same PREF. + PREF could have PREV if to be downloaded (must be the same for all), but won't if to be built + """ + def __init__(self): + self.ref = None + self.package_id = None + self.prev = None + self.nodes = [] # GraphNode + self.binary = None # The action BINARY_DOWNLOAD, etc must be the same for all nodes + self.context = None # Same PREF could be in both contexts, but only 1 context is enough to + # be able to reproduce, typically host preferrably + self.options = [] # to be able to fire a build, the options will be necessary + self.filenames = [] # The build_order.json filenames e.g. "windows_build_order" + self.depends = [] # List of full prefs + self.overrides = Overrides() + + @property + def pref(self): + return PkgReference(self.ref, self.package_id, self.prev) + + @property + def conanfile(self): + return self.nodes[0].conanfile + + @staticmethod + def create(node): + result = _InstallConfiguration() + result.ref = node.ref + result.package_id = node.pref.package_id + result.prev = node.pref.revision + result.binary = node.binary + result.context = node.context + # self_options are the minimum to reproduce state + result.options = node.conanfile.self_options.dumps().splitlines() + result.overrides = node.overrides() + + result.nodes.append(node) + for dep in node.dependencies: + if dep.dst.binary != BINARY_SKIP: + if dep.dst.pref not in result.depends: + result.depends.append(dep.dst.pref) + return result + + def add(self, node): + assert self.package_id == node.package_id, f"{self.pref}!={node.pref}" + assert self.binary == node.binary, f"Binary for {node}: {self.binary}!={node.binary}" + assert self.prev == node.prev + # The context might vary, but if same package_id, all fine + # assert self.context == node.context + self.nodes.append(node) + + for dep in node.dependencies: + if dep.dst.binary != BINARY_SKIP: + if dep.dst.pref not in self.depends: + self.depends.append(dep.dst.pref) + + def _build_args(self): + if self.binary != BINARY_BUILD: + return None + cmd = f"--require={self.ref}" if self.context == "host" else f"--tool-require={self.ref}" + cmd += f" --build={self.ref}" + if self.options: + cmd += " " + " ".join(f"-o {o}" for o in self.options) + if self.overrides: + cmd += f' --lockfile-overrides="{self.overrides}"' + return cmd + + def serialize(self): + return {"ref": self.ref.repr_notime(), + "pref": self.pref.repr_notime(), + "package_id": self.pref.package_id, + "prev": self.pref.revision, + "context": self.context, + "binary": self.binary, + "options": self.options, + "filenames": self.filenames, + "depends": [d.repr_notime() for d in self.depends], + "overrides": self.overrides.serialize(), + "build_args": self._build_args() + } + + @staticmethod + def deserialize(data, filename): + result = _InstallConfiguration() + result.ref = RecipeReference.loads(data["ref"]) + result.package_id = data["package_id"] + result.prev = data["prev"] + result.binary = data["binary"] + result.context = data["context"] + result.options = data["options"] + result.filenames = data["filenames"] or [filename] + result.depends = [PkgReference.loads(p) for p in data["depends"]] + result.overrides = Overrides.deserialize(data["overrides"]) + return result + + def merge(self, other): + assert self.ref == other.ref + for d in other.depends: + if d not in self.depends: + self.depends.append(d) + + for d in other.filenames: + if d not in self.filenames: + self.filenames.append(d) + + class InstallGraph: """ A graph containing the package references in order to be built/downloaded """ - def __init__(self, deps_graph=None): + def __init__(self, deps_graph, order="recipe"): self._nodes = {} # ref with rev: _InstallGraphNode - + self._order = order + self._node_cls = _InstallRecipeReference if order == "recipe" else _InstallConfiguration self._is_test_package = False if deps_graph is not None: self._initialize_deps_graph(deps_graph) @@ -217,6 +327,8 @@ def merge(self, other): """ @type other: InstallGraph """ + if self._order != other._order: + raise ConanException(f"Cannot merge build-orders of `{self._order}!={other._order}") for ref, install_node in other._nodes.items(): existing = self._nodes.get(ref) if existing is None: @@ -226,11 +338,17 @@ def merge(self, other): @staticmethod def deserialize(data, filename): - result = InstallGraph() + # Automatic deduction of the order based on the data + try: + order = "recipe" if "packages" in data[0][0] else "configuration" + except IndexError: + order = "recipe" + result = InstallGraph(None, order=order) for level in data: for item in level: - elem = _InstallRecipeReference.deserialize(item, filename) - result._nodes[elem.ref] = elem + elem = result._node_cls.deserialize(item, filename) + key = elem.ref if order == "recipe" else elem.pref + result._nodes[key] = elem return result def _initialize_deps_graph(self, deps_graph): @@ -238,9 +356,10 @@ def _initialize_deps_graph(self, deps_graph): if node.recipe in (RECIPE_CONSUMER, RECIPE_VIRTUAL) or node.binary == BINARY_SKIP: continue - existing = self._nodes.get(node.ref) + key = node.ref if self._order == "recipe" else node.pref + existing = self._nodes.get(key) if existing is None: - self._nodes[node.ref] = _InstallRecipeReference.create(node) + self._nodes[key] = self._node_cls.create(node) else: existing.add(node)

diff --git a/conans/test/integration/command_v2/test_info_build_order.py b/conans/test/integration/command_v2/test_info_build_order.py index 6e9354b057e..3f484445761 100644 --- a/conans/test/integration/command_v2/test_info_build_order.py +++ b/conans/test/integration/command_v2/test_info_build_order.py @@ -62,6 +62,55 @@ def test_info_build_order(): assert bo_json == result +def test_info_build_order_configuration(): + c = TestClient() + c.save({"dep/conanfile.py": GenConanfile(), + "pkg/conanfile.py": GenConanfile().with_requires("dep/0.1"), + "consumer/conanfile.txt": "[requires]\npkg/0.1"}) + c.run("export dep --name=dep --version=0.1") + c.run("export pkg --name=pkg --version=0.1") + c.run("graph build-order consumer --build=missing --order=configuration --format=json") + bo_json = json.loads(c.stdout) + + result = [ + [ + { + "ref": "dep/0.1#4d670581ccb765839f2239cc8dff8fbd", + "pref": "dep/0.1#4d670581ccb765839f2239cc8dff8fbd:da39a3ee5e6b4b0d3255bfef95601890afd80709", + "depends": [], + "package_id": "da39a3ee5e6b4b0d3255bfef95601890afd80709", + 'prev': None, + 'filenames': [], + "context": "host", + "binary": "Build", + 'build_args': '--require=dep/0.1 --build=dep/0.1', + "options": [], + "overrides": {} + } + ], + [ + { + "ref": "pkg/0.1#1ac8dd17c0f9f420935abd3b6a8fa032", + "pref": "pkg/0.1#1ac8dd17c0f9f420935abd3b6a8fa032:59205ba5b14b8f4ebc216a6c51a89553021e82c1", + "depends": [ + "dep/0.1#4d670581ccb765839f2239cc8dff8fbd:da39a3ee5e6b4b0d3255bfef95601890afd80709" + ], + "package_id": "59205ba5b14b8f4ebc216a6c51a89553021e82c1", + 'prev': None, + 'filenames': [], + "context": "host", + "binary": "Build", + 'build_args': '--require=pkg/0.1 --build=pkg/0.1', + "options": [], + "overrides": {} + + } + ] + ] + + assert bo_json == result + + def test_info_build_order_build_require(): c = TestClient() c.save({"dep/conanfile.py": GenConanfile(), @@ -252,6 +301,83 @@ def test_info_build_order_merge_multi_product(): assert bo_json == result +def test_info_build_order_merge_multi_product_configurations(): + c = TestClient() + c.save({"dep/conanfile.py": GenConanfile(), + "pkg/conanfile.py": GenConanfile().with_requires("dep/0.1"), + "consumer1/conanfile.txt": "[requires]\npkg/0.1", + "consumer2/conanfile.txt": "[requires]\npkg/0.2"}) + c.run("export dep --name=dep --version=0.1") + c.run("export pkg --name=pkg --version=0.1") + c.run("export pkg --name=pkg --version=0.2") + c.run("graph build-order consumer1 --build=missing --order=configuration --format=json", + redirect_stdout="bo1.json") + c.run("graph build-order consumer2 --build=missing --order=configuration --format=json", + redirect_stdout="bo2.json") + c.run("graph build-order-merge --file=bo1.json --file=bo2.json --format=json", + redirect_stdout="bo3.json") + + bo_json = json.loads(c.load("bo3.json")) + result = [ + [ + { + "ref": "dep/0.1#4d670581ccb765839f2239cc8dff8fbd", + "pref": "dep/0.1#4d670581ccb765839f2239cc8dff8fbd:da39a3ee5e6b4b0d3255bfef95601890afd80709", + "package_id": "da39a3ee5e6b4b0d3255bfef95601890afd80709", + "prev": None, + "context": "host", + "binary": "Build", + "options": [], + "filenames": [ + "bo1", + "bo2" + ], + "depends": [], + "overrides": {}, + "build_args": "--require=dep/0.1 --build=dep/0.1" + } + ], + [ + { + "ref": "pkg/0.1#1ac8dd17c0f9f420935abd3b6a8fa032", + "pref": "pkg/0.1#1ac8dd17c0f9f420935abd3b6a8fa032:59205ba5b14b8f4ebc216a6c51a89553021e82c1", + "package_id": "59205ba5b14b8f4ebc216a6c51a89553021e82c1", + "prev": None, + "context": "host", + "binary": "Build", + "options": [], + "filenames": [ + "bo1" + ], + "depends": [ + "dep/0.1#4d670581ccb765839f2239cc8dff8fbd:da39a3ee5e6b4b0d3255bfef95601890afd80709" + ], + "overrides": {}, + "build_args": "--require=pkg/0.1 --build=pkg/0.1" + }, + { + "ref": "pkg/0.2#1ac8dd17c0f9f420935abd3b6a8fa032", + "pref": "pkg/0.2#1ac8dd17c0f9f420935abd3b6a8fa032:59205ba5b14b8f4ebc216a6c51a89553021e82c1", + "package_id": "59205ba5b14b8f4ebc216a6c51a89553021e82c1", + "prev": None, + "context": "host", + "binary": "Build", + "options": [], + "filenames": [ + "bo2" + ], + "depends": [ + "dep/0.1#4d670581ccb765839f2239cc8dff8fbd:da39a3ee5e6b4b0d3255bfef95601890afd80709" + ], + "overrides": {}, + "build_args": "--require=pkg/0.2 --build=pkg/0.2" + } + ] + ] + + assert bo_json == result + + def test_info_build_order_merge_conditionals(): c = TestClient() conanfile = textwrap.dedent("""

[ { "components": [ { "doc": "Represents a single, unique PackageReference to be downloaded, built, etc.\nSame PREF should only be built or downloaded once, but it is possible to have multiple\nnodes in the DepsGraph that share the same PREF.\nPREF could have PREV if to be downloaded (must be the sa...

[ "conans/test/integration/command_v2/test_info_build_order.py::test_info_build_order_configuration", "conans/test/integration/command_v2/test_info_build_order.py::test_info_build_order_merge_multi_product_configurations" ]

[ "conans/test/integration/command_v2/test_info_build_order.py::test_info_build_order", "conans/test/integration/command_v2/test_info_build_order.py::test_info_build_order_build_require", "conans/test/integration/command_v2/test_info_build_order.py::test_info_build_order_options", "conans/test/integration/comma...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> graph build-order --order=configuration Changelog: Feature: New ``conan graph build-order --order=configuration`` to output a different order, sorted by package binaries/configurations, not grouped by recipe revisions. Docs: https://github.com/conan-io/docs/pull/3552 Close https://github.com/conan-io/conan/issues/15254 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conans/client/graph/install_graph.py] (definition of _InstallConfiguration:) class _InstallConfiguration: """Represents a single, unique PackageReference to be downloaded, built, etc. Same PREF should only be built or downloaded once, but it is possible to have multiple nodes in the DepsGraph that share the same PREF. PREF could have PREV if to be downloaded (must be the same for all), but won't if to be built""" (definition of _InstallConfiguration.__init__:) def __init__(self): (definition of _InstallConfiguration.pref:) def pref(self): (definition of _InstallConfiguration.conanfile:) def conanfile(self): (definition of _InstallConfiguration.create:) def create(node): (definition of _InstallConfiguration.add:) def add(self, node): (definition of _InstallConfiguration._build_args:) def _build_args(self): (definition of _InstallConfiguration.serialize:) def serialize(self): (definition of _InstallConfiguration.deserialize:) def deserialize(data, filename): (definition of _InstallConfiguration.merge:) def merge(self, other): [end of new definitions in conans/client/graph/install_graph.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

4a5b19a75db9225316c8cb022a2dfb9705a2af34

Project-MONAI__MONAI-7308

7,308

Project-MONAI/MONAI

null

c64993431198774ef896f525bad0fd6cc932e788

2023-12-11T06:23:04Z

diff --git a/docs/source/losses.rst b/docs/source/losses.rst index 61dd959807..ba794af3eb 100644 --- a/docs/source/losses.rst +++ b/docs/source/losses.rst @@ -139,6 +139,11 @@ Reconstruction Losses .. autoclass:: JukeboxLoss :members: +`SURELoss` +~~~~~~~~~~ +.. autoclass:: SURELoss + :members: + Loss Wrappers ------------- diff --git a/docs/source/networks.rst b/docs/source/networks.rst index 8eada7933f..b59c8af5fc 100644 --- a/docs/source/networks.rst +++ b/docs/source/networks.rst @@ -408,6 +408,11 @@ Layers .. autoclass:: LLTM :members: +`ConjugateGradient` +~~~~~~~~~~~~~~~~~~~ +.. autoclass:: ConjugateGradient + :members: + `Utilities` ~~~~~~~~~~~ .. automodule:: monai.networks.layers.convutils diff --git a/monai/losses/__init__.py b/monai/losses/__init__.py index 4ebedb2084..e937b53fa4 100644 --- a/monai/losses/__init__.py +++ b/monai/losses/__init__.py @@ -41,5 +41,6 @@ from .spatial_mask import MaskedLoss from .spectral_loss import JukeboxLoss from .ssim_loss import SSIMLoss +from .sure_loss import SURELoss from .tversky import TverskyLoss from .unified_focal_loss import AsymmetricUnifiedFocalLoss diff --git a/monai/losses/sure_loss.py b/monai/losses/sure_loss.py new file mode 100644 index 0000000000..ebf25613a6 --- /dev/null +++ b/monai/losses/sure_loss.py @@ -0,0 +1,200 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import annotations + +from typing import Callable, Optional + +import torch +import torch.nn as nn +from torch.nn.modules.loss import _Loss + + +def complex_diff_abs_loss(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: + """ + First compute the difference in the complex domain, + then get the absolute value and take the mse + + Args: + x, y - B, 2, H, W real valued tensors representing complex numbers + or B,1,H,W complex valued tensors + Returns: + l2_loss - scalar + """ + if not x.is_complex(): + x = torch.view_as_complex(x.permute(0, 2, 3, 1).contiguous()) + if not y.is_complex(): + y = torch.view_as_complex(y.permute(0, 2, 3, 1).contiguous()) + + diff = torch.abs(x - y) + return nn.functional.mse_loss(diff, torch.zeros_like(diff), reduction="mean") + + +def sure_loss_function( + operator: Callable, + x: torch.Tensor, + y_pseudo_gt: torch.Tensor, + y_ref: Optional[torch.Tensor] = None, + eps: Optional[float] = -1.0, + perturb_noise: Optional[torch.Tensor] = None, + complex_input: Optional[bool] = False, +) -> torch.Tensor: + """ + Args: + operator (function): The operator function that takes in an input + tensor x and returns an output tensor y. We will use this to compute + the divergence. More specifically, we will perturb the input x by a + small amount and compute the divergence between the perturbed output + and the reference output + + x (torch.Tensor): The input tensor of shape (B, C, H, W) to the + operator. For complex input, the shape is (B, 2, H, W) aka C=2 real. + For real input, the shape is (B, 1, H, W) real. + + y_pseudo_gt (torch.Tensor): The pseudo ground truth tensor of shape + (B, C, H, W) used to compute the L2 loss. For complex input, the shape is + (B, 2, H, W) aka C=2 real. For real input, the shape is (B, 1, H, W) + real. + + y_ref (torch.Tensor, optional): The reference output tensor of shape + (B, C, H, W) used to compute the divergence. Defaults to None. For + complex input, the shape is (B, 2, H, W) aka C=2 real. For real input, + the shape is (B, 1, H, W) real. + + eps (float, optional): The perturbation scalar. Set to -1 to set it + automatically estimated based on y_pseudo_gtk + + perturb_noise (torch.Tensor, optional): The noise vector of shape (B, C, H, W). + Defaults to None. For complex input, the shape is (B, 2, H, W) aka C=2 real. + For real input, the shape is (B, 1, H, W) real. + + complex_input(bool, optional): Whether the input is complex or not. + Defaults to False. + + Returns: + sure_loss (torch.Tensor): The SURE loss scalar. + """ + # perturb input + if perturb_noise is None: + perturb_noise = torch.randn_like(x) + if eps == -1.0: + eps = float(torch.abs(y_pseudo_gt.max())) / 1000 + # get y_ref if not provided + if y_ref is None: + y_ref = operator(x) + + # get perturbed output + x_perturbed = x + eps * perturb_noise + y_perturbed = operator(x_perturbed) + # divergence + divergence = torch.sum(1.0 / eps * torch.matmul(perturb_noise.permute(0, 1, 3, 2), y_perturbed - y_ref)) # type: ignore + # l2 loss between y_ref, y_pseudo_gt + if complex_input: + l2_loss = complex_diff_abs_loss(y_ref, y_pseudo_gt) + else: + # real input + l2_loss = nn.functional.mse_loss(y_ref, y_pseudo_gt, reduction="mean") + + # sure loss + sure_loss = l2_loss * divergence / (x.shape[0] * x.shape[2] * x.shape[3]) + return sure_loss + + +class SURELoss(_Loss): + """ + Calculate the Stein's Unbiased Risk Estimator (SURE) loss for a given operator. + + This is a differentiable loss function that can be used to train/guide an + operator (e.g. neural network), where the pseudo ground truth is available + but the reference ground truth is not. For example, in the MRI + reconstruction, the pseudo ground truth is the zero-filled reconstruction + and the reference ground truth is the fully sampled reconstruction. Often, + the reference ground truth is not available due to the lack of fully sampled + data. + + The original SURE loss is proposed in [1]. The SURE loss used for guiding + the diffusion model based MRI reconstruction is proposed in [2]. + + Reference + + [1] Stein, C.M.: Estimation of the mean of a multivariate normal distribution. Annals of Statistics + + [2] B. Ozturkler et al. SMRD: SURE-based Robust MRI Reconstruction with Diffusion Models. + (https://arxiv.org/pdf/2310.01799.pdf) + """ + + def __init__(self, perturb_noise: Optional[torch.Tensor] = None, eps: Optional[float] = None) -> None: + """ + Args: + perturb_noise (torch.Tensor, optional): The noise vector of shape + (B, C, H, W). Defaults to None. For complex input, the shape is (B, 2, H, W) aka C=2 real. + For real input, the shape is (B, 1, H, W) real. + + eps (float, optional): The perturbation scalar. Defaults to None. + """ + super().__init__() + self.perturb_noise = perturb_noise + self.eps = eps + + def forward( + self, + operator: Callable, + x: torch.Tensor, + y_pseudo_gt: torch.Tensor, + y_ref: Optional[torch.Tensor] = None, + complex_input: Optional[bool] = False, + ) -> torch.Tensor: + """ + Args: + operator (function): The operator function that takes in an input + tensor x and returns an output tensor y. We will use this to compute + the divergence. More specifically, we will perturb the input x by a + small amount and compute the divergence between the perturbed output + and the reference output + + x (torch.Tensor): The input tensor of shape (B, C, H, W) to the + operator. C=1 or 2: For complex input, the shape is (B, 2, H, W) aka + C=2 real. For real input, the shape is (B, 1, H, W) real. + + y_pseudo_gt (torch.Tensor): The pseudo ground truth tensor of shape + (B, C, H, W) used to compute the L2 loss. C=1 or 2: For complex + input, the shape is (B, 2, H, W) aka C=2 real. For real input, the + shape is (B, 1, H, W) real. + + y_ref (torch.Tensor, optional): The reference output tensor of the + same shape as y_pseudo_gt + + Returns: + sure_loss (torch.Tensor): The SURE loss scalar. + """ + + # check inputs shapes + if x.dim() != 4: + raise ValueError(f"Input tensor x should be 4D, got {x.dim()}.") + if y_pseudo_gt.dim() != 4: + raise ValueError(f"Input tensor y_pseudo_gt should be 4D, but got {y_pseudo_gt.dim()}.") + if y_ref is not None and y_ref.dim() != 4: + raise ValueError(f"Input tensor y_ref should be 4D, but got {y_ref.dim()}.") + if x.shape != y_pseudo_gt.shape: + raise ValueError( + f"Input tensor x and y_pseudo_gt should have the same shape, but got x shape {x.shape}, " + f"y_pseudo_gt shape {y_pseudo_gt.shape}." + ) + if y_ref is not None and y_pseudo_gt.shape != y_ref.shape: + raise ValueError( + f"Input tensor y_pseudo_gt and y_ref should have the same shape, but got y_pseudo_gt shape {y_pseudo_gt.shape}, " + f"y_ref shape {y_ref.shape}." + ) + + # compute loss + loss = sure_loss_function(operator, x, y_pseudo_gt, y_ref, self.eps, self.perturb_noise, complex_input) + + return loss diff --git a/monai/networks/layers/__init__.py b/monai/networks/layers/__init__.py index d61ed57f7f..3a6e4aa554 100644 --- a/monai/networks/layers/__init__.py +++ b/monai/networks/layers/__init__.py @@ -11,6 +11,7 @@ from __future__ import annotations +from .conjugate_gradient import ConjugateGradient from .convutils import calculate_out_shape, gaussian_1d, polyval, same_padding, stride_minus_kernel_padding from .drop_path import DropPath from .factories import Act, Conv, Dropout, LayerFactory, Norm, Pad, Pool, split_args diff --git a/monai/networks/layers/conjugate_gradient.py b/monai/networks/layers/conjugate_gradient.py new file mode 100644 index 0000000000..93a45930d7 --- /dev/null +++ b/monai/networks/layers/conjugate_gradient.py @@ -0,0 +1,112 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import annotations + +from typing import Callable + +import torch +from torch import nn + + +def _zdot(x1: torch.Tensor, x2: torch.Tensor) -> torch.Tensor: + """ + Complex dot product between tensors x1 and x2: sum(x1.*x2) + """ + if torch.is_complex(x1): + assert torch.is_complex(x2), "x1 and x2 must both be complex" + return torch.sum(x1.conj() * x2) + else: + return torch.sum(x1 * x2) + + +def _zdot_single(x: torch.Tensor) -> torch.Tensor: + """ + Complex dot product between tensor x and itself + """ + res = _zdot(x, x) + if torch.is_complex(res): + return res.real + else: + return res + + +class ConjugateGradient(nn.Module): + """ + Congugate Gradient (CG) solver for linear systems Ax = y. + + For linear_op that is positive definite and self-adjoint, CG is + guaranteed to converge CG is often used to solve linear systems of the form + Ax = y, where A is too large to store explicitly, but can be computed via a + linear operator. + + As a result, here we won't set A explicitly as a matrix, but rather as a + linear operator. For example, A could be a FFT/IFFT operation + """ + + def __init__(self, linear_op: Callable, num_iter: int): + """ + Args: + linear_op: Linear operator + num_iter: Number of iterations to run CG + """ + super().__init__() + + self.linear_op = linear_op + self.num_iter = num_iter + + def update( + self, x: torch.Tensor, p: torch.Tensor, r: torch.Tensor, rsold: torch.Tensor + ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: + """ + perform one iteration of the CG method. It takes the current solution x, + the current search direction p, the current residual r, and the old + residual norm rsold as inputs. Then it computes the new solution, search + direction, residual, and residual norm, and returns them. + """ + + dy = self.linear_op(p) + p_dot_dy = _zdot(p, dy) + alpha = rsold / p_dot_dy + x = x + alpha * p + r = r - alpha * dy + rsnew = _zdot_single(r) + beta = rsnew / rsold + rsold = rsnew + p = beta * p + r + return x, p, r, rsold + + def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: + """ + run conjugate gradient for num_iter iterations to solve Ax = y + + Args: + x: tensor (real or complex); Initial guess for linear system Ax = y. + The size of x should be applicable to the linear operator. For + example, if the linear operator is FFT, then x is HCHW; if the + linear operator is a matrix multiplication, then x is a vector + + y: tensor (real or complex); Measurement. Same size as x + + Returns: + x: Solution to Ax = y + """ + # Compute residual + r = y - self.linear_op(x) + rsold = _zdot_single(r) + p = r + + # Update + for _i in range(self.num_iter): + x, p, r, rsold = self.update(x, p, r, rsold) + if rsold < 1e-10: + break + return x

diff --git a/tests/test_conjugate_gradient.py b/tests/test_conjugate_gradient.py new file mode 100644 index 0000000000..239dbe3ecd --- /dev/null +++ b/tests/test_conjugate_gradient.py @@ -0,0 +1,55 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import annotations + +import unittest + +import torch + +from monai.networks.layers import ConjugateGradient + + +class TestConjugateGradient(unittest.TestCase): + def test_real_valued_inverse(self): + """Test ConjugateGradient with real-valued input: when the input is real + value, the output should be the inverse of the matrix.""" + a_dim = 3 + a_mat = torch.tensor([[1, 2, 3], [2, 1, 2], [3, 2, 1]], dtype=torch.float) + + def a_op(x): + return a_mat @ x + + cg_solver = ConjugateGradient(a_op, num_iter=100) + # define the measurement + y = torch.tensor([1, 2, 3], dtype=torch.float) + # solve for x + x = cg_solver(torch.zeros(a_dim), y) + x_ref = torch.linalg.solve(a_mat, y) + # assert torch.allclose(x, x_ref, atol=1e-6), 'CG solver failed to converge to reference solution' + self.assertTrue(torch.allclose(x, x_ref, atol=1e-6)) + + def test_complex_valued_inverse(self): + a_dim = 3 + a_mat = torch.tensor([[1, 2, 3], [2, 1, 2], [3, 2, 1]], dtype=torch.complex64) + + def a_op(x): + return a_mat @ x + + cg_solver = ConjugateGradient(a_op, num_iter=100) + y = torch.tensor([1, 2, 3], dtype=torch.complex64) + x = cg_solver(torch.zeros(a_dim, dtype=torch.complex64), y) + x_ref = torch.linalg.solve(a_mat, y) + self.assertTrue(torch.allclose(x, x_ref, atol=1e-6)) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_sure_loss.py b/tests/test_sure_loss.py new file mode 100644 index 0000000000..945da657bf --- /dev/null +++ b/tests/test_sure_loss.py @@ -0,0 +1,71 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import annotations + +import unittest + +import torch + +from monai.losses import SURELoss + + +class TestSURELoss(unittest.TestCase): + def test_real_value(self): + """Test SURELoss with real-valued input: when the input is real value, the loss should be 0.0.""" + sure_loss_real = SURELoss(perturb_noise=torch.zeros(2, 1, 128, 128), eps=0.1) + + def operator(x): + return x + + y_pseudo_gt = torch.randn(2, 1, 128, 128) + x = torch.randn(2, 1, 128, 128) + loss = sure_loss_real(operator, x, y_pseudo_gt, complex_input=False) + self.assertAlmostEqual(loss.item(), 0.0) + + def test_complex_value(self): + """Test SURELoss with complex-valued input: when the input is complex value, the loss should be 0.0.""" + + def operator(x): + return x + + sure_loss_complex = SURELoss(perturb_noise=torch.zeros(2, 2, 128, 128), eps=0.1) + y_pseudo_gt = torch.randn(2, 2, 128, 128) + x = torch.randn(2, 2, 128, 128) + loss = sure_loss_complex(operator, x, y_pseudo_gt, complex_input=True) + self.assertAlmostEqual(loss.item(), 0.0) + + def test_complex_general_input(self): + """Test SURELoss with complex-valued input: when the input is general complex value, the loss should be 0.0.""" + + def operator(x): + return x + + perturb_noise_real = torch.randn(2, 1, 128, 128) + perturb_noise_complex = torch.zeros(2, 2, 128, 128) + perturb_noise_complex[:, 0, :, :] = perturb_noise_real.squeeze() + y_pseudo_gt_real = torch.randn(2, 1, 128, 128) + y_pseudo_gt_complex = torch.zeros(2, 2, 128, 128) + y_pseudo_gt_complex[:, 0, :, :] = y_pseudo_gt_real.squeeze() + x_real = torch.randn(2, 1, 128, 128) + x_complex = torch.zeros(2, 2, 128, 128) + x_complex[:, 0, :, :] = x_real.squeeze() + + sure_loss_real = SURELoss(perturb_noise=perturb_noise_real, eps=0.1) + sure_loss_complex = SURELoss(perturb_noise=perturb_noise_complex, eps=0.1) + + loss_real = sure_loss_real(operator, x_real, y_pseudo_gt_real, complex_input=False) + loss_complex = sure_loss_complex(operator, x_complex, y_pseudo_gt_complex, complex_input=True) + self.assertAlmostEqual(loss_real.item(), loss_complex.abs().item(), places=6) + + +if __name__ == "__main__": + unittest.main()

diff --git a/docs/source/losses.rst b/docs/source/losses.rst index 61dd959807..ba794af3eb 100644 --- a/docs/source/losses.rst +++ b/docs/source/losses.rst @@ -139,6 +139,11 @@ Reconstruction Losses .. autoclass:: JukeboxLoss :members: +`SURELoss` +~~~~~~~~~~ +.. autoclass:: SURELoss + :members: + Loss Wrappers ------------- diff --git a/docs/source/networks.rst b/docs/source/networks.rst index 8eada7933f..b59c8af5fc 100644 --- a/docs/source/networks.rst +++ b/docs/source/networks.rst @@ -408,6 +408,11 @@ Layers .. autoclass:: LLTM :members: +`ConjugateGradient` +~~~~~~~~~~~~~~~~~~~ +.. autoclass:: ConjugateGradient + :members: + `Utilities` ~~~~~~~~~~~ .. automodule:: monai.networks.layers.convutils

[ { "components": [ { "doc": "First compute the difference in the complex domain,\nthen get the absolute value and take the mse\n\nArgs:\n x, y - B, 2, H, W real valued tensors representing complex numbers\n or B,1,H,W complex valued tensors\nReturns:\n l2_loss - scalar", "...

[ "tests/test_conjugate_gradient.py::TestConjugateGradient::test_complex_valued_inverse", "tests/test_conjugate_gradient.py::TestConjugateGradient::test_real_valued_inverse", "tests/test_sure_loss.py::TestSURELoss::test_complex_general_input", "tests/test_sure_loss.py::TestSURELoss::test_complex_value", "test...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Stein's Unbiased Risk Estimator (SURE) loss and Conjugate Gradient ### Description Based on the discussion topic [here](https://github.com/Project-MONAI/MONAI/discussions/7161#discussion-5773293), we implemented the Conjugate-Gradient algorithm for linear operator inversion, and Stein's Unbiased Risk Estimator (SURE) [1] loss for ground-truth-date free diffusion process guidance that is proposed in [2] and illustrated in the algorithm below: <img width="650" alt="Screenshot 2023-12-10 at 10 19 25 PM" src="https://github.com/Project-MONAI/MONAI/assets/8581162/97069466-cbaf-44e0-b7a7-ae9deb8fd7f2"> The Conjugate-Gradient (CG) algorithm is used to solve for the inversion of the linear operator in Line-4 in the algorithm above, where the linear operator is too large to store explicitly as a matrix (such as FFT/IFFT of an image) and invert directly. Instead, we can solve for the linear inversion iteratively as in CG. The SURE loss is applied for Line-6 above. This is a differentiable loss function that can be used to train/giude an operator (e.g. neural network), where the pseudo ground truth is available but the reference ground truth is not. For example, in the MRI reconstruction, the pseudo ground truth is the zero-filled reconstruction and the reference ground truth is the fully sampled reconstruction. The reference ground truth is not available due to the lack of fully sampled. **Reference** [1] Stein, C.M.: Estimation of the mean of a multivariate normal distribution. Annals of Statistics 1981 [[paper link](https://projecteuclid.org/journals/annals-of-statistics/volume-9/issue-6/Estimation-of-the-Mean-of-a-Multivariate-Normal-Distribution/10.1214/aos/1176345632.full)] [2] B. Ozturkler et al. SMRD: SURE-based Robust MRI Reconstruction with Diffusion Models. MICCAI 2023 [[paper link](https://arxiv.org/pdf/2310.01799.pdf)] ### Types of changes  - [x] Non-breaking change (fix or new feature that would not break existing functionality). - [ ] Breaking change (fix or new feature that would cause existing functionality to change). - [x] New tests added to cover the changes. - [x] Integration tests passed locally by running `./runtests.sh -f -u --net --coverage`. - [x] Quick tests passed locally by running `./runtests.sh --quick --unittests --disttests`. - [x] In-line docstrings updated. - [x] Documentation updated, tested `make html` command in the `docs/` folder. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in monai/losses/sure_loss.py] (definition of complex_diff_abs_loss:) def complex_diff_abs_loss(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: """First compute the difference in the complex domain, then get the absolute value and take the mse Args: x, y - B, 2, H, W real valued tensors representing complex numbers or B,1,H,W complex valued tensors Returns: l2_loss - scalar""" (definition of sure_loss_function:) def sure_loss_function( operator: Callable, x: torch.Tensor, y_pseudo_gt: torch.Tensor, y_ref: Optional[torch.Tensor] = None, eps: Optional[float] = -1.0, perturb_noise: Optional[torch.Tensor] = None, complex_input: Optional[bool] = False, ) -> torch.Tensor: """Args: operator (function): The operator function that takes in an input tensor x and returns an output tensor y. We will use this to compute the divergence. More specifically, we will perturb the input x by a small amount and compute the divergence between the perturbed output and the reference output x (torch.Tensor): The input tensor of shape (B, C, H, W) to the operator. For complex input, the shape is (B, 2, H, W) aka C=2 real. For real input, the shape is (B, 1, H, W) real. y_pseudo_gt (torch.Tensor): The pseudo ground truth tensor of shape (B, C, H, W) used to compute the L2 loss. For complex input, the shape is (B, 2, H, W) aka C=2 real. For real input, the shape is (B, 1, H, W) real. y_ref (torch.Tensor, optional): The reference output tensor of shape (B, C, H, W) used to compute the divergence. Defaults to None. For complex input, the shape is (B, 2, H, W) aka C=2 real. For real input, the shape is (B, 1, H, W) real. eps (float, optional): The perturbation scalar. Set to -1 to set it automatically estimated based on y_pseudo_gtk perturb_noise (torch.Tensor, optional): The noise vector of shape (B, C, H, W). Defaults to None. For complex input, the shape is (B, 2, H, W) aka C=2 real. For real input, the shape is (B, 1, H, W) real. complex_input(bool, optional): Whether the input is complex or not. Defaults to False. Returns: sure_loss (torch.Tensor): The SURE loss scalar.""" (definition of SURELoss:) class SURELoss(_Loss): """Calculate the Stein's Unbiased Risk Estimator (SURE) loss for a given operator. This is a differentiable loss function that can be used to train/guide an operator (e.g. neural network), where the pseudo ground truth is available but the reference ground truth is not. For example, in the MRI reconstruction, the pseudo ground truth is the zero-filled reconstruction and the reference ground truth is the fully sampled reconstruction. Often, the reference ground truth is not available due to the lack of fully sampled data. The original SURE loss is proposed in [1]. The SURE loss used for guiding the diffusion model based MRI reconstruction is proposed in [2]. Reference [1] Stein, C.M.: Estimation of the mean of a multivariate normal distribution. Annals of Statistics [2] B. Ozturkler et al. SMRD: SURE-based Robust MRI Reconstruction with Diffusion Models. (https://arxiv.org/pdf/2310.01799.pdf)""" (definition of SURELoss.__init__:) def __init__(self, perturb_noise: Optional[torch.Tensor] = None, eps: Optional[float] = None) -> None: """Args: perturb_noise (torch.Tensor, optional): The noise vector of shape (B, C, H, W). Defaults to None. For complex input, the shape is (B, 2, H, W) aka C=2 real. For real input, the shape is (B, 1, H, W) real. eps (float, optional): The perturbation scalar. Defaults to None.""" (definition of SURELoss.forward:) def forward( self, operator: Callable, x: torch.Tensor, y_pseudo_gt: torch.Tensor, y_ref: Optional[torch.Tensor] = None, complex_input: Optional[bool] = False, ) -> torch.Tensor: """Args: operator (function): The operator function that takes in an input tensor x and returns an output tensor y. We will use this to compute the divergence. More specifically, we will perturb the input x by a small amount and compute the divergence between the perturbed output and the reference output x (torch.Tensor): The input tensor of shape (B, C, H, W) to the operator. C=1 or 2: For complex input, the shape is (B, 2, H, W) aka C=2 real. For real input, the shape is (B, 1, H, W) real. y_pseudo_gt (torch.Tensor): The pseudo ground truth tensor of shape (B, C, H, W) used to compute the L2 loss. C=1 or 2: For complex input, the shape is (B, 2, H, W) aka C=2 real. For real input, the shape is (B, 1, H, W) real. y_ref (torch.Tensor, optional): The reference output tensor of the same shape as y_pseudo_gt Returns: sure_loss (torch.Tensor): The SURE loss scalar.""" [end of new definitions in monai/losses/sure_loss.py] [start of new definitions in monai/networks/layers/conjugate_gradient.py] (definition of _zdot:) def _zdot(x1: torch.Tensor, x2: torch.Tensor) -> torch.Tensor: """Complex dot product between tensors x1 and x2: sum(x1.*x2)""" (definition of _zdot_single:) def _zdot_single(x: torch.Tensor) -> torch.Tensor: """Complex dot product between tensor x and itself""" (definition of ConjugateGradient:) class ConjugateGradient(nn.Module): """Congugate Gradient (CG) solver for linear systems Ax = y. For linear_op that is positive definite and self-adjoint, CG is guaranteed to converge CG is often used to solve linear systems of the form Ax = y, where A is too large to store explicitly, but can be computed via a linear operator. As a result, here we won't set A explicitly as a matrix, but rather as a linear operator. For example, A could be a FFT/IFFT operation""" (definition of ConjugateGradient.__init__:) def __init__(self, linear_op: Callable, num_iter: int): """Args: linear_op: Linear operator num_iter: Number of iterations to run CG""" (definition of ConjugateGradient.update:) def update( self, x: torch.Tensor, p: torch.Tensor, r: torch.Tensor, rsold: torch.Tensor ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: """perform one iteration of the CG method. It takes the current solution x, the current search direction p, the current residual r, and the old residual norm rsold as inputs. Then it computes the new solution, search direction, residual, and residual norm, and returns them.""" (definition of ConjugateGradient.forward:) def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: """run conjugate gradient for num_iter iterations to solve Ax = y Args: x: tensor (real or complex); Initial guess for linear system Ax = y. The size of x should be applicable to the linear operator. For example, if the linear operator is FFT, then x is HCHW; if the linear operator is a matrix multiplication, then x is a vector y: tensor (real or complex); Measurement. Same size as x Returns: x: Solution to Ax = y""" [end of new definitions in monai/networks/layers/conjugate_gradient.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

e73257caa79309dcce1e93abf1632f4bfd75b11f

astronomer__astronomer-cosmos-758

758

astronomer/astronomer-cosmos

null

9fcee8e785ea3bcb0d19e8d36f3f5b94bedafc98

2023-12-11T01:54:27Z

diff --git a/cosmos/profiles/athena/access_key.py b/cosmos/profiles/athena/access_key.py index a8f71c2b7..02de2be24 100644 --- a/cosmos/profiles/athena/access_key.py +++ b/cosmos/profiles/athena/access_key.py @@ -3,20 +3,33 @@ from typing import Any +from cosmos.exceptions import CosmosValueError + from ..base import BaseProfileMapping class AthenaAccessKeyProfileMapping(BaseProfileMapping): """ - Maps Airflow AWS connections to a dbt Athena profile using an access key id and secret access key. + Uses the Airflow AWS Connection provided to get_credentials() to generate the profile for dbt. - https://docs.getdbt.com/docs/core/connect-data-platform/athena-setup https://airflow.apache.org/docs/apache-airflow-providers-amazon/stable/connections/aws.html + + + This behaves similarly to other provider operators such as the AWS Athena Operator. + Where you pass the aws_conn_id and the operator will generate the credentials for you. + + https://registry.astronomer.io/providers/amazon/versions/latest/modules/athenaoperator + + Information about the dbt Athena profile that is generated can be found here: + + https://github.com/dbt-athena/dbt-athena?tab=readme-ov-file#configuring-your-profile + https://docs.getdbt.com/docs/core/connect-data-platform/athena-setup """ airflow_connection_type: str = "aws" dbt_profile_type: str = "athena" is_community: bool = True + temporary_credentials = None required_fields = [ "aws_access_key_id", @@ -26,11 +39,7 @@ class AthenaAccessKeyProfileMapping(BaseProfileMapping): "s3_staging_dir", "schema", ] - secret_fields = ["aws_secret_access_key", "aws_session_token"] airflow_param_mapping = { - "aws_access_key_id": "login", - "aws_secret_access_key": "password", - "aws_session_token": "extra.aws_session_token", "aws_profile_name": "extra.aws_profile_name", "database": "extra.database", "debug_query_state": "extra.debug_query_state", @@ -49,11 +58,43 @@ class AthenaAccessKeyProfileMapping(BaseProfileMapping): @property def profile(self) -> dict[str, Any | None]: "Gets profile. The password is stored in an environment variable." + + self.temporary_credentials = self._get_temporary_credentials() # type: ignore + profile = { **self.mapped_params, **self.profile_args, - # aws_secret_access_key and aws_session_token should always get set as env var + "aws_access_key_id": self.temporary_credentials.access_key, "aws_secret_access_key": self.get_env_var_format("aws_secret_access_key"), "aws_session_token": self.get_env_var_format("aws_session_token"), } + return self.filter_null(profile) + + @property + def env_vars(self) -> dict[str, str]: + "Overwrites the env_vars for athena, Returns a dictionary of environment variables that should be set based on the self.temporary_credentials." + + if self.temporary_credentials is None: + raise CosmosValueError(f"Could not find the athena credentials.") + + env_vars = {} + + env_secret_key_name = self.get_env_var_name("aws_secret_access_key") + env_session_token_name = self.get_env_var_name("aws_session_token") + + env_vars[env_secret_key_name] = str(self.temporary_credentials.secret_key) + env_vars[env_session_token_name] = str(self.temporary_credentials.token) + + return env_vars + + def _get_temporary_credentials(self): # type: ignore + """ + Helper function to retrieve temporary short lived credentials + Returns an object including access_key, secret_key and token + """ + from airflow.providers.amazon.aws.hooks.base_aws import AwsGenericHook + + hook = AwsGenericHook(self.conn_id) # type: ignore + credentials = hook.get_credentials() + return credentials diff --git a/pyproject.toml b/pyproject.toml index c08de4ade..9d367c075 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -57,6 +57,7 @@ dbt-all = [ ] dbt-athena = [ "dbt-athena-community", + "apache-airflow-providers-amazon>=8.0.0", ] dbt-bigquery = [ "dbt-bigquery", @@ -110,7 +111,6 @@ tests = [ "mypy", "sqlalchemy-stubs", # Change when sqlalchemy is upgraded https://docs.sqlalchemy.org/en/14/orm/extensions/mypy.html ] - docker = [ "apache-airflow-providers-docker>=3.5.0", ] @@ -121,7 +121,6 @@ pydantic = [ "pydantic>=1.10.0,<2.0.0", ] - [project.entry-points.cosmos] provider_info = "cosmos:get_provider_info"

diff --git a/tests/profiles/athena/test_athena_access_key.py b/tests/profiles/athena/test_athena_access_key.py index 22c8efa2c..c224a9d4b 100644 --- a/tests/profiles/athena/test_athena_access_key.py +++ b/tests/profiles/athena/test_athena_access_key.py @@ -1,20 +1,49 @@ "Tests for the Athena profile." import json -from unittest.mock import patch - +from collections import namedtuple +import sys +from unittest.mock import MagicMock, patch import pytest from airflow.models.connection import Connection from cosmos.profiles import get_automatic_profile_mapping from cosmos.profiles.athena.access_key import AthenaAccessKeyProfileMapping +Credentials = namedtuple("Credentials", ["access_key", "secret_key", "token"]) + +mock_assumed_credentials = Credentials( + secret_key="my_aws_assumed_secret_key", + access_key="my_aws_assumed_access_key", + token="my_aws_assumed_token", +) + +mock_missing_credentials = Credentials(access_key=None, secret_key=None, token=None) + + +@pytest.fixture(autouse=True) +def mock_aws_module(): + mock_aws_hook = MagicMock() + + class MockAwsGenericHook: + def __init__(self, conn_id: str) -> None: + pass + + def get_credentials(self) -> Credentials: + return mock_assumed_credentials + + mock_aws_hook.AwsGenericHook = MockAwsGenericHook + + with patch.dict(sys.modules, {"airflow.providers.amazon.aws.hooks.base_aws": mock_aws_hook}): + yield mock_aws_hook + @pytest.fixture() def mock_athena_conn(): # type: ignore """ Sets the connection as an environment variable. """ + conn = Connection( conn_id="my_athena_connection", conn_type="aws", @@ -24,7 +53,7 @@ def mock_athena_conn(): # type: ignore { "aws_session_token": "token123", "database": "my_database", - "region_name": "my_region", + "region_name": "us-east-1", "s3_staging_dir": "s3://my_bucket/dbt/", "schema": "my_schema", } @@ -48,6 +77,7 @@ def test_athena_connection_claiming() -> None: # - region_name # - s3_staging_dir # - schema + potential_values = { "conn_type": "aws", "login": "my_aws_access_key_id", @@ -55,7 +85,7 @@ def test_athena_connection_claiming() -> None: "extra": json.dumps( { "database": "my_database", - "region_name": "my_region", + "region_name": "us-east-1", "s3_staging_dir": "s3://my_bucket/dbt/", "schema": "my_schema", } @@ -68,12 +98,14 @@ def test_athena_connection_claiming() -> None: del values[key] conn = Connection(**values) # type: ignore - print("testing with", values) - - with patch("airflow.hooks.base.BaseHook.get_connection", return_value=conn): - # should raise an InvalidMappingException - profile_mapping = AthenaAccessKeyProfileMapping(conn, {}) - assert not profile_mapping.can_claim_connection() + with patch( + "cosmos.profiles.athena.access_key.AthenaAccessKeyProfileMapping._get_temporary_credentials", + return_value=mock_missing_credentials, + ): + with patch("airflow.hooks.base.BaseHook.get_connection", return_value=conn): + # should raise an InvalidMappingException + profile_mapping = AthenaAccessKeyProfileMapping(conn, {}) + assert not profile_mapping.can_claim_connection() # if we have them all, it should claim conn = Connection(**potential_values) # type: ignore @@ -88,6 +120,7 @@ def test_athena_profile_mapping_selected( """ Tests that the correct profile mapping is selected for Athena. """ + profile_mapping = get_automatic_profile_mapping( mock_athena_conn.conn_id, ) @@ -100,13 +133,14 @@ def test_athena_profile_args( """ Tests that the profile values get set correctly for Athena. """ + profile_mapping = get_automatic_profile_mapping( mock_athena_conn.conn_id, ) assert profile_mapping.profile == { "type": "athena", - "aws_access_key_id": mock_athena_conn.login, + "aws_access_key_id": mock_assumed_credentials.access_key, "aws_secret_access_key": "{{ env_var('COSMOS_CONN_AWS_AWS_SECRET_ACCESS_KEY') }}", "aws_session_token": "{{ env_var('COSMOS_CONN_AWS_AWS_SESSION_TOKEN') }}", "database": mock_athena_conn.extra_dejson.get("database"), @@ -122,9 +156,14 @@ def test_athena_profile_args_overrides( """ Tests that you can override the profile values for Athena. """ + profile_mapping = get_automatic_profile_mapping( mock_athena_conn.conn_id, - profile_args={"schema": "my_custom_schema", "database": "my_custom_db", "aws_session_token": "override_token"}, + profile_args={ + "schema": "my_custom_schema", + "database": "my_custom_db", + "aws_session_token": "override_token", + }, ) assert profile_mapping.profile_args == { @@ -135,7 +174,7 @@ def test_athena_profile_args_overrides( assert profile_mapping.profile == { "type": "athena", - "aws_access_key_id": mock_athena_conn.login, + "aws_access_key_id": mock_assumed_credentials.access_key, "aws_secret_access_key": "{{ env_var('COSMOS_CONN_AWS_AWS_SECRET_ACCESS_KEY') }}", "aws_session_token": "{{ env_var('COSMOS_CONN_AWS_AWS_SESSION_TOKEN') }}", "database": "my_custom_db", @@ -151,10 +190,12 @@ def test_athena_profile_env_vars( """ Tests that the environment variables get set correctly for Athena. """ + profile_mapping = get_automatic_profile_mapping( mock_athena_conn.conn_id, ) + assert profile_mapping.env_vars == { - "COSMOS_CONN_AWS_AWS_SECRET_ACCESS_KEY": mock_athena_conn.password, - "COSMOS_CONN_AWS_AWS_SESSION_TOKEN": mock_athena_conn.extra_dejson.get("aws_session_token"), + "COSMOS_CONN_AWS_AWS_SECRET_ACCESS_KEY": mock_assumed_credentials.secret_key, + "COSMOS_CONN_AWS_AWS_SESSION_TOKEN": mock_assumed_credentials.token, }

diff --git a/pyproject.toml b/pyproject.toml index c08de4ade..9d367c075 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -57,6 +57,7 @@ dbt-all = [ ] dbt-athena = [ "dbt-athena-community", + "apache-airflow-providers-amazon>=8.0.0", ] dbt-bigquery = [ "dbt-bigquery", @@ -110,7 +111,6 @@ tests = [ "mypy", "sqlalchemy-stubs", # Change when sqlalchemy is upgraded https://docs.sqlalchemy.org/en/14/orm/extensions/mypy.html ] - docker = [ "apache-airflow-providers-docker>=3.5.0", ] @@ -121,7 +121,6 @@ pydantic = [ "pydantic>=1.10.0,<2.0.0", ] - [project.entry-points.cosmos] provider_info = "cosmos:get_provider_info"

[ { "components": [ { "doc": "Overwrites the env_vars for athena, Returns a dictionary of environment variables that should be set based on the self.temporary_credentials.", "lines": [ 75, 89 ], "name": "AthenaAccessKeyProfileMapping.env_vars", "si...

[ "tests/profiles/athena/test_athena_access_key.py::test_athena_connection_claiming", "tests/profiles/athena/test_athena_access_key.py::test_athena_profile_args", "tests/profiles/athena/test_athena_access_key.py::test_athena_profile_args_overrides", "tests/profiles/athena/test_athena_access_key.py::test_athena_...

[ "tests/profiles/athena/test_athena_access_key.py::test_athena_profile_mapping_selected" ]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Athena - Get temporary credentials from the conn_id ## Description  Passes the `conn_id` to the `AwsGenericHook` and uses `get_credentials()`, which handles the creation of a session, credentials, freezing of credentials & also masking. [See get_credentials() docs here](https://airflow.apache.org/docs/apache-airflow-providers-amazon/stable/_api/airflow/providers/amazon/aws/hooks/base_aws/index.html#airflow.providers.amazon.aws.hooks.base_aws.AwsGenericHook.get_credentials) ## Related Issue(s) #691   ## Breaking Change?  ## Checklist - [ ] I have made corresponding changes to the documentation (if required) - [X] I have added tests that prove my fix is effective or that my feature works ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in cosmos/profiles/athena/access_key.py] (definition of AthenaAccessKeyProfileMapping.env_vars:) def env_vars(self) -> dict[str, str]: """Overwrites the env_vars for athena, Returns a dictionary of environment variables that should be set based on the self.temporary_credentials.""" (definition of AthenaAccessKeyProfileMapping._get_temporary_credentials:) def _get_temporary_credentials(self): """Helper function to retrieve temporary short lived credentials Returns an object including access_key, secret_key and token""" [end of new definitions in cosmos/profiles/athena/access_key.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c5edba07d2265d5185eaba149a639e8a0740e498

conan-io__conan-15221

15,221

conan-io/conan

null

acbaf44874c0c821a6f6702f46f99d2ee7553deb

2023-12-05T21:26:03Z

diff --git a/conans/model/dependencies.py b/conans/model/dependencies.py index e001141cc8b..c1eebef5302 100644 --- a/conans/model/dependencies.py +++ b/conans/model/dependencies.py @@ -73,6 +73,17 @@ def items(self): def values(self): return self._data.values() + def __contains__(self, item): + try: + self.get(item) + return True + except KeyError: + return False + except ConanException: + # ConanException is raised when there are more than one matching the filters + # so it's definitely in the dict + return True + class ConanFileDependencies(UserRequirementsDict):

diff --git a/conans/test/integration/graph/test_dependencies_visit.py b/conans/test/integration/graph/test_dependencies_visit.py index 75c9fda1402..3bb77dc92d4 100644 --- a/conans/test/integration/graph/test_dependencies_visit.py +++ b/conans/test/integration/graph/test_dependencies_visit.py @@ -29,6 +29,18 @@ def generate(self): self.output.info("DefPRefBuild: {}!!!".format(dep.pref.repr_notime())) for r, d in self.dependencies.build.items(): self.output.info("DIRECTBUILD {}: {}".format(r.direct, d)) + + if "openssl" in self.dependencies: + self.output.info("OpenSSL found in deps") + + if "cmake" in self.dependencies: + self.output.info("cmake found in default deps") + + if "cmake" in self.dependencies.build: + self.output.info("cmake found in deps.build") + + if "badlib" in self.dependencies: + self.output.info("badlib found in deps") """) client.save({"conanfile.py": conanfile}) @@ -48,6 +60,12 @@ def generate(self): assert "conanfile.py: DIRECTBUILD True: cmake/0.1" in client.out assert "conanfile.py: DIRECTBUILD False: openssl/0.2" in client.out + assert "OpenSSL found in deps" in client.out + assert "badlib found in deps" not in client.out + + assert "cmake found in default deps" not in client.out + assert "cmake found in deps.build" in client.out + def test_dependencies_visit_settings_options(): client = TestClient() @@ -89,6 +107,9 @@ def generate(self): '- cmake/0.2, Traits: build=True, headers=False, libs=False, run=False, visible=False' ), ('self.dependencies["missing"]', True, "'missing' not found in the dependency set"), + ('self.output.info("Missing in deps: " + str("missing" in self.dependencies))', False, "Missing in deps: False"), + ('self.output.info("Zlib in deps: " + str("zlib" in self.dependencies))', False, "Zlib in deps: True"), + ('self.output.info("Zlib in deps.build: " + str("zlib" in self.dependencies.build))', False, "Zlib in deps.build: True"), ]

[ { "components": [ { "doc": "", "lines": [ 76, 85 ], "name": "UserRequirementsDict.__contains__", "signature": "def __contains__(self, item):", "type": "function" } ], "file": "conans/model/dependencies.py" } ]

[ "conans/test/integration/graph/test_dependencies_visit.py::test_dependencies_visit", "conans/test/integration/graph/test_dependencies_visit.py::test_cmake_zlib[self.output.info(\"Missing", "conans/test/integration/graph/test_dependencies_visit.py::test_cmake_zlib[self.output.info(\"Zlib" ]

[ "conans/test/integration/graph/test_dependencies_visit.py::test_dependencies_visit_settings_options", "conans/test/integration/graph/test_dependencies_visit.py::test_cmake_zlib[print(\"=>{}\".format(self.dependencies[\"zlib\"].ref))-False-=>zlib/0.2]", "conans/test/integration/graph/test_dependencies_visit.py::...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add `in` operator support for ConanFile's `self.dependencies` Changelog: Feature: Add `in` operator support for ConanFile's `self.dependencies`. Docs: https://github.com/conan-io/docs/pull/3481 Closes https://github.com/conan-io/conan/issues/12832 Found this in the wild as a leftover while going over my created issues :) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conans/model/dependencies.py] (definition of UserRequirementsDict.__contains__:) def __contains__(self, item): [end of new definitions in conans/model/dependencies.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

4a5b19a75db9225316c8cb022a2dfb9705a2af34

googleapis__python-aiplatform-3060

3,060

googleapis/python-aiplatform

null

d0c2ffa8d8d070f9ef247c3c742a67b12d1bc16d

2023-12-05T17:21:57Z

diff --git a/samples/model-builder/vector_search/vector_search_find_neighbors_sample.py b/samples/model-builder/vector_search/vector_search_find_neighbors_sample.py new file mode 100644 index 0000000000..8afef4a82d --- /dev/null +++ b/samples/model-builder/vector_search/vector_search_find_neighbors_sample.py @@ -0,0 +1,59 @@ +# Copyright 2023 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import List + +from google.cloud import aiplatform + + +# [START aiplatform_sdk_vector_search_find_neighbors_sample] +def vector_search_find_neighbors( + project: str, + location: str, + index_endpoint_name: str, + deployed_index_id: str, + queries: List[List[float]], + num_neighbors: int, +) -> None: + """Query the vector search index. + + Args: + project (str): Required. Project ID + location (str): Required. The region name + index_endpoint_name (str): Required. Index endpoint to run the query + against. + deployed_index_id (str): Required. The ID of the DeployedIndex to run + the queries against. + queries (List[List[float]]): Required. A list of queries. Each query is + a list of floats, representing a single embedding. + num_neighbors (int): Required. The number of neighbors to return. + """ + # Initialize the Vertex AI client + aiplatform.init(project=project, location=location) + + # Create the index endpoint instance from an existing endpoint. + my_index_endpoint = aiplatform.MatchingEngineIndexEndpoint( + index_endpoint_name=index_endpoint_name + ) + + # Query the index endpoint for the nearest neighbors. + resp = my_index_endpoint.find_neighbors( + deployed_index_id=deployed_index_id, + queries=queries, + num_neighbors=num_neighbors, + ) + print(resp) + + +# [END aiplatform_sdk_vector_search_find_neighbors_sample] diff --git a/samples/model-builder/vector_search/vector_search_stream_update_sample.py b/samples/model-builder/vector_search/vector_search_stream_update_sample.py new file mode 100644 index 0000000000..03ab377878 --- /dev/null +++ b/samples/model-builder/vector_search/vector_search_stream_update_sample.py @@ -0,0 +1,47 @@ +# Copyright 2023 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Sequence + +from google.cloud import aiplatform + + +# [START aiplatform_sdk_vector_search_stream_update_sample] +def stream_update_vector_search_index( + project: str, location: str, index_name: str, datapoints: Sequence[dict] +) -> None: + """Stream update an existing vector search index + + Args: + project (str): Required. The Project ID + location (str): Required. The region name, e.g. "us-central1" + index_name (str): Required. The index to update. A fully-qualified index + resource name or a index ID. Example: + "projects/123/locations/us-central1/ indexes/my_index_id" or + "my_index_id". + datapoints: Sequence[dict]: Required. The datapoints to be updated. The dict + element should be of the IndexDatapoint type. + """ + # Initialize the Vertex AI client + aiplatform.init(project=project, location=location) + + # Create the index instance from an existing index with stream_update + # enabled + my_index = aiplatform.MatchingEngineIndex(index_name=index_name) + + # Upsert the datapoints to the index + my_index.upsert_datapoints(datapoints=datapoints) + + +# [END aiplatform_sdk_vector_search_stream_update_sample]

diff --git a/samples/model-builder/conftest.py b/samples/model-builder/conftest.py index a9679e74e3..750e682e20 100644 --- a/samples/model-builder/conftest.py +++ b/samples/model-builder/conftest.py @@ -1204,3 +1204,52 @@ def mock_autolog(): with patch.object(aiplatform, "autolog") as mock_autolog_method: mock_autolog_method.return_value = None yield mock_autolog_method + + +""" +---------------------------------------------------------------------------- +Vector Search Fixtures +---------------------------------------------------------------------------- +""" + + +@pytest.fixture +def mock_index(): + mock = MagicMock(aiplatform.MatchingEngineIndex) + yield mock + + +@pytest.fixture +def mock_index_endpoint(): + mock = MagicMock(aiplatform.MatchingEngineIndexEndpoint) + yield mock + + +@pytest.fixture +def mock_index_init(mock_index): + with patch.object(aiplatform, "MatchingEngineIndex") as mock: + mock.return_value = mock_index + yield mock + + +@pytest.fixture +def mock_index_upsert_datapoints(mock_index): + with patch.object(mock_index, "upsert_datapoints") as mock_upsert: + mock_upsert.return_value = None + yield mock_upsert + + +@pytest.fixture +def mock_index_endpoint_init(mock_index_endpoint): + with patch.object(aiplatform, "MatchingEngineIndexEndpoint") as mock: + mock.return_value = mock_index_endpoint + yield mock + + +@pytest.fixture +def mock_index_endpoint_find_neighbors(mock_index_endpoint): + with patch.object( + mock_index_endpoint, "find_neighbors" + ) as mock_find_neighbors: + mock_find_neighbors.return_value = None + yield mock_find_neighbors diff --git a/samples/model-builder/test_constants.py b/samples/model-builder/test_constants.py index 4c0b349e3d..924d888746 100644 --- a/samples/model-builder/test_constants.py +++ b/samples/model-builder/test_constants.py @@ -338,3 +338,12 @@ ) TENSORBOARD_EXPERIMENT_NAME = "my-tensorboard-experiment" TENSORBOARD_PLUGIN_PROFILE_NAME = "profile" + +# Vector Search +VECTOR_SEARCH_INDEX = "123" +VECTOR_SERACH_INDEX_DATAPOINTS = [ + {"datapoint_id": "datapoint_id_1", "feature_vector": [0.1]} +] +VECTOR_SEARCH_INDEX_ENDPOINT = "456" +VECTOR_SEARCH_DEPLOYED_INDEX_ID = "789" +VECTOR_SERACH_INDEX_QUERIES = [[0.1]] diff --git a/samples/model-builder/vector_search/vector_search_find_neighbors_sample_test.py b/samples/model-builder/vector_search/vector_search_find_neighbors_sample_test.py new file mode 100644 index 0000000000..d4ba3143cb --- /dev/null +++ b/samples/model-builder/vector_search/vector_search_find_neighbors_sample_test.py @@ -0,0 +1,45 @@ +# Copyright 2023 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import test_constants as constants +from vector_search import vector_search_find_neighbors_sample + + +def test_vector_search_find_neighbors_sample( + mock_sdk_init, mock_index_endpoint_init, mock_index_endpoint_find_neighbors +): + vector_search_find_neighbors_sample.vector_search_find_neighbors( + project=constants.PROJECT, + location=constants.LOCATION, + index_endpoint_name=constants.VECTOR_SEARCH_INDEX_ENDPOINT, + deployed_index_id=constants.VECTOR_SEARCH_DEPLOYED_INDEX_ID, + queries=constants.VECTOR_SERACH_INDEX_QUERIES, + num_neighbors=10 + ) + + # Check client initialization + mock_sdk_init.assert_called_with( + project=constants.PROJECT, location=constants.LOCATION + ) + + # Check index endpoint initialization with right index endpoint name + mock_index_endpoint_init.assert_called_with( + index_endpoint_name=constants.VECTOR_SEARCH_INDEX_ENDPOINT) + + # Check index_endpoint.find_neighbors is called with right params. + mock_index_endpoint_find_neighbors.assert_called_with( + deployed_index_id=constants.VECTOR_SEARCH_DEPLOYED_INDEX_ID, + queries=constants.VECTOR_SERACH_INDEX_QUERIES, + num_neighbors=10 + ) diff --git a/samples/model-builder/vector_search/vector_search_stream_update_sample_test.py b/samples/model-builder/vector_search/vector_search_stream_update_sample_test.py new file mode 100644 index 0000000000..884a851fcc --- /dev/null +++ b/samples/model-builder/vector_search/vector_search_stream_update_sample_test.py @@ -0,0 +1,40 @@ +# Copyright 2023 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# limitations under the License. + +import test_constants as constants +from vector_search import vector_search_stream_update_sample + + +def test_vector_search_stream_update_sample( + mock_sdk_init, mock_index_init, mock_index_upsert_datapoints +): + vector_search_stream_update_sample.stream_update_vector_search_index( + project=constants.PROJECT, + location=constants.LOCATION, + index_name=constants.VECTOR_SEARCH_INDEX, + datapoints=constants.VECTOR_SERACH_INDEX_DATAPOINTS, + ) + + # Check client initialization + mock_sdk_init.assert_called_with( + project=constants.PROJECT, location=constants.LOCATION + ) + + # Check index initialization with right index name + mock_index_init.assert_called_with(index_name=constants.VECTOR_SEARCH_INDEX) + + # Check index.upsert_datapoints is called with right params. + mock_index_upsert_datapoints.assert_called_with( + datapoints=constants.VECTOR_SERACH_INDEX_DATAPOINTS + )

[ { "components": [ { "doc": "Query the vector search index.\n\nArgs:\n project (str): Required. Project ID\n location (str): Required. The region name\n index_endpoint_name (str): Required. Index endpoint to run the query\n against.\n deployed_index_id (str): Required. The ID of the ...

[ "samples/model-builder/vector_search/vector_search_find_neighbors_sample_test.py::test_vector_search_find_neighbors_sample", "samples/model-builder/vector_search/vector_search_stream_update_sample_test.py::test_vector_search_stream_update_sample" ]

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> chore: adding code samples for vector search streaming update and find neighbors chore: adding code samples for vector search streaming update and find neighbors ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in samples/model-builder/vector_search/vector_search_find_neighbors_sample.py] (definition of vector_search_find_neighbors:) def vector_search_find_neighbors( project: str, location: str, index_endpoint_name: str, deployed_index_id: str, queries: List[List[float]], num_neighbors: int, ) -> None: """Query the vector search index. Args: project (str): Required. Project ID location (str): Required. The region name index_endpoint_name (str): Required. Index endpoint to run the query against. deployed_index_id (str): Required. The ID of the DeployedIndex to run the queries against. queries (List[List[float]]): Required. A list of queries. Each query is a list of floats, representing a single embedding. num_neighbors (int): Required. The number of neighbors to return.""" [end of new definitions in samples/model-builder/vector_search/vector_search_find_neighbors_sample.py] [start of new definitions in samples/model-builder/vector_search/vector_search_stream_update_sample.py] (definition of stream_update_vector_search_index:) def stream_update_vector_search_index( project: str, location: str, index_name: str, datapoints: Sequence[dict] ) -> None: """Stream update an existing vector search index Args: project (str): Required. The Project ID location (str): Required. The region name, e.g. "us-central1" index_name (str): Required. The index to update. A fully-qualified index resource name or a index ID. Example: "projects/123/locations/us-central1/ indexes/my_index_id" or "my_index_id". datapoints: Sequence[dict]: Required. The datapoints to be updated. The dict element should be of the IndexDatapoint type.""" [end of new definitions in samples/model-builder/vector_search/vector_search_stream_update_sample.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

67358fa6a830eb842f6b52d09061af4a41b54af6

google-deepmind__optax-651

651

google-deepmind/optax

null

b67577e2810b473d38fa851dee3da695a9bf2135

2023-12-01T20:06:12Z

diff --git a/docs/api.rst b/docs/api.rst index 9efa959c3..510dc74d6 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -776,6 +776,10 @@ scale_gradient SAMState cocob COCOBState + dadapt_adamw + DAdaptAdamWState + prodigy + ProdigyState Complex-Valued Optimization diff --git a/optax/contrib/__init__.py b/optax/contrib/__init__.py index a9d4b9892..39fd9c35e 100644 --- a/optax/contrib/__init__.py +++ b/optax/contrib/__init__.py @@ -27,3 +27,5 @@ from optax.contrib.sam import NormalizeState from optax.contrib.sam import sam from optax.contrib.sam import SAMState +from optax.contrib.dadapt_adamw import dadapt_adamw +from optax.contrib.prodigy import prodigy diff --git a/optax/contrib/dadapt_adamw.py b/optax/contrib/dadapt_adamw.py new file mode 100644 index 000000000..df0cc5aa8 --- /dev/null +++ b/optax/contrib/dadapt_adamw.py @@ -0,0 +1,123 @@ + +# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""D-Adatation (AdamW variant). + +A contributed implementation of the method from "Learning-Rate-Free Learning +by D-Adaptation" (https://arxiv.org/abs/2301.07733) by Aaron Defazio and +Konstantin Mishchenko (ICML 2023 Outstanding Paper award). +""" +import jax.numpy as jnp +from jax.tree_util import tree_map + +from typing import NamedTuple, Optional, Tuple +from optax import tree_utils +from optax._src import base +from optax._src import utils + +class DAdaptAdamWState(NamedTuple): + exp_avg: base.Updates + exp_avg_sq: base.Updates + grad_sum: base.Updates # exponential moving average of the sum of gradients + estim_lr: float # Distance to solution estimate + numerator_weighted: float + count: float + +def dadapt_adamw(learning_rate: base.ScalarOrSchedule = 1.0, + betas=(0.9, 0.999), + eps=1e-8, + estim_lr0=1e-6, + weight_decay=0) -> base.GradientTransformation: + """Learning rate free AdamW by D-Adaptation + + Adapts the baseline learning rate of AdamW automatically by estimating the + initial distance to solution in the infinity norm. + This method works best when combined with a learning rate schedule that + treats 1.0 as the base (usually max) value. + + References: + [Defazio & Mishchenko, 2023](https://arxiv.org/abs/2301.07733) + + Args: + learning_rate: Learning rate scheduling parameter. The recommended schedule + is a linear_schedule with init_value=1.0 and end_value=0, combined with a + 0-20% learning rate warmup. + betas: Betas for the underlying AdamW Optimizer. + eps: eps for the underlying AdamW Optimizer. + estim_lr0: Initial (under-)estimate of the learning rate. + weight_decay: AdamW style weight-decay. To use Regular Adam decay, chain + with add_decayed_weights. + + Returns: + A `GradientTransformation` object. + """ + def init_fn(params: base.Params) -> DAdaptAdamWState: + exp_avg = tree_map(lambda p: jnp.zeros(p.shape), params) + exp_avg_sq = tree_map(lambda p: jnp.zeros(p.shape), params) + grad_sum = tree_map(lambda p: jnp.zeros(p.shape), params) + estim_lr = estim_lr0 + numerator_weighted = 0 + count = 0 + return DAdaptAdamWState(exp_avg, exp_avg_sq, + grad_sum, estim_lr, numerator_weighted, count) + + def update_fn( + updates: base.Updates, + state: DAdaptAdamWState, + params: Optional[base.Params] = None, + ) -> Tuple[base.Updates, DAdaptAdamWState]: + if params is None: + raise ValueError(base.NO_PARAMS_MSG) + + count = state.count + beta1, beta2 = betas + sb2 = beta2**(0.5) + sched = learning_rate(count) if callable(learning_rate) else learning_rate + + grad_sum = state.grad_sum + numerator_weighted = state.numerator_weighted + + bc = ((1-beta2**(count+1))**0.5)/(1-beta1**(count+1)) + dlr = state.estim_lr * sched * bc + + s_weighted = tree_map(lambda sk, eas: sk/(jnp.sqrt(eas)+eps), + grad_sum, state.exp_avg_sq) + numerator_acum = tree_utils.tree_vdot(updates, s_weighted) + + exp_avg = tree_map(lambda ea, g: beta1*ea + (1-beta1)*dlr*g, + state.exp_avg, updates) + exp_avg_sq = tree_map(lambda eas, g: beta2*eas + (1-beta2)*g*g, + state.exp_avg_sq, updates) + + grad_sum = tree_map(lambda sk, g: sb2*sk + (1-sb2)*dlr*g, grad_sum, updates) + + grad_sum_l1 = tree_utils.tree_sum(tree_map(jnp.abs, grad_sum)) + + numerator_weighted = sb2*numerator_weighted + (1-sb2)*dlr*numerator_acum + + d_estimate = numerator_weighted/((1-sb2)*grad_sum_l1) + estim_lr = jnp.maximum(state.estim_lr, d_estimate) + + p_update = tree_map(lambda ea, eas, p: + -weight_decay*dlr*p + - ea/(jnp.sqrt(eas)+eps), + exp_avg, exp_avg_sq, params) + + new_state = DAdaptAdamWState(exp_avg, exp_avg_sq, grad_sum, + estim_lr, numerator_weighted, + utils.safe_int32_increment(count)) + return p_update, new_state + + return base.GradientTransformation(init_fn, update_fn) diff --git a/optax/contrib/prodigy.py b/optax/contrib/prodigy.py new file mode 100644 index 000000000..14addd895 --- /dev/null +++ b/optax/contrib/prodigy.py @@ -0,0 +1,137 @@ + +# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Prodigy Optimizer. + +A contributed implementation of the method from "Prodigy: An Expeditiously +Adaptive Parameter-Free Learner" (https://arxiv.org/abs/2306.06101) by +Konstantin Mishchenko and Aaron Defazio. A new variant of D-Adapt Adam that +adapts the learning rate faster. +""" +import jax.numpy as jnp +from jax.tree_util import tree_map + +from typing import NamedTuple, Optional, Tuple +from optax import tree_utils +from optax._src import base +from optax._src import utils + +class ProdigyState(NamedTuple): + exp_avg: base.Updates + exp_avg_sq: base.Updates + grad_sum: base.Updates # exponential moving average of the sum of gradients + params0: base.Updates # Initial point + estim_lr: float # Distance to solution estimate + numerator_weighted: float + count: float + +def prodigy(learning_rate: base.ScalarOrSchedule = 0.1, + betas=(0.9, 0.999), + beta3=None, + eps=1e-8, + estim_lr0=1e-6, + estim_lr_coef=1.0, + weight_decay=0) -> base.GradientTransformation: + """Learning rate free AdamW with Prodigy + + Implementation of the Prodigy method from "Prodigy: An Expeditiously + Adaptive Parameter-Free Learner", a version of D-Adapt AdamW that adapts the + baseline learning rate faster by using a weighting of the gradients that + places higher weights on more recent gradients. + This method works best when combined with a learning rate schedule that + treats 1.0 as the base (usually max) value. + + References: + [Mishchenko & Defazio, 2023](https://arxiv.org/abs/2306.06101) + + Args: + learning_rate: Learning rate scheduling parameter. The recommended schedule + is a linear_schedule with init_value=1.0 and end_value=0, combined with a + 0-20% learning rate warmup. + betas: Betas for the underlying AdamW Optimizer. + beta3: Optional momentum parameter for estimation of D. + eps: eps for the underlying AdamW Optimizer. + estim_lr0: Initial (under-)estimate of the learning rate. + estim_lr_coef: LR estimates are multiplied by this parameter. + weight_decay: AdamW style weight-decay. To use Regular Adam decay, chain + with add_decayed_weights. + + Returns: + A `GradientTransformation` object. + """ + beta1, beta2 = betas + if beta3 is None: + beta3 = beta2**0.5 + + def init_fn(params: base.Params) -> ProdigyState: + exp_avg = tree_map(lambda p: jnp.zeros(p.shape), params) + exp_avg_sq = tree_map(lambda p: jnp.zeros(p.shape), params) + grad_sum = tree_map(lambda p: jnp.zeros(p.shape), params) + params0 = params + estim_lr = estim_lr0 + numerator_weighted = 0 + count = 0 + return ProdigyState(exp_avg, exp_avg_sq, + grad_sum, params0, estim_lr, + numerator_weighted, count) + + def update_fn(updates: base.Updates, + state: ProdigyState, + params: Optional[base.Params] = None, + ) -> Tuple[base.Updates, ProdigyState]: + if params is None: + raise ValueError(base.NO_PARAMS_MSG) + + count = state.count + sched = learning_rate(count) if callable(learning_rate) else learning_rate + grad_sum = state.grad_sum + params0 = state.params0 + estim_lr = state.estim_lr + numerator_weighted = state.numerator_weighted + + bc = ((1-beta2**(count+1))**0.5)/(1-beta1**(count+1)) + dlr = estim_lr * sched * bc + dg = tree_map(lambda g: estim_lr * g, updates) + + param_diff = tree_map(lambda p0, p: p0-p, params0, params) + numerator_acum = tree_utils.tree_vdot(updates, param_diff) + + exp_avg = tree_map(lambda ea, dgk: beta1*ea + (1-beta1)*dgk, + state.exp_avg, dg) + exp_avg_sq = tree_map(lambda eas, dgk: beta2*eas + (1-beta2)*dgk*dgk, + state.exp_avg_sq, dg) + + grad_sum = tree_map(lambda sk, dgk: beta3*sk + dlr*dgk/estim_lr0, + grad_sum, dg) + + numerator_weighted = beta3*numerator_weighted + numerator_weighted += (estim_lr/estim_lr0)*dlr*numerator_acum + + denominator = tree_utils.tree_sum(tree_map(jnp.abs, grad_sum)) + + lr_estimate = estim_lr_coef*numerator_weighted/denominator + estim_lr = jnp.maximum(state.estim_lr, lr_estimate) + + p_update = tree_map(lambda ea, eas, p: + -weight_decay*dlr*p + - dlr*ea/(jnp.sqrt(eas) + estim_lr*eps), + exp_avg, exp_avg_sq, params) + + new_state = ProdigyState(exp_avg, exp_avg_sq, grad_sum, params0, + estim_lr, numerator_weighted, + utils.safe_int32_increment(count)) + return p_update, new_state + + return base.GradientTransformation(init_fn, update_fn)

diff --git a/optax/contrib/dadapt_adamw_test.py b/optax/contrib/dadapt_adamw_test.py new file mode 100644 index 000000000..992fe1046 --- /dev/null +++ b/optax/contrib/dadapt_adamw_test.py @@ -0,0 +1,86 @@ +# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Tests for `dadapt_adamw.py`.""" + +from absl.testing import absltest +from absl.testing import parameterized + +import chex +import jax +import jax.numpy as jnp + +from optax import contrib +from optax._src import numerics +from optax._src import update +from optax.tree_utils import _state_utils + + +def _setup_parabola(dtype): + """Quadratic function as an optimization target.""" + initial_params = jnp.array([-1.0, 10.0, 1.0], dtype=dtype) + final_params = jnp.array([1.0, -1.0, 1.0], dtype=dtype) + + @jax.grad + def get_updates(params): + return jnp.sum(numerics.abs_sq(params - final_params)) + + return initial_params, final_params, get_updates + + +def _setup_rosenbrock(dtype): + """Rosenbrock function as an optimization target.""" + a = 1.0 + b = 100.0 + + initial_params = jnp.array([0.0, 0.0], dtype=dtype) + final_params = jnp.array([a, a**2], dtype=dtype) + + @jax.grad + def get_updates(params): + return (numerics.abs_sq(a - params[0]) + + b * numerics.abs_sq(params[1] - params[0]**2)) + + return initial_params, final_params, get_updates + +class DAdaptAdamWTest(chex.TestCase): + @parameterized.product( + opt_name=('dadapt_adamw',), + target=(_setup_parabola, _setup_rosenbrock), + dtype=(jnp.float32,), + ) + def test_optimization(self, opt_name, target, dtype): + + opt = getattr(contrib, opt_name)() + initial_params, final_params, get_updates = target(dtype) + + @jax.jit + def step(params, state): + updates = get_updates(params) + updates, state = opt.update(updates, state, params) + params = update.apply_updates(params, updates) + return params, state + + params = initial_params + state = opt.init(params) + # A no-op change, to verify that tree map works. + state = _state_utils.tree_map_params(opt, lambda v: v, state) + + for _ in range(15000): + params, state = step(params, state) + + chex.assert_trees_all_close(params, final_params, rtol=3e-2, atol=3e-2) + +if __name__ == '__main__': + absltest.main() diff --git a/optax/contrib/prodigy_test.py b/optax/contrib/prodigy_test.py new file mode 100644 index 000000000..f6bcbabcb --- /dev/null +++ b/optax/contrib/prodigy_test.py @@ -0,0 +1,86 @@ +# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Tests for `prodigy.py`.""" + +from absl.testing import absltest +from absl.testing import parameterized + +import chex +import jax +import jax.numpy as jnp + +from optax import contrib +from optax._src import numerics +from optax._src import update +from optax.tree_utils import _state_utils + + +def _setup_parabola(dtype): + """Quadratic function as an optimization target.""" + initial_params = jnp.array([-1.0, 10.0, 1.0], dtype=dtype) + final_params = jnp.array([1.0, -1.0, 1.0], dtype=dtype) + + @jax.grad + def get_updates(params): + return jnp.sum(numerics.abs_sq(params - final_params)) + + return initial_params, final_params, get_updates + + +def _setup_rosenbrock(dtype): + """Rosenbrock function as an optimization target.""" + a = 1.0 + b = 100.0 + + initial_params = jnp.array([0.0, 0.0], dtype=dtype) + final_params = jnp.array([a, a**2], dtype=dtype) + + @jax.grad + def get_updates(params): + return (numerics.abs_sq(a - params[0]) + + b * numerics.abs_sq(params[1] - params[0]**2)) + + return initial_params, final_params, get_updates + +class ProdigyTest(chex.TestCase): + @parameterized.product( + opt_name=('prodigy',), + target=(_setup_parabola, _setup_rosenbrock), + dtype=(jnp.float32,), + ) + def test_optimization(self, opt_name, target, dtype): + + opt = getattr(contrib, opt_name)() + initial_params, final_params, get_updates = target(dtype) + + @jax.jit + def step(params, state): + updates = get_updates(params) + updates, state = opt.update(updates, state, params) + params = update.apply_updates(params, updates) + return params, state + + params = initial_params + state = opt.init(params) + # A no-op change, to verify that tree map works. + state = _state_utils.tree_map_params(opt, lambda v: v, state) + + for _ in range(10000): + params, state = step(params, state) + + chex.assert_trees_all_close(params, final_params, rtol=3e-2, atol=3e-2) + +if __name__ == '__main__': + absltest.main()

diff --git a/docs/api.rst b/docs/api.rst index 9efa959c3..510dc74d6 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -776,6 +776,10 @@ scale_gradient SAMState cocob COCOBState + dadapt_adamw + DAdaptAdamWState + prodigy + ProdigyState Complex-Valued Optimization

[ { "components": [ { "doc": "", "lines": [ 30, 36 ], "name": "DAdaptAdamWState", "signature": "class DAdaptAdamWState(NamedTuple):", "type": "class" }, { "doc": "Learning rate free AdamW by D-Adaptation\n\nAdapts the ba...

[ "optax/contrib/dadapt_adamw_test.py::DAdaptAdamWTest::test_optimization0", "optax/contrib/dadapt_adamw_test.py::DAdaptAdamWTest::test_optimization1", "optax/contrib/prodigy_test.py::ProdigyTest::test_optimization0", "optax/contrib/prodigy_test.py::ProdigyTest::test_optimization1" ]

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> D-Adaptation and Prodigy contrib implementations Implementations of D-Adaptation AdamW and the related method Prodigy based on the official PyTorch implementations. I have verified that they give the same outputs as the PyTorch version on an example problem. Unit tests similar to those used on other optimizers in contrib. https://github.com/facebookresearch/dadaptation https://github.com/konstmish/prodigy These two new optimizers perform learning rate adaptation, similar to Mechanic and COCOB, two optimizers already included in contrib, but by a different mechanism, and so I think these are relevant to Optax and interesting to the community. D-Adaptation won an ICML outstanding paper award and is already gaining a lot of traction in the ML community, particularly for fine-tuning diffusion models with the Prodigy variant. ---------- Thanks @adefazio for the contribution! </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in optax/contrib/dadapt_adamw.py] (definition of DAdaptAdamWState:) class DAdaptAdamWState(NamedTuple): (definition of dadapt_adamw:) def dadapt_adamw(learning_rate: base.ScalarOrSchedule = 1.0, betas=(0.9, 0.999), eps=1e-8, estim_lr0=1e-6, weight_decay=0) -> base.GradientTransformation: """Learning rate free AdamW by D-Adaptation Adapts the baseline learning rate of AdamW automatically by estimating the initial distance to solution in the infinity norm. This method works best when combined with a learning rate schedule that treats 1.0 as the base (usually max) value. References: [Defazio & Mishchenko, 2023](https://arxiv.org/abs/2301.07733) Args: learning_rate: Learning rate scheduling parameter. The recommended schedule is a linear_schedule with init_value=1.0 and end_value=0, combined with a 0-20% learning rate warmup. betas: Betas for the underlying AdamW Optimizer. eps: eps for the underlying AdamW Optimizer. estim_lr0: Initial (under-)estimate of the learning rate. weight_decay: AdamW style weight-decay. To use Regular Adam decay, chain with add_decayed_weights. Returns: A `GradientTransformation` object.""" (definition of dadapt_adamw.init_fn:) def init_fn(params: base.Params) -> DAdaptAdamWState: (definition of dadapt_adamw.update_fn:) def update_fn( updates: base.Updates, state: DAdaptAdamWState, params: Optional[base.Params] = None, ) -> Tuple[base.Updates, DAdaptAdamWState]: [end of new definitions in optax/contrib/dadapt_adamw.py] [start of new definitions in optax/contrib/prodigy.py] (definition of ProdigyState:) class ProdigyState(NamedTuple): (definition of prodigy:) def prodigy(learning_rate: base.ScalarOrSchedule = 0.1, betas=(0.9, 0.999), beta3=None, eps=1e-8, estim_lr0=1e-6, estim_lr_coef=1.0, weight_decay=0) -> base.GradientTransformation: """Learning rate free AdamW with Prodigy Implementation of the Prodigy method from "Prodigy: An Expeditiously Adaptive Parameter-Free Learner", a version of D-Adapt AdamW that adapts the baseline learning rate faster by using a weighting of the gradients that places higher weights on more recent gradients. This method works best when combined with a learning rate schedule that treats 1.0 as the base (usually max) value. References: [Mishchenko & Defazio, 2023](https://arxiv.org/abs/2306.06101) Args: learning_rate: Learning rate scheduling parameter. The recommended schedule is a linear_schedule with init_value=1.0 and end_value=0, combined with a 0-20% learning rate warmup. betas: Betas for the underlying AdamW Optimizer. beta3: Optional momentum parameter for estimation of D. eps: eps for the underlying AdamW Optimizer. estim_lr0: Initial (under-)estimate of the learning rate. estim_lr_coef: LR estimates are multiplied by this parameter. weight_decay: AdamW style weight-decay. To use Regular Adam decay, chain with add_decayed_weights. Returns: A `GradientTransformation` object.""" (definition of prodigy.init_fn:) def init_fn(params: base.Params) -> ProdigyState: (definition of prodigy.update_fn:) def update_fn(updates: base.Updates, state: ProdigyState, params: Optional[base.Params] = None, ) -> Tuple[base.Updates, ProdigyState]: [end of new definitions in optax/contrib/prodigy.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

1e08bccf195ac54e7d9d766eb5e69345bf0e3230

deepset-ai__haystack-6413

6,413

deepset-ai/haystack

null

5353706cf6778443a975fb93c5359c4d676e7173

2023-11-27T08:30:06Z

diff --git a/haystack/pipeline.py b/haystack/pipeline.py index 0478e36988..be8d79583b 100644 --- a/haystack/pipeline.py +++ b/haystack/pipeline.py @@ -1,4 +1,5 @@ -from typing import Any, Dict, Optional, Union, TextIO +from collections import defaultdict +from typing import Any, Dict, Optional, Union, TextIO, Tuple from pathlib import Path import datetime import logging @@ -35,14 +36,76 @@ def __init__( def run(self, data: Dict[str, Any], debug: bool = False) -> Dict[str, Any]: """ - Runs the pipeline. + Runs the pipeline with given input data. + + :param data: A dictionary of inputs for the pipeline's components. Each key is a component name + and its value is a dictionary of that component's input parameters. + :param debug: Set to True to collect and return debug information. + :return: A dictionary containing the pipeline's output. + :raises PipelineRuntimeError: If a component fails or returns unexpected output. + + Example a - Using named components: + Consider a 'Hello' component that takes a 'word' input and outputs a greeting. + + ```python + @component + class Hello: + @component.output_types(output=str) + def run(self, word: str): + return {"output": f"Hello, {word}!"} + ``` + + Create a pipeline with two 'Hello' components connected together: + + ```python + pipeline = Pipeline() + pipeline.add_component("hello", Hello()) + pipeline.add_component("hello2", Hello()) + pipeline.connect("hello.output", "hello2.word") + result = pipeline.run(data={"hello": {"word": "world"}}) + ``` + + This runs the pipeline with the specified input for 'hello', yielding + {'hello2': {'output': 'Hello, Hello, world!!'}}. + + Example b - Using flat inputs: + You can also pass inputs directly without specifying component names: + + ```python + result = pipeline.run(data={"word": "world"}) + ``` + + The pipeline resolves inputs to the correct components, returning + {'hello2': {'output': 'Hello, Hello, world!!'}}. + """ + # check whether the data is a nested dictionary of component inputs where each key is a component name + # and each value is a dictionary of input parameters for that component + is_nested_component_input = all(isinstance(value, dict) for value in data.values()) + if is_nested_component_input: + return self._run_internal(data=data, debug=debug) + else: + # flat input, a dict where keys are input names and values are the corresponding values + # we need to convert it to a nested dictionary of component inputs and then run the pipeline + # just like in the previous case + pipeline_inputs, unresolved_inputs = self._prepare_component_input_data(data) + if unresolved_inputs: + logger.warning( + "Inputs %s were not matched to any component inputs, please check your run parameters.", + list(unresolved_inputs.keys()), + ) + + return self._run_internal(data=pipeline_inputs, debug=debug) + + def _run_internal(self, data: Dict[str, Any], debug: bool = False) -> Dict[str, Any]: + """ + Runs the pipeline by invoking the underlying run to initiate the pipeline execution. :params data: the inputs to give to the input components of the Pipeline. :params debug: whether to collect and return debug information. :returns: A dictionary with the outputs of the output components of the Pipeline. - :raises PipelineRuntimeError: if the any of the components fail or return unexpected output. + :raises PipelineRuntimeError: if any of the components fail or return unexpected output. """ pipeline_running(self) return super().run(data=data, debug=debug) @@ -97,3 +160,41 @@ def load(cls, fp: TextIO, marshaller: Marshaller = DEFAULT_MARSHALLER) -> "Pipel :returns: A `Pipeline` object. """ return cls.from_dict(marshaller.unmarshal(fp.read())) + + def _prepare_component_input_data(self, data: Dict[str, Any]) -> Tuple[Dict[str, Dict[str, Any]], Dict[str, Any]]: + """ + Organizes input data for pipeline components and identifies any inputs that are not matched to any + component's input slots. + + This method processes a flat dictionary of input data, where each key-value pair represents an input name + and its corresponding value. It distributes these inputs to the appropriate pipeline components based on + their input requirements. Inputs that don't match any component's input slots are classified as unresolved. + + :param data: A dictionary with input names as keys and input values as values. + :type data: Dict[str, Any] + :return: A tuple containing two elements: + 1. A dictionary mapping component names to their respective matched inputs. + 2. A dictionary of inputs that were not matched to any component, termed as unresolved keyword arguments. + :rtype: Tuple[Dict[str, Dict[str, Any]], Dict[str, Any]] + """ + pipeline_input_data: Dict[str, Dict[str, Any]] = defaultdict(dict) + unresolved_kwargs = {} + + # Retrieve the input slots for each component in the pipeline + available_inputs: Dict[str, Dict[str, Any]] = self.inputs() + + # Go through all provided to distribute them to the appropriate component inputs + for input_name, input_value in data.items(): + resolved_at_least_once = False + + # Check each component to see if it has a slot for the current kwarg + for component_name, component_inputs in available_inputs.items(): + if input_name in component_inputs: + # If a match is found, add the kwarg to the component's input data + pipeline_input_data[component_name][input_name] = input_value + resolved_at_least_once = True + + if not resolved_at_least_once: + unresolved_kwargs[input_name] = input_value + + return pipeline_input_data, unresolved_kwargs diff --git a/releasenotes/notes/allow-simplified-pipeline-run-input-e3dd98ff38f0bc01.yaml b/releasenotes/notes/allow-simplified-pipeline-run-input-e3dd98ff38f0bc01.yaml new file mode 100644 index 0000000000..6badfe24ed --- /dev/null +++ b/releasenotes/notes/allow-simplified-pipeline-run-input-e3dd98ff38f0bc01.yaml @@ -0,0 +1,6 @@ +--- +preview: + - | + Adds option to run pipelines without specifying component inputs and their corresponding key/value pairs. Instead, + provide the input keys/values directly, and the pipeline's internal mechanisms will automatically determine the + appropriate components.

diff --git a/test/test_pipeline.py b/test/test_pipeline.py index b5e4aee973..64d5374224 100644 --- a/test/test_pipeline.py +++ b/test/test_pipeline.py @@ -56,3 +56,111 @@ def test_pipeline_load(test_files_path): assert pipeline.max_loops_allowed == 99 assert isinstance(pipeline.get_component("Comp1"), TestComponent) assert isinstance(pipeline.get_component("Comp2"), TestComponent) + + +@pytest.mark.unit +def test_pipeline_resolution_simple_input(): + @component + class Hello: + @component.output_types(output=str) + def run(self, word: str): + """ + Takes a string in input and returns "Hello, <string>!" + in output. + """ + return {"output": f"Hello, {word}!"} + + pipeline = Pipeline() + pipeline.add_component("hello", Hello()) + pipeline.add_component("hello2", Hello()) + + pipeline.connect("hello.output", "hello2.word") + result = pipeline.run(data={"hello": {"word": "world"}}) + assert result == {"hello2": {"output": "Hello, Hello, world!!"}} + + result = pipeline.run(data={"word": "world"}) + assert result == {"hello2": {"output": "Hello, Hello, world!!"}} + + +def test_pipeline_resolution_wrong_input_name(caplog): + @component + class Hello: + @component.output_types(output=str) + def run(self, who: str): + """ + Takes a string in input and returns "Hello, <string>!" + in output. + """ + return {"output": f"Hello, {who}!"} + + pipeline = Pipeline() + pipeline.add_component("hello", Hello()) + pipeline.add_component("hello2", Hello()) + + pipeline.connect("hello.output", "hello2.who") + + # test case with nested component inputs + with pytest.raises(ValueError): + pipeline.run(data={"hello": {"non_existing_input": "world"}}) + + # test case with flat component inputs + with pytest.raises(ValueError): + pipeline.run(data={"non_existing_input": "world"}) + + # important to check that the warning is logged for UX purposes, leave it here + assert "were not matched to any component" in caplog.text + + +def test_pipeline_resolution_with_mixed_correct_and_incorrect_input_names(caplog): + @component + class Hello: + @component.output_types(output=str) + def run(self, who: str): + """ + Takes a string in input and returns "Hello, <string>!" + in output. + """ + return {"output": f"Hello, {who}!"} + + pipeline = Pipeline() + pipeline.add_component("hello", Hello()) + pipeline.add_component("hello2", Hello()) + + pipeline.connect("hello.output", "hello2.who") + + # test case with nested component inputs + # this will raise ValueError because hello component does not have an input named "non_existing_input" + # even though it has an input named "who" + with pytest.raises(ValueError): + pipeline.run(data={"hello": {"non_existing_input": "world", "who": "world"}}) + + # test case with flat component inputs + # this will not raise ValueError because the input "who" will be resolved to the correct component + # and we'll log a warning for the input "non_existing_input" which was not resolved + result = pipeline.run(data={"non_existing_input": "world", "who": "world"}) + assert result == {"hello2": {"output": "Hello, Hello, world!!"}} + + # important to check that the warning is logged for UX purposes, leave it here + assert "were not matched to any component" in caplog.text + + +def test_pipeline_resolution_duplicate_input_names_across_components(): + @component + class Hello: + @component.output_types(output=str) + def run(self, who: str, what: str): + return {"output": f"Hello {who} {what}!"} + + pipe = Pipeline() + pipe.add_component("hello", Hello()) + pipe.add_component("hello2", Hello()) + + pipe.connect("hello.output", "hello2.who") + + result = pipe.run(data={"what": "Haystack", "who": "world"}) + assert result == {"hello2": {"output": "Hello Hello world Haystack! Haystack!"}} + + resolved, _ = pipe._prepare_component_input_data(data={"what": "Haystack", "who": "world"}) + + # why does hello2 have only one input? Because who of hello2 is inserted from hello.output + assert resolved == {"hello": {"what": "Haystack", "who": "world"}, "hello2": {"what": "Haystack"}}

diff --git a/releasenotes/notes/allow-simplified-pipeline-run-input-e3dd98ff38f0bc01.yaml b/releasenotes/notes/allow-simplified-pipeline-run-input-e3dd98ff38f0bc01.yaml new file mode 100644 index 0000000000..6badfe24ed --- /dev/null +++ b/releasenotes/notes/allow-simplified-pipeline-run-input-e3dd98ff38f0bc01.yaml @@ -0,0 +1,6 @@ +--- +preview: + - | + Adds option to run pipelines without specifying component inputs and their corresponding key/value pairs. Instead, + provide the input keys/values directly, and the pipeline's internal mechanisms will automatically determine the + appropriate components.

[ { "components": [ { "doc": "Runs the pipeline by invoking the underlying run to initiate the pipeline execution.\n\n:params data: the inputs to give to the input components of the Pipeline.\n:params debug: whether to collect and return debug information.\n\n:returns: A dictionary with the outputs ...

[ "[", "test/test_pipeline.py::test_pipeline_resolution_simple_input", "test/test_pipeline.py::test_pipeline_resolution_wrong_input_name", "test/test_pipeline.py::test_pipeline_resolution_with_mixed_correct_and_incorrect_input_names", "test/test_pipeline.py::test_pipeline_resolution_duplicate_input_names_acro...

[ "test/test_pipeline.py::test_pipeline_dumps", "test/test_pipeline.py::test_pipeline_loads", "test/test_pipeline.py::test_pipeline_dump", "test/test_pipeline.py::test_pipeline_load" ]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat: Allow flat dictionary `Pipeline.run()` inputs ### Why: This pull request introduces a significant enhancement to the `Pipeline` class. The main objective is to simplify the way users interact with pipelines, especially in terms of specifying inputs for various components. - fixes https://github.com/deepset-ai/haystack/issues/6101 - supersedes https://github.com/deepset-ai/haystack/pull/6266 ### What: - **Modification to `Pipeline.run()`**: The `run` method of the `Pipeline` class has been updated to handle both nested and flat input dictionaries. This allows users to run pipelines without explicitly specifying component inputs and their corresponding key/value pairs. - **New `_prepare_component_input_data()` Method**: A private method `_prepare_component_input_data` has been added. It organizes input data for pipeline components and identifies any inputs that are not matched to any component's input slots. - **Release Notes Addition**: A new file `allow-simplified-pipeline-run-input-e3dd98ff38f0bc01.yaml` has been added to the `releasenotes/notes` directory, describing the new feature. - **Updated Unit Tests**: The `test_pipeline.py` file has been updated with new unit tests to cover the changes in pipeline input resolution. ### How can it be used: Users can now run pipelines with simplified input formats. Instead of specifying a nested dictionary with each key being a component name and its value a dictionary of that component's input parameters, users can provide flat input dictionaries. The pipeline's internal mechanisms will automatically determine the appropriate components for each input. This feature enhances usability and reduces the complexity of pipeline executions. ### How did you test it: New unit tests have been added to `test_pipeline.py` to cover the new functionality. These tests include scenarios for both nested and flat input dictionaries, verifying the pipeline's ability to correctly resolve inputs to the appropriate components. The tests also cover cases with incorrect input names to ensure that the pipeline appropriately handles and logs warnings for unmatched inputs. ### Notes for the reviewer: - Please review the changes in the context of overall pipeline functionality to ensure that this new feature integrates well with existing capabilities. - Pay special attention to the new `_prepare_component_input_data()` method to ensure it aligns with the intended use cases and handles edge cases effectively. - The release notes addition should accurately reflect the scope and impact of these changes for end users. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in haystack/pipeline.py] (definition of Pipeline._run_internal:) def _run_internal(self, data: Dict[str, Any], debug: bool = False) -> Dict[str, Any]: """Runs the pipeline by invoking the underlying run to initiate the pipeline execution. :params data: the inputs to give to the input components of the Pipeline. :params debug: whether to collect and return debug information. :returns: A dictionary with the outputs of the output components of the Pipeline. :raises PipelineRuntimeError: if any of the components fail or return unexpected output.""" (definition of Pipeline._prepare_component_input_data:) def _prepare_component_input_data(self, data: Dict[str, Any]) -> Tuple[Dict[str, Dict[str, Any]], Dict[str, Any]]: """Organizes input data for pipeline components and identifies any inputs that are not matched to any component's input slots. This method processes a flat dictionary of input data, where each key-value pair represents an input name and its corresponding value. It distributes these inputs to the appropriate pipeline components based on their input requirements. Inputs that don't match any component's input slots are classified as unresolved. :param data: A dictionary with input names as keys and input values as values. :type data: Dict[str, Any] :return: A tuple containing two elements: 1. A dictionary mapping component names to their respective matched inputs. 2. A dictionary of inputs that were not matched to any component, termed as unresolved keyword arguments. :rtype: Tuple[Dict[str, Dict[str, Any]], Dict[str, Any]]""" [end of new definitions in haystack/pipeline.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

f4d9c2bb917be0ffe132dffcc2ad4f1b0fcc5967

roboflow__supervision-620

620

roboflow/supervision

null

10c44b0143c13b33c1951509f9f11c37c6373752

2023-11-26T10:27:34Z

diff --git a/supervision/draw/color.py b/supervision/draw/color.py index 69bcc9c5e..9d1b4ad98 100644 --- a/supervision/draw/color.py +++ b/supervision/draw/color.py @@ -71,6 +71,21 @@ def from_hex(cls, color_hex: str) -> Color: r, g, b = (int(color_hex[i : i + 2], 16) for i in range(0, 6, 2)) return cls(r, g, b) + def as_hex(self) -> str: + """ + Converts the Color instance to a hex string. + + Returns: + str: The hexadecimal color string. + + Example: + ``` + >>> Color(r=255, g=0, b=255).as_hex() + '#ff00ff' + ``` + """ + return f"#{self.r:02x}{self.g:02x}{self.b:02x}" + def as_rgb(self) -> Tuple[int, int, int]: """ Returns the color as an RGB tuple.

diff --git a/test/draw/test_color.py b/test/draw/test_color.py index 723f7043e..eb4c36574 100644 --- a/test/draw/test_color.py +++ b/test/draw/test_color.py @@ -30,3 +30,22 @@ def test_color_from_hex( with exception: result = Color.from_hex(color_hex=color_hex) assert result == expected_result + + +@pytest.mark.parametrize( + "color, expected_result, exception", + [ + (Color.white(), "#ffffff", DoesNotRaise()), + (Color.black(), "#000000", DoesNotRaise()), + (Color.red(), "#ff0000", DoesNotRaise()), + (Color.green(), "#00ff00", DoesNotRaise()), + (Color.blue(), "#0000ff", DoesNotRaise()), + (Color(r=128, g=128, b=0), "#808000", DoesNotRaise()), + ], +) +def test_color_as_hex( + color: Color, expected_result: Optional[str], exception: Exception +) -> None: + with exception: + result = color.as_hex() + assert result == expected_result

[ { "components": [ { "doc": "Converts the Color instance to a hex string.\n\nReturns:\n str: The hexadecimal color string.\n\nExample:\n ```\n >>> Color(r=255, g=0, b=255).as_hex()\n '#ff00ff'\n ```", "lines": [ 74, 87 ], "name": "Color.as_...

[ "test/draw/test_color.py::test_color_as_hex[color0-#ffffff-exception0]", "test/draw/test_color.py::test_color_as_hex[color1-#000000-exception1]", "test/draw/test_color.py::test_color_as_hex[color2-#ff0000-exception2]", "test/draw/test_color.py::test_color_as_hex[color3-#00ff00-exception3]", "test/draw/test_...

[ "test/draw/test_color.py::test_color_from_hex[fff-expected_result0-exception0]", "test/draw/test_color.py::test_color_from_hex[#fff-expected_result1-exception1]", "test/draw/test_color.py::test_color_from_hex[ffffff-expected_result2-exception2]", "test/draw/test_color.py::test_color_from_hex[#ffffff-expected_...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add 'as_hex' method and corresponding test to `Color` class. ## Type of change Please delete options that are not relevant. - [ ] Bug fix (non-breaking change which fixes an issue) - [x] New feature (non-breaking change which adds functionality) - [ ] This change requires a documentation update ## Docs - [x] Docs updated? What were the changes: ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in supervision/draw/color.py] (definition of Color.as_hex:) def as_hex(self) -> str: """Converts the Color instance to a hex string. Returns: str: The hexadecimal color string. Example: ``` >>> Color(r=255, g=0, b=255).as_hex() '#ff00ff' ```""" [end of new definitions in supervision/draw/color.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

3eb5c0b024e3e46877b7fe4fd66e6177d1308ba0

slackapi__python-slack-sdk-1431

1,431

slackapi/python-slack-sdk

null

3e2d7e825cce2d06a35324772ade72483d7cdec1

2023-11-21T05:36:22Z

diff --git a/slack_sdk/models/blocks/__init__.py b/slack_sdk/models/blocks/__init__.py index 87febae70..96ecfb9e8 100644 --- a/slack_sdk/models/blocks/__init__.py +++ b/slack_sdk/models/blocks/__init__.py @@ -43,6 +43,12 @@ from .block_elements import StaticSelectElement from .block_elements import UserMultiSelectElement from .block_elements import UserSelectElement +from .block_elements import RichTextElement +from .block_elements import RichTextElementParts +from .block_elements import RichTextListElement +from .block_elements import RichTextPreformattedElement +from .block_elements import RichTextQuoteElement +from .block_elements import RichTextSectionElement from .blocks import ActionsBlock from .blocks import Block from .blocks import CallBlock @@ -54,6 +60,7 @@ from .blocks import InputBlock from .blocks import SectionBlock from .blocks import VideoBlock +from .blocks import RichTextBlock __all__ = [ "ButtonStyles", @@ -93,6 +100,12 @@ "StaticSelectElement", "UserMultiSelectElement", "UserSelectElement", + "RichTextElement", + "RichTextElementParts", + "RichTextListElement", + "RichTextPreformattedElement", + "RichTextQuoteElement", + "RichTextSectionElement", "ActionsBlock", "Block", "CallBlock", @@ -104,4 +117,5 @@ "InputBlock", "SectionBlock", "VideoBlock", + "RichTextBlock", ] diff --git a/slack_sdk/models/blocks/block_elements.py b/slack_sdk/models/blocks/block_elements.py index 8b9ac4ed2..bf2518f0c 100644 --- a/slack_sdk/models/blocks/block_elements.py +++ b/slack_sdk/models/blocks/block_elements.py @@ -1834,3 +1834,309 @@ def __init__( self.workflow = workflow self.style = style self.accessibility_label = accessibility_label + + +# ------------------------------------------------- +# Rich text elements +# ------------------------------------------------- + + +class RichTextElement(BlockElement): + pass + + +class RichTextListElement(RichTextElement): + type = "rich_text_list" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"elements", "style", "indent", "offset", "border"}) + + def __init__( + self, + *, + elements: Sequence[Union[dict, RichTextElement]], + style: Optional[str] = None, # bullet, ordered + indent: Optional[int] = None, + offset: Optional[int] = None, + border: Optional[int] = None, + **others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.elements = elements + self.style = style + self.indent = indent + self.offset = offset + self.border = border + + +class RichTextPreformattedElement(RichTextElement): + type = "rich_text_preformatted" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"elements", "border"}) + + def __init__( + self, + *, + elements: Sequence[Union[dict, RichTextElement]], + border: Optional[int] = None, + **others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.elements = elements + self.border = border + + +class RichTextQuoteElement(RichTextElement): + type = "rich_text_quote" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"elements"}) + + def __init__( + self, + *, + elements: Sequence[Union[dict, RichTextElement]], + **others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.elements = elements + + +class RichTextSectionElement(RichTextElement): + type = "rich_text_section" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"elements"}) + + def __init__( + self, + *, + elements: Sequence[Union[dict, RichTextElement]], + **others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.elements = elements + + +class RichTextElementParts: + class TextStyle: + def __init__( + self, + *, + bold: Optional[bool] = None, + italic: Optional[bool] = None, + strike: Optional[bool] = None, + code: Optional[bool] = None, + ): + self.bold = bold + self.italic = italic + self.strike = strike + self.code = code + + def to_dict(self, *args) -> dict: + result = { + "bold": self.bold, + "italic": self.italic, + "strike": self.strike, + "code": self.code, + } + return {k: v for k, v in result.items() if v is not None} + + class Text(RichTextElement): + type = "text" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"text", "style"}) + + def __init__( + self, + *, + text: str, + style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, + **others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.text = text + self.style = style + + class Channel(RichTextElement): + type = "channel" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"channel_id", "style"}) + + def __init__( + self, + *, + channel_id: str, + style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, + **others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.channel_id = channel_id + self.style = style + + class User(RichTextElement): + type = "user" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"user_id", "style"}) + + def __init__( + self, + *, + user_id: str, + style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, + **others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.user_id = user_id + self.style = style + + class Emoji(RichTextElement): + type = "emoji" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"name", "skin_tone", "unicode", "style"}) + + def __init__( + self, + *, + name: str, + skin_tone: Optional[int] = None, + unicode: Optional[str] = None, + style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, + **others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.name = name + self.skin_tone = skin_tone + self.unicode = unicode + self.style = style + + class Link(RichTextElement): + type = "link" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"url", "text", "style"}) + + def __init__( + self, + *, + url: str, + text: Optional[str] = None, + style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, + **others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.url = url + self.text = text + self.style = style + + class Team(RichTextElement): + type = "team" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"team_id", "style"}) + + def __init__( + self, + *, + team_id: str, + style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, + **others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.team_id = team_id + self.style = style + + class UserGroup(RichTextElement): + type = "usergroup" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"usergroup_id", "style"}) + + def __init__( + self, + *, + usergroup_id: str, + style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, + **others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.usergroup_id = usergroup_id + self.style = style + + class Date(RichTextElement): + type = "date" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"timestamp"}) + + def __init__( + self, + *, + timestamp: str, + **others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.timestamp = timestamp + + class Broadcast(RichTextElement): + type = "broadcast" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"range"}) + + def __init__( + self, + *, + range: str, # channel, here, .. + **others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.range = range + + class Color(RichTextElement): + type = "color" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"value"}) + + def __init__( + self, + *, + value: str, + **others: dict, + ): + super().__init__(type=self.type) + show_unknown_key_warning(self, others) + self.value = value diff --git a/slack_sdk/models/blocks/blocks.py b/slack_sdk/models/blocks/blocks.py index 590f8ae26..5bd0171da 100644 --- a/slack_sdk/models/blocks/blocks.py +++ b/slack_sdk/models/blocks/blocks.py @@ -11,7 +11,7 @@ from .basic_components import MarkdownTextObject from .basic_components import PlainTextObject from .basic_components import TextObject -from .block_elements import BlockElement +from .block_elements import BlockElement, RichTextElement from .block_elements import ImageElement from .block_elements import InputInteractiveElement from .block_elements import InteractiveElement @@ -604,3 +604,34 @@ def _validate_title_length(self): @JsonValidator(f"author_name attribute cannot exceed {author_name_max_length} characters") def _validate_author_name_length(self): return self.author_name is None or len(self.author_name) < self.author_name_max_length + + +class RichTextBlock(Block): + type = "rich_text" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"elements"}) + + def __init__( + self, + *, + elements: Sequence[Union[dict, RichTextElement]], + block_id: Optional[str] = None, + **others: dict, + ): + """A block that is used to hold interactive elements. + https://api.slack.com/reference/block-kit/blocks#rich_text + + Args: + elements (required): An array of rich text objects - + rich_text_section, rich_text_list, rich_text_quote, rich_text_preformatted + block_id: A unique identifier for a block. If not specified, one will be generated. + Maximum length for this field is 255 characters. + block_id should be unique for each message or view and each iteration of a message or view. + If a message or view is updated, use a new block_id. + """ + super().__init__(type=self.type, block_id=block_id) + show_unknown_key_warning(self, others) + + self.elements = BlockElement.parse_all(elements)

diff --git a/tests/slack_sdk/models/test_blocks.py b/tests/slack_sdk/models/test_blocks.py index 5461ba8d3..4ea1158ef 100644 --- a/tests/slack_sdk/models/test_blocks.py +++ b/tests/slack_sdk/models/test_blocks.py @@ -22,6 +22,12 @@ HeaderBlock, VideoBlock, Option, + RichTextBlock, + RichTextSectionElement, + RichTextListElement, + RichTextQuoteElement, + RichTextPreformattedElement, + RichTextElementParts, ) from . import STRING_3001_CHARS @@ -825,3 +831,219 @@ def test_title_length_200(self): } with self.assertRaises(SlackObjectFormationError): VideoBlock(**input).validate_json() + + +# ---------------------------------------------- +# RichTextBlock +# ---------------------------------------------- + + +class RichTextBlockTests(unittest.TestCase): + def test_document(self): + inputs = [ + { + "type": "rich_text", + "elements": [ + { + "type": "rich_text_section", + "elements": [{"type": "text", "text": "Hello there, I am a basic rich text block!"}], + } + ], + }, + { + "type": "rich_text", + "elements": [ + { + "type": "rich_text_section", + "elements": [ + {"type": "text", "text": "Hello there, "}, + {"type": "text", "text": "I am a bold rich text block!", "style": {"bold": True}}, + ], + } + ], + }, + { + "type": "rich_text", + "elements": [ + { + "type": "rich_text_section", + "elements": [ + {"type": "text", "text": "Hello there, "}, + {"type": "text", "text": "I am an italic rich text block!", "style": {"italic": True}}, + ], + } + ], + }, + { + "type": "rich_text", + "elements": [ + { + "type": "rich_text_section", + "elements": [ + {"type": "text", "text": "Hello there, "}, + {"type": "text", "text": "I am a strikethrough rich text block!", "style": {"strike": True}}, + ], + } + ], + }, + ] + for input in inputs: + self.assertDictEqual(input, RichTextBlock(**input).to_dict()) + + def test_complex(self): + self.maxDiff = None + dict_block = { + "type": "rich_text", + "block_id": "3Uk3Q", + "elements": [ + { + "type": "rich_text_section", + "elements": [ + {"type": "text", "text": "Hey!", "style": {"bold": True}}, + {"type": "text", "text": " this is "}, + {"type": "text", "text": "very", "style": {"strike": True}}, + {"type": "text", "text": " rich text "}, + {"type": "text", "text": "block", "style": {"code": True}}, + {"type": "text", "text": " "}, + {"type": "text", "text": "test", "style": {"italic": True}}, + {"type": "link", "url": "https://slack.com", "text": "Slack website!"}, + ], + }, + { + "type": "rich_text_list", + "elements": [ + {"type": "rich_text_section", "elements": [{"type": "text", "text": "a"}]}, + {"type": "rich_text_section", "elements": [{"type": "text", "text": "b"}]}, + ], + "style": "ordered", + "indent": 0, + "border": 0, + }, + { + "type": "rich_text_list", + "elements": [{"type": "rich_text_section", "elements": [{"type": "text", "text": "bb"}]}], + "style": "ordered", + "indent": 1, + "border": 0, + }, + { + "type": "rich_text_list", + "elements": [{"type": "rich_text_section", "elements": [{"type": "text", "text": "BBB"}]}], + "style": "ordered", + "indent": 2, + "border": 0, + }, + { + "type": "rich_text_list", + "elements": [{"type": "rich_text_section", "elements": [{"type": "text", "text": "c"}]}], + "style": "ordered", + "indent": 0, + "offset": 2, + "border": 0, + }, + {"type": "rich_text_section", "elements": [{"type": "text", "text": "\n"}]}, + { + "type": "rich_text_list", + "elements": [ + {"type": "rich_text_section", "elements": [{"type": "text", "text": "todo"}]}, + {"type": "rich_text_section", "elements": [{"type": "text", "text": "todo"}]}, + {"type": "rich_text_section", "elements": [{"type": "text", "text": "todo"}]}, + ], + "style": "bullet", + "indent": 0, + "border": 0, + }, + {"type": "rich_text_section", "elements": [{"type": "text", "text": "\n"}]}, + {"type": "rich_text_quote", "elements": [{"type": "text", "text": "this is very important"}]}, + { + "type": "rich_text_preformatted", + "elements": [{"type": "text", "text": 'print("Hello world")'}], + "border": 0, + }, + { + "type": "rich_text_section", + "elements": [ + {"type": "user", "user_id": "WJC6QG0MS"}, + {"type": "text", "text": " "}, + {"type": "usergroup", "usergroup_id": "S01BL602YLU"}, + {"type": "text", "text": " "}, + {"type": "channel", "channel_id": "C02GD0YEHDJ"}, + ], + }, + ], + } + self.assertDictEqual(dict_block, RichTextBlock(**dict_block).to_dict()) + + _ = RichTextElementParts + class_block = RichTextBlock( + block_id="3Uk3Q", + elements=[ + RichTextSectionElement( + elements=[ + _.Text(text="Hey!", style=_.TextStyle(bold=True)), + _.Text(text=" this is "), + _.Text(text="very", style=_.TextStyle(strike=True)), + _.Text(text=" rich text "), + _.Text(text="block", style=_.TextStyle(code=True)), + _.Text(text=" "), + _.Text(text="test", style=_.TextStyle(italic=True)), + _.Link(text="Slack website!", url="https://slack.com"), + ] + ), + RichTextListElement( + elements=[ + RichTextSectionElement(elements=[_.Text(text="a")]), + RichTextSectionElement(elements=[_.Text(text="b")]), + ], + style="ordered", + indent=0, + border=0, + ), + RichTextListElement( + elements=[RichTextSectionElement(elements=[_.Text(text="bb")])], + style="ordered", + indent=1, + border=0, + ), + RichTextListElement( + elements=[RichTextSectionElement(elements=[_.Text(text="BBB")])], + style="ordered", + indent=2, + border=0, + ), + RichTextListElement( + elements=[RichTextSectionElement(elements=[_.Text(text="c")])], + style="ordered", + indent=0, + offset=2, + border=0, + ), + RichTextSectionElement(elements=[_.Text(text="\n")]), + RichTextListElement( + elements=[ + RichTextSectionElement(elements=[_.Text(text="todo")]), + RichTextSectionElement(elements=[_.Text(text="todo")]), + RichTextSectionElement(elements=[_.Text(text="todo")]), + ], + style="bullet", + indent=0, + border=0, + ), + RichTextSectionElement(elements=[_.Text(text="\n")]), + RichTextQuoteElement(elements=[_.Text(text="this is very important")]), + RichTextPreformattedElement( + elements=[_.Text(text='print("Hello world")')], + border=0, + ), + RichTextSectionElement( + elements=[ + _.User(user_id="WJC6QG0MS"), + _.Text(text=" "), + _.UserGroup(usergroup_id="S01BL602YLU"), + _.Text(text=" "), + _.Channel(channel_id="C02GD0YEHDJ"), + ] + ), + ], + ) + self.assertDictEqual(dict_block, class_block.to_dict())

[ { "components": [ { "doc": "", "lines": [ 1844, 1845 ], "name": "RichTextElement", "signature": "class RichTextElement(BlockElement):", "type": "class" }, { "doc": "", "lines": [ 1848, 1871 ...

[ "tests/slack_sdk/models/test_blocks.py::BlockTests::test_eq", "tests/slack_sdk/models/test_blocks.py::BlockTests::test_parse", "tests/slack_sdk/models/test_blocks.py::SectionBlockTests::test_document_1", "tests/slack_sdk/models/test_blocks.py::SectionBlockTests::test_document_2", "tests/slack_sdk/models/tes...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Fix #1428 Add rich_text classes to slack_sdk.models module ## Summary This pull request resolves #1428 ### Category (place an `x` in each of the `[ ]`) - [ ] **slack_sdk.web.WebClient (sync/async)** (Web API client) - [ ] **slack_sdk.webhook.WebhookClient (sync/async)** (Incoming Webhook, response_url sender) - [ ] **slack_sdk.socket_mode** (Socket Mode client) - [ ] **slack_sdk.signature** (Request Signature Verifier) - [ ] **slack_sdk.oauth** (OAuth Flow Utilities) - [x] **slack_sdk.models** (UI component builders) - [ ] **slack_sdk.scim** (SCIM API client) - [ ] **slack_sdk.audit_logs** (Audit Logs API client) - [ ] **slack_sdk.rtm_v2** (RTM client) - [ ] `/docs-src` (Documents, have you run `./scripts/docs.sh`?) - [ ] `/docs-src-v2` (Documents, have you run `./scripts/docs-v2.sh`?) - [ ] `/tutorial` (PythOnBoardingBot tutorial) - [ ] `tests`/`integration_tests` (Automated tests for this library) ## Requirements (place an `x` in each `[ ]`) - [x] I've read and understood the [Contributing Guidelines](https://github.com/slackapi/python-slack-sdk/blob/main/.github/contributing.md) and have done my best effort to follow them. - [x] I've read and agree to the [Code of Conduct](https://slackhq.github.io/code-of-conduct). - [x] I've run `python3 -m venv .venv && source .venv/bin/activate && ./scripts/run_validation.sh` after making the changes. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in slack_sdk/models/blocks/block_elements.py] (definition of RichTextElement:) class RichTextElement(BlockElement): (definition of RichTextListElement:) class RichTextListElement(RichTextElement): (definition of RichTextListElement.attributes:) def attributes(self) -> Set[str]: (definition of RichTextListElement.__init__:) def __init__( self, *, elements: Sequence[Union[dict, RichTextElement]], style: Optional[str] = None, (definition of RichTextPreformattedElement:) class RichTextPreformattedElement(RichTextElement): (definition of RichTextPreformattedElement.attributes:) def attributes(self) -> Set[str]: (definition of RichTextPreformattedElement.__init__:) def __init__( self, *, elements: Sequence[Union[dict, RichTextElement]], border: Optional[int] = None, **others: dict, ): (definition of RichTextQuoteElement:) class RichTextQuoteElement(RichTextElement): (definition of RichTextQuoteElement.attributes:) def attributes(self) -> Set[str]: (definition of RichTextQuoteElement.__init__:) def __init__( self, *, elements: Sequence[Union[dict, RichTextElement]], **others: dict, ): (definition of RichTextSectionElement:) class RichTextSectionElement(RichTextElement): (definition of RichTextSectionElement.attributes:) def attributes(self) -> Set[str]: (definition of RichTextSectionElement.__init__:) def __init__( self, *, elements: Sequence[Union[dict, RichTextElement]], **others: dict, ): (definition of RichTextElementParts:) class RichTextElementParts: (definition of RichTextElementParts.TextStyle:) class TextStyle: (definition of RichTextElementParts.TextStyle.__init__:) def __init__( self, *, bold: Optional[bool] = None, italic: Optional[bool] = None, strike: Optional[bool] = None, code: Optional[bool] = None, ): (definition of RichTextElementParts.TextStyle.to_dict:) def to_dict(self, *args) -> dict: (definition of RichTextElementParts.Text:) class Text(RichTextElement): (definition of RichTextElementParts.Text.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.Text.__init__:) def __init__( self, *, text: str, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, **others: dict, ): (definition of RichTextElementParts.Channel:) class Channel(RichTextElement): (definition of RichTextElementParts.Channel.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.Channel.__init__:) def __init__( self, *, channel_id: str, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, **others: dict, ): (definition of RichTextElementParts.User:) class User(RichTextElement): (definition of RichTextElementParts.User.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.User.__init__:) def __init__( self, *, user_id: str, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, **others: dict, ): (definition of RichTextElementParts.Emoji:) class Emoji(RichTextElement): (definition of RichTextElementParts.Emoji.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.Emoji.__init__:) def __init__( self, *, name: str, skin_tone: Optional[int] = None, unicode: Optional[str] = None, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, **others: dict, ): (definition of RichTextElementParts.Link:) class Link(RichTextElement): (definition of RichTextElementParts.Link.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.Link.__init__:) def __init__( self, *, url: str, text: Optional[str] = None, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, **others: dict, ): (definition of RichTextElementParts.Team:) class Team(RichTextElement): (definition of RichTextElementParts.Team.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.Team.__init__:) def __init__( self, *, team_id: str, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, **others: dict, ): (definition of RichTextElementParts.UserGroup:) class UserGroup(RichTextElement): (definition of RichTextElementParts.UserGroup.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.UserGroup.__init__:) def __init__( self, *, usergroup_id: str, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, **others: dict, ): (definition of RichTextElementParts.Date:) class Date(RichTextElement): (definition of RichTextElementParts.Date.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.Date.__init__:) def __init__( self, *, timestamp: str, **others: dict, ): (definition of RichTextElementParts.Broadcast:) class Broadcast(RichTextElement): (definition of RichTextElementParts.Broadcast.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.Broadcast.__init__:) def __init__( self, *, range: str, (definition of RichTextElementParts.Color:) class Color(RichTextElement): (definition of RichTextElementParts.Color.attributes:) def attributes(self) -> Set[str]: (definition of RichTextElementParts.Color.__init__:) def __init__( self, *, value: str, **others: dict, ): [end of new definitions in slack_sdk/models/blocks/block_elements.py] [start of new definitions in slack_sdk/models/blocks/blocks.py] (definition of RichTextBlock:) class RichTextBlock(Block): (definition of RichTextBlock.attributes:) def attributes(self) -> Set[str]: (definition of RichTextBlock.__init__:) def __init__( self, *, elements: Sequence[Union[dict, RichTextElement]], block_id: Optional[str] = None, **others: dict, ): """A block that is used to hold interactive elements. https://api.slack.com/reference/block-kit/blocks#rich_text Args: elements (required): An array of rich text objects - rich_text_section, rich_text_list, rich_text_quote, rich_text_preformatted block_id: A unique identifier for a block. If not specified, one will be generated. Maximum length for this field is 255 characters. block_id should be unique for each message or view and each iteration of a message or view. If a message or view is updated, use a new block_id.""" [end of new definitions in slack_sdk/models/blocks/blocks.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Add rich_text classes to slack_sdk.models module I'm currently refactoring code using `slack_sdk` models, and most of my modals use `RichText` objects. I've noticed while available in Block Kit Builder and documented thoroughly, there is not a model for it. I created my own (I'd share, but the way it's constructed is significantly different than how I see it done in this project), but when I try to pass this through the `View()` constructor, it skips those blocks because it doesn't recognize the type, despite how well established and integrated into documentation that component appears to be. I'm wondering if there is a plan to add a model for this in place, and if so, where that is on the priority scale? Also hoping to get clarity on what appears should be `LinkTextObject` for use inside a section or list of a `RichTextElement`. Passing `subtype="link"` to TextObject "works", but the url property gets discarded. ### Category (place an `x` in each of the `[ ]`) - [ ] **slack_sdk.web.WebClient (sync/async)** (Web API client) - [ ] **slack_sdk.webhook.WebhookClient (sync/async)** (Incoming Webhook, response_url sender) - [x] **slack_sdk.models** (UI component builders) - [ ] **slack_sdk.oauth** (OAuth Flow Utilities) - [ ] **slack_sdk.socket_mode** (Socket Mode client) - [ ] **slack_sdk.audit_logs** (Audit Logs API client) - [ ] **slack_sdk.scim** (SCIM API client) - [ ] **slack_sdk.rtm** (RTM client) - [ ] **slack_sdk.signature** (Request Signature Verifier) ### Requirements Please read the [Contributing guidelines](https://github.com/slackapi/python-slack-sdk/blob/main/.github/contributing.md) and [Code of Conduct](https://slackhq.github.io/code-of-conduct) before creating this issue or pull request. By submitting, you are agreeing to those rules. ---------- Hi @tj-smith47, thanks for writing in! >'m wondering if there is a plan to add a model for this in place, and if so, where that is on the priority scale? Since Slack's platform unlocked those rich_text blocks to 3rd party apps recently, this project has not yet supported it. However, we definitely plan to add it! (Actually it's already done for Node and Java SDKs). I cannot tell the exact date to publish a new version yet, but it won't take weeks for sure. If everything goes well, a new version including it would be available by the end of this week. >Also hoping to get clarity on what appears should be LinkTextObject for use inside a section or list of a RichTextElement. Passing subtype="link" to TextObject "works", but the url property gets discarded. I won't reuse the TextObject class for the link item in rich text list objects. The TextObject represents a typical property of a block, which possesses either a "plain_text" or "mrkdwn" type (and usually it is supposed to be used for label etc.). This object cannot be an item of "rich_text_section" block element. They are completely different ones. So, when we add rich_text block elements to the model module, we will introduce a new class for the link item. @seratch This is great news! Thank you for your work on this, can't wait to see it! -------------------- </issues>

2997a1786c4fd969b00ce69af888ebae8e8ebed0

conan-io__conan-15136

15,136

conan-io/conan

null

412a0279dbe7da2f3d4dcb1f8940bc51c3baac3a

2023-11-19T20:53:34Z

diff --git a/conan/cli/printers/graph.py b/conan/cli/printers/graph.py index a7a67a09588..6513636f8d4 100644 --- a/conan/cli/printers/graph.py +++ b/conan/cli/printers/graph.py @@ -56,6 +56,11 @@ def _format_resolved(title, reqs_to_print): for k, v in sorted(reqs_to_print.items()): output.info(" {}: {}".format(k, v), Color.BRIGHT_CYAN) + if graph.replaced_requires: + output.info("Replaced requires", Color.BRIGHT_YELLOW) + for k, v in graph.replaced_requires.items(): + output.info(" {}: {}".format(k, v), Color.BRIGHT_CYAN) + _format_resolved("Resolved alias", graph.aliased) if graph.aliased: output.warning("'alias' is a Conan 1.X legacy feature, no longer recommended and " diff --git a/conans/client/graph/graph.py b/conans/client/graph/graph.py index cce23757564..2481c2fadb3 100644 --- a/conans/client/graph/graph.py +++ b/conans/client/graph/graph.py @@ -319,6 +319,7 @@ def __init__(self): self.nodes = [] self.aliased = {} self.resolved_ranges = {} + self.replaced_requires = {} self.error = False def overrides(self): @@ -391,4 +392,5 @@ def serialize(self): result["root"] = {self.root.id: repr(self.root.ref)} # TODO: ref of consumer/virtual result["overrides"] = self.overrides().serialize() result["resolved_ranges"] = {repr(r): s.repr_notime() for r, s in self.resolved_ranges.items()} + result["replaced_requires"] = {k: v for k, v in self.replaced_requires.items()} return result diff --git a/conans/client/graph/graph_builder.py b/conans/client/graph/graph_builder.py index 7d1f6bfdbcf..27d8449d82c 100644 --- a/conans/client/graph/graph_builder.py +++ b/conans/client/graph/graph_builder.py @@ -38,7 +38,7 @@ def load_graph(self, root_node, profile_host, profile_build, graph_lock=None): dep_graph = DepsGraph() self._prepare_node(root_node, profile_host, profile_build, Options()) - self._initialize_requires(root_node, dep_graph, graph_lock) + self._initialize_requires(root_node, dep_graph, graph_lock, profile_build, profile_host) dep_graph.add_node(root_node) open_requires = deque((r, root_node) for r in root_node.conanfile.requires.values()) @@ -51,7 +51,8 @@ def load_graph(self, root_node, profile_host, profile_build, graph_lock=None): new_node = self._expand_require(require, node, dep_graph, profile_host, profile_build, graph_lock) if new_node: - self._initialize_requires(new_node, dep_graph, graph_lock) + self._initialize_requires(new_node, dep_graph, graph_lock, profile_build, + profile_host) open_requires.extendleft((r, new_node) for r in reversed(new_node.conanfile.requires.values())) self._remove_overrides(dep_graph) @@ -160,7 +161,7 @@ def _prepare_node(node, profile_host, profile_build, down_options): node.conanfile.requires.tool_require(tool_require.repr_notime(), raise_if_duplicated=False) - def _initialize_requires(self, node, graph, graph_lock): + def _initialize_requires(self, node, graph, graph_lock, profile_build, profile_host): for require in node.conanfile.requires.values(): alias = require.alias # alias needs to be processed this early if alias is not None: @@ -170,6 +171,7 @@ def _initialize_requires(self, node, graph, graph_lock): # if partial, we might still need to resolve the alias if not resolved: self._resolve_alias(node, require, alias, graph) + self._resolve_replace_requires(node, require, profile_build, profile_host, graph) node.transitive_deps[require] = TransitiveRequirement(require, node=None) def _resolve_alias(self, node, require, alias, graph): @@ -233,6 +235,40 @@ def _resolved_system(node, require, profile_build, profile_host, resolve_prerele require.ref.revision = d.revision return d, ConanFile(str(d)), RECIPE_PLATFORM, None + def _resolve_replace_requires(self, node, require, profile_build, profile_host, graph): + profile = profile_build if node.context == CONTEXT_BUILD else profile_host + replacements = profile.replace_tool_requires if require.build else profile.replace_requires + if not replacements: + return + + for pattern, alternative_ref in replacements.items(): + if pattern.name != require.ref.name: + continue # no match in name + if pattern.version != "*": # we need to check versions + rrange = require.version_range + valid = rrange.contains(pattern.version, self._resolve_prereleases) if rrange else \ + require.ref.version == pattern.version + if not valid: + continue + if pattern.user != "*" and pattern.user != require.ref.user: + continue + if pattern.channel != "*" and pattern.channel != require.ref.channel: + continue + original_require = repr(require.ref) + if alternative_ref.version != "*": + require.ref.version = alternative_ref.version + if alternative_ref.user != "*": + require.ref.user = alternative_ref.user + if alternative_ref.channel != "*": + require.ref.channel = alternative_ref.channel + if alternative_ref.revision != "*": + require.ref.revision = alternative_ref.revision + if require.ref.name != alternative_ref.name: # This requires re-doing dict! + node.conanfile.requires.reindex(require, alternative_ref.name) + require.ref.name = alternative_ref.name + graph.replaced_requires[original_require] = repr(require.ref) + break # First match executes the alternative and finishes checking others + def _create_new_node(self, node, require, graph, profile_host, profile_build, graph_lock): if require.ref.version == "<host_version>": if not require.build or require.visible: diff --git a/conans/client/profile_loader.py b/conans/client/profile_loader.py index 097c18c1566..54b6d3d0140 100644 --- a/conans/client/profile_loader.py +++ b/conans/client/profile_loader.py @@ -223,7 +223,8 @@ def get_profile(profile_text, base_profile=None): "system_tools", # DEPRECATED: platform_tool_requires "platform_requires", "platform_tool_requires", "settings", - "options", "conf", "buildenv", "runenv"]) + "options", "conf", "buildenv", "runenv", + "replace_requires", "replace_tool_requires"]) # Parse doc sections into Conan model, Settings, Options, etc settings, package_settings = _ProfileValueParser._parse_settings(doc) @@ -238,6 +239,26 @@ def get_profile(profile_text, base_profile=None): platform_tool_requires = [RecipeReference.loads(r) for r in doc_platform_tool_requires.splitlines()] platform_requires = [RecipeReference.loads(r) for r in doc_platform_requires.splitlines()] + def load_replace(doc_replace_requires): + result = {} + for r in doc_replace_requires.splitlines(): + r = r.strip() + if not r or r.startswith("#"): + continue + try: + src, target = r.split(":") + target = RecipeReference.loads(target.strip()) + src = RecipeReference.loads(src.strip()) + except Exception as e: + raise ConanException(f"Error in [replace_xxx] '{r}'.\nIt should be in the form" + f" 'pattern: replacement', without package-ids.\n" + f"Original error: {str(e)}") + result[src] = target + return result + + replace_requires = load_replace(doc.replace_requires) if doc.replace_requires else {} + replace_tool = load_replace(doc.replace_tool_requires) if doc.replace_tool_requires else {} + if doc.conf: conf = ConfDefinition() conf.loads(doc.conf, profile=True) @@ -248,6 +269,9 @@ def get_profile(profile_text, base_profile=None): # Create or update the profile base_profile = base_profile or Profile() + base_profile.replace_requires.update(replace_requires) + base_profile.replace_tool_requires.update(replace_tool) + current_platform_tool_requires = {r.name: r for r in base_profile.platform_tool_requires} current_platform_tool_requires.update({r.name: r for r in platform_tool_requires}) base_profile.platform_tool_requires = list(current_platform_tool_requires.values()) diff --git a/conans/model/profile.py b/conans/model/profile.py index df78bb9ba64..7654ed9acf3 100644 --- a/conans/model/profile.py +++ b/conans/model/profile.py @@ -17,6 +17,8 @@ def __init__(self): self.package_settings = defaultdict(OrderedDict) self.options = Options() self.tool_requires = OrderedDict() # ref pattern: list of ref + self.replace_requires = {} + self.replace_tool_requires = {} self.platform_tool_requires = [] self.platform_requires = [] self.conf = ConfDefinition() @@ -120,6 +122,9 @@ def compose_profile(self, other): existing[r.name] = req self.tool_requires[pattern] = list(existing.values()) + self.replace_requires.update(other.replace_requires) + self.replace_tool_requires.update(other.replace_tool_requires) + current_platform_tool_requires = {r.name: r for r in self.platform_tool_requires} current_platform_tool_requires.update({r.name: r for r in other.platform_tool_requires}) self.platform_tool_requires = list(current_platform_tool_requires.values()) diff --git a/conans/model/requires.py b/conans/model/requires.py index 7604e411cbf..fd7c0f62c7a 100644 --- a/conans/model/requires.py +++ b/conans/model/requires.py @@ -467,6 +467,18 @@ def __init__(self, declared=None, declared_build=None, declared_test=None, raise ConanException("Wrong 'tool_requires' definition, " "did you mean 'build_requirements()'?") + def reindex(self, require, new_name): + """ This operation is necessary when the reference name of a package is changed + as a result of an "alternative" replacement of the package name, otherwise the dictionary + gets broken by modified key + """ + result = OrderedDict() + for k, v in self._requires.items(): + if k is require: + k.ref.name = new_name + result[k] = v + self._requires = result + def values(self): return self._requires.values()

diff --git a/conans/test/integration/graph/test_replace_requires.py b/conans/test/integration/graph/test_replace_requires.py new file mode 100644 index 00000000000..9fb129fda07 --- /dev/null +++ b/conans/test/integration/graph/test_replace_requires.py @@ -0,0 +1,144 @@ +import json + +import pytest + +from conans.model.recipe_ref import RecipeReference +from conans.test.assets.genconanfile import GenConanfile +from conans.test.utils.tools import TestClient + + +@pytest.mark.parametrize("require, pattern, alternative, pkg", [ + # PATTERN VERSIONS + # override all dependencies to "dep" to a specific version,user and channel) + # TODO: This is a version override, is this really wanted? + ("dep/1.3", "dep/*", "dep/1.1", "dep/1.1"), + ("dep/[>=1.0 <2]", "dep/*", "dep/1.1", "dep/1.1"), + # override all dependencies to "dep" to the same version with other user, remove channel) + ("dep/1.3", "dep/*", "dep/*@system", "dep/1.3@system"), + ("dep/[>=1.0 <2]", "dep/*", "dep/*@system", "dep/1.1@system"), + # override all dependencies to "dep" to the same version with other user, same channel) + ("dep/1.3@comp/stable", "dep/*@*/*", "dep/*@system/*", "dep/1.3@system/stable"), + ("dep/[>=1.0 <2]@comp/stable", "dep/*@*/*", "dep/*@system/*", "dep/1.1@system/stable"), + # EXACT VERSIONS + # replace exact dependency version for one in the system + ("dep/1.1", "dep/1.1", "dep/1.1@system", "dep/1.1@system"), + ("dep/[>=1.0 <2]", "dep/1.1", "dep/1.1@system", "dep/1.1@system"), + ("dep/[>=1.0 <2]@comp", "dep/1.1@*", "dep/1.1@*/stable", "dep/1.1@comp/stable"), + ("dep/1.1@comp", "dep/1.1@*", "dep/1.1@*/stable", "dep/1.1@comp/stable"), + # PACKAGE ALTERNATIVES (zlib->zlibng) + ("dep/1.0", "dep/*", "depng/*", "depng/1.0"), + ("dep/[>=1.0 <2]", "dep/*", "depng/*", "depng/1.1"), + ("dep/[>=1.0 <2]", "dep/1.1", "depng/1.2", "depng/1.2"), + # NON MATCHING + ("dep/1.3", "dep/1.1", "dep/1.1@system", "dep/1.3"), + ("dep/1.3", "dep/*@comp", "dep/*@system", "dep/1.3"), + ("dep/[>=1.0 <2]", "dep/2.1", "dep/2.1@system", "dep/1.1"), +]) +@pytest.mark.parametrize("tool_require", [False, True]) +class TestReplaceRequires: + def test_alternative(self, tool_require, require, pattern, alternative, pkg): + c = TestClient() + conanfile = GenConanfile().with_tool_requires(require) if tool_require else \ + GenConanfile().with_requires(require) + profile_tag = "replace_requires" if not tool_require else "replace_tool_requires" + c.save({"dep/conanfile.py": GenConanfile(), + "pkg/conanfile.py": conanfile, + "profile": f"[{profile_tag}]\n{pattern}: {alternative}"}) + ref = RecipeReference.loads(pkg) + user = f"--user={ref.user}" if ref.user else "" + channel = f"--channel={ref.channel}" if ref.channel else "" + c.run(f"create dep --name={ref.name} --version={ref.version} {user} {channel}") + rrev = c.exported_recipe_revision() + c.run("install pkg -pr=profile") + c.assert_listed_require({f"{pkg}#{rrev}": "Cache"}, build=tool_require) + + # Check lockfile + c.run("lock create pkg -pr=profile") + lock = c.load("pkg/conan.lock") + assert f"{pkg}#{rrev}" in lock + + # c.run("create dep2 --version=1.2") + # with lockfile + c.run("install pkg -pr=profile") + c.assert_listed_require({f"{pkg}#{rrev}": "Cache"}, build=tool_require) + + def test_diamond(self, tool_require, require, pattern, alternative, pkg): + c = TestClient() + conanfile = GenConanfile().with_tool_requires(require) if tool_require else \ + GenConanfile().with_requires(require) + profile_tag = "replace_requires" if not tool_require else "replace_tool_requires" + + c.save({"dep/conanfile.py": GenConanfile(), + "libb/conanfile.py": conanfile, + "libc/conanfile.py": conanfile, + "app/conanfile.py": GenConanfile().with_requires("libb/0.1", "libc/0.1"), + "profile": f"[{profile_tag}]\n{pattern}: {alternative}"}) + ref = RecipeReference.loads(pkg) + user = f"--user={ref.user}" if ref.user else "" + channel = f"--channel={ref.channel}" if ref.channel else "" + c.run(f"create dep --name={ref.name} --version={ref.version} {user} {channel}") + rrev = c.exported_recipe_revision() + + c.run("export libb --name=libb --version=0.1") + c.run("export libc --name=libc --version=0.1") + + c.run("install app -pr=profile", assert_error=True) + assert "ERROR: Missing binary: libb/0.1" in c.out + assert "ERROR: Missing binary: libc/0.1" in c.out + + c.run("install app -pr=profile --build=missing") + c.assert_listed_require({f"{pkg}#{rrev}": "Cache"}, build=tool_require) + + # Check lockfile + c.run("lock create app -pr=profile") + lock = c.load("app/conan.lock") + assert f"{pkg}#{rrev}" in lock + + # with lockfile + c.run("install app -pr=profile") + c.assert_listed_require({f"{pkg}#{rrev}": "Cache"}, build=tool_require) + + +@pytest.mark.parametrize("pattern, replace", [ + ("pkg", "pkg/0.1"), + ("pkg/*", "pkg"), + ("pkg/*:pid1", "pkg/0.1"), + ("pkg/*:pid1", "pkg/0.1:pid2"), + ("pkg/*", "pkg/0.1:pid2"), + (":", ""), + ("pkg/version:pid", ""), + ("pkg/version:pid", ":") +]) +def test_replace_requires_errors(pattern, replace): + c = TestClient() + c.save({"pkg/conanfile.py": GenConanfile("pkg", "0.1"), + "app/conanfile.py": GenConanfile().with_requires("pkg/0.2"), + "profile": f"[replace_requires]\n{pattern}: {replace}"}) + c.run("create pkg") + c.run("install app -pr=profile", assert_error=True) + assert "ERROR: Error reading 'profile' profile: Error in [replace_xxx]" in c.out + + +def test_replace_requires_invalid_requires_errors(): + """ + replacing for something incorrect not existing is not an error per-se, it is valid that + a recipe requires("pkg/2.*"), and then it will fail because such package doesn't exist + """ + c = TestClient() + c.save({"app/conanfile.py": GenConanfile().with_requires("pkg/0.2"), + "profile": f"[replace_requires]\npkg/0.2: pkg/2.*"}) + c.run("install app -pr=profile", assert_error=True) + assert "pkg/0.2: pkg/2.*" in c.out # The replacement happens + assert "ERROR: Package 'pkg/2.*' not resolved" in c.out + + +def test_replace_requires_json_format(): + c = TestClient() + c.save({"pkg/conanfile.py": GenConanfile("pkg", "0.2"), + "app/conanfile.py": GenConanfile().with_requires("pkg/0.1"), + "profile": f"[replace_requires]\npkg/0.1: pkg/0.2"}) + c.run("create pkg") + c.run("install app -pr=profile --format=json") + assert "pkg/0.1: pkg/0.2" in c.out # The replacement happens + graph = json.loads(c.stdout) + assert graph["graph"]["replaced_requires"] == {"pkg/0.1": "pkg/0.2"}

[ { "components": [ { "doc": "", "lines": [ 238, 270 ], "name": "DepsGraphBuilder._resolve_replace_requires", "signature": "def _resolve_replace_requires(self, node, require, profile_build, profile_host, graph):", "type": "function" }...

[ "conans/test/integration/graph/test_replace_requires.py::TestReplaceRequires::test_alternative[False-dep/1.3-dep/*-dep/1.1-dep/1.1]", "conans/test/integration/graph/test_replace_requires.py::TestReplaceRequires::test_alternative[False-dep/[>=1.0", "conans/test/integration/graph/test_replace_requires.py::TestRep...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> require-replaces proposal Changelog: Feature: New ``[replace_requires]`` and ``[replace_tool_requires]`` in profile for redefining requires, useful for package replacements like ``zlibng/zlib``, to solve conflicts, and to replace some dependencies by system alternatives wrapped in another Conan package recipe. Docs: https://github.com/conan-io/docs/pull/3495 Complement https://github.com/conan-io/conan/pull/14871 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conans/client/graph/graph_builder.py] (definition of DepsGraphBuilder._resolve_replace_requires:) def _resolve_replace_requires(self, node, require, profile_build, profile_host, graph): [end of new definitions in conans/client/graph/graph_builder.py] [start of new definitions in conans/client/profile_loader.py] (definition of _ProfileValueParser.get_profile.load_replace:) def load_replace(doc_replace_requires): [end of new definitions in conans/client/profile_loader.py] [start of new definitions in conans/model/requires.py] (definition of Requirements.reindex:) def reindex(self, require, new_name): """This operation is necessary when the reference name of a package is changed as a result of an "alternative" replacement of the package name, otherwise the dictionary gets broken by modified key""" [end of new definitions in conans/model/requires.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

4a5b19a75db9225316c8cb022a2dfb9705a2af34

roboflow__supervision-605

605

roboflow/supervision

null

bb7695a7744932553ef5e9665e8ca0064b458450

2023-11-16T12:59:04Z

diff --git a/supervision/__init__.py b/supervision/__init__.py index 44f25f7f1..93f4626fa 100644 --- a/supervision/__init__.py +++ b/supervision/__init__.py @@ -35,6 +35,7 @@ from supervision.detection.tools.polygon_zone import PolygonZone, PolygonZoneAnnotator from supervision.detection.utils import ( box_iou_batch, + calculate_masks_centroids, filter_polygons_by_area, mask_to_polygons, mask_to_xyxy, diff --git a/supervision/annotators/core.py b/supervision/annotators/core.py index 0e34cc16c..82d299da7 100644 --- a/supervision/annotators/core.py +++ b/supervision/annotators/core.py @@ -760,7 +760,7 @@ def annotate( ![dot-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/dot-annotator-example-purple.png) """ - xy = detections.get_anchor_coordinates(anchor=self.position) + xy = detections.get_anchors_coordinates(anchor=self.position) for detection_idx in range(len(detections)): color = resolve_color( color=self.color, @@ -808,49 +808,46 @@ def __init__( self.text_scale: float = text_scale self.text_thickness: int = text_thickness self.text_padding: int = text_padding - self.text_position: Position = text_position + self.text_anchor: Position = text_position self.color_lookup: ColorLookup = color_lookup @staticmethod def resolve_text_background_xyxy( - detection_xyxy: Tuple[int, int, int, int], + center_coordinates: Tuple[int, int], text_wh: Tuple[int, int], - text_padding: int, position: Position, ) -> Tuple[int, int, int, int]: - padded_text_wh = (text_wh[0] + 2 * text_padding, text_wh[1] + 2 * text_padding) - x1, y1, x2, y2 = detection_xyxy - center_x = (x1 + x2) // 2 - center_y = (y1 + y2) // 2 + center_x, center_y = center_coordinates + text_w, text_h = text_wh if position == Position.TOP_LEFT: - return x1, y1 - padded_text_wh[1], x1 + padded_text_wh[0], y1 + return center_x, center_y - text_h, center_x + text_w, center_y elif position == Position.TOP_RIGHT: - return x2 - padded_text_wh[0], y1 - padded_text_wh[1], x2, y1 + return center_x - text_w, center_y - text_h, center_x, center_y elif position == Position.TOP_CENTER: return ( - center_x - padded_text_wh[0] // 2, - y1 - padded_text_wh[1], - center_x + padded_text_wh[0] // 2, - y1, + center_x - text_w // 2, + center_y - text_h, + center_x + text_w // 2, + center_y, ) - elif position == Position.CENTER: + elif position == Position.CENTER or position == Position.CENTER_OF_MASS: return ( - center_x - padded_text_wh[0] // 2, - center_y - padded_text_wh[1] // 2, - center_x + padded_text_wh[0] // 2, - center_y + padded_text_wh[1] // 2, + center_x - text_w // 2, + center_y - text_h // 2, + center_x + text_w // 2, + center_y + text_h // 2, ) elif position == Position.BOTTOM_LEFT: - return x1, y2, x1 + padded_text_wh[0], y2 + padded_text_wh[1] + return center_x, center_y, center_x + text_w, center_y + text_h elif position == Position.BOTTOM_RIGHT: - return x2 - padded_text_wh[0], y2, x2, y2 + padded_text_wh[1] + return center_x - text_w, center_y, center_x, center_y + text_h elif position == Position.BOTTOM_CENTER: return ( - center_x - padded_text_wh[0] // 2, - y2, - center_x + padded_text_wh[0] // 2, - y2 + padded_text_wh[1], + center_x - text_w // 2, + center_y, + center_x + text_w // 2, + center_y + text_h, ) def annotate( @@ -891,8 +888,10 @@ def annotate( supervision-annotator-examples/label-annotator-example-purple.png) """ font = cv2.FONT_HERSHEY_SIMPLEX - for detection_idx in range(len(detections)): - detection_xyxy = detections.xyxy[detection_idx].astype(int) + anchors_coordinates = detections.get_anchors_coordinates( + anchor=self.text_anchor + ).astype(int) + for detection_idx, center_coordinates in enumerate(anchors_coordinates): color = resolve_color( color=self.color, detections=detections, @@ -906,22 +905,22 @@ def annotate( if (labels is None or len(detections) != len(labels)) else labels[detection_idx] ) - text_wh = cv2.getTextSize( + text_w, text_h = cv2.getTextSize( text=text, fontFace=font, fontScale=self.text_scale, thickness=self.text_thickness, )[0] - + text_w_padded = text_w + 2 * self.text_padding + text_h_padded = text_h + 2 * self.text_padding text_background_xyxy = self.resolve_text_background_xyxy( - detection_xyxy=detection_xyxy, - text_wh=text_wh, - text_padding=self.text_padding, - position=self.text_position, + center_coordinates=tuple(center_coordinates), + text_wh=(text_w_padded, text_h_padded), + position=self.text_anchor, ) text_x = text_background_xyxy[0] + self.text_padding - text_y = text_background_xyxy[1] + self.text_padding + text_wh[1] + text_y = text_background_xyxy[1] + self.text_padding + text_h cv2.rectangle( img=scene, @@ -1181,7 +1180,7 @@ def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: if self.heat_mask is None: self.heat_mask = np.zeros(scene.shape[:2]) mask = np.zeros(scene.shape[:2]) - for xy in detections.get_anchor_coordinates(self.position): + for xy in detections.get_anchors_coordinates(self.position): cv2.circle(mask, (int(xy[0]), int(xy[1])), self.radius, 1, -1) self.heat_mask = mask + self.heat_mask temp = self.heat_mask.copy() diff --git a/supervision/annotators/utils.py b/supervision/annotators/utils.py index 5b4e86cba..e206c8cbb 100644 --- a/supervision/annotators/utils.py +++ b/supervision/annotators/utils.py @@ -102,7 +102,7 @@ def put(self, detections: Detections) -> None: frame_id = np.full(len(detections), self.current_frame_id, dtype=int) self.frame_id = np.concatenate([self.frame_id, frame_id]) self.xy = np.concatenate( - [self.xy, detections.get_anchor_coordinates(self.anchor)] + [self.xy, detections.get_anchors_coordinates(self.anchor)] ) self.tracker_id = np.concatenate([self.tracker_id, detections.tracker_id]) diff --git a/supervision/detection/core.py b/supervision/detection/core.py index 77bfca9da..4079f8966 100644 --- a/supervision/detection/core.py +++ b/supervision/detection/core.py @@ -6,6 +6,7 @@ import numpy as np from supervision.detection.utils import ( + calculate_masks_centroids, extract_ultralytics_masks, non_max_suppression, process_roboflow_result, @@ -600,7 +601,7 @@ def __all_not_none(item_list: List[Any]): tracker_id=tracker_id, ) - def get_anchor_coordinates(self, anchor: Position) -> np.ndarray: + def get_anchors_coordinates(self, anchor: Position) -> np.ndarray: """ Calculates and returns the coordinates of a specific anchor point within the bounding boxes defined by the `xyxy` attribute. The anchor @@ -627,6 +628,12 @@ def get_anchor_coordinates(self, anchor: Position) -> np.ndarray: (self.xyxy[:, 1] + self.xyxy[:, 3]) / 2, ] ).transpose() + elif anchor == Position.CENTER_OF_MASS: + if self.mask is None: + raise ValueError( + "Cannot use `Position.CENTER_OF_MASS` without a detection mask." + ) + return calculate_masks_centroids(masks=self.mask) elif anchor == Position.CENTER_LEFT: return np.array( [ diff --git a/supervision/detection/tools/polygon_zone.py b/supervision/detection/tools/polygon_zone.py index 15ee1aa23..8e18d8bdd 100644 --- a/supervision/detection/tools/polygon_zone.py +++ b/supervision/detection/tools/polygon_zone.py @@ -60,7 +60,7 @@ def trigger(self, detections: Detections) -> np.ndarray: ) clipped_detections = replace(detections, xyxy=clipped_xyxy) clipped_anchors = np.ceil( - clipped_detections.get_anchor_coordinates(anchor=self.triggering_position) + clipped_detections.get_anchors_coordinates(anchor=self.triggering_position) ).astype(int) is_in_zone = self.mask[clipped_anchors[:, 1], clipped_anchors[:, 0]] self.current_count = int(np.sum(is_in_zone)) diff --git a/supervision/detection/utils.py b/supervision/detection/utils.py index 7aa2c846a..1e5fdc351 100644 --- a/supervision/detection/utils.py +++ b/supervision/detection/utils.py @@ -393,3 +393,33 @@ def move_boxes(xyxy: np.ndarray, offset: np.ndarray) -> np.ndarray: (np.ndarray) repositioned bounding boxes """ return xyxy + np.hstack([offset, offset]) + + +def calculate_masks_centroids(masks: np.ndarray) -> np.ndarray: + """ + Calculate the centroids of binary masks in a tensor. + + Parameters: + masks (np.ndarray): A 3D NumPy array of shape (num_masks, height, width). + Each 2D array in the tensor represents a binary mask. + + Returns: + A 2D NumPy array of shape (num_masks, 2), where each row contains the x and y + coordinates (in that order) of the centroid of the corresponding mask. + """ + num_masks, height, width = masks.shape + total_pixels = masks.sum(axis=(1, 2)) + + # offset for 1-based indexing + vertical_indices, horizontal_indices = np.indices((height, width)) + 0.5 + # avoid division by zero for empty masks + total_pixels[total_pixels == 0] = 1 + + def sum_over_mask(indices: np.ndarray, axis: tuple) -> np.ndarray: + return np.tensordot(masks, indices, axes=axis) + + aggregation_axis = ([1, 2], [0, 1]) + centroid_x = sum_over_mask(horizontal_indices, aggregation_axis) / total_pixels + centroid_y = sum_over_mask(vertical_indices, aggregation_axis) / total_pixels + + return np.column_stack((centroid_x, centroid_y)).astype(int) diff --git a/supervision/geometry/core.py b/supervision/geometry/core.py index 1771a356d..d118b5a43 100644 --- a/supervision/geometry/core.py +++ b/supervision/geometry/core.py @@ -19,6 +19,7 @@ class Position(Enum): BOTTOM_LEFT = "BOTTOM_LEFT" BOTTOM_CENTER = "BOTTOM_CENTER" BOTTOM_RIGHT = "BOTTOM_RIGHT" + CENTER_OF_MASS = "CENTER_OF_MASS" @classmethod def list(cls):

diff --git a/test/detection/test_core.py b/test/detection/test_core.py index 9708f338d..0d17e09b3 100644 --- a/test/detection/test_core.py +++ b/test/detection/test_core.py @@ -270,6 +270,6 @@ def test_get_anchor_coordinates( expected_result: np.ndarray, exception: Exception, ) -> None: - result = detections.get_anchor_coordinates(anchor) + result = detections.get_anchors_coordinates(anchor) with exception: assert np.array_equal(result, expected_result) diff --git a/test/detection/test_utils.py b/test/detection/test_utils.py index 6b3249b40..dc8e9e166 100644 --- a/test/detection/test_utils.py +++ b/test/detection/test_utils.py @@ -5,6 +5,7 @@ import pytest from supervision.detection.utils import ( + calculate_masks_centroids, clip_boxes, filter_polygons_by_area, move_boxes, @@ -498,5 +499,97 @@ def test_move_boxes( expected_result: np.ndarray, exception: Exception, ) -> None: - result = move_boxes(xyxy=xyxy, offset=offset) - assert np.array_equal(result, expected_result) + with exception: + result = move_boxes(xyxy=xyxy, offset=offset) + assert np.array_equal(result, expected_result) + + +@pytest.mark.parametrize( + "masks, expected_result, exception", + [ + ( + np.array( + [ + [ + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + ] + ] + ), + np.array([[0, 0]]), + DoesNotRaise(), + ), # single mask with all zeros + ( + np.array( + [ + [ + [1, 1, 1, 1], + [1, 1, 1, 1], + [1, 1, 1, 1], + [1, 1, 1, 1], + ] + ] + ), + np.array([[2, 2]]), + DoesNotRaise(), + ), # single mask with all ones + ( + np.array( + [ + [ + [0, 1, 1, 0], + [1, 1, 1, 1], + [1, 1, 1, 1], + [0, 1, 1, 0], + ] + ] + ), + np.array([[2, 2]]), + DoesNotRaise(), + ), # single mask with symmetric ones + ( + np.array( + [ + [ + [0, 0, 0, 0], + [0, 0, 1, 1], + [0, 0, 1, 1], + [0, 0, 0, 0], + ] + ] + ), + np.array([[3, 2]]), + DoesNotRaise(), + ), # single mask with asymmetric ones + ( + np.array( + [ + [ + [0, 1, 1, 0], + [1, 1, 1, 1], + [1, 1, 1, 1], + [0, 1, 1, 0], + ], + [ + [0, 0, 0, 0], + [0, 0, 1, 1], + [0, 0, 1, 1], + [0, 0, 0, 0], + ], + ] + ), + np.array([[2, 2], [3, 2]]), + DoesNotRaise(), + ), # two masks + ], +) +def test_calculate_masks_centroids( + masks: np.ndarray, + expected_result: np.ndarray, + exception: Exception, +) -> None: + with exception: + result = calculate_masks_centroids(masks=masks) + assert np.array_equal(result, expected_result)

[ { "components": [ { "doc": "Calculates and returns the coordinates of a specific anchor point\nwithin the bounding boxes defined by the `xyxy` attribute. The anchor\npoint can be any of the predefined positions in the `Position` enum,\nsuch as `CENTER`, `CENTER_LEFT`, `BOTTOM_RIGHT`, etc.\n\nArgs:...

[ "test/detection/test_core.py::test_getitem[detections0-index0-expected_result0-exception0]", "test/detection/test_core.py::test_getitem[detections1-index1-expected_result1-exception1]", "test/detection/test_core.py::test_getitem[detections2-index2-expected_result2-exception2]", "test/detection/test_core.py::t...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add centroid calculation for binary masks # Description Added `calculate_centroids` function to compute center of mass for binary mask representations. Method added to `utils.py` and method import added to `core.py`. `Position` enumeration updated with `CENTER_OF_MASS` constant. Test function is added with test cases covering different mask scenarios. Update allows for masks to carry center of mass information too, useful in object detection. ## Type of change Please delete options that are not relevant. - [ ] Bug fix (non-breaking change which fixes an issue) - [x] New feature (non-breaking change which adds functionality) - [ ] This change requires a documentation update ## Docs - [x] Docs updated? What were the changes: ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in supervision/detection/core.py] (definition of Detections.get_anchors_coordinates:) def get_anchors_coordinates(self, anchor: Position) -> np.ndarray: """Calculates and returns the coordinates of a specific anchor point within the bounding boxes defined by the `xyxy` attribute. The anchor point can be any of the predefined positions in the `Position` enum, such as `CENTER`, `CENTER_LEFT`, `BOTTOM_RIGHT`, etc. Args: anchor (Position): An enum specifying the position of the anchor point within the bounding box. Supported positions are defined in the `Position` enum. Returns: np.ndarray: An array of shape `(n, 2)`, where `n` is the number of bounding boxes. Each row contains the `[x, y]` coordinates of the specified anchor point for the corresponding bounding box. Raises: ValueError: If the provided `anchor` is not supported.""" [end of new definitions in supervision/detection/core.py] [start of new definitions in supervision/detection/utils.py] (definition of calculate_masks_centroids:) def calculate_masks_centroids(masks: np.ndarray) -> np.ndarray: """Calculate the centroids of binary masks in a tensor. Parameters: masks (np.ndarray): A 3D NumPy array of shape (num_masks, height, width). Each 2D array in the tensor represents a binary mask. Returns: A 2D NumPy array of shape (num_masks, 2), where each row contains the x and y coordinates (in that order) of the centroid of the corresponding mask.""" (definition of calculate_masks_centroids.sum_over_mask:) def sum_over_mask(indices: np.ndarray, axis: tuple) -> np.ndarray: [end of new definitions in supervision/detection/utils.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

3eb5c0b024e3e46877b7fe4fd66e6177d1308ba0

pyvista__pyvista-5192

5,192

pyvista/pyvista

0.43

673600daf5c1a4633b1750fb0849f77733dfe48a

2023-11-14T01:57:17Z

diff --git a/pyvista/plotting/_property.py b/pyvista/plotting/_property.py index 36c7af1b414..17a5ae55a21 100644 --- a/pyvista/plotting/_property.py +++ b/pyvista/plotting/_property.py @@ -2,6 +2,7 @@ from typing import Union import pyvista +from pyvista import vtk_version_info from pyvista.core.utilities.misc import _check_range, no_new_attr from . import _vtk @@ -107,6 +108,16 @@ class Property(_vtk.vtkProperty): * ``"front"`` - Enable frontface culling * ``'none'`` - Disable both backface and frontface culling + edge_opacity : float, default: :attr:`pyvista.plotting.themes.Theme.edge_opacity` + Edge opacity of the mesh. A single float value that will be applied globally + edge opacity of the mesh and uniformly applied everywhere - should be + between 0 and 1. + + .. note:: + `edge_opacity` uses ``SetEdgeOpacity`` as the underlying method which + requires VTK version 9.3 or higher. If ``SetEdgeOpacity`` is not + available, `edge_opacity` is set to 1. + Examples -------- Create a :class:`pyvista.Actor` and assign properties to it. @@ -166,6 +177,7 @@ def __init__( lighting=None, line_width=None, culling=None, + edge_opacity=None, ): """Initialize this property.""" self._theme = pyvista.themes.Theme() @@ -230,6 +242,16 @@ def __init__( self.line_width = line_width if culling is not None: self.culling = culling + if vtk_version_info < (9, 3) and edge_opacity is not None: # pragma: no cover + import warnings + + warnings.warn( + '`edge_opacity` cannot be used under VTK v9.3.0. Try installing VTK v9.3.0 or newer.', + UserWarning, + ) + if edge_opacity is None: + edge_opacity = self._theme.edge_opacity + self.edge_opacity = edge_opacity @property def style(self) -> str: # numpydoc ignore=RT01 @@ -398,6 +420,51 @@ def opacity(self, value: float): # numpydoc ignore=GL08 _check_range(value, (0, 1), 'opacity') self.SetOpacity(value) + @property + def edge_opacity(self) -> float: # numpydoc ignore=RT01 + """Return or set the edge opacity of this property. + + Edge opacity of the mesh. A single float value that will be applied globally + edge opacity of the mesh and uniformly applied everywhere. Between 0 and 1. + + .. note:: + `edge_opacity` uses ``SetEdgeOpacity`` as the underlying method which + requires VTK version 9.3 or higher. If ``SetEdgeOpacity`` is not + available, `edge_opacity` is set to 1. + + Examples + -------- + Set edge opacity to ``0.5``. + + >>> import pyvista as pv + >>> prop = pv.Property() + >>> prop.show_edges = True + >>> prop.edge_opacity = 0.5 + >>> prop.edge_opacity + 0.5 + + Visualize default edge opacity of ``1.0``. + + >>> prop.edge_opacity = 1.0 + >>> prop.plot() + + Visualize edge opacity of ``0.1``. + + >>> prop.edge_opacity = 0.1 + >>> prop.plot() + + """ + if vtk_version_info < (9, 3): + return 1.0 + else: + return self.GetEdgeOpacity() + + @edge_opacity.setter + def edge_opacity(self, value: float): # numpydoc ignore=GL08 + _check_range(value, (0, 1), 'edge_opacity') + if vtk_version_info >= (9, 3): + self.SetEdgeOpacity(value) + @property def show_edges(self) -> bool: # numpydoc ignore=RT01 """Return or set the visibility of edges. diff --git a/pyvista/plotting/plotter.py b/pyvista/plotting/plotter.py index b9c13003d3c..99c1adf0a55 100644 --- a/pyvista/plotting/plotter.py +++ b/pyvista/plotting/plotter.py @@ -2323,6 +2323,7 @@ def add_composite( color_missing_with_nan=False, copy_mesh=False, show_vertices=None, + edge_opacity=None, **kwargs, ): """Add a composite dataset to the plotter. @@ -2587,6 +2588,16 @@ def add_composite( * ``vertex_style`` - Change style to ``'points_gaussian'`` * ``vertex_opacity`` - Control the opacity of the vertices + edge_opacity : float, optional + Edge opacity of the mesh. A single float value that will be applied globally + edge opacity of the mesh and uniformly applied everywhere - should be + between 0 and 1. + + .. note:: + `edge_opacity` uses ``SetEdgeOpacity`` as the underlying method which + requires VTK version 9.3 or higher. If ``SetEdgeOpacity`` is not + available, `edge_opacity` is set to 1. + **kwargs : dict, optional Optional keyword arguments. @@ -2710,6 +2721,7 @@ def add_composite( line_width=line_width, opacity=opacity, culling=culling, + edge_opacity=edge_opacity, ) actor.SetProperty(prop) @@ -2847,6 +2859,7 @@ def add_mesh( copy_mesh=False, backface_params=None, show_vertices=None, + edge_opacity=None, **kwargs, ): """Add any PyVista/VTK mesh or dataset that PyVista can wrap to the scene. @@ -3180,6 +3193,16 @@ def add_mesh( * ``vertex_style`` - Change style to ``'points_gaussian'`` * ``vertex_opacity`` - Control the opacity of the vertices + edge_opacity : float, optional + Edge opacity of the mesh. A single float value that will be applied globally + edge opacity of the mesh and uniformly applied everywhere - should be + between 0 and 1. + + .. note:: + `edge_opacity` uses ``SetEdgeOpacity`` as the underlying method which + requires VTK version 9.3 or higher. If ``SetEdgeOpacity`` is not + available, `edge_opacity` is set to 1. + **kwargs : dict, optional Optional keyword arguments. diff --git a/pyvista/plotting/themes.py b/pyvista/plotting/themes.py index f724028fe66..a71ea8f6299 100644 --- a/pyvista/plotting/themes.py +++ b/pyvista/plotting/themes.py @@ -1567,6 +1567,7 @@ class Theme(_ThemeConfig): '_opacity', '_before_close_callback', '_logo_file', + '_edge_opacity', ] def __init__(self): @@ -1650,6 +1651,7 @@ def __init__(self): self._lighting_params = _LightingConfig() self._interpolate_before_map = True self._opacity = 1.0 + self._edge_opacity = 1.0 self._logo_file = None @@ -1755,6 +1757,28 @@ def opacity(self, opacity: float): # numpydoc ignore=GL08 _check_range(opacity, (0, 1), 'opacity') self._opacity = float(opacity) + @property + def edge_opacity(self) -> float: # numpydoc ignore=RT01 + """Return or set the edges opacity. + + .. note:: + `edge_opacity` uses ``SetEdgeOpacity`` as the underlying method which + requires VTK version 9.3 or higher. If ``SetEdgeOpacity`` is not + available, `edge_opacity` is set to 1. + + Examples + -------- + >>> import pyvista as pv + >>> pv.global_theme.edge_opacity = 0.5 + + """ + return self._edge_opacity + + @edge_opacity.setter + def edge_opacity(self, edge_opacity: float): # numpydoc ignore=GL08 + _check_range(edge_opacity, (0, 1), 'edge_opacity') + self._edge_opacity = float(edge_opacity) + @property def above_range_color(self) -> Color: # numpydoc ignore=RT01 """Return or set the default above range color.

diff --git a/tests/plotting/test_property.py b/tests/plotting/test_property.py index 3662cc0936b..072ef3040ea 100644 --- a/tests/plotting/test_property.py +++ b/tests/plotting/test_property.py @@ -44,6 +44,15 @@ def test_property_opacity(prop): prop.opacity = 2 +@pytest.mark.skipif(pv.vtk_version_info < (9, 3), reason="Functions not implemented before 9.3.X") +def test_property_edge_opacity(prop): + edge_opacity = 0.5 + prop.edge_opacity = edge_opacity + assert prop.edge_opacity == edge_opacity + with pytest.raises(ValueError): + prop.edge_opacity = 2 + + def test_property_show_edges(prop): value = False prop.show_edges = value

[ { "components": [ { "doc": "", "lines": [ 463, 466 ], "name": "Property.edge_opacity", "signature": "def edge_opacity(self, value: float):", "type": "function" } ], "file": "pyvista/plotting/_property.py" }, { "compo...

[ "tests/plotting/test_property.py::test_property_edge_opacity" ]

[ "tests/plotting/test_property.py::test_check_range", "tests/plotting/test_property.py::test_property_init", "tests/plotting/test_property.py::test_property_style", "tests/plotting/test_property.py::test_property_edge_color", "tests/plotting/test_property.py::test_property_opacity", "tests/plotting/test_pr...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add `edge_opacity` property to `Property` class ### Overview  resolves #5191   ### Details - [x] `vtk` version 9.3 or later ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pyvista/plotting/_property.py] (definition of Property.edge_opacity:) def edge_opacity(self, value: float): [end of new definitions in pyvista/plotting/_property.py] [start of new definitions in pyvista/plotting/themes.py] (definition of Theme.edge_opacity:) def edge_opacity(self, edge_opacity: float): [end of new definitions in pyvista/plotting/themes.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> add SetEdgeOpacity ### Describe the feature you would like to be added. Is it possible to add `SetEdgeOpacity` ? ### Links to VTK Documentation, Examples, or Class Definitions. https://vtk.org/doc/nightly/html/classvtkProperty.html#abe49ba1d9dfb86de9201fe6d5b16f4be ---------- -------------------- </issues>

25921025e45cafe97b2e274de39c3076b3c84681

googleapis__python-aiplatform-2956

2,956

googleapis/python-aiplatform

null

568d833bf44872b1045a4e2479451aedf592bf9e

2023-11-13T21:07:14Z

diff --git a/google/cloud/aiplatform/compat/types/__init__.py b/google/cloud/aiplatform/compat/types/__init__.py index 83387b064f..f543fb0114 100644 --- a/google/cloud/aiplatform/compat/types/__init__.py +++ b/google/cloud/aiplatform/compat/types/__init__.py @@ -52,6 +52,7 @@ index_endpoint as index_endpoint_v1beta1, hyperparameter_tuning_job as hyperparameter_tuning_job_v1beta1, io as io_v1beta1, + index_service as index_service_v1beta1, job_service as job_service_v1beta1, job_state as job_state_v1beta1, lineage_subgraph as lineage_subgraph_v1beta1, @@ -275,6 +276,7 @@ matching_engine_deployed_index_ref_v1beta1, index_v1beta1, index_endpoint_v1beta1, + index_service_v1beta1, match_service_v1beta1, metadata_service_v1beta1, metadata_schema_v1beta1, diff --git a/google/cloud/aiplatform/matching_engine/matching_engine_index.py b/google/cloud/aiplatform/matching_engine/matching_engine_index.py index 07eff0d325..c0713a83b9 100644 --- a/google/cloud/aiplatform/matching_engine/matching_engine_index.py +++ b/google/cloud/aiplatform/matching_engine/matching_engine_index.py @@ -21,6 +21,7 @@ from google.protobuf import field_mask_pb2 from google.cloud.aiplatform import base from google.cloud.aiplatform.compat.types import ( + index_service_v1beta1 as gca_index_service_v1beta1, matching_engine_deployed_index_ref as gca_matching_engine_deployed_index_ref, matching_engine_index as gca_matching_engine_index, encryption_spec as gca_encryption_spec, @@ -661,6 +662,46 @@ def create_brute_force_index( encryption_spec_key_name=encryption_spec_key_name, ) + def remove_datapoints( + self, + datapoint_ids: Sequence[str], + ) -> "MatchingEngineIndex": + """Remove datapoints for this index. + + Args: + datapoints_ids (Sequence[str]): + Required. The list of datapoints ids to be deleted. + + Returns: + MatchingEngineIndex - Index resource object + """ + self.wait() + + _LOGGER.log_action_start_against_resource( + "Removing datapoints", + "index", + self, + ) + + remove_lro = self.api_client.remove_datapoints( + gca_index_service_v1beta1.RemoveDatapointsRequest( + index=self.resource_name, + datapoint_ids=datapoint_ids, + ) + ) + + _LOGGER.log_action_started_against_resource_with_lro( + "Remove datapoints", "index", self.__class__, remove_lro + ) + + self._gca_resource = remove_lro.result(timeout=None) + + _LOGGER.log_action_completed_against_resource( + "index", "Removed datapoints", self + ) + + return self + _INDEX_UPDATE_METHOD_TO_ENUM_VALUE = { "STREAM_UPDATE": gca_matching_engine_index.Index.IndexUpdateMethod.STREAM_UPDATE,

diff --git a/tests/unit/aiplatform/test_matching_engine_index.py b/tests/unit/aiplatform/test_matching_engine_index.py index 40d12ef0a9..36320a13b3 100644 --- a/tests/unit/aiplatform/test_matching_engine_index.py +++ b/tests/unit/aiplatform/test_matching_engine_index.py @@ -35,6 +35,7 @@ from google.cloud.aiplatform.compat.types import ( index as gca_index, encryption_spec as gca_encryption_spec, + index_service_v1beta1 as gca_index_service_v1beta1, ) import constants as test_constants @@ -110,6 +111,9 @@ # Encryption spec _TEST_ENCRYPTION_SPEC_KEY_NAME = "TEST_ENCRYPTION_SPEC" +# Streaming update +_TEST_DATAPOINT_IDS = ("1", "2") + def uuid_mock(): return uuid.UUID(int=1) @@ -192,6 +196,16 @@ def create_index_mock(): yield create_index_mock +@pytest.fixture +def remove_datapoints_mock(): + with patch.object( + index_service_client.IndexServiceClient, "remove_datapoints" + ) as remove_datapoints_mock: + remove_datapoints_lro_mock = mock.Mock(operation.Operation) + remove_datapoints_mock.return_value = remove_datapoints_lro_mock + yield remove_datapoints_mock + + @pytest.mark.usefixtures("google_auth_mock") class TestMatchingEngineIndex: def setup_method(self): @@ -414,3 +428,19 @@ def test_create_brute_force_index( index=expected, metadata=_TEST_REQUEST_METADATA, ) + + @pytest.mark.usefixtures("get_index_mock") + def test_remove_datapoints(self, remove_datapoints_mock): + aiplatform.init(project=_TEST_PROJECT) + + my_index = aiplatform.MatchingEngineIndex(index_name=_TEST_INDEX_ID) + my_index.remove_datapoints( + datapoint_ids=_TEST_DATAPOINT_IDS, + ) + + remove_datapoints_request = gca_index_service_v1beta1.RemoveDatapointsRequest( + index=_TEST_INDEX_NAME, + datapoint_ids=_TEST_DATAPOINT_IDS, + ) + + remove_datapoints_mock.assert_called_once_with(remove_datapoints_request)

[ { "components": [ { "doc": "Remove datapoints for this index.\n\nArgs:\n datapoints_ids (Sequence[str]):\n Required. The list of datapoints ids to be deleted.\n\nReturns:\n MatchingEngineIndex - Index resource object", "lines": [ 665, 703 ], ...

[ "tests/unit/aiplatform/test_matching_engine_index.py::TestMatchingEngineIndex::test_init_index[index_id]", "tests/unit/aiplatform/test_matching_engine_index.py::TestMatchingEngineIndex::test_init_index[projects/test-project/locations/us-central1/indexes/index_id]", "tests/unit/aiplatform/test_matching_engine_in...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat: add `remove_datapoints()` to `MatchingEngineIndex`. feat: add `remove_datapoints()` to `MatchingEngineIndex`. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in google/cloud/aiplatform/matching_engine/matching_engine_index.py] (definition of MatchingEngineIndex.remove_datapoints:) def remove_datapoints( self, datapoint_ids: Sequence[str], ) -> "MatchingEngineIndex": """Remove datapoints for this index. Args: datapoints_ids (Sequence[str]): Required. The list of datapoints ids to be deleted. Returns: MatchingEngineIndex - Index resource object""" [end of new definitions in google/cloud/aiplatform/matching_engine/matching_engine_index.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

67358fa6a830eb842f6b52d09061af4a41b54af6

google-deepmind__optax-634

634

google-deepmind/optax

null

b7ff8ac43b59b27e4db28769995aade577ce4f99

2023-11-13T17:03:04Z

diff --git a/optax/contrib/mechanic.py b/optax/contrib/mechanic.py index 17e9f6602..aef7d18d4 100644 --- a/optax/contrib/mechanic.py +++ b/optax/contrib/mechanic.py @@ -26,31 +26,18 @@ using Mechanic to be the same for reasonably large batch sizes (>1k). """ - -import functools import operator from typing import NamedTuple, Optional, Tuple import chex import jax import jax.numpy as jnp + +from optax import tree_utils from optax._src import base from optax._src import utils -def _vdot_safe(a, b): - vdot = functools.partial(jnp.vdot, precision=jax.lax.Precision.HIGHEST) - cvdot = vdot(jnp.asarray(a), jnp.asarray(b)) - return cvdot - - -@jax.jit -def _tree_vdot(tree_x, tree_y): - """Compute the inner product <tree_x, tree_y>.""" - vdots = jax.tree_util.tree_map(_vdot_safe, tree_x, tree_y) - return jax.tree_util.tree_reduce(operator.add, vdots) - - @jax.jit def _tree_sum(tree_x): """Compute sum(tree_x).""" @@ -193,7 +180,7 @@ def add_weight_decay(gi, pi): ) # Now we are ready to run the actual Mechanic algorithm. - h = _tree_vdot(updates, delta_prev) + h = tree_utils.tree_vdot(updates, delta_prev) # This clipping was not part of the original paper but we introduced it # a little later. diff --git a/optax/tree_utils/__init__.py b/optax/tree_utils/__init__.py index 68989be69..a0fd7930d 100644 --- a/optax/tree_utils/__init__.py +++ b/optax/tree_utils/__init__.py @@ -12,6 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== -"""The tree_util optimisation sub-package.""" +"""The tree_utils sub-package.""" from optax.tree_utils._state_utils import tree_map_params +from optax.tree_utils._tree_math import tree_vdot diff --git a/optax/tree_utils/_tree_math.py b/optax/tree_utils/_tree_math.py new file mode 100644 index 000000000..e87164e71 --- /dev/null +++ b/optax/tree_utils/_tree_math.py @@ -0,0 +1,54 @@ +# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== + +"""Utilities to perform maths on pytrees.""" + +import functools +import operator +from typing import Any + +import chex +import jax +from jax import tree_util as jtu +import jax.numpy as jnp + + +_vdot = functools.partial(jnp.vdot, precision=jax.lax.Precision.HIGHEST) + + +def _vdot_safe(a, b): + return _vdot(jnp.asarray(a), jnp.asarray(b)) + + +def tree_vdot(tree_x: Any, tree_y: Any) -> chex.Numeric: + r"""Compute the inner product between two pytrees. + + Args: + tree_x: first pytree to use. + tree_y: second pytree to use. + Returns: + inner product between ``tree_x`` and ``tree_y``, a scalar value. + + >>> optax.tree_utils.tree_vdot( + >>> {a: jnp.array([1, 2]), b: jnp.array([1, 2])}, + >>> {a: jnp.array([-1, -1]), b: jnp.array([1, 1])}, + >>> ) + 0.0 + + Implementation detail: we upcast the values to the highest precision to avoid + numerical issues. + """ + vdots = jtu.tree_map(_vdot_safe, tree_x, tree_y) + return jtu.tree_reduce(operator.add, vdots)

diff --git a/optax/tree_utils/_tree_math_test.py b/optax/tree_utils/_tree_math_test.py new file mode 100644 index 000000000..0c7f1210e --- /dev/null +++ b/optax/tree_utils/_tree_math_test.py @@ -0,0 +1,56 @@ +# Copyright 2021 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== + +"""Tests for optax.tree_utils.""" + +from absl.testing import absltest + +import jax.numpy as jnp +import numpy as np + +from optax import tree_utils as tu + + +class TreeUtilsTest(absltest.TestCase): + + def setUp(self): + super().setUp() + rng = np.random.RandomState(0) + + self.tree_a = (rng.randn(20, 10) + 1j * rng.randn(20, 10), rng.randn(20)) + self.tree_b = (rng.randn(20, 10), rng.randn(20)) + + self.tree_a_dict = (1.0, {'k1': 1.0, 'k2': (1.0, 1.0)}, 1.0) + self.tree_b_dict = (1.0, {'k1': 2.0, 'k2': (3.0, 4.0)}, 5.0) + + self.array_a = rng.randn(20) + 1j * rng.randn(20) + self.array_b = rng.randn(20) + + def test_tree_vdot(self): + expected = jnp.vdot(self.array_a, self.array_b) + got = tu.tree_vdot(self.array_a, self.array_b) + np.testing.assert_allclose(expected, got) + + expected = 15.0 + got = tu.tree_vdot(self.tree_a_dict, self.tree_b_dict) + np.testing.assert_allclose(expected, got) + + expected = (jnp.vdot(self.tree_a[0], self.tree_b[0]) + + jnp.vdot(self.tree_a[1], self.tree_b[1])) + got = tu.tree_vdot(self.tree_a, self.tree_b) + np.testing.assert_allclose(expected, got) + +if __name__ == '__main__': + absltest.main()

[ { "components": [ { "doc": "", "lines": [ 31, 32 ], "name": "_vdot_safe", "signature": "def _vdot_safe(a, b):", "type": "function" }, { "doc": "Compute the inner product between two pytrees.\n\nArgs:\n tree_x: first p...

[ "optax/tree_utils/_tree_math_test.py::TreeUtilsTest::test_tree_vdot" ]

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add tree_vdot to tree_utils. Add tree_vdot to tree_utils. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in optax/tree_utils/_tree_math.py] (definition of _vdot_safe:) def _vdot_safe(a, b): (definition of tree_vdot:) def tree_vdot(tree_x: Any, tree_y: Any) -> chex.Numeric: """Compute the inner product between two pytrees. Args: tree_x: first pytree to use. tree_y: second pytree to use. Returns: inner product between ``tree_x`` and ``tree_y``, a scalar value. >>> optax.tree_utils.tree_vdot( >>> {a: jnp.array([1, 2]), b: jnp.array([1, 2])}, >>> {a: jnp.array([-1, -1]), b: jnp.array([1, 1])}, >>> ) 0.0 Implementation detail: we upcast the values to the highest precision to avoid numerical issues.""" [end of new definitions in optax/tree_utils/_tree_math.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

1e08bccf195ac54e7d9d766eb5e69345bf0e3230

google-deepmind__optax-632

632

google-deepmind/optax

null

35920a3712d71992429dc0bd605e75d31cbe2b21

2023-11-13T14:40:27Z

diff --git a/optax/__init__.py b/optax/__init__.py index 0b373684d..6f844478d 100644 --- a/optax/__init__.py +++ b/optax/__init__.py @@ -17,6 +17,7 @@ from optax import contrib from optax import losses from optax import monte_carlo +from optax import projections from optax import schedules from optax import second_order from optax import tree_utils diff --git a/optax/projections/__init__.py b/optax/projections/__init__.py new file mode 100644 index 000000000..9b38aeb6c --- /dev/null +++ b/optax/projections/__init__.py @@ -0,0 +1,18 @@ +# Copyright 2021 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== + +"""The projections sub-package.""" + +from optax.projections._projections import projection_non_negative diff --git a/optax/projections/_projections.py b/optax/projections/_projections.py new file mode 100644 index 000000000..316cd21fb --- /dev/null +++ b/optax/projections/_projections.py @@ -0,0 +1,39 @@ +# Copyright 2021 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== + +"""Euclidean projections.""" + +from typing import Any + +import jax +from jax import tree_util as jtu + + +def projection_non_negative(pytree: Any) -> Any: + r"""Projection onto the non-negative orthant. + + .. math:: + + \underset{p}{\text{argmin}} ~ ||x - p||_2^2 \quad + \textrm{subject to} \quad p \ge 0 + + where :math:`x` is the input pytree. + + Args: + pytree: pytree to project. + Returns: + projected pytree, with the same structure as ``pytree``. + """ + return jtu.tree_map(jax.nn.relu, pytree)

diff --git a/optax/projections/_projections_test.py b/optax/projections/_projections_test.py new file mode 100644 index 000000000..15d4f1204 --- /dev/null +++ b/optax/projections/_projections_test.py @@ -0,0 +1,47 @@ +# Copyright 2021 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== + +"""Tests for optax.projections.""" + +from absl.testing import absltest +from absl.testing import parameterized + +import chex +import jax.numpy as jnp +import numpy as np + +from optax import projections as proj + + +class ProjectionsTest(parameterized.TestCase): + + def test_projection_non_negative(self): + # test with array + x = jnp.array([-1.0, 2.0, 3.0]) + expected = jnp.array([0, 2.0, 3.0]) + np.testing.assert_array_equal(proj.projection_non_negative(x), expected) + + # test with tuple + np.testing.assert_array_equal(proj.projection_non_negative((x, x)), + (expected, expected)) + + # test with nested pytree + tree_x = (-1.0, {'k1': 1.0, 'k2': (1.0, 1.0)}, 1.0) + tree_expected = (0.0, {'k1': 1.0, 'k2': (1.0, 1.0)}, 1.0) + chex.assert_trees_all_equal(proj.projection_non_negative(tree_x), + tree_expected) + +if __name__ == '__main__': + absltest.main()

[ { "components": [ { "doc": "Projection onto the non-negative orthant.\n\n.. math::\n\n \\underset{p}{\\text{argmin}} ~ ||x - p||_2^2 \\quad\n \\textrm{subject to} \\quad p \\ge 0\n\nwhere :math:`x` is the input pytree.\n\nArgs:\n pytree: pytree to project.\nReturns:\n projected pytree, with th...

[ "optax/projections/_projections_test.py::ProjectionsTest::test_projection_non_negative" ]

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Start optax.projections subpackage and add projection_non_negative. Start optax.projections subpackage and add projection_non_negative. In the future, this subpackage will contain more projections (projection_simplex, projection_l1_ball, etc) as well as non-Euclidean projections. I used typing.Any as a type annotation for pytrees for the time being, as chex.ArrayTree doesn't seem to accept tuples. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in optax/projections/_projections.py] (definition of projection_non_negative:) def projection_non_negative(pytree: Any) -> Any: """Projection onto the non-negative orthant. .. math:: \underset{p}{\text{argmin}} ~ ||x - p||_2^2 \quad \textrm{subject to} \quad p \ge 0 where :math:`x` is the input pytree. Args: pytree: pytree to project. Returns: projected pytree, with the same structure as ``pytree``.""" [end of new definitions in optax/projections/_projections.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

1e08bccf195ac54e7d9d766eb5e69345bf0e3230

pvlib__pvlib-python-1907

1,907

pvlib/pvlib-python

0.9

4e99ddca47499715231578c3eae81ec0c4db8573

2023-11-12T20:46:36Z

diff --git a/docs/examples/irradiance-transposition/plot_rtranpose_limitations.py b/docs/examples/irradiance-transposition/plot_rtranpose_limitations.py new file mode 100644 index 0000000000..8df8339ad4 --- /dev/null +++ b/docs/examples/irradiance-transposition/plot_rtranpose_limitations.py @@ -0,0 +1,181 @@ +""" +Reverse transposition limitations +==================================== + +Unfortunately, sometimes there is not a unique solution. + +Author: Anton Driesse + +""" + +# %% +# +# Introduction +# ------------ +# When irradiance is measured on a tilted plane, it is useful to be able to +# estimate the GHI that produces the POA irradiance. +# The estimation requires inverting a GHI-to-POA irradiance model, +# which involves two parts: +# a decomposition of GHI into direct and diffuse components, +# and a transposition model that calculates the direct and diffuse irradiance +# on the tilted plane. +# Recovering GHI from POA irradiance is termed "reverse transposition." +# +# Unfortunately, for a given POA irradiance value, sometimes there is not a +# unique solution for GHI. +# Different GHI values can produce different combinations of direct and +# diffuse irradiance that sum to the same POA irradiance value. +# +# In this example we look at a single point in time and consider a full range +# of possible GHI and POA global values as shown in figures 3 and 4 of [1]_. +# Then we use :py:meth:`pvlib.irradiance.ghi_from_poa_driesse_2023` to estimate +# the original GHI from POA global. +# +# References +# ---------- +# .. [1] Driesse, A., Jensen, A., Perez, R., 2024. A Continuous form of the +# Perez diffuse sky model for forward and reverse transposition. +# Solar Energy vol. 267. :doi:`10.1016/j.solener.2023.112093` +# + +import numpy as np + +import matplotlib +import matplotlib.pyplot as plt + +from pvlib.irradiance import (erbs_driesse, + get_total_irradiance, + ghi_from_poa_driesse_2023, + ) + +matplotlib.rcParams['axes.grid'] = True + +# %% +# +# Define the conditions that were used for figure 3 in [1]_. +# + +dni_extra = 1366.1 +albedo = 0.25 +surface_tilt = 40 +surface_azimuth = 180 + +solar_azimuth = 82 +solar_zenith = 75 + +# %% +# +# Define a range of possible GHI values and calculate the corresponding +# POA global. First estimate DNI and DHI using the Erbs-Driesse model, then +# transpose using the Perez-Driesse model. +# + +ghi = np.linspace(0, 500, 100+1) + +erbsout = erbs_driesse(ghi, solar_zenith, dni_extra=dni_extra) + +dni = erbsout['dni'] +dhi = erbsout['dhi'] + +irrads = get_total_irradiance(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + dni, ghi, dhi, + dni_extra, + model='perez-driesse') + +poa_global = irrads['poa_global'] + +# %% +# +# Suppose you measure that POA global is 200 W/m2. What would GHI be? +# + +poa_test = 200 + +ghi_hat = ghi_from_poa_driesse_2023(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + poa_test, + dni_extra, + full_output=False) + +print('Estimated GHI: %.2f W/m².' % ghi_hat) + +# %% +# +# Show this result on the graph of all possible combinations of GHI and POA. +# + +plt.figure() +plt.plot(ghi, poa_global, 'k-') +plt.axvline(ghi_hat, color='g', lw=1) +plt.axhline(poa_test, color='g', lw=1) +plt.plot(ghi_hat, poa_test, 'gs') +plt.annotate('GHI=%.2f' % (ghi_hat), + xy=(ghi_hat-2, 200+2), + xytext=(ghi_hat-20, 200+20), + ha='right', + arrowprops={'arrowstyle': 'simple'}) +plt.xlim(0, 500) +plt.ylim(0, 250) +plt.xlabel('GHI [W/m²]') +plt.ylabel('POA [W/m²]') +plt.show() + +# %% +# +# Now change the solar azimuth to match the conditions for figure 4 in [1]_. +# + +solar_azimuth = 76 + +# %% +# +# Again, estimate DNI and DHI using the Erbs-Driesse model, then +# transpose using the Perez-Driesse model. +# + +erbsout = erbs_driesse(ghi, solar_zenith, dni_extra=dni_extra) + +dni = erbsout['dni'] +dhi = erbsout['dhi'] + +irrads = get_total_irradiance(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + dni, ghi, dhi, + dni_extra, + model='perez-driesse') + +poa_global = irrads['poa_global'] + +# %% +# +# Now reverse transpose all the POA values and observe that the original +# GHI cannot always be found. There is a range of POA values that +# maps to three possible GHI values, and there is not enough information +# to choose one of them. Sometimes we get lucky and the right one comes +# out, other times not. +# + +result = ghi_from_poa_driesse_2023(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + poa_global, + dni_extra, + full_output=True, + ) + +ghi_hat, conv, niter = result +correct = np.isclose(ghi, ghi_hat, atol=0.01) + +plt.figure() +plt.plot(np.where(correct, ghi, np.nan), np.where(correct, poa_global, np.nan), + 'g.', label='correct GHI found') +plt.plot(ghi[~correct], poa_global[~correct], 'r.', label='unreachable GHI') +plt.plot(ghi[~conv], poa_global[~conv], 'm.', label='out of range (kt > 1.25)') +plt.axhspan(88, 103, color='y', alpha=0.25, label='problem region') + +plt.xlim(0, 500) +plt.ylim(0, 250) +plt.xlabel('GHI [W/m²]') +plt.ylabel('POA [W/m²]') +plt.legend() +plt.show() diff --git a/docs/examples/irradiance-transposition/plot_rtranpose_year.py b/docs/examples/irradiance-transposition/plot_rtranpose_year.py new file mode 100644 index 0000000000..c0b9860bba --- /dev/null +++ b/docs/examples/irradiance-transposition/plot_rtranpose_year.py @@ -0,0 +1,152 @@ +""" +Reverse transposition using one year of hourly data +=================================================== + +With a brief look at accuracy and speed. + +Author: Anton Driesse + +""" +# %% +# +# Introduction +# ------------ +# When irradiance is measured on a tilted plane, it is useful to be able to +# estimate the GHI that produces the POA irradiance. +# The estimation requires inverting a GHI-to-POA irradiance model, +# which involves two parts: +# a decomposition of GHI into direct and diffuse components, +# and a transposition model that calculates the direct and diffuse +# irradiance on the tilted plane. +# Recovering GHI from POA irradiance is termed "reverse transposition." +# +# In this example we start with a TMY file and calculate POA global irradiance. +# Then we use :py:meth:`pvlib.irradiance.ghi_from_poa_driesse_2023` to estimate +# the original GHI from POA global. Details of the method found in [1]_. +# +# Another method for reverse tranposition called GTI-DIRINT is also +# available in pvlib python (:py:meth:`pvlib.irradiance.gti_dirint`). +# More information is available in [2]_. +# +# References +# ---------- +# .. [1] Driesse, A., Jensen, A., Perez, R., 2024. A Continuous form of the +# Perez diffuse sky model for forward and reverse transposition. +# Solar Energy vol. 267. :doi:`10.1016/j.solener.2023.112093` +# +# .. [2] B. Marion, A model for deriving the direct normal and +# diffuse horizontal irradiance from the global tilted +# irradiance, Solar Energy 122, 1037-1046. +# :doi:`10.1016/j.solener.2015.10.024` + +import os +import time +import pandas as pd + +import matplotlib.pyplot as plt + +import pvlib +from pvlib import iotools, location +from pvlib.irradiance import (get_extra_radiation, + get_total_irradiance, + ghi_from_poa_driesse_2023, + aoi, + ) + +# %% +# +# Read a TMY3 file containing weather data and select needed columns. +# + +PVLIB_DIR = pvlib.__path__[0] +DATA_FILE = os.path.join(PVLIB_DIR, 'data', '723170TYA.CSV') + +tmy, metadata = iotools.read_tmy3(DATA_FILE, coerce_year=1990, + map_variables=True) + +df = pd.DataFrame({'ghi': tmy['ghi'], 'dhi': tmy['dhi'], 'dni': tmy['dni'], + 'temp_air': tmy['temp_air'], + 'wind_speed': tmy['wind_speed'], + }) + +# %% +# +# Shift the timestamps to the middle of the hour and calculate sun positions. +# + +df.index = df.index - pd.Timedelta(minutes=30) + +loc = location.Location.from_tmy(metadata) +solpos = loc.get_solarposition(df.index) + +# %% +# +# Estimate global irradiance on a fixed-tilt array (forward transposition). +# The array is tilted 30 degrees and oriented 30 degrees east of south. +# + +TILT = 30 +ORIENT = 150 + +df['dni_extra'] = get_extra_radiation(df.index) + +total_irrad = get_total_irradiance(TILT, ORIENT, + solpos.apparent_zenith, + solpos.azimuth, + df.dni, df.ghi, df.dhi, + dni_extra=df.dni_extra, + model='perez-driesse') + +df['poa_global'] = total_irrad.poa_global +df['aoi'] = aoi(TILT, ORIENT, solpos.apparent_zenith, solpos.azimuth) + +# %% +# +# Now estimate ghi from poa_global using reverse transposition. +# The algorithm uses a simple bisection search, which is quite slow +# because scipy doesn't offer a vectorized version (yet). +# For this reason we'll process a random sample of 1000 timestamps +# rather than the whole year. +# + +df = df[df.ghi > 0].sample(n=1000) +solpos = solpos.reindex(df.index) + +start = time.process_time() + +df['ghi_rev'] = ghi_from_poa_driesse_2023(TILT, ORIENT, + solpos.apparent_zenith, + solpos.azimuth, + df.poa_global, + dni_extra=df.dni_extra) +finish = time.process_time() + +print('Elapsed time for reverse transposition: %.1f s' % (finish - start)) + +# %% +# +# This graph shows the reverse transposed values vs. the original values. +# The markers are color-coded by angle-of-incidence to show that +# errors occur primarily with incidence angle approaching 90° and beyond. +# +# Note that the results look particularly good because the POA values +# were calculated using the same models as used in reverse transposition. +# This isn't cheating though. It's a way of ensuring that the errors +# we see are really due to the reverse transposition algorithm. +# Expect to see larger errors with real-word POA measurements +# because errors from forward and reverse transposition will both be present. +# + +df = df.sort_values('aoi') + +plt.figure() +plt.gca().grid(True, alpha=.5) +pc = plt.scatter(df['ghi'], df['ghi_rev'], c=df['aoi'], s=15, + cmap='jet', vmin=60, vmax=120) +plt.colorbar(label='AOI [°]') +pc.set_alpha(0.5) + +plt.xlabel('GHI original [W/m²]') +plt.ylabel('GHI from POA [W/m²]') + +plt.show() diff --git a/docs/sphinx/source/reference/irradiance/transposition.rst b/docs/sphinx/source/reference/irradiance/transposition.rst index 7b3624e692..22136f0c58 100644 --- a/docs/sphinx/source/reference/irradiance/transposition.rst +++ b/docs/sphinx/source/reference/irradiance/transposition.rst @@ -15,3 +15,4 @@ Transposition models irradiance.klucher irradiance.reindl irradiance.king + irradiance.ghi_from_poa_driesse_2023 diff --git a/docs/sphinx/source/whatsnew/v0.10.3.rst b/docs/sphinx/source/whatsnew/v0.10.3.rst index 007eb8d34b..63f7b90b84 100644 --- a/docs/sphinx/source/whatsnew/v0.10.3.rst +++ b/docs/sphinx/source/whatsnew/v0.10.3.rst @@ -9,6 +9,9 @@ Enhancements ~~~~~~~~~~~~ * Added the continuous Perez-Driesse transposition model. :py:func:`pvlib.irradiance.perez_driesse` (:issue:`1841`, :pull:`1876`) +* Added a reverse transposition algorithm using the Perez-Driesse model. + :py:func:`pvlib.irradiance.ghi_from_poa_driesse_2023` + (:issue:`1901`, :pull:`1907`) * :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance` and :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance_poa` now include shaded fraction in returned variables. (:pull:`1871`) @@ -27,8 +30,10 @@ Documentation ~~~~~~~~~~~~~ * Create :ref:`weatherdata` User's Guide page. (:pull:`1754`) * Fixed a plotting issue in the IV curve gallery example (:pull:`1895`) +* Added two examples to demonstrate reverse transposition (:pull:`1907`) * Fixed `detect_clearsky` example in `clearsky.rst` (:issue:`1914`) + Requirements ~~~~~~~~~~~~ * Minimum version of scipy advanced from 1.4.0 to 1.5.0. (:issue:`1918`, :pull:`1919`) diff --git a/pvlib/irradiance.py b/pvlib/irradiance.py index efae7f6236..f5e9a44b7a 100644 --- a/pvlib/irradiance.py +++ b/pvlib/irradiance.py @@ -11,6 +11,7 @@ import numpy as np import pandas as pd from scipy.interpolate import splev +from scipy.optimize import bisect from pvlib import atmosphere, solarposition, tools import pvlib # used to avoid dni name collision in complete_irradiance @@ -1380,9 +1381,9 @@ def perez_driesse(surface_tilt, surface_azimuth, dhi, dni, dni_extra, References ---------- - .. [1] A. Driesse, A. Jensen, R. Perez, A Continuous Form of the Perez - Diffuse Sky Model for Forward and Reverse Transposition, accepted - for publication in the Solar Energy Journal. + .. [1] Driesse, A., Jensen, A., Perez, R., 2024. A Continuous form of the + Perez diffuse sky model for forward and reverse transposition. + Solar Energy vol. 267. :doi:`10.1016/j.solener.2023.112093` .. [2] Perez, R., Ineichen, P., Seals, R., Michalsky, J., Stewart, R., 1990. Modeling daylight availability and irradiance components from @@ -1444,6 +1445,170 @@ def perez_driesse(surface_tilt, surface_azimuth, dhi, dni, dni_extra, return sky_diffuse +def _poa_from_ghi(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + ghi, + dni_extra, airmass, albedo): + ''' + Transposition function that includes decomposition of GHI using the + continuous Erbs-Driesse model. + + Helper function for ghi_from_poa_driesse_2023. + ''' + # Contributed by Anton Driesse (@adriesse), PV Performance Labs. Nov., 2023 + + erbsout = erbs_driesse(ghi, solar_zenith, dni_extra=dni_extra) + + dni = erbsout['dni'] + dhi = erbsout['dhi'] + + irrads = get_total_irradiance(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + dni, ghi, dhi, + dni_extra, airmass, albedo, + model='perez-driesse') + + return irrads['poa_global'] + + +def _ghi_from_poa(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + poa_global, + dni_extra, airmass, albedo, + xtol=0.01): + ''' + Reverse transposition function that uses the scalar bisection from scipy. + + Helper function for ghi_from_poa_driesse_2023. + ''' + # Contributed by Anton Driesse (@adriesse), PV Performance Labs. Nov., 2023 + + # propagate nans and zeros quickly + if np.isnan(poa_global): + return np.nan, False, 0 + if poa_global <= 0: + return 0.0, True, 0 + + # function whose root needs to be found + def poa_error(ghi): + poa_hat = _poa_from_ghi(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + ghi, + dni_extra, airmass, albedo) + return poa_hat - poa_global + + # calculate an upper bound for ghi using clearness index 1.25 + ghi_clear = dni_extra * tools.cosd(solar_zenith) + ghi_high = np.maximum(10, 1.25 * ghi_clear) + + try: + result = bisect(poa_error, + a=0, + b=ghi_high, + xtol=xtol, + maxiter=25, + full_output=True, + disp=False, + ) + except ValueError: + # this occurs when poa_error has the same sign at both end points + ghi = np.nan + conv = False + niter = -1 + else: + ghi = result[0] + conv = result[1].converged + niter = result[1].iterations + + return ghi, conv, niter + + +def ghi_from_poa_driesse_2023(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + poa_global, + dni_extra=None, airmass=None, albedo=0.25, + xtol=0.01, + full_output=False): + ''' + Estimate global horizontal irradiance (GHI) from global plane-of-array + (POA) irradiance. This reverse transposition algorithm uses a bisection + search together with the continuous Perez-Driesse transposition and + continuous Erbs-Driesse decomposition models, as described in [1]_. + + Parameters + ---------- + surface_tilt : numeric + Panel tilt from horizontal. [degree] + surface_azimuth : numeric + Panel azimuth from north. [degree] + solar_zenith : numeric + Solar zenith angle. [degree] + solar_azimuth : numeric + Solar azimuth angle. [degree] + poa_global : numeric + Plane-of-array global irradiance, aka global tilted irradiance. [W/m^2] + dni_extra : None or numeric, default None + Extraterrestrial direct normal irradiance. [W/m^2] + airmass : None or numeric, default None + Relative airmass (not adjusted for pressure). [unitless] + albedo : numeric, default 0.25 + Ground surface albedo. [unitless] + xtol : numeric, default 0.01 + Convergence criterion. The estimated GHI will be within xtol of the + true value. [W/m^2] + full_output : boolean, default False + If full_output is False, only ghi is returned, otherwise the return + value is (ghi, converged, niter). (see Returns section for details). + + Returns + ------- + ghi : numeric + Estimated GHI. [W/m^2] + converged : boolean, optional + Present if full_output=True. Indicates which elements converged + successfully. + niter : integer, optional + Present if full_output=True. Indicates how many bisection iterations + were done. + + Notes + ----- + Since :py:func:`scipy.optimize.bisect` is not vectorized, high-resolution + time series can be quite slow to process. + + References + ---------- + .. [1] Driesse, A., Jensen, A., Perez, R., 2024. A Continuous form of the + Perez diffuse sky model for forward and reverse transposition. + Solar Energy vol. 267. :doi:`10.1016/j.solener.2023.112093` + + See also + -------- + perez_driesse + erbs_driesse + gti_dirint + ''' + # Contributed by Anton Driesse (@adriesse), PV Performance Labs. Nov., 2023 + + ghi_from_poa_array = np.vectorize(_ghi_from_poa) + + ghi, conv, niter = ghi_from_poa_array(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth, + poa_global, + dni_extra, airmass, albedo, + xtol=0.01) + + if isinstance(poa_global, pd.Series): + ghi = pd.Series(ghi, poa_global.index) + conv = pd.Series(conv, poa_global.index) + niter = pd.Series(niter, poa_global.index) + + if full_output: + return ghi, conv, niter + else: + return ghi + + def clearsky_index(ghi, clearsky_ghi, max_clearsky_index=2.0): """ Calculate the clearsky index. @@ -2567,8 +2732,9 @@ def erbs_driesse(ghi, zenith, datetime_or_doy=None, dni_extra=None, References ---------- - .. [1] A. Driesse, A. Jensen, R. Perez, A Continuous Form of the Perez - Diffuse Sky Model for Forward and Reverse Transposition, forthcoming. + .. [1] Driesse, A., Jensen, A., Perez, R., 2024. A Continuous form of the + Perez diffuse sky model for forward and reverse transposition. + Solar Energy vol. 267. :doi:`10.1016/j.solener.2023.112093` .. [2] D. G. Erbs, S. A. Klein and J. A. Duffie, Estimation of the diffuse radiation fraction for hourly, daily and monthly-average

diff --git a/pvlib/tests/test_irradiance.py b/pvlib/tests/test_irradiance.py index ba66f4dc36..55fef490ba 100644 --- a/pvlib/tests/test_irradiance.py +++ b/pvlib/tests/test_irradiance.py @@ -782,6 +782,50 @@ def test_dirint_min_cos_zenith_max_zenith(): assert_series_equal(out, expected, check_less_precise=True) +def test_ghi_from_poa_driesse(): + # inputs copied from test_gti_dirint + times = pd.DatetimeIndex( + ['2014-06-24T06-0700', '2014-06-24T09-0700', '2014-06-24T12-0700']) + poa_global = np.array([20, 300, 1000]) + zenith = np.array([80, 45, 20]) + azimuth = np.array([90, 135, 180]) + surface_tilt = 30 + surface_azimuth = 180 + + # test core function + output = irradiance.ghi_from_poa_driesse_2023( + surface_tilt, surface_azimuth, zenith, azimuth, + poa_global, dni_extra=1366.1) + + expected = [22.089, 304.088, 931.143] + assert_allclose(expected, output, atol=0.001) + + # test series output + poa_global = pd.Series([20, 300, 1000], index=times) + + output = irradiance.ghi_from_poa_driesse_2023( + surface_tilt, surface_azimuth, zenith, azimuth, + poa_global, dni_extra=1366.1) + + assert isinstance(output, pd.Series) + + # test full_output option and special cases + poa_global = np.array([0, 1500, np.nan]) + + ghi, conv, niter = irradiance.ghi_from_poa_driesse_2023( + surface_tilt, surface_azimuth, zenith, azimuth, + poa_global, dni_extra=1366.1, full_output=True) + + expected = [0, np.nan, np.nan] + assert_allclose(expected, ghi, atol=0.001) + + expected = [True, False, False] + assert_allclose(expected, conv) + + expected = [0, -1, 0] + assert_allclose(expected, niter) + + def test_gti_dirint(): times = pd.DatetimeIndex( ['2014-06-24T06-0700', '2014-06-24T09-0700', '2014-06-24T12-0700'])

diff --git a/docs/sphinx/source/reference/irradiance/transposition.rst b/docs/sphinx/source/reference/irradiance/transposition.rst index 7b3624e692..22136f0c58 100644 --- a/docs/sphinx/source/reference/irradiance/transposition.rst +++ b/docs/sphinx/source/reference/irradiance/transposition.rst @@ -15,3 +15,4 @@ Transposition models irradiance.klucher irradiance.reindl irradiance.king + irradiance.ghi_from_poa_driesse_2023 diff --git a/docs/sphinx/source/whatsnew/v0.10.3.rst b/docs/sphinx/source/whatsnew/v0.10.3.rst index 007eb8d34b..63f7b90b84 100644 --- a/docs/sphinx/source/whatsnew/v0.10.3.rst +++ b/docs/sphinx/source/whatsnew/v0.10.3.rst @@ -9,6 +9,9 @@ Enhancements ~~~~~~~~~~~~ * Added the continuous Perez-Driesse transposition model. :py:func:`pvlib.irradiance.perez_driesse` (:issue:`1841`, :pull:`1876`) +* Added a reverse transposition algorithm using the Perez-Driesse model. + :py:func:`pvlib.irradiance.ghi_from_poa_driesse_2023` + (:issue:`1901`, :pull:`1907`) * :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance` and :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance_poa` now include shaded fraction in returned variables. (:pull:`1871`) @@ -27,8 +30,10 @@ Documentation ~~~~~~~~~~~~~ * Create :ref:`weatherdata` User's Guide page. (:pull:`1754`) * Fixed a plotting issue in the IV curve gallery example (:pull:`1895`) +* Added two examples to demonstrate reverse transposition (:pull:`1907`) * Fixed `detect_clearsky` example in `clearsky.rst` (:issue:`1914`) + Requirements ~~~~~~~~~~~~ * Minimum version of scipy advanced from 1.4.0 to 1.5.0. (:issue:`1918`, :pull:`1919`)

[ { "components": [ { "doc": "Transposition function that includes decomposition of GHI using the\ncontinuous Erbs-Driesse model.\n\nHelper function for ghi_from_poa_driesse_2023.", "lines": [ 1448, 1471 ], "name": "_poa_from_ghi", "signature": "de...

[ "pvlib/tests/test_irradiance.py::test_ghi_from_poa_driesse" ]

[ "pvlib/tests/test_irradiance.py::test_get_extra_radiation[asce-300-1383.636203]", "pvlib/tests/test_irradiance.py::test_get_extra_radiation[asce-300.0-1383.636203]", "pvlib/tests/test_irradiance.py::test_get_extra_radiation[asce-testval2-1383.636203]", "pvlib/tests/test_irradiance.py::test_get_extra_radiation...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Implement reverse transposition using Perez-Driesse forward transposition  - [x] Closes #1901 - [x] I am familiar with the [contributing guidelines](https://pvlib-python.readthedocs.io/en/latest/contributing.html) - [x] Tests added - [x] Updates entries in [`docs/sphinx/source/reference`](https://github.com/pvlib/pvlib-python/blob/main/docs/sphinx/source/reference) for API changes. - [x] Adds description and name entries in the appropriate "what's new" file in [`docs/sphinx/source/whatsnew`](https://github.com/pvlib/pvlib-python/tree/main/docs/sphinx/source/whatsnew) for all changes. Includes link to the GitHub Issue with `` :issue:`num` `` or this Pull Request with `` :pull:`num` ``. Includes contributor name and/or GitHub username (link with `` :ghuser:`user` ``). - [x] New code is fully documented. Includes [numpydoc](https://numpydoc.readthedocs.io/en/latest/format.html) compliant docstrings, examples, and comments where necessary. - [x] Pull request is nearly complete and ready for detailed review. - [x] Maintainer: Appropriate GitHub Labels (including `remote-data`) and Milestone are assigned to the Pull Request and linked Issue. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pvlib/irradiance.py] (definition of _poa_from_ghi:) def _poa_from_ghi(surface_tilt, surface_azimuth, solar_zenith, solar_azimuth, ghi, dni_extra, airmass, albedo): """Transposition function that includes decomposition of GHI using the continuous Erbs-Driesse model. Helper function for ghi_from_poa_driesse_2023.""" (definition of _ghi_from_poa:) def _ghi_from_poa(surface_tilt, surface_azimuth, solar_zenith, solar_azimuth, poa_global, dni_extra, airmass, albedo, xtol=0.01): """Reverse transposition function that uses the scalar bisection from scipy. Helper function for ghi_from_poa_driesse_2023.""" (definition of _ghi_from_poa.poa_error:) def poa_error(ghi): (definition of ghi_from_poa_driesse_2023:) def ghi_from_poa_driesse_2023(surface_tilt, surface_azimuth, solar_zenith, solar_azimuth, poa_global, dni_extra=None, airmass=None, albedo=0.25, xtol=0.01, full_output=False): """Estimate global horizontal irradiance (GHI) from global plane-of-array (POA) irradiance. This reverse transposition algorithm uses a bisection search together with the continuous Perez-Driesse transposition and continuous Erbs-Driesse decomposition models, as described in [1]_. Parameters ---------- surface_tilt : numeric Panel tilt from horizontal. [degree] surface_azimuth : numeric Panel azimuth from north. [degree] solar_zenith : numeric Solar zenith angle. [degree] solar_azimuth : numeric Solar azimuth angle. [degree] poa_global : numeric Plane-of-array global irradiance, aka global tilted irradiance. [W/m^2] dni_extra : None or numeric, default None Extraterrestrial direct normal irradiance. [W/m^2] airmass : None or numeric, default None Relative airmass (not adjusted for pressure). [unitless] albedo : numeric, default 0.25 Ground surface albedo. [unitless] xtol : numeric, default 0.01 Convergence criterion. The estimated GHI will be within xtol of the true value. [W/m^2] full_output : boolean, default False If full_output is False, only ghi is returned, otherwise the return value is (ghi, converged, niter). (see Returns section for details). Returns ------- ghi : numeric Estimated GHI. [W/m^2] converged : boolean, optional Present if full_output=True. Indicates which elements converged successfully. niter : integer, optional Present if full_output=True. Indicates how many bisection iterations were done. Notes ----- Since :py:func:`scipy.optimize.bisect` is not vectorized, high-resolution time series can be quite slow to process. References ---------- .. [1] Driesse, A., Jensen, A., Perez, R., 2024. A Continuous form of the Perez diffuse sky model for forward and reverse transposition. Solar Energy vol. 267. :doi:`10.1016/j.solener.2023.112093` See also -------- perez_driesse erbs_driesse gti_dirint""" [end of new definitions in pvlib/irradiance.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Demonstrate reverse transposition using Perez-Driesse forward transposition **Is your feature request related to a problem? Please describe.** One of the motivations for developing the Perez-Driesse transposition #1841 was to facilitate and improve reverse transposition. So it would be great to see this in action. **Describe the solution you'd like** Add reverse transposition function(s). **Describe alternatives you've considered** Add reverse transposition as an example only. **References** _A. Driesse, A. Jensen, R. Perez, A Continuous Form of the Perez Diffuse Sky Model for Forward and Reverse Transposition, Solar Energy Journal._ https://doi.org/10.1016/j.solener.2023.112093 ---------- -------------------- </issues>

d53f97e984bfdd268aa92f8bf482ced0edda0110

google-deepmind__optax-629

629

google-deepmind/optax

null

83360c55f5afe0959b996e8653a9e2c85a310821

2023-11-10T22:49:29Z

diff --git a/docs/api.rst b/docs/api.rst index 39b129d0b..8552cd33a 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -619,6 +619,7 @@ Schedules .. autofunction:: piecewise_constant_schedule .. autofunction:: piecewise_interpolate_schedule .. autofunction:: polynomial_schedule +.. autofunction:: optax.contrib.reduce_on_plateau .. autofunction:: sgdr_schedule .. autofunction:: warmup_cosine_decay_schedule .. autofunction:: warmup_exponential_decay_schedule diff --git a/optax/contrib/__init__.py b/optax/contrib/__init__.py index ce85ff06b..ebb850148 100644 --- a/optax/contrib/__init__.py +++ b/optax/contrib/__init__.py @@ -25,6 +25,8 @@ from optax.contrib.privacy import differentially_private_aggregate from optax.contrib.privacy import DifferentiallyPrivateAggregateState from optax.contrib.privacy import dpsgd +from optax.contrib.reduce_on_plateau import reduce_on_plateau +from optax.contrib.reduce_on_plateau import ReduceLROnPlateauState from optax.contrib.prodigy import prodigy from optax.contrib.prodigy import ProdigyState from optax.contrib.sam import normalize diff --git a/optax/contrib/reduce_on_plateau.py b/optax/contrib/reduce_on_plateau.py new file mode 100644 index 000000000..218f03f0a --- /dev/null +++ b/optax/contrib/reduce_on_plateau.py @@ -0,0 +1,141 @@ +# Copyright 2023 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Reduce Learning Rate on Plateau callback. + +This callback monitors a quantity and if no improvement is seen for a 'patience' +number of epochs, the learning rate is reduced by a factor of 'reduce_factor'. +Optionally, a cooldown period can be specified during which the learning rate +will not be reduced. +""" +from typing import NamedTuple + +import jax +import jax.numpy as jnp + +from optax._src import base + + +class ReduceLROnPlateauState(NamedTuple): + """State for the ReduceLROnPlateau callback.""" + reduce_factor: float + patience: int + min_improvement: float + best_loss: float + plateau_count: int + lr: float + cooldown_counter: int + cooldown: int + + +def reduce_on_plateau( + reduce_factor: float, + patience: int, + min_improvement: float, + cooldown: int +) -> base.GradientTransformationExtraArgs: + """ Reduce learning rate when a metric has stopped improving. + + Models often benefit from reducing the learning once learning stagnates. + his scheduler reads a metrics quantity and if no improvement is seen for + a ‘patience’ number of epochs, the learning rate is reduced. + + Args: + + reduce_factor: Factor by which the learning rate will be reduced. + new_lr = lr * factor. + patience: Number of iterations with no improvement after which learning + rate will be reduced. + min_improvement: Threshold for measuring the new optimum, to only focus on + significant changes. + cooldown: Number of iterations to wait before resuming normal operation + after lr has been reduced. + """ + + + def init_fn(params): + del params + return ReduceLROnPlateauState(patience=patience, + reduce_factor=reduce_factor, + min_improvement=min_improvement, + cooldown=cooldown, + cooldown_counter=0, + plateau_count=0, + best_loss=float("inf"), + lr=1, + ) + + def update_fn( + updates, + state, + params=None, + extra_args=None, + ): + del params + if extra_args is None: + extra_args = {} + current_loss = extra_args.get("loss") + + # Check if the current loss is the best so far + best_loss = state.best_loss + # Update plateau count and check if plateaued + has_improved = jnp.where( + (current_loss / best_loss - 1) < -state.min_improvement, 1, 0 + ) + new_best_loss = jnp.where(has_improved, current_loss, best_loss) + + curr_plateau_count = jnp.where(has_improved, 0, state.plateau_count + 1) + + + # We're in cooldown, so reduce the counter and ignore any bad epochs + def in_cooldown(): + new_plateau_count = 0 + new_lr = state.lr + new_cooldown_counter = state.cooldown_counter - 1 + return new_plateau_count, new_lr, new_cooldown_counter + + # We're not in cooldown, so update the plateau count and lr as usual + def not_in_cooldown(): + new_plateau_count = jnp.where( + curr_plateau_count == state.patience, 0, curr_plateau_count + ) + new_lr = jnp.where( + curr_plateau_count == state.patience, + state.lr * state.reduce_factor, + state.lr, + ) + new_cooldown_counter = jnp.where( + curr_plateau_count == state.patience, state.cooldown, 0 + ) + return new_plateau_count, new_lr, new_cooldown_counter + + new_plateau_count, new_lr, new_cooldown_counter = jax.lax.cond( + state.cooldown_counter > 0, in_cooldown, not_in_cooldown) + + updates = jax.tree_util.tree_map(lambda g: new_lr * g, updates) + + new_state = ReduceLROnPlateauState( + patience=state.patience, + reduce_factor=state.reduce_factor, + min_improvement=state.min_improvement, + plateau_count=new_plateau_count, + best_loss=new_best_loss, + lr=new_lr, + cooldown_counter=new_cooldown_counter, + cooldown=state.cooldown, + ) + return updates, new_state + + + return base.GradientTransformationExtraArgs(init_fn, update_fn)

diff --git a/optax/contrib/reduce_on_plateau_test.py b/optax/contrib/reduce_on_plateau_test.py new file mode 100644 index 000000000..97980ceb3 --- /dev/null +++ b/optax/contrib/reduce_on_plateau_test.py @@ -0,0 +1,110 @@ +# Copyright 2023 DeepMind Technologies Limited. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Tests for `reduce_on_plateau.py`.""" + +from absl.testing import absltest + +from optax.contrib.reduce_on_plateau import ReduceLROnPlateauState, reduce_on_plateau + + +class ReduceLROnPlateauTest(absltest.TestCase): + def test_learning_rate_reduced_after_cooldown_period_is_over(self): + """Test that learning rate is reduced again after cooldown period is over. + """ + # Define a state where cooldown_counter is zero + state = ReduceLROnPlateauState( + reduce_factor=0.5, + patience=5, + min_improvement=1e-4, + best_loss=0.1, + ## + plateau_count=4, + ## + lr=0.01, + cooldown=5, + cooldown_counter=0, + ) + # Define a dummy update and extra_args + updates = {'params': 1} + extra_args = {'loss': 0.15} + # Apply the transformation to the updates and state + transform = reduce_on_plateau( + reduce_factor=0.5, patience=5, min_improvement=1e-4, cooldown=5) + _, new_state = transform.update( + updates=updates, state=state, extra_args=extra_args) + # Check that learning rate is reduced + assert new_state.lr == 0.005 + assert new_state.plateau_count == 0 + assert new_state.cooldown_counter == 5 + _, new_state = transform.update( + updates=updates, state=new_state, extra_args=extra_args) + assert new_state.lr == 0.005 + assert new_state.plateau_count == 0 + assert new_state.cooldown_counter == 4 + + + def test_learning_rate_is_not_reduced(self): + """Test that plateau count resets after a new best loss is found.""" + state = ReduceLROnPlateauState( + reduce_factor=0.5, + patience=5, + min_improvement=1e-4, + best_loss=0.1, + plateau_count=3, + lr=0.01, + cooldown_counter=0, + cooldown=5, + ) + # Define a dummy update and extra_args + updates = {'params': 1} + extra_args = {'loss': 0.01} + # Apply the transformation to the updates and state + transform = reduce_on_plateau( + reduce_factor=0.5, patience=5, min_improvement=1e-4, cooldown=5) + _, new_state = transform.update( + updates=updates, state=state, extra_args=extra_args) + # Check that plateau count resets + assert new_state.plateau_count == 0 + assert new_state.best_loss == 0.01 + + + def test_learning_rate_not_reduced_during_cooldown(self): + """Test that learning rate is not reduced during cooldown.""" + # Define a state where cooldown_counter is positive + state = ReduceLROnPlateauState( + reduce_factor=0.5, + patience=5, + min_improvement=1e-4, + best_loss=0.1, + plateau_count=4, + lr=0.01, + cooldown=5, + cooldown_counter=3, + ) + # Define a dummy update and extra_args + updates = {'params': 1} + extra_args = {'loss': 0.15} + # Apply the transformation to the updates and state + transform = reduce_on_plateau( + reduce_factor=0.5, patience=5, min_improvement=1e-4, cooldown=5) + _, new_state = transform.update( + updates=updates, state=state, extra_args=extra_args) + # Check that learning rate is not reduced + assert new_state.lr == 0.01 + + +if __name__ == '__main__': + absltest.main() + \ No newline at end of file

diff --git a/docs/api.rst b/docs/api.rst index 39b129d0b..8552cd33a 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -619,6 +619,7 @@ Schedules .. autofunction:: piecewise_constant_schedule .. autofunction:: piecewise_interpolate_schedule .. autofunction:: polynomial_schedule +.. autofunction:: optax.contrib.reduce_on_plateau .. autofunction:: sgdr_schedule .. autofunction:: warmup_cosine_decay_schedule .. autofunction:: warmup_exponential_decay_schedule

[ { "components": [ { "doc": "State for the ReduceLROnPlateau callback.", "lines": [ 30, 39 ], "name": "ReduceLROnPlateauState", "signature": "class ReduceLROnPlateauState(NamedTuple):", "type": "class" }, { "doc": "Redu...

[ "optax/contrib/reduce_on_plateau_test.py::ReduceLROnPlateauTest::test_learning_rate_is_not_reduced", "optax/contrib/reduce_on_plateau_test.py::ReduceLROnPlateauTest::test_learning_rate_not_reduced_during_cooldown", "optax/contrib/reduce_on_plateau_test.py::ReduceLROnPlateauTest::test_learning_rate_reduced_after...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add reduce_on_plateau LR scheduler to contrib directory. Following pull request #505 and issue #221 with @mtthss suggestions on changing where the scheduler is located (contrib) and using GradientTransformationExtraArgs API. Let me know if there's anything else that needs to be done to merge this. Cheers. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in optax/contrib/reduce_on_plateau.py] (definition of ReduceLROnPlateauState:) class ReduceLROnPlateauState(NamedTuple): """State for the ReduceLROnPlateau callback.""" (definition of reduce_on_plateau:) def reduce_on_plateau( reduce_factor: float, patience: int, min_improvement: float, cooldown: int ) -> base.GradientTransformationExtraArgs: """Reduce learning rate when a metric has stopped improving. Models often benefit from reducing the learning once learning stagnates. his scheduler reads a metrics quantity and if no improvement is seen for a ‘patience’ number of epochs, the learning rate is reduced. Args: reduce_factor: Factor by which the learning rate will be reduced. new_lr = lr * factor. patience: Number of iterations with no improvement after which learning rate will be reduced. min_improvement: Threshold for measuring the new optimum, to only focus on significant changes. cooldown: Number of iterations to wait before resuming normal operation after lr has been reduced.""" (definition of reduce_on_plateau.init_fn:) def init_fn(params): (definition of reduce_on_plateau.update_fn:) def update_fn( updates, state, params=None, extra_args=None, ): (definition of reduce_on_plateau.update_fn.in_cooldown:) def in_cooldown(): (definition of reduce_on_plateau.update_fn.not_in_cooldown:) def not_in_cooldown(): [end of new definitions in optax/contrib/reduce_on_plateau.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

1e08bccf195ac54e7d9d766eb5e69345bf0e3230

tobymao__sqlglot-2531

2,531

tobymao/sqlglot

null

08d5d779c79736859471d52e4acf82ad77f16483

2023-11-08T20:42:53Z

diff --git a/sqlglot/dialects/hive.py b/sqlglot/dialects/hive.py index 4f18e75a27..b5b02f3e46 100644 --- a/sqlglot/dialects/hive.py +++ b/sqlglot/dialects/hive.py @@ -242,10 +242,10 @@ class Tokenizer(tokens.Tokenizer): "ADD JAR": TokenType.COMMAND, "ADD JARS": TokenType.COMMAND, "MSCK REPAIR": TokenType.COMMAND, - "REFRESH": TokenType.COMMAND, - "WITH SERDEPROPERTIES": TokenType.SERDE_PROPERTIES, + "REFRESH": TokenType.REFRESH, "TIMESTAMP AS OF": TokenType.TIMESTAMP_SNAPSHOT, "VERSION AS OF": TokenType.VERSION_SNAPSHOT, + "WITH SERDEPROPERTIES": TokenType.SERDE_PROPERTIES, } NUMERIC_LITERALS = { diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index 161fecd39f..cc4bf3c153 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -1021,6 +1021,10 @@ class Uncache(Expression): arg_types = {"this": True, "exists": False} +class Refresh(Expression): + pass + + class DDL(Expression): @property def ctes(self): diff --git a/sqlglot/generator.py b/sqlglot/generator.py index 21cb70bfa9..b89c30ad9c 100644 --- a/sqlglot/generator.py +++ b/sqlglot/generator.py @@ -3030,6 +3030,11 @@ def forin_sql(self, expression: exp.ForIn) -> str: expression_sql = self.sql(expression, "expression") return f"FOR {this} DO {expression_sql}" + def refresh_sql(self, expression: exp.Refresh) -> str: + this = self.sql(expression, "this") + table = "" if isinstance(expression.this, exp.Literal) else "TABLE " + return f"REFRESH {table}{this}" + def _simplify_unless_literal(self, expression: E) -> E: if not isinstance(expression, exp.Literal): from sqlglot.optimizer.simplify import simplify diff --git a/sqlglot/parser.py b/sqlglot/parser.py index c4d3f62b4b..ba25910381 100644 --- a/sqlglot/parser.py +++ b/sqlglot/parser.py @@ -302,6 +302,7 @@ class Parser(metaclass=_Parser): TokenType.RANGE, TokenType.RECURSIVE, TokenType.REFERENCES, + TokenType.REFRESH, TokenType.RIGHT, TokenType.ROW, TokenType.ROWS, @@ -563,6 +564,7 @@ class Parser(metaclass=_Parser): TokenType.MERGE: lambda self: self._parse_merge(), TokenType.PIVOT: lambda self: self._parse_simplified_pivot(), TokenType.PRAGMA: lambda self: self.expression(exp.Pragma, this=self._parse_expression()), + TokenType.REFRESH: lambda self: self._parse_refresh(), TokenType.ROLLBACK: lambda self: self._parse_commit_or_rollback(), TokenType.SET: lambda self: self._parse_set(), TokenType.UNCACHE: lambda self: self._parse_uncache(), @@ -5050,6 +5052,10 @@ def _parse_commit_or_rollback(self) -> exp.Commit | exp.Rollback: return self.expression(exp.Commit, chain=chain) + def _parse_refresh(self) -> exp.Refresh: + self._match(TokenType.TABLE) + return self.expression(exp.Refresh, this=self._parse_string() or self._parse_table()) + def _parse_add_column(self) -> t.Optional[exp.Expression]: if not self._match_text_seq("ADD"): return None diff --git a/sqlglot/tokens.py b/sqlglot/tokens.py index 270e6301c6..e55579376e 100644 --- a/sqlglot/tokens.py +++ b/sqlglot/tokens.py @@ -297,6 +297,7 @@ class TokenType(AutoName): QUOTE = auto() RANGE = auto() RECURSIVE = auto() + REFRESH = auto() REPLACE = auto() RETURNING = auto() REFERENCES = auto()

diff --git a/tests/dialects/test_spark.py b/tests/dialects/test_spark.py index 841a005365..97427f234b 100644 --- a/tests/dialects/test_spark.py +++ b/tests/dialects/test_spark.py @@ -230,11 +230,18 @@ def test_spark(self): self.assertIsInstance(expr.args.get("ignore_nulls"), exp.Boolean) self.assertEqual(expr.sql(dialect="spark"), "ANY_VALUE(col, TRUE)") + self.assertEqual( + parse_one("REFRESH TABLE t", read="spark").assert_is(exp.Refresh).sql(dialect="spark"), + "REFRESH TABLE t", + ) + + self.validate_identity("REFRESH 'hdfs://path/to/table'") + self.validate_identity("REFRESH TABLE tempDB.view1") self.validate_identity("SELECT CASE WHEN a = NULL THEN 1 ELSE 2 END") self.validate_identity("SELECT * FROM t1 SEMI JOIN t2 ON t1.x = t2.x") self.validate_identity("SELECT TRANSFORM(ARRAY(1, 2, 3), x -> x + 1)") self.validate_identity("SELECT TRANSFORM(ARRAY(1, 2, 3), (x, i) -> x + i)") - self.validate_identity("REFRESH table a.b.c") + self.validate_identity("REFRESH TABLE a.b.c") self.validate_identity("INTERVAL -86 days") self.validate_identity("SELECT UNIX_TIMESTAMP()") self.validate_identity("TRIM(' SparkSQL ')")

[]

[ "tests/dialects/test_spark.py::TestSpark::test_spark" ]

[ "tests/dialects/test_spark.py::TestSpark::test_bool_or", "tests/dialects/test_spark.py::TestSpark::test_current_user", "tests/dialects/test_spark.py::TestSpark::test_ddl", "tests/dialects/test_spark.py::TestSpark::test_explode_to_unnest", "tests/dialects/test_spark.py::TestSpark::test_hint", "tests/dialec...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat(hive): add fine-grained parsing for REFRESH Fixes #2530 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> `REFRESH TABLE table.name` doesn't seem to parse as expected Read: Spark **Fully reproducible code snippet** ```python import sqlglot sqlglot.parse_one("REFRESH TABLE table.name", read="spark") ``` ``` > (COMMAND this: REFRESH, expression: (LITERAL this: TABLE table.name, is_string: True)) ``` I'd expect something like ``` > (COMMAND this: REFRESH TABLE, expression: (TABLE this: (IDENTIFIER this: name, quoted: False), db: (IDENTIFIER this: table, quoted: False)))) ``` **Official Documentation** For the first change (REFRESH vs REFRESH TABLE), seems like they are distinct statements in the dialect: - [REFRESH](https://spark.apache.org/docs/latest/sql-ref-syntax-aux-cache-refresh.html) - [REFRESH TABLE](https://spark.apache.org/docs/latest/sql-ref-syntax-aux-cache-refresh-table.html) ---------- -------------------- </issues>

ceb42fabad60312699e4b15936aeebac00e22e4d

huggingface__datasets-6391

6,391

huggingface/datasets

null

27d1fe52857c6a25a29cac63a296405136b2797c

2023-11-08T17:31:59Z

diff --git a/docs/source/image_dataset.mdx b/docs/source/image_dataset.mdx index 030406f6a46..8ec6d867b1f 100644 --- a/docs/source/image_dataset.mdx +++ b/docs/source/image_dataset.mdx @@ -148,6 +148,46 @@ Upload your dataset with [`~datasets.DatasetDict.push_to_hub`]: >>> dataset.push_to_hub("stevhliu/my-image-captioning-dataset") ``` +## WebDataset + +The [WebDataset](https://github.com/webdataset/webdataset) format is based on TAR archives and is suitable for big image datasets. +Indeed you can group your images in TAR archives (e.g. 1GB of images per TAR archive) and have thousands of TAR archives: + +``` +folder/train/00000.tar +folder/train/00001.tar +folder/train/00002.tar +... +``` + +In the archives, each example is made of files sharing the same prefix: + +``` +e39871fd9fd74f55.jpg +e39871fd9fd74f55.json +f18b91585c4d3f3e.jpg +f18b91585c4d3f3e.json +ede6e66b2fb59aab.jpg +ede6e66b2fb59aab.json +ed600d57fcee4f94.jpg +ed600d57fcee4f94.json +... +``` + +You can put your images labels/captions/bounding boxes using JSON or text files for example. + +For more details on the WebDataset format and the python library, please check the [WebDataset documentation](https://webdataset.github.io/webdataset). + +Load your WebDataset and it will create on column per file suffix (here "jpg" and "json"): + +```python +>>> from datasets import load_dataset + +>>> dataset = load_dataset("webdataset", data_dir="/path/to/folder", split="train") +>>> dataset[0]["json"] +{"bbox": [[302.0, 109.0, 73.0, 52.0]], "categories": [0]} +``` + ## Loading script Write a dataset loading script to share a dataset. It defines a dataset's splits and configurations, and handles downloading and generating a dataset. The script is located in the same folder or repository as the dataset and should have the same name. diff --git a/docs/source/image_load.mdx b/docs/source/image_load.mdx index 2f09f227784..b150bd04e73 100644 --- a/docs/source/image_load.mdx +++ b/docs/source/image_load.mdx @@ -1,6 +1,6 @@ # Load image data -Image datasets are loaded from the `image` column, which contains a PIL object. +Image datasets have [`Image`] type columns, which contain PIL objects. <Tip> @@ -8,7 +8,7 @@ To work with image datasets, you need to have the `vision` dependency installed. </Tip> -When you load an image dataset and call the `image` column, the [`Image`] feature automatically decodes the PIL object into an image: +When you load an image dataset and call the image column, the images are decoded as PIL Images: ```py >>> from datasets import load_dataset, Image @@ -93,3 +93,16 @@ To ignore the information in the metadata file, set `drop_labels=False` in [`loa For more information about creating your own `ImageFolder` dataset, take a look at the [Create an image dataset](./image_dataset) guide. </Tip> + +## WebDataset + +The [WebDataset](https://github.com/webdataset/webdataset) format is based on a folder of TAR archives and is suitable for big image datasets. +Because of their size, WebDatasets are generally loaded in streaming mode (using `streaming=True`). + +You can load a WebDataset like this: + +```python +>>> from datasets import load_dataset + +>>> dataset = load_dataset("webdataset", data_dir="/path/to/folder", streaming=True) +``` diff --git a/docs/source/loading.mdx b/docs/source/loading.mdx index 7ca48559dc6..aa907ac1774 100644 --- a/docs/source/loading.mdx +++ b/docs/source/loading.mdx @@ -224,6 +224,31 @@ For more details, check out the [how to load tabular datasets from SQL databases </Tip> +### WebDataset + +The [WebDataset](https://github.com/webdataset/webdataset) format is based on TAR archives and is suitable for big image datasets. +Because of their size, WebDatasets are generally loaded in streaming mode (using `streaming=True`). + +You can load a WebDataset like this: + +```python +>>> from datasets import load_dataset +>>> +>>> path = "path/to/train/*.tar" +>>> dataset = load_dataset("webdataset", data_files={"train": path}, split="train", streaming=True) +``` + +To load remote WebDatasets via HTTP, pass the URLs instead: + +```python +>>> from datasets import load_dataset +>>> +>>> base_url = "https://huggingface.co/datasets/lhoestq/small-publaynet-wds/resolve/main/publaynet-train-{i:06d}.tar" +>>> urls = [base_url.format(i=i) for i in range(4)] +>>> dataset = load_dataset("webdataset", data_files={"train": urls}, split="train", streaming=True) +``` + + ## Multiprocessing When a dataset is made of several files (that we call "shards"), it is possible to significantly speed up the dataset downloading and preparation step. diff --git a/docs/source/package_reference/loading_methods.mdx b/docs/source/package_reference/loading_methods.mdx index d91714cb41c..6401708e762 100644 --- a/docs/source/package_reference/loading_methods.mdx +++ b/docs/source/package_reference/loading_methods.mdx @@ -96,3 +96,7 @@ load_dataset("csv", data_dir="path/to/data/dir", sep="\t") [[autodoc]] datasets.packaged_modules.audiofolder.AudioFolderConfig [[autodoc]] datasets.packaged_modules.audiofolder.AudioFolder + +### WebDataset + +[[autodoc]] datasets.packaged_modules.webdataset.WebDataset diff --git a/src/datasets/config.py b/src/datasets/config.py index 3e1f20475ac..6197144a5ba 100644 --- a/src/datasets/config.py +++ b/src/datasets/config.py @@ -141,7 +141,6 @@ LZ4_AVAILABLE = importlib.util.find_spec("lz4") is not None PY7ZR_AVAILABLE = importlib.util.find_spec("py7zr") is not None - # Cache location DEFAULT_XDG_CACHE_HOME = "~/.cache" XDG_CACHE_HOME = os.getenv("XDG_CACHE_HOME", DEFAULT_XDG_CACHE_HOME) diff --git a/src/datasets/packaged_modules/__init__.py b/src/datasets/packaged_modules/__init__.py index dc9409040b0..2acccc37880 100644 --- a/src/datasets/packaged_modules/__init__.py +++ b/src/datasets/packaged_modules/__init__.py @@ -12,6 +12,7 @@ from .parquet import parquet from .sql import sql # noqa F401 from .text import text +from .webdataset import webdataset def _hash_python_lines(lines: List[str]) -> str: @@ -37,6 +38,7 @@ def _hash_python_lines(lines: List[str]) -> str: "text": (text.__name__, _hash_python_lines(inspect.getsource(text).splitlines())), "imagefolder": (imagefolder.__name__, _hash_python_lines(inspect.getsource(imagefolder).splitlines())), "audiofolder": (audiofolder.__name__, _hash_python_lines(inspect.getsource(audiofolder).splitlines())), + "webdataset": (webdataset.__name__, _hash_python_lines(inspect.getsource(webdataset).splitlines())), } # Used to infer the module to use based on the data files extensions @@ -48,6 +50,7 @@ def _hash_python_lines(lines: List[str]) -> str: ".parquet": ("parquet", {}), ".arrow": ("arrow", {}), ".txt": ("text", {}), + ".tar": ("webdataset", {}), } _EXTENSION_TO_MODULE.update({ext: ("imagefolder", {}) for ext in imagefolder.ImageFolder.EXTENSIONS}) _EXTENSION_TO_MODULE.update({ext.upper(): ("imagefolder", {}) for ext in imagefolder.ImageFolder.EXTENSIONS}) diff --git a/src/datasets/packaged_modules/webdataset/__init__.py b/src/datasets/packaged_modules/webdataset/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/src/datasets/packaged_modules/webdataset/_tenbin.py b/src/datasets/packaged_modules/webdataset/_tenbin.py new file mode 100644 index 00000000000..cd8c054842e --- /dev/null +++ b/src/datasets/packaged_modules/webdataset/_tenbin.py @@ -0,0 +1,285 @@ +# +# Copyright (c) 2017-2021 NVIDIA CORPORATION. All rights reserved. +# This file coems from the WebDataset library. +# See the LICENSE file for licensing terms (BSD-style). +# + +""" +Binary tensor encodings for PyTorch and NumPy. + +This defines efficient binary encodings for tensors. The format is 8 byte +aligned and can be used directly for computations when transmitted, say, +via RDMA. The format is supported by WebDataset with the `.ten` filename +extension. It is also used by Tensorcom, Tensorcom RDMA, and can be used +for fast tensor storage with LMDB and in disk files (which can be memory +mapped) + +Data is encoded as a series of chunks: + +- magic number (int64) +- length in bytes (int64) +- bytes (multiple of 64 bytes long) + +Arrays are a header chunk followed by a data chunk. +Header chunks have the following structure: + +- dtype (int64) +- 8 byte array name +- ndim (int64) +- dim[0] +- dim[1] +- ... +""" + +import struct +import sys + +import numpy as np + + +def bytelen(a): + """Determine the length of a in bytes.""" + if hasattr(a, "nbytes"): + return a.nbytes + elif isinstance(a, (bytearray, bytes)): + return len(a) + else: + raise ValueError(a, "cannot determine nbytes") + + +def bytedata(a): + """Return a the raw data corresponding to a.""" + if isinstance(a, (bytearray, bytes, memoryview)): + return a + elif hasattr(a, "data"): + return a.data + else: + raise ValueError(a, "cannot return bytedata") + + +# tables for converting between long/short NumPy dtypes + +long_to_short = """ +float16 f2 +float32 f4 +float64 f8 +int8 i1 +int16 i2 +int32 i4 +int64 i8 +uint8 u1 +uint16 u2 +unit32 u4 +uint64 u8 +""".strip() +long_to_short = [x.split() for x in long_to_short.split("\n")] +long_to_short = {x[0]: x[1] for x in long_to_short} +short_to_long = {v: k for k, v in long_to_short.items()} + + +def check_acceptable_input_type(data, allow64): + """Check that the data has an acceptable type for tensor encoding. + + :param data: array + :param allow64: allow 64 bit types + """ + for a in data: + if a.dtype.name not in long_to_short: + raise ValueError("unsupported dataypte") + if not allow64 and a.dtype.name not in ["float64", "int64", "uint64"]: + raise ValueError("64 bit datatypes not allowed unless explicitly enabled") + + +def str64(s): + """Convert a string to an int64.""" + s = s + "\0" * (8 - len(s)) + s = s.encode("ascii") + return struct.unpack("@q", s)[0] + + +def unstr64(i): + """Convert an int64 to a string.""" + b = struct.pack("@q", i) + return b.decode("ascii").strip("\0") + + +def check_infos(data, infos, required_infos=None): + """Verify the info strings.""" + if required_infos is False or required_infos is None: + return data + if required_infos is True: + return data, infos + if not isinstance(required_infos, (tuple, list)): + raise ValueError("required_infos must be tuple or list") + for required, actual in zip(required_infos, infos): + raise ValueError(f"actual info {actual} doesn't match required info {required}") + return data + + +def encode_header(a, info=""): + """Encode an array header as a byte array.""" + if a.ndim >= 10: + raise ValueError("too many dimensions") + if a.nbytes != np.prod(a.shape) * a.itemsize: + raise ValueError("mismatch between size and shape") + if a.dtype.name not in long_to_short: + raise ValueError("unsupported array type") + header = [str64(long_to_short[a.dtype.name]), str64(info), len(a.shape)] + list(a.shape) + return bytedata(np.array(header, dtype="i8")) + + +def decode_header(h): + """Decode a byte array into an array header.""" + h = np.frombuffer(h, dtype="i8") + if unstr64(h[0]) not in short_to_long: + raise ValueError("unsupported array type") + dtype = np.dtype(short_to_long[unstr64(h[0])]) + info = unstr64(h[1]) + rank = int(h[2]) + shape = tuple(h[3 : 3 + rank]) + return shape, dtype, info + + +def encode_list(l, infos=None): # noqa: E741 + """Given a list of arrays, encode them into a list of byte arrays.""" + if infos is None: + infos = [""] + else: + if len(l) != len(infos): + raise ValueError(f"length of list {l} must muatch length of infos {infos}") + result = [] + for i, a in enumerate(l): + header = encode_header(a, infos[i % len(infos)]) + result += [header, bytedata(a)] + return result + + +def decode_list(l, infos=False): # noqa: E741 + """Given a list of byte arrays, decode them into arrays.""" + result = [] + infos0 = [] + for header, data in zip(l[::2], l[1::2]): + shape, dtype, info = decode_header(header) + a = np.frombuffer(data, dtype=dtype, count=np.prod(shape)).reshape(*shape) + result += [a] + infos0 += [info] + return check_infos(result, infos0, infos) + + +magic_str = "~TenBin~" +magic = str64(magic_str) +magic_bytes = unstr64(magic).encode("ascii") + + +def roundup(n, k=64): + """Round up to the next multiple of 64.""" + return k * ((n + k - 1) // k) + + +def encode_chunks(l): # noqa: E741 + """Encode a list of chunks into a single byte array, with lengths and magics..""" + size = sum(16 + roundup(b.nbytes) for b in l) + result = bytearray(size) + offset = 0 + for b in l: + result[offset : offset + 8] = magic_bytes + offset += 8 + result[offset : offset + 8] = struct.pack("@q", b.nbytes) + offset += 8 + result[offset : offset + bytelen(b)] = b + offset += roundup(bytelen(b)) + return result + + +def decode_chunks(buf): + """Decode a byte array into a list of chunks.""" + result = [] + offset = 0 + total = bytelen(buf) + while offset < total: + if magic_bytes != buf[offset : offset + 8]: + raise ValueError("magic bytes mismatch") + offset += 8 + nbytes = struct.unpack("@q", buf[offset : offset + 8])[0] + offset += 8 + b = buf[offset : offset + nbytes] + offset += roundup(nbytes) + result.append(b) + return result + + +def encode_buffer(l, infos=None): # noqa: E741 + """Encode a list of arrays into a single byte array.""" + if not isinstance(l, list): + raise ValueError("requires list") + return encode_chunks(encode_list(l, infos=infos)) + + +def decode_buffer(buf, infos=False): + """Decode a byte array into a list of arrays.""" + return decode_list(decode_chunks(buf), infos=infos) + + +def write_chunk(stream, buf): + """Write a byte chunk to the stream with magics, length, and padding.""" + nbytes = bytelen(buf) + stream.write(magic_bytes) + stream.write(struct.pack("@q", nbytes)) + stream.write(bytedata(buf)) + padding = roundup(nbytes) - nbytes + if padding > 0: + stream.write(b"\0" * padding) + + +def read_chunk(stream): + """Read a byte chunk from a stream with magics, length, and padding.""" + magic = stream.read(8) + if magic == b"": + return None + if magic != magic_bytes: + raise ValueError("magic number does not match") + nbytes = stream.read(8) + nbytes = struct.unpack("@q", nbytes)[0] + if nbytes < 0: + raise ValueError("negative nbytes") + data = stream.read(nbytes) + padding = roundup(nbytes) - nbytes + if padding > 0: + stream.read(padding) + return data + + +def write(stream, l, infos=None): # noqa: E741 + """Write a list of arrays to a stream, with magics, length, and padding.""" + for chunk in encode_list(l, infos=infos): + write_chunk(stream, chunk) + + +def read(stream, n=sys.maxsize, infos=False): + """Read a list of arrays from a stream, with magics, length, and padding.""" + chunks = [] + for _ in range(n): + header = read_chunk(stream) + if header is None: + break + data = read_chunk(stream) + if data is None: + raise ValueError("premature EOF") + chunks += [header, data] + return decode_list(chunks, infos=infos) + + +def save(fname, *args, infos=None, nocheck=False): + """Save a list of arrays to a file, with magics, length, and padding.""" + if not nocheck and not fname.endswith(".ten"): + raise ValueError("file name should end in .ten") + with open(fname, "wb") as stream: + write(stream, args, infos=infos) + + +def load(fname, infos=False, nocheck=False): + """Read a list of arrays from a file, with magics, length, and padding.""" + if not nocheck and not fname.endswith(".ten"): + raise ValueError("file name should end in .ten") + with open(fname, "rb") as stream: + return read(stream, infos=infos) diff --git a/src/datasets/packaged_modules/webdataset/webdataset.py b/src/datasets/packaged_modules/webdataset/webdataset.py new file mode 100644 index 00000000000..e44bf50857c --- /dev/null +++ b/src/datasets/packaged_modules/webdataset/webdataset.py @@ -0,0 +1,242 @@ +import io +import json +from itertools import islice +from typing import Any, Callable, Dict, List + +import numpy as np +import pyarrow as pa + +import datasets + + +logger = datasets.utils.logging.get_logger(__name__) + + +class WebDataset(datasets.GeneratorBasedBuilder): + DEFAULT_WRITER_BATCH_SIZE = 100 + IMAGE_EXTENSIONS: List[str] # definition at the bottom of the script + DECODERS: Dict[str, Callable[[Any], Any]] # definition at the bottom of the script + NUM_EXAMPLES_FOR_FEATURES_INFERENCE = 5 + + @classmethod + def _get_pipeline_from_tar(cls, tar_path, tar_iterator): + current_example = {} + for filename, f in tar_iterator: + if "." in filename: + example_key, field_name = filename.split(".", 1) + if current_example and current_example["__key__"] != example_key: + yield current_example + current_example = {} + current_example["__key__"] = example_key + current_example["__url__"] = tar_path + current_example[field_name.lower()] = f.read() + if field_name in cls.DECODERS: + current_example[field_name] = cls.DECODERS[field_name](current_example[field_name]) + if current_example: + yield current_example + + def _info(self) -> datasets.DatasetInfo: + return datasets.DatasetInfo() + + def _split_generators(self, dl_manager): + """We handle string, list and dicts in datafiles""" + # Download the data files + if not self.config.data_files: + raise ValueError(f"At least one data file must be specified, but got data_files={self.config.data_files}") + data_files = dl_manager.download(self.config.data_files) + if isinstance(data_files, (str, list, tuple)): + tar_paths = data_files + if isinstance(tar_paths, str): + tar_paths = [tar_paths] + tar_iterators = [dl_manager.iter_archive(tar_path) for tar_path in tar_paths] + splits = [ + datasets.SplitGenerator( + name=datasets.Split.TRAIN, gen_kwargs={"tar_paths": tar_paths, "tar_iterators": tar_iterators} + ) + ] + else: + splits = [] + for split_name, tar_paths in data_files.items(): + if isinstance(tar_paths, str): + tar_paths = [tar_paths] + tar_iterators = [dl_manager.iter_archive(tar_path) for tar_path in tar_paths] + splits.append( + datasets.SplitGenerator( + name=split_name, gen_kwargs={"tar_paths": tar_paths, "tar_iterators": tar_iterators} + ) + ) + + # Get one example to get the feature types + pipeline = self._get_pipeline_from_tar(tar_paths[0], tar_iterators[0]) + first_examples = list(islice(pipeline, self.NUM_EXAMPLES_FOR_FEATURES_INFERENCE)) + if any(example.keys() != first_examples[0].keys() for example in first_examples): + raise ValueError( + "The TAR archives of the dataset should be in WebDataset format, " + "but the files in the archive don't share the same prefix or the same types." + ) + inferred_arrow_schema = pa.Table.from_pylist(first_examples[:1]).schema + features = datasets.Features.from_arrow_schema(inferred_arrow_schema) + + # Set Image types + for field_name in first_examples[0]: + extension = field_name.rsplit(".", 1)[-1] + if extension in self.IMAGE_EXTENSIONS: + features[field_name] = datasets.Image() + self.info.features = features + + return splits + + def _generate_examples(self, tar_paths, tar_iterators): + image_field_names = [ + field_name for field_name, feature in self.info.features.items() if isinstance(feature, datasets.Image) + ] + for tar_idx, (tar_path, tar_iterator) in enumerate(zip(tar_paths, tar_iterators)): + for example_idx, example in enumerate(self._get_pipeline_from_tar(tar_path, tar_iterator)): + for field_name in image_field_names: + example[field_name] = {"path": example["__key__"] + "." + field_name, "bytes": example[field_name]} + yield f"{tar_idx}_{example_idx}", example + + +# Obtained with: +# ``` +# import PIL.Image +# IMAGE_EXTENSIONS = [] +# PIL.Image.init() +# for ext, format in PIL.Image.EXTENSION.items(): +# if format in PIL.Image.OPEN: +# IMAGE_EXTENSIONS.append(ext[1:]) +# ``` +# We intentionally do not run this code on launch because: +# (1) Pillow is an optional dependency, so importing Pillow in global namespace is not allowed +# (2) To ensure the list of supported extensions is deterministic +IMAGE_EXTENSIONS = [ + "blp", + "bmp", + "dib", + "bufr", + "cur", + "pcx", + "dcx", + "dds", + "ps", + "eps", + "fit", + "fits", + "fli", + "flc", + "ftc", + "ftu", + "gbr", + "gif", + "grib", + "h5", + "hdf", + "png", + "apng", + "jp2", + "j2k", + "jpc", + "jpf", + "jpx", + "j2c", + "icns", + "ico", + "im", + "iim", + "tif", + "tiff", + "jfif", + "jpe", + "jpg", + "jpeg", + "mpg", + "mpeg", + "msp", + "pcd", + "pxr", + "pbm", + "pgm", + "ppm", + "pnm", + "psd", + "bw", + "rgb", + "rgba", + "sgi", + "ras", + "tga", + "icb", + "vda", + "vst", + "webp", + "wmf", + "emf", + "xbm", + "xpm", +] +WebDataset.IMAGE_EXTENSIONS = IMAGE_EXTENSIONS + + +def text_loads(data: bytes): + return data.decode("utf-8") + + +def tenbin_loads(data: bytes): + from . import _tenbin + + return _tenbin.decode_buffer(data) + + +def msgpack_loads(data: bytes): + import msgpack + + return msgpack.unpackb(data) + + +def npy_loads(data: bytes): + import numpy.lib.format + + stream = io.BytesIO(data) + return numpy.lib.format.read_array(stream, allow_pickle=False) + + +def npz_loads(data: bytes): + return np.load(io.BytesIO(data), allow_pickle=False) + + +def cbor_loads(data: bytes): + import cbor + + return cbor.loads(data) + + +# Obtained by checking `decoders` in `webdataset.autodecode` +# and removing unsafe extension decoders. +# Removed Pickle decoders: +# - "pyd": lambda data: pickle.loads(data) +# - "pickle": lambda data: pickle.loads(data) +# Removed Torch decoders: +# - "pth": lambda data: torch_loads(data) +# Modified NumPy decoders to fix CVE-2019-6446 (add allow_pickle=False): +# - "npy": npy_loads, +# - "npz": lambda data: np.load(io.BytesIO(data)), +DECODERS = { + "txt": text_loads, + "text": text_loads, + "transcript": text_loads, + "cls": int, + "cls2": int, + "index": int, + "inx": int, + "id": int, + "json": json.loads, + "jsn": json.loads, + "ten": tenbin_loads, + "tb": tenbin_loads, + "mp": msgpack_loads, + "msg": msgpack_loads, + "npy": npy_loads, + "npz": npz_loads, + "cbor": cbor_loads, +} +WebDataset.DECODERS = DECODERS

diff --git a/tests/packaged_modules/test_webdataset.py b/tests/packaged_modules/test_webdataset.py new file mode 100644 index 00000000000..c9b032dfa51 --- /dev/null +++ b/tests/packaged_modules/test_webdataset.py @@ -0,0 +1,63 @@ +import tarfile + +import pytest + +from datasets import DownloadManager, Features, Image, Value +from datasets.packaged_modules.webdataset.webdataset import WebDataset + +from ..utils import require_pil + + +@pytest.fixture +def tar_file(tmp_path, image_file, text_file): + filename = tmp_path / "file.tar" + num_examples = 3 + with tarfile.open(str(filename), "w") as f: + for example_idx in range(num_examples): + f.add(text_file, f"{example_idx:05d}.txt") + f.add(image_file, f"{example_idx:05d}.jpg") + return str(filename) + + +@pytest.fixture +def bad_tar_file(tmp_path, image_file, text_file): + filename = tmp_path / "bad_file.tar" + with tarfile.open(str(filename), "w") as f: + f.add(image_file) + f.add(text_file) + return str(filename) + + +@require_pil +def test_webdataset(tar_file): + import PIL.Image + + data_files = {"train": [tar_file]} + webdataset = WebDataset(data_files=data_files) + split_generators = webdataset._split_generators(DownloadManager()) + assert webdataset.info.features == Features( + { + "__key__": Value("string"), + "__url__": Value("string"), + "txt": Value("string"), + "jpg": Image(), + } + ) + assert len(split_generators) == 1 + split_generator = split_generators[0] + assert split_generator.name == "train" + generator = webdataset._generate_examples(**split_generator.gen_kwargs) + _, examples = zip(*generator) + assert len(examples) == 3 + assert isinstance(examples[0]["txt"], str) + assert isinstance(examples[0]["jpg"], dict) # keep encoded to avoid unecessary copies + decoded = webdataset.info.features.decode_example(examples[0]) + assert isinstance(decoded["txt"], str) + assert isinstance(decoded["jpg"], PIL.Image.Image) + + +def test_webdataset_errors_on_bad_file(bad_tar_file): + data_files = {"train": [bad_tar_file]} + webdataset = WebDataset(data_files=data_files) + with pytest.raises(ValueError): + webdataset._split_generators(DownloadManager())

diff --git a/docs/source/image_dataset.mdx b/docs/source/image_dataset.mdx index 030406f6a46..8ec6d867b1f 100644 --- a/docs/source/image_dataset.mdx +++ b/docs/source/image_dataset.mdx @@ -148,6 +148,46 @@ Upload your dataset with [`~datasets.DatasetDict.push_to_hub`]: >>> dataset.push_to_hub("stevhliu/my-image-captioning-dataset") ``` +## WebDataset + +The [WebDataset](https://github.com/webdataset/webdataset) format is based on TAR archives and is suitable for big image datasets. +Indeed you can group your images in TAR archives (e.g. 1GB of images per TAR archive) and have thousands of TAR archives: + +``` +folder/train/00000.tar +folder/train/00001.tar +folder/train/00002.tar +... +``` + +In the archives, each example is made of files sharing the same prefix: + +``` +e39871fd9fd74f55.jpg +e39871fd9fd74f55.json +f18b91585c4d3f3e.jpg +f18b91585c4d3f3e.json +ede6e66b2fb59aab.jpg +ede6e66b2fb59aab.json +ed600d57fcee4f94.jpg +ed600d57fcee4f94.json +... +``` + +You can put your images labels/captions/bounding boxes using JSON or text files for example. + +For more details on the WebDataset format and the python library, please check the [WebDataset documentation](https://webdataset.github.io/webdataset). + +Load your WebDataset and it will create on column per file suffix (here "jpg" and "json"): + +```python +>>> from datasets import load_dataset + +>>> dataset = load_dataset("webdataset", data_dir="/path/to/folder", split="train") +>>> dataset[0]["json"] +{"bbox": [[302.0, 109.0, 73.0, 52.0]], "categories": [0]} +``` + ## Loading script Write a dataset loading script to share a dataset. It defines a dataset's splits and configurations, and handles downloading and generating a dataset. The script is located in the same folder or repository as the dataset and should have the same name. diff --git a/docs/source/image_load.mdx b/docs/source/image_load.mdx index 2f09f227784..b150bd04e73 100644 --- a/docs/source/image_load.mdx +++ b/docs/source/image_load.mdx @@ -1,6 +1,6 @@ # Load image data -Image datasets are loaded from the `image` column, which contains a PIL object. +Image datasets have [`Image`] type columns, which contain PIL objects. <Tip> @@ -8,7 +8,7 @@ To work with image datasets, you need to have the `vision` dependency installed. </Tip> -When you load an image dataset and call the `image` column, the [`Image`] feature automatically decodes the PIL object into an image: +When you load an image dataset and call the image column, the images are decoded as PIL Images: ```py >>> from datasets import load_dataset, Image @@ -93,3 +93,16 @@ To ignore the information in the metadata file, set `drop_labels=False` in [`loa For more information about creating your own `ImageFolder` dataset, take a look at the [Create an image dataset](./image_dataset) guide. </Tip> + +## WebDataset + +The [WebDataset](https://github.com/webdataset/webdataset) format is based on a folder of TAR archives and is suitable for big image datasets. +Because of their size, WebDatasets are generally loaded in streaming mode (using `streaming=True`). + +You can load a WebDataset like this: + +```python +>>> from datasets import load_dataset + +>>> dataset = load_dataset("webdataset", data_dir="/path/to/folder", streaming=True) +``` diff --git a/docs/source/loading.mdx b/docs/source/loading.mdx index 7ca48559dc6..aa907ac1774 100644 --- a/docs/source/loading.mdx +++ b/docs/source/loading.mdx @@ -224,6 +224,31 @@ For more details, check out the [how to load tabular datasets from SQL databases </Tip> +### WebDataset + +The [WebDataset](https://github.com/webdataset/webdataset) format is based on TAR archives and is suitable for big image datasets. +Because of their size, WebDatasets are generally loaded in streaming mode (using `streaming=True`). + +You can load a WebDataset like this: + +```python +>>> from datasets import load_dataset +>>> +>>> path = "path/to/train/*.tar" +>>> dataset = load_dataset("webdataset", data_files={"train": path}, split="train", streaming=True) +``` + +To load remote WebDatasets via HTTP, pass the URLs instead: + +```python +>>> from datasets import load_dataset +>>> +>>> base_url = "https://huggingface.co/datasets/lhoestq/small-publaynet-wds/resolve/main/publaynet-train-{i:06d}.tar" +>>> urls = [base_url.format(i=i) for i in range(4)] +>>> dataset = load_dataset("webdataset", data_files={"train": urls}, split="train", streaming=True) +``` + + ## Multiprocessing When a dataset is made of several files (that we call "shards"), it is possible to significantly speed up the dataset downloading and preparation step. diff --git a/docs/source/package_reference/loading_methods.mdx b/docs/source/package_reference/loading_methods.mdx index d91714cb41c..6401708e762 100644 --- a/docs/source/package_reference/loading_methods.mdx +++ b/docs/source/package_reference/loading_methods.mdx @@ -96,3 +96,7 @@ load_dataset("csv", data_dir="path/to/data/dir", sep="\t") [[autodoc]] datasets.packaged_modules.audiofolder.AudioFolderConfig [[autodoc]] datasets.packaged_modules.audiofolder.AudioFolder + +### WebDataset + +[[autodoc]] datasets.packaged_modules.webdataset.WebDataset

[ { "components": [ { "doc": "Determine the length of a in bytes.", "lines": [ 40, 47 ], "name": "bytelen", "signature": "def bytelen(a):", "type": "function" }, { "doc": "Return a the raw data corresponding to a.", ...

[ "tests/packaged_modules/test_webdataset.py::test_webdataset_errors_on_bad_file" ]

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Webdataset dataset builder Allow `load_dataset` to support the Webdataset format. It allows users to download/stream data from local files or from the Hugging Face Hub. Moreover it will enable the Dataset Viewer for Webdataset datasets on HF. ## Implementation details - I added a new Webdataset builder - dataset with TAR files are now read using the Webdataset builder - Basic decoding from `webdataset` is used by default, except unsafe ones like pickle - HF authentication support is done with `xopen` ## TODOS - [x] tests - [x] docs ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/datasets/packaged_modules/webdataset/_tenbin.py] (definition of bytelen:) def bytelen(a): """Determine the length of a in bytes.""" (definition of bytedata:) def bytedata(a): """Return a the raw data corresponding to a.""" (definition of check_acceptable_input_type:) def check_acceptable_input_type(data, allow64): """Check that the data has an acceptable type for tensor encoding. :param data: array :param allow64: allow 64 bit types""" (definition of str64:) def str64(s): """Convert a string to an int64.""" (definition of unstr64:) def unstr64(i): """Convert an int64 to a string.""" (definition of check_infos:) def check_infos(data, infos, required_infos=None): """Verify the info strings.""" (definition of encode_header:) def encode_header(a, info=""): """Encode an array header as a byte array.""" (definition of decode_header:) def decode_header(h): """Decode a byte array into an array header.""" (definition of encode_list:) def encode_list(l, infos=None): """Given a list of arrays, encode them into a list of byte arrays.""" (definition of decode_list:) def decode_list(l, infos=False): """Given a list of byte arrays, decode them into arrays.""" (definition of roundup:) def roundup(n, k=64): """Round up to the next multiple of 64.""" (definition of encode_chunks:) def encode_chunks(l): """Encode a list of chunks into a single byte array, with lengths and magics..""" (definition of decode_chunks:) def decode_chunks(buf): """Decode a byte array into a list of chunks.""" (definition of encode_buffer:) def encode_buffer(l, infos=None): """Encode a list of arrays into a single byte array.""" (definition of decode_buffer:) def decode_buffer(buf, infos=False): """Decode a byte array into a list of arrays.""" (definition of write_chunk:) def write_chunk(stream, buf): """Write a byte chunk to the stream with magics, length, and padding.""" (definition of read_chunk:) def read_chunk(stream): """Read a byte chunk from a stream with magics, length, and padding.""" (definition of write:) def write(stream, l, infos=None): """Write a list of arrays to a stream, with magics, length, and padding.""" (definition of read:) def read(stream, n=sys.maxsize, infos=False): """Read a list of arrays from a stream, with magics, length, and padding.""" (definition of save:) def save(fname, *args, infos=None, nocheck=False): """Save a list of arrays to a file, with magics, length, and padding.""" (definition of load:) def load(fname, infos=False, nocheck=False): """Read a list of arrays from a file, with magics, length, and padding.""" [end of new definitions in src/datasets/packaged_modules/webdataset/_tenbin.py] [start of new definitions in src/datasets/packaged_modules/webdataset/webdataset.py] (definition of WebDataset:) class WebDataset(datasets.GeneratorBasedBuilder): (definition of WebDataset._get_pipeline_from_tar:) def _get_pipeline_from_tar(cls, tar_path, tar_iterator): (definition of WebDataset._info:) def _info(self) -> datasets.DatasetInfo: (definition of WebDataset._split_generators:) def _split_generators(self, dl_manager): """We handle string, list and dicts in datafiles""" (definition of WebDataset._generate_examples:) def _generate_examples(self, tar_paths, tar_iterators): (definition of text_loads:) def text_loads(data: bytes): (definition of tenbin_loads:) def tenbin_loads(data: bytes): (definition of msgpack_loads:) def msgpack_loads(data: bytes): (definition of npy_loads:) def npy_loads(data: bytes): (definition of npz_loads:) def npz_loads(data: bytes): (definition of cbor_loads:) def cbor_loads(data: bytes): [end of new definitions in src/datasets/packaged_modules/webdataset/webdataset.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

5142a8cf61d8a4495eda3d91dc4283a6df01ea14

Project-MONAI__MONAI-7198

7,198

Project-MONAI/MONAI

null

97678fa75a851c411c713658059bac3b2ce5cf70

2023-11-03T21:24:28Z

diff --git a/docs/source/transforms.rst b/docs/source/transforms.rst index 8990e7991d..bd3feb3497 100644 --- a/docs/source/transforms.rst +++ b/docs/source/transforms.rst @@ -661,6 +661,27 @@ Post-processing :members: :special-members: __call__ +Regularization +^^^^^^^^^^^^^^ + +`CutMix` +"""""""" +.. autoclass:: CutMix + :members: + :special-members: __call__ + +`CutOut` +"""""""" +.. autoclass:: CutOut + :members: + :special-members: __call__ + +`MixUp` +""""""" +.. autoclass:: MixUp + :members: + :special-members: __call__ + Signal ^^^^^^^ @@ -1707,6 +1728,27 @@ Post-processing (Dict) :members: :special-members: __call__ +Regularization (Dict) +^^^^^^^^^^^^^^^^^^^^^ + +`CutMixd` +""""""""" +.. autoclass:: CutMixd + :members: + :special-members: __call__ + +`CutOutd` +""""""""" +.. autoclass:: CutOutd + :members: + :special-members: __call__ + +`MixUpd` +"""""""" +.. autoclass:: MixUpd + :members: + :special-members: __call__ + Signal (Dict) ^^^^^^^^^^^^^ diff --git a/docs/source/transforms_idx.rst b/docs/source/transforms_idx.rst index f4d02a483f..650d45db71 100644 --- a/docs/source/transforms_idx.rst +++ b/docs/source/transforms_idx.rst @@ -74,6 +74,16 @@ Post-processing post.array post.dictionary +Regularization +^^^^^^^^^^^^^^ + +.. autosummary:: + :toctree: _gen + :nosignatures: + + regularization.array + regularization.dictionary + Signal ^^^^^^ diff --git a/monai/transforms/__init__.py b/monai/transforms/__init__.py index 2aa8fbf8a1..349533fb3e 100644 --- a/monai/transforms/__init__.py +++ b/monai/transforms/__init__.py @@ -336,6 +336,18 @@ VoteEnsembled, VoteEnsembleDict, ) +from .regularization.array import CutMix, CutOut, MixUp +from .regularization.dictionary import ( + CutMixd, + CutMixD, + CutMixDict, + CutOutd, + CutOutD, + CutOutDict, + MixUpd, + MixUpD, + MixUpDict, +) from .signal.array import ( SignalContinuousWavelet, SignalFillEmpty, diff --git a/monai/transforms/regularization/__init__.py b/monai/transforms/regularization/__init__.py new file mode 100644 index 0000000000..1e97f89407 --- /dev/null +++ b/monai/transforms/regularization/__init__.py @@ -0,0 +1,10 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/monai/transforms/regularization/array.py b/monai/transforms/regularization/array.py new file mode 100644 index 0000000000..6c9022d647 --- /dev/null +++ b/monai/transforms/regularization/array.py @@ -0,0 +1,173 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import annotations + +from abc import abstractmethod +from math import ceil, sqrt + +import torch + +from ..transform import RandomizableTransform + +__all__ = ["MixUp", "CutMix", "CutOut", "Mixer"] + + +class Mixer(RandomizableTransform): + def __init__(self, batch_size: int, alpha: float = 1.0) -> None: + """ + Mixer is a base class providing the basic logic for the mixup-class of + augmentations. In all cases, we need to sample the mixing weights for each + sample (lambda in the notation used in the papers). Also, pairs of samples + being mixed are picked by randomly shuffling the batch samples. + + Args: + batch_size (int): number of samples per batch. That is, samples are expected tp + be of size batchsize x channels [x depth] x height x width. + alpha (float, optional): mixing weights are sampled from the Beta(alpha, alpha) + distribution. Defaults to 1.0, the uniform distribution. + """ + super().__init__() + if alpha <= 0: + raise ValueError(f"Expected positive number, but got {alpha = }") + self.alpha = alpha + self.batch_size = batch_size + + @abstractmethod + def apply(self, data: torch.Tensor): + raise NotImplementedError() + + def randomize(self, data=None) -> None: + """ + Sometimes you need may to apply the same transform to different tensors. + The idea is to get a sample and then apply it with apply() as often + as needed. You need to call this method everytime you apply the transform to a new + batch. + """ + self._params = ( + torch.from_numpy(self.R.beta(self.alpha, self.alpha, self.batch_size)).type(torch.float32), + self.R.permutation(self.batch_size), + ) + + +class MixUp(Mixer): + """MixUp as described in: + Hongyi Zhang, Moustapha Cisse, Yann N. Dauphin, David Lopez-Paz. + mixup: Beyond Empirical Risk Minimization, ICLR 2018 + + Class derived from :py:class:`monai.transforms.Mixer`. See corresponding + documentation for details on the constructor parameters. + """ + + def apply(self, data: torch.Tensor): + weight, perm = self._params + nsamples, *dims = data.shape + if len(weight) != nsamples: + raise ValueError(f"Expected batch of size: {len(weight)}, but got {nsamples}") + + if len(dims) not in [3, 4]: + raise ValueError("Unexpected number of dimensions") + + mixweight = weight[(Ellipsis,) + (None,) * len(dims)] + return mixweight * data + (1 - mixweight) * data[perm, ...] + + def __call__(self, data: torch.Tensor, labels: torch.Tensor | None = None): + self.randomize() + if labels is None: + return self.apply(data) + return self.apply(data), self.apply(labels) + + +class CutMix(Mixer): + """CutMix augmentation as described in: + Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, Youngjoon Yoo. + CutMix: Regularization Strategy to Train Strong Classifiers with Localizable Features, + ICCV 2019 + + Class derived from :py:class:`monai.transforms.Mixer`. See corresponding + documentation for details on the constructor parameters. Here, alpha not only determines + the mixing weight but also the size of the random rectangles used during for mixing. + Please refer to the paper for details. + + The most common use case is something close to: + + .. code-block:: python + + cm = CutMix(batch_size=8, alpha=0.5) + for batch in loader: + images, labels = batch + augimg, auglabels = cm(images, labels) + output = model(augimg) + loss = loss_function(output, auglabels) + ... + + """ + + def apply(self, data: torch.Tensor): + weights, perm = self._params + nsamples, _, *dims = data.shape + if len(weights) != nsamples: + raise ValueError(f"Expected batch of size: {len(weights)}, but got {nsamples}") + + mask = torch.ones_like(data) + for s, weight in enumerate(weights): + coords = [torch.randint(0, d, size=(1,)) for d in dims] + lengths = [d * sqrt(1 - weight) for d in dims] + idx = [slice(None)] + [slice(c, min(ceil(c + ln), d)) for c, ln, d in zip(coords, lengths, dims)] + mask[s][idx] = 0 + + return mask * data + (1 - mask) * data[perm, ...] + + def apply_on_labels(self, labels: torch.Tensor): + weights, perm = self._params + nsamples, *dims = labels.shape + if len(weights) != nsamples: + raise ValueError(f"Expected batch of size: {len(weights)}, but got {nsamples}") + + mixweight = weights[(Ellipsis,) + (None,) * len(dims)] + return mixweight * labels + (1 - mixweight) * labels[perm, ...] + + def __call__(self, data: torch.Tensor, labels: torch.Tensor | None = None): + self.randomize() + augmented = self.apply(data) + return (augmented, self.apply_on_labels(labels)) if labels is not None else augmented + + +class CutOut(Mixer): + """Cutout as described in the paper: + Terrance DeVries, Graham W. Taylor. + Improved Regularization of Convolutional Neural Networks with Cutout, + arXiv:1708.04552 + + Class derived from :py:class:`monai.transforms.Mixer`. See corresponding + documentation for details on the constructor parameters. Here, alpha not only determines + the mixing weight but also the size of the random rectangles being cut put. + Please refer to the paper for details. + """ + + def apply(self, data: torch.Tensor): + weights, _ = self._params + nsamples, _, *dims = data.shape + if len(weights) != nsamples: + raise ValueError(f"Expected batch of size: {len(weights)}, but got {nsamples}") + + mask = torch.ones_like(data) + for s, weight in enumerate(weights): + coords = [torch.randint(0, d, size=(1,)) for d in dims] + lengths = [d * sqrt(1 - weight) for d in dims] + idx = [slice(None)] + [slice(c, min(ceil(c + ln), d)) for c, ln, d in zip(coords, lengths, dims)] + mask[s][idx] = 0 + + return mask * data + + def __call__(self, data: torch.Tensor): + self.randomize() + return self.apply(data) diff --git a/monai/transforms/regularization/dictionary.py b/monai/transforms/regularization/dictionary.py new file mode 100644 index 0000000000..373913da99 --- /dev/null +++ b/monai/transforms/regularization/dictionary.py @@ -0,0 +1,97 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import annotations + +from monai.config import KeysCollection +from monai.utils.misc import ensure_tuple + +from ..transform import MapTransform +from .array import CutMix, CutOut, MixUp + +__all__ = ["MixUpd", "MixUpD", "MixUpDict", "CutMixd", "CutMixD", "CutMixDict", "CutOutd", "CutOutD", "CutOutDict"] + + +class MixUpd(MapTransform): + """ + Dictionary-based version :py:class:`monai.transforms.MixUp`. + + Notice that the mixup transformation will be the same for all entries + for consistency, i.e. images and labels must be applied the same augmenation. + """ + + def __init__( + self, keys: KeysCollection, batch_size: int, alpha: float = 1.0, allow_missing_keys: bool = False + ) -> None: + super().__init__(keys, allow_missing_keys) + self.mixup = MixUp(batch_size, alpha) + + def __call__(self, data): + self.mixup.randomize() + result = dict(data) + for k in self.keys: + result[k] = self.mixup.apply(data[k]) + return result + + +class CutMixd(MapTransform): + """ + Dictionary-based version :py:class:`monai.transforms.CutMix`. + + Notice that the mixture weights will be the same for all entries + for consistency, i.e. images and labels must be aggregated with the same weights, + but the random crops are not. + """ + + def __init__( + self, + keys: KeysCollection, + batch_size: int, + label_keys: KeysCollection | None = None, + alpha: float = 1.0, + allow_missing_keys: bool = False, + ) -> None: + super().__init__(keys, allow_missing_keys) + self.mixer = CutMix(batch_size, alpha) + self.label_keys = ensure_tuple(label_keys) if label_keys is not None else [] + + def __call__(self, data): + self.mixer.randomize() + result = dict(data) + for k in self.keys: + result[k] = self.mixer.apply(data[k]) + for k in self.label_keys: + result[k] = self.mixer.apply_on_labels(data[k]) + return result + + +class CutOutd(MapTransform): + """ + Dictionary-based version :py:class:`monai.transforms.CutOut`. + + Notice that the cutout is different for every entry in the dictionary. + """ + + def __init__(self, keys: KeysCollection, batch_size: int, allow_missing_keys: bool = False) -> None: + super().__init__(keys, allow_missing_keys) + self.cutout = CutOut(batch_size) + + def __call__(self, data): + result = dict(data) + self.cutout.randomize() + for k in self.keys: + result[k] = self.cutout(data[k]) + return result + + +MixUpD = MixUpDict = MixUpd +CutMixD = CutMixDict = CutMixd +CutOutD = CutOutDict = CutOutd

diff --git a/tests/test_regularization.py b/tests/test_regularization.py new file mode 100644 index 0000000000..d381ea72ca --- /dev/null +++ b/tests/test_regularization.py @@ -0,0 +1,90 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import annotations + +import unittest + +import torch + +from monai.transforms import CutMix, CutMixd, CutOut, MixUp, MixUpd + + +class TestMixup(unittest.TestCase): + def test_mixup(self): + for dims in [2, 3]: + shape = (6, 3) + (32,) * dims + sample = torch.rand(*shape, dtype=torch.float32) + mixup = MixUp(6, 1.0) + output = mixup(sample) + self.assertEqual(output.shape, sample.shape) + self.assertTrue(any(not torch.allclose(sample, mixup(sample)) for _ in range(10))) + + with self.assertRaises(ValueError): + MixUp(6, -0.5) + + mixup = MixUp(6, 0.5) + for dims in [2, 3]: + with self.assertRaises(ValueError): + shape = (5, 3) + (32,) * dims + sample = torch.rand(*shape, dtype=torch.float32) + mixup(sample) + + def test_mixupd(self): + for dims in [2, 3]: + shape = (6, 3) + (32,) * dims + t = torch.rand(*shape, dtype=torch.float32) + sample = {"a": t, "b": t} + mixup = MixUpd(["a", "b"], 6) + output = mixup(sample) + self.assertTrue(torch.allclose(output["a"], output["b"])) + + with self.assertRaises(ValueError): + MixUpd(["k1", "k2"], 6, -0.5) + + +class TestCutMix(unittest.TestCase): + def test_cutmix(self): + for dims in [2, 3]: + shape = (6, 3) + (32,) * dims + sample = torch.rand(*shape, dtype=torch.float32) + cutmix = CutMix(6, 1.0) + output = cutmix(sample) + self.assertEqual(output.shape, sample.shape) + self.assertTrue(any(not torch.allclose(sample, cutmix(sample)) for _ in range(10))) + + def test_cutmixd(self): + for dims in [2, 3]: + shape = (6, 3) + (32,) * dims + t = torch.rand(*shape, dtype=torch.float32) + label = torch.randint(0, 1, shape) + sample = {"a": t, "b": t, "lbl1": label, "lbl2": label} + cutmix = CutMixd(["a", "b"], 6, label_keys=("lbl1", "lbl2")) + output = cutmix(sample) + # croppings are different on each application + self.assertTrue(not torch.allclose(output["a"], output["b"])) + # but mixing of labels is not affected by it + self.assertTrue(torch.allclose(output["lbl1"], output["lbl2"])) + + +class TestCutOut(unittest.TestCase): + def test_cutout(self): + for dims in [2, 3]: + shape = (6, 3) + (32,) * dims + sample = torch.rand(*shape, dtype=torch.float32) + cutout = CutOut(6, 1.0) + output = cutout(sample) + self.assertEqual(output.shape, sample.shape) + self.assertTrue(any(not torch.allclose(sample, cutout(sample)) for _ in range(10))) + + +if __name__ == "__main__": + unittest.main()

diff --git a/docs/source/transforms.rst b/docs/source/transforms.rst index 8990e7991d..bd3feb3497 100644 --- a/docs/source/transforms.rst +++ b/docs/source/transforms.rst @@ -661,6 +661,27 @@ Post-processing :members: :special-members: __call__ +Regularization +^^^^^^^^^^^^^^ + +`CutMix` +"""""""" +.. autoclass:: CutMix + :members: + :special-members: __call__ + +`CutOut` +"""""""" +.. autoclass:: CutOut + :members: + :special-members: __call__ + +`MixUp` +""""""" +.. autoclass:: MixUp + :members: + :special-members: __call__ + Signal ^^^^^^^ @@ -1707,6 +1728,27 @@ Post-processing (Dict) :members: :special-members: __call__ +Regularization (Dict) +^^^^^^^^^^^^^^^^^^^^^ + +`CutMixd` +""""""""" +.. autoclass:: CutMixd + :members: + :special-members: __call__ + +`CutOutd` +""""""""" +.. autoclass:: CutOutd + :members: + :special-members: __call__ + +`MixUpd` +"""""""" +.. autoclass:: MixUpd + :members: + :special-members: __call__ + Signal (Dict) ^^^^^^^^^^^^^ diff --git a/docs/source/transforms_idx.rst b/docs/source/transforms_idx.rst index f4d02a483f..650d45db71 100644 --- a/docs/source/transforms_idx.rst +++ b/docs/source/transforms_idx.rst @@ -74,6 +74,16 @@ Post-processing post.array post.dictionary +Regularization +^^^^^^^^^^^^^^ + +.. autosummary:: + :toctree: _gen + :nosignatures: + + regularization.array + regularization.dictionary + Signal ^^^^^^

[ { "components": [ { "doc": "", "lines": [ 24, 57 ], "name": "Mixer", "signature": "class Mixer(RandomizableTransform):", "type": "class" }, { "doc": "Mixer is a base class providing the basic logic for the mixup-class ...

[ "tests/test_regularization.py::TestMixup::test_mixup", "tests/test_regularization.py::TestMixup::test_mixupd", "tests/test_regularization.py::TestCutMix::test_cutmix", "tests/test_regularization.py::TestCutMix::test_cutmixd", "tests/test_regularization.py::TestCutOut::test_cutout" ]

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> 2872 implementation of mixup, cutmix and cutout Fixes #2872 ### Description Implementation of mixup, cutmix and cutout as described in the original papers. Current implementation support both, the dictionary-based batches and tuples of tensors. ### Types of changes  - [x] Non-breaking change (fix or new feature that would not break existing functionality). - [ ] Breaking change (fix or new feature that would cause existing functionality to change). - [x] New tests added to cover the changes. - [ ] Integration tests passed locally by running `./runtests.sh -f -u --net --coverage`. - [x] Quick tests passed locally by running `./runtests.sh --quick --unittests --disttests`. - [x] In-line docstrings updated. - [x] Documentation updated, tested `make html` command in the `docs/` folder. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in monai/transforms/regularization/array.py] (definition of Mixer:) class Mixer(RandomizableTransform): (definition of Mixer.__init__:) def __init__(self, batch_size: int, alpha: float = 1.0) -> None: """Mixer is a base class providing the basic logic for the mixup-class of augmentations. In all cases, we need to sample the mixing weights for each sample (lambda in the notation used in the papers). Also, pairs of samples being mixed are picked by randomly shuffling the batch samples. Args: batch_size (int): number of samples per batch. That is, samples are expected tp be of size batchsize x channels [x depth] x height x width. alpha (float, optional): mixing weights are sampled from the Beta(alpha, alpha) distribution. Defaults to 1.0, the uniform distribution.""" (definition of Mixer.apply:) def apply(self, data: torch.Tensor): (definition of Mixer.randomize:) def randomize(self, data=None) -> None: """Sometimes you need may to apply the same transform to different tensors. The idea is to get a sample and then apply it with apply() as often as needed. You need to call this method everytime you apply the transform to a new batch.""" (definition of MixUp:) class MixUp(Mixer): """MixUp as described in: Hongyi Zhang, Moustapha Cisse, Yann N. Dauphin, David Lopez-Paz. mixup: Beyond Empirical Risk Minimization, ICLR 2018 Class derived from :py:class:`monai.transforms.Mixer`. See corresponding documentation for details on the constructor parameters.""" (definition of MixUp.apply:) def apply(self, data: torch.Tensor): (definition of MixUp.__call__:) def __call__(self, data: torch.Tensor, labels: torch.Tensor | None = None): (definition of CutMix:) class CutMix(Mixer): """CutMix augmentation as described in: Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, Youngjoon Yoo. CutMix: Regularization Strategy to Train Strong Classifiers with Localizable Features, ICCV 2019 Class derived from :py:class:`monai.transforms.Mixer`. See corresponding documentation for details on the constructor parameters. Here, alpha not only determines the mixing weight but also the size of the random rectangles used during for mixing. Please refer to the paper for details. The most common use case is something close to: .. code-block:: python cm = CutMix(batch_size=8, alpha=0.5) for batch in loader: images, labels = batch augimg, auglabels = cm(images, labels) output = model(augimg) loss = loss_function(output, auglabels) ...""" (definition of CutMix.apply:) def apply(self, data: torch.Tensor): (definition of CutMix.apply_on_labels:) def apply_on_labels(self, labels: torch.Tensor): (definition of CutMix.__call__:) def __call__(self, data: torch.Tensor, labels: torch.Tensor | None = None): (definition of CutOut:) class CutOut(Mixer): """Cutout as described in the paper: Terrance DeVries, Graham W. Taylor. Improved Regularization of Convolutional Neural Networks with Cutout, arXiv:1708.04552 Class derived from :py:class:`monai.transforms.Mixer`. See corresponding documentation for details on the constructor parameters. Here, alpha not only determines the mixing weight but also the size of the random rectangles being cut put. Please refer to the paper for details.""" (definition of CutOut.apply:) def apply(self, data: torch.Tensor): (definition of CutOut.__call__:) def __call__(self, data: torch.Tensor): [end of new definitions in monai/transforms/regularization/array.py] [start of new definitions in monai/transforms/regularization/dictionary.py] (definition of MixUpd:) class MixUpd(MapTransform): """Dictionary-based version :py:class:`monai.transforms.MixUp`. Notice that the mixup transformation will be the same for all entries for consistency, i.e. images and labels must be applied the same augmenation.""" (definition of MixUpd.__init__:) def __init__( self, keys: KeysCollection, batch_size: int, alpha: float = 1.0, allow_missing_keys: bool = False ) -> None: (definition of MixUpd.__call__:) def __call__(self, data): (definition of CutMixd:) class CutMixd(MapTransform): """Dictionary-based version :py:class:`monai.transforms.CutMix`. Notice that the mixture weights will be the same for all entries for consistency, i.e. images and labels must be aggregated with the same weights, but the random crops are not.""" (definition of CutMixd.__init__:) def __init__( self, keys: KeysCollection, batch_size: int, label_keys: KeysCollection | None = None, alpha: float = 1.0, allow_missing_keys: bool = False, ) -> None: (definition of CutMixd.__call__:) def __call__(self, data): (definition of CutOutd:) class CutOutd(MapTransform): """Dictionary-based version :py:class:`monai.transforms.CutOut`. Notice that the cutout is different for every entry in the dictionary.""" (definition of CutOutd.__init__:) def __init__(self, keys: KeysCollection, batch_size: int, allow_missing_keys: bool = False) -> None: (definition of CutOutd.__call__:) def __call__(self, data): [end of new definitions in monai/transforms/regularization/dictionary.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Mismatch result in "integration_segmentation_3d" ``` ====================================================================== ERROR: test_timing (__main__.IntegrationSegmentation3D) ---------------------------------------------------------------------- ValueError: no matched results for integration_segmentation_3d, losses. [0.5442982316017151, 0.4741817444562912, 0.4535954713821411, 0.44163046181201937, 0.4307525992393494, 0.428487154841423]. The above exception was the direct cause of the following exception: Traceback (most recent call last): File "/workspace/MONAI/tests/utils.py", line 628, in _wrapper raise RuntimeError(res.traceback) from res RuntimeError: Traceback (most recent call last): File "/workspace/MONAI/tests/utils.py", line 580, in run_process output = func(*args, **kwargs) File "/workspace/MONAI/tests/utils.py", line 660, in _call_original_func return f(*args, **kwargs) File "/workspace/MONAI/tests/test_integration_segmentation_3d.py", line 301, in test_timing self.train_and_infer(idx=3) File "/workspace/MONAI/tests/test_integration_segmentation_3d.py", line 284, in train_and_infer self.assertTrue(test_integration_value(TASK, key="losses", data=results[:6], rtol=1e-3)) File "/workspace/MONAI/tests/testing_data/integration_answers.py", line 616, in test_integration_value raise ValueError(f"no matched results for {test_name}, {key}. {data}.") ValueError: no matched results for integration_segmentation_3d, losses. [0.5442982316017151, 0.4741817444562912, 0.4535954713821411, 0.44163046181201937, 0.4307525992393494, 0.428487154841423]. ====================================================================== ERROR: test_training (__main__.IntegrationSegmentation3D) ---------------------------------------------------------------------- Traceback (most recent call last): File "/workspace/MONAI/tests/test_integration_segmentation_3d.py", line 293, in test_training results = self.train_and_infer(i) File "/workspace/MONAI/tests/test_integration_segmentation_3d.py", line 284, in train_and_infer self.assertTrue(test_integration_value(TASK, key="losses", data=results[:6], rtol=1e-3)) File "/workspace/MONAI/tests/testing_data/integration_answers.py", line 616, in test_integration_value raise ValueError(f"no matched results for {test_name}, {key}. {data}.") ValueError: no matched results for integration_segmentation_3d, losses. [0.5442982316017151, 0.4741817444562912, 0.4535954713821411, 0.44163046181201937, 0.4307525992393494, 0.428487154841423]. ---------------------------------------------------------------------- Ran 2 tests in 243.671s FAILED (errors=2) losses [0.5442982316017151, 0.4741817444562912, 0.4535954713821411, 0.44163046181201937, 0.4307525992393494, 0.428487154841423] best metric 0.9314384460449219 infer metric 0.9315622448921204 [0.14268704426414708, 0.1528672845845743, 0.1521782248125706, 0.14028769128068194, 0.1889830671664784, 0.16999075690664475, 0.14736282992708227, 0.16877952654821815, 0.15779597155181269, 0.17987829927082263, 0.16320253928314676, 0.16854299322173155, 0.14497470986956967, 0.11437140546369519, 0.1624117412960871, 0.20156009294443875, 0.1764654154256958, 0.0982348259217418, 0.1942436068604293, 0.20359421536407518, 0.19661953116976483, 0.2088326101468625, 0.16273043545239807, 0.1326107887439663, 0.1489245275752285, 0.143107476635514, 0.23189027677929547, 0.1613818424566088, 0.14889532196775188, 0.10332622984492143, 0.11940054688302351, 0.13040496302762658, 0.11472123087193181, 0.15307044007394474, 0.16371989575844717, 0.1942898223272055, 0.2230120930471398, 0.1814679187634795, 0.19069496508164732, 0.07537197031940022] ``` ---------- -------------------- </issues>

e73257caa79309dcce1e93abf1632f4bfd75b11f

tobymao__sqlglot-2484

2,484

tobymao/sqlglot

null

df0a69842daf3ec957effba206b79e27a97c91b4

2023-10-30T16:11:39Z

diff --git a/sqlglot/dialects/spark.py b/sqlglot/dialects/spark.py index 8461920fe8..ba73ac01ab 100644 --- a/sqlglot/dialects/spark.py +++ b/sqlglot/dialects/spark.py @@ -56,7 +56,11 @@ class Parser(Spark2.Parser): def _parse_generated_as_identity( self, - ) -> exp.GeneratedAsIdentityColumnConstraint | exp.ComputedColumnConstraint: + ) -> ( + exp.GeneratedAsIdentityColumnConstraint + | exp.ComputedColumnConstraint + | exp.GeneratedAsRowColumnConstraint + ): this = super()._parse_generated_as_identity() if this.expression: return self.expression(exp.ComputedColumnConstraint, this=this.expression) diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index 7740382d7c..cafaeb4ff7 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -1297,6 +1297,10 @@ class AutoIncrementColumnConstraint(ColumnConstraintKind): pass +class PeriodForSystemTimeConstraint(ColumnConstraintKind): + arg_types = {"this": True, "expression": True} + + class CaseSpecificColumnConstraint(ColumnConstraintKind): arg_types = {"not_": True} @@ -1351,6 +1355,10 @@ class GeneratedAsIdentityColumnConstraint(ColumnConstraintKind): } +class GeneratedAsRowColumnConstraint(ColumnConstraintKind): + arg_types = {"start": True, "hidden": False} + + # https://dev.mysql.com/doc/refman/8.0/en/create-table.html class IndexColumnConstraint(ColumnConstraintKind): arg_types = { @@ -2243,6 +2251,11 @@ class WithJournalTableProperty(Property): arg_types = {"this": True} +class WithSystemVersioningProperty(Property): + # this -> history table name, expression -> data consistency check + arg_types = {"this": True, "expression": False} + + class Properties(Expression): arg_types = {"expressions": True} diff --git a/sqlglot/generator.py b/sqlglot/generator.py index e2d8edf750..5e369aa120 100644 --- a/sqlglot/generator.py +++ b/sqlglot/generator.py @@ -328,6 +328,7 @@ class Generator: exp.VolatileProperty: exp.Properties.Location.POST_CREATE, exp.WithDataProperty: exp.Properties.Location.POST_EXPRESSION, exp.WithJournalTableProperty: exp.Properties.Location.POST_NAME, + exp.WithSystemVersioningProperty: exp.Properties.Location.POST_SCHEMA, } # Keywords that can't be used as unquoted identifier names @@ -748,6 +749,18 @@ def generatedasidentitycolumnconstraint_sql( return f"GENERATED{this} AS {expr}{sequence_opts}" + def generatedasrowcolumnconstraint_sql( + self, expression: exp.GeneratedAsRowColumnConstraint + ) -> str: + start = "START" if expression.args["start"] else "END" + hidden = " HIDDEN" if expression.args.get("hidden") else "" + return f"GENERATED ALWAYS AS ROW {start}{hidden}" + + def periodforsystemtimeconstraint_sql( + self, expression: exp.PeriodForSystemTimeConstraint + ) -> str: + return f"PERIOD FOR SYSTEM_TIME ({self.sql(expression, 'this')}, {self.sql(expression, 'expression')})" + def notnullcolumnconstraint_sql(self, expression: exp.NotNullColumnConstraint) -> str: return f"{'' if expression.args.get('allow_null') else 'NOT '}NULL" @@ -1255,6 +1268,20 @@ def withdataproperty_sql(self, expression: exp.WithDataProperty) -> str: statistics_sql = f" AND {'NO ' if not statistics else ''}STATISTICS" return f"{data_sql}{statistics_sql}" + def withsystemversioningproperty_sql(self, expression: exp.WithSystemVersioningProperty) -> str: + sql = "WITH(SYSTEM_VERSIONING=ON" + if expression.this is None: + return f"{sql})" + + history_table = self.sql(expression.this) + sql = f"{sql}(HISTORY_TABLE={history_table}" + if expression.expression is None: + return f"{sql}))" + + data_consistency_check = "ON" if expression.expression else "OFF" + sql = f"{sql}, DATA_CONSISTENCY_CHECK={data_consistency_check}" + return f"{sql}))" + def insert_sql(self, expression: exp.Insert) -> str: overwrite = expression.args.get("overwrite") diff --git a/sqlglot/parser.py b/sqlglot/parser.py index f8256fe858..4dfc008f5a 100644 --- a/sqlglot/parser.py +++ b/sqlglot/parser.py @@ -696,6 +696,7 @@ class Parser(metaclass=_Parser): exp.StabilityProperty, this=exp.Literal.string("STABLE") ), "STORED": lambda self: self._parse_stored(), + "SYSTEM_VERSIONING": lambda self: self._parse_system_versioning_property(), "TBLPROPERTIES": lambda self: self._parse_wrapped_csv(self._parse_property), "TEMP": lambda self: self.expression(exp.TemporaryProperty), "TEMPORARY": lambda self: self.expression(exp.TemporaryProperty), @@ -753,6 +754,7 @@ class Parser(metaclass=_Parser): ) or self.expression(exp.OnProperty, this=self._parse_id_var()), "PATH": lambda self: self.expression(exp.PathColumnConstraint, this=self._parse_string()), + "PERIOD": lambda self: self._parse_period_for_system_time(), "PRIMARY KEY": lambda self: self._parse_primary_key(), "REFERENCES": lambda self: self._parse_references(match=False), "TITLE": lambda self: self.expression( @@ -774,7 +776,7 @@ class Parser(metaclass=_Parser): "RENAME": lambda self: self._parse_alter_table_rename(), } - SCHEMA_UNNAMED_CONSTRAINTS = {"CHECK", "FOREIGN KEY", "LIKE", "PRIMARY KEY", "UNIQUE"} + SCHEMA_UNNAMED_CONSTRAINTS = {"CHECK", "FOREIGN KEY", "LIKE", "PRIMARY KEY", "UNIQUE", "PERIOD"} NO_PAREN_FUNCTION_PARSERS = { "ANY": lambda self: self.expression(exp.Any, this=self._parse_bitwise()), @@ -1523,6 +1525,19 @@ def _parse_volatile_property(self) -> exp.VolatileProperty | exp.StabilityProper return self.expression(exp.StabilityProperty, this=exp.Literal.string("VOLATILE")) + def _parse_system_versioning_property(self) -> exp.WithSystemVersioningProperty: + self._match_pair(TokenType.EQ, TokenType.ON) + self._match_l_paren() + self._match_text_seq("HISTORY_TABLE") + self._match(TokenType.EQ) + this = self.expression(exp.WithSystemVersioningProperty, this=self._parse_table_parts()) + if self._match(TokenType.COMMA): + self._match_text_seq("DATA_CONSISTENCY_CHECK") + self._match(TokenType.EQ) + this.set("expression", self._match_texts(("ON", "OFF"))) + self._match_r_paren() + return this + def _parse_with_property( self, ) -> t.Optional[exp.Expression] | t.List[exp.Expression]: @@ -3864,7 +3879,11 @@ def _parse_compress(self) -> exp.CompressColumnConstraint: def _parse_generated_as_identity( self, - ) -> exp.GeneratedAsIdentityColumnConstraint | exp.ComputedColumnConstraint: + ) -> ( + exp.GeneratedAsIdentityColumnConstraint + | exp.ComputedColumnConstraint + | exp.GeneratedAsRowColumnConstraint + ): if self._match_text_seq("BY", "DEFAULT"): on_null = self._match_pair(TokenType.ON, TokenType.NULL) this = self.expression( @@ -3875,6 +3894,14 @@ def _parse_generated_as_identity( this = self.expression(exp.GeneratedAsIdentityColumnConstraint, this=True) self._match(TokenType.ALIAS) + + if self._match_text_seq("ROW"): + start = self._match_text_seq("START") + if not start: + self._match(TokenType.END) + hidden = self._match_text_seq("HIDDEN") + return self.expression(exp.GeneratedAsRowColumnConstraint, start=start, hidden=hidden) + identity = self._match_text_seq("IDENTITY") if self._match(TokenType.L_PAREN): @@ -4047,6 +4074,16 @@ def _parse_foreign_key(self) -> exp.ForeignKey: def _parse_primary_key_part(self) -> t.Optional[exp.Expression]: return self._parse_field() + def _parse_period_for_system_time(self) -> exp.PeriodForSystemTimeConstraint: + self._match(TokenType.TIMESTAMP_SNAPSHOT) + + id_vars = self._parse_wrapped_id_vars() + return self.expression( + exp.PeriodForSystemTimeConstraint, + this=seq_get(id_vars, 0), + expression=seq_get(id_vars, 1), + ) + def _parse_primary_key( self, wrapped_optional: bool = False, in_props: bool = False ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:

diff --git a/tests/dialects/test_tsql.py b/tests/dialects/test_tsql.py index 47750207f2..240b2fbe02 100644 --- a/tests/dialects/test_tsql.py +++ b/tests/dialects/test_tsql.py @@ -1256,6 +1256,20 @@ def test_temp_table(self): }, ) + def test_temporal_table(self): + self.validate_identity( + """CREATE TABLE test ("data" CHAR(7), "valid_from" DATETIME2(2) GENERATED ALWAYS AS ROW START HIDDEN NOT NULL, "valid_to" DATETIME2(2) GENERATED ALWAYS AS ROW END HIDDEN NOT NULL, PERIOD FOR SYSTEM_TIME ("valid_from", "valid_to")) WITH(SYSTEM_VERSIONING=ON(HISTORY_TABLE="dbo"."benchmark_history", DATA_CONSISTENCY_CHECK=ON))""" + ) + self.validate_identity( + """CREATE TABLE test ("data" CHAR(7), "valid_from" DATETIME2(2) GENERATED ALWAYS AS ROW START NOT NULL, "valid_to" DATETIME2(2) GENERATED ALWAYS AS ROW END NOT NULL, PERIOD FOR SYSTEM_TIME ("valid_from", "valid_to")) WITH(SYSTEM_VERSIONING=ON(HISTORY_TABLE="dbo"."benchmark_history", DATA_CONSISTENCY_CHECK=ON))""" + ) + self.validate_identity( + """CREATE TABLE test ("data" CHAR(7), "valid_from" DATETIME2(2) GENERATED ALWAYS AS ROW START NOT NULL, "valid_to" DATETIME2(2) GENERATED ALWAYS AS ROW END NOT NULL, PERIOD FOR SYSTEM_TIME ("valid_from", "valid_to")) WITH(SYSTEM_VERSIONING=ON(HISTORY_TABLE="dbo"."benchmark_history"))""" + ) + self.validate_identity( + """CREATE TABLE test ("data" CHAR(7), "valid_from" DATETIME2(2) GENERATED ALWAYS AS ROW START NOT NULL, "valid_to" DATETIME2(2) GENERATED ALWAYS AS ROW END NOT NULL, PERIOD FOR SYSTEM_TIME ("valid_from", "valid_to")) WITH(SYSTEM_VERSIONING=ON(HISTORY_TABLE="dbo"."benchmark_history"))""" + ) + def test_system_time(self): self.validate_all( "SELECT [x] FROM [a].[b] FOR SYSTEM_TIME AS OF 'foo'",

[]

[ "tests/dialects/test_tsql.py::TestTSQL::test_temporal_table" ]

[ "tests/dialects/test_tsql.py::TestTSQL::test__types_ints", "tests/dialects/test_tsql.py::TestTSQL::test_add_date", "tests/dialects/test_tsql.py::TestTSQL::test_charindex", "tests/dialects/test_tsql.py::TestTSQL::test_commit", "tests/dialects/test_tsql.py::TestTSQL::test_convert_date_format", "tests/dialec...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat(tsql): add PERIOD FOR SYSTEM_TIME constraint, SYSTEM_VERSIONING property Add GENERATED ALWAYS AS ROW START/END column constraint, PERIOD FOR SYSTEM_TIME table constraint, and SYSTEM_VERSIONING property, following the [T-SQL spec for CREATE TABLE](https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql#full-syntax). ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

ceb42fabad60312699e4b15936aeebac00e22e4d

astropy__astropy-15545

15,545

astropy/astropy

v5.3

955e810650f1bf8cd159f71b54afe7ea6f43a77d

2023-10-27T17:09:27Z

diff --git a/astropy/modeling/functional_models.py b/astropy/modeling/functional_models.py index 769b4a80b935..97acf450c41a 100644 --- a/astropy/modeling/functional_models.py +++ b/astropy/modeling/functional_models.py @@ -27,6 +27,7 @@ "Disk2D", "Gaussian1D", "Gaussian2D", + "GeneralSersic2D", "Linear1D", "Lorentz1D", "RickerWavelet1D", @@ -3234,7 +3235,7 @@ class Sersic2D(Fittable2DModel): See Also -------- - Gaussian2D, Moffat2D + GeneralSersic2D, Gaussian2D, Moffat2D Notes ----- @@ -3246,7 +3247,6 @@ class Sersic2D(Fittable2DModel): -b_{n} \left[\left(\frac{r(x, y)}{r_{e}}\right)^{(1/n)} -1\right]\right\} - where :math:`I_{e}` is the ``amplitude``, :math:`r_{e}` is ``reff``, and :math:`r(x, y)` is a rotated ellipse defined as: @@ -3318,33 +3318,31 @@ class Sersic2D(Fittable2DModel): "Rotation angle either as a float (in radians) or a |Quantity| angle" ), ) - _gammaincinv = None @classmethod - def evaluate(cls, x, y, amplitude, r_eff, n, x_0, y_0, ellip, theta): + def evaluate(cls, x, y, amplitude, r_eff, n, x_0, y_0, ellip, theta, c=0): """Two dimensional Sersic profile function.""" - if cls._gammaincinv is None: - from scipy.special import gammaincinv - - cls._gammaincinv = gammaincinv + from scipy.special import gammaincinv - bn = cls._gammaincinv(2.0 * n, 0.5) - a, b = r_eff, (1 - ellip) * r_eff - cos_theta, sin_theta = np.cos(theta), np.sin(theta) - x_maj = (x - x_0) * cos_theta + (y - y_0) * sin_theta - x_min = -(x - x_0) * sin_theta + (y - y_0) * cos_theta - z = np.sqrt((x_maj / a) ** 2 + (x_min / b) ** 2) + bn = gammaincinv(2.0 * n, 0.5) + cos_theta = np.cos(theta) + sin_theta = np.sin(theta) + x_maj = np.abs((x - x_0) * cos_theta + (y - y_0) * sin_theta) + x_min = np.abs(-(x - x_0) * sin_theta + (y - y_0) * cos_theta) - return amplitude * np.exp(-bn * (z ** (1 / n) - 1)) + b = (1 - ellip) * r_eff + expon = 2.0 + c + inv_expon = 1.0 / expon + z = ((x_maj / r_eff) ** expon + (x_min / b) ** expon) ** inv_expon + return amplitude * np.exp(-bn * (z ** (1 / n) - 1.0)) @property def input_units(self): - if self.x_0.input_unit is None: - return None - return { - self.inputs[0]: self.x_0.input_unit, - self.inputs[1]: self.y_0.input_unit, - } + if self.x_0.input_unit is not None: + return { + self.inputs[0]: self.x_0.input_unit, + self.inputs[1]: self.y_0.input_unit, + } def _parameter_units_for_data_units(self, inputs_unit, outputs_unit): # Note that here we need to make sure that x and y are in the same @@ -3361,6 +3359,164 @@ def _parameter_units_for_data_units(self, inputs_unit, outputs_unit): } +class GeneralSersic2D(Sersic2D): + r""" + Generalized two dimensional Sersic surface brightness profile that + allows for "boxy" or "disky" (kite-like) isophote shapes. + + Parameters + ---------- + amplitude : float + Surface brightness at ``r_eff``. + r_eff : float + Effective (half-light) radius. + n : float + Sersic index controlling the shape of the profile. Particular + values of ``n`` are equivalent to the following profiles: + + * n=4 : `de Vaucouleurs <https://en.wikipedia.org/wiki/De_Vaucouleurs%27s_law>`_ :math:`r^{1/4}` profile + * n=1 : Exponential profile + * n=0.5 : Gaussian profile + x_0 : float, optional + x position of the center. + y_0 : float, optional + y position of the center. + ellip : float, optional + Ellipticity of the isophote, defined as 1.0 minus the ratio of + the lengths of the semimajor and semiminor axes: + + .. math:: ellip = 1 - \frac{b}{a} + theta : float or `~astropy.units.Quantity`, optional + The rotation angle as an angular quantity + (`~astropy.units.Quantity` or `~astropy.coordinates.Angle`) + or a value in radians (as a float). The rotation angle + increases counterclockwise from the positive x axis. + c : float, optional + Parameter controlling the shape of the generalized ellipses. + Negative values correspond to disky (kite-like) isophotes and + positive values correspond to boxy isophotes. Setting ``c=0`` + provides perfectly elliptical isophotes (the same model as + `Sersic2D`). + + See Also + -------- + Sersic2D, Gaussian2D, Moffat2D + + Notes + ----- + Model formula: + + .. math:: + + I(x, y) = I_{e} \exp\left\{ + -b_{n} \left[\left(\frac{r(x, y)}{r_{e}}\right)^{(1/n)} + -1\right]\right\} + + where :math:`I_{e}` is the ``amplitude``, :math:`r_{e}` + is ``reff``, and :math:`r(x, y)` is a rotated + "generalized" ellipse (see `Athanassoula et al. 1990 + <https://ui.adsabs.harvard.edu/abs/1990MNRAS.245..130A/abstract>`_) + defined as: + + .. math:: + + r(x, y)^2 = |A|^{c + 2} + + \left(\frac{|B|}{1 - ellip}\right)^{c + 2} + + .. math:: + + A = (x - x_0) \cos(\theta) + (y - y_0) \sin(\theta) + + .. math:: + + B = -(x - x_0) \sin(\theta) + (y - y_0) \cos(\theta) + + The constant :math:`b_{n}` is defined such that :math:`r_{e}` + contains half the total luminosity. It can be solved for numerically + from the following equation: + + .. math:: + + \Gamma(2n) = 2\gamma (2n, b_{n}) + + where :math:`\Gamma(a)` is the `gamma function + <https://en.wikipedia.org/wiki/Gamma_function>`_ and + :math:`\gamma(a, x)` is the `lower incomplete gamma function + <https://en.wikipedia.org/wiki/Incomplete_gamma_function>`_. + + Examples + -------- + .. plot:: + :include-source: + + import numpy as np + from astropy.modeling.models import GeneralSersic2D + import matplotlib.pyplot as plt + + x, y = np.meshgrid(np.arange(100), np.arange(100)) + + mod = GeneralSersic2D(amplitude=1, r_eff=25, n=4, x_0=50, y_0=50, + c=-1.0, ellip=0.5, theta=-1) + img = mod(x, y) + log_img = np.log10(img) + + fig, ax = plt.subplots() + im = ax.imshow(log_img, origin='lower', interpolation='nearest', + vmin=-1, vmax=2) + cbar = fig.colorbar(im, ax=ax) + cbar.set_label('Log Brightness', rotation=270, labelpad=25) + cbar.set_ticks([-1, 0, 1, 2]) + plt.title('Disky isophote with c=-1.0') + plt.xlabel('x') + plt.ylabel('y') + plt.show() + + .. plot:: + :include-source: + + import numpy as np + from astropy.modeling.models import GeneralSersic2D + import matplotlib.pyplot as plt + + x, y = np.meshgrid(np.arange(100), np.arange(100)) + + mod = GeneralSersic2D(amplitude=1, r_eff=25, n=4, x_0=50, y_0=50, + c=1.0, ellip=0.5, theta=-1) + img = mod(x, y) + log_img = np.log10(img) + + fig, ax = plt.subplots() + im = ax.imshow(log_img, origin='lower', interpolation='nearest', + vmin=-1, vmax=2) + cbar = fig.colorbar(im, ax=ax) + cbar.set_label('Log Brightness', rotation=270, labelpad=25) + cbar.set_ticks([-1, 0, 1, 2]) + plt.title('Boxy isophote with c=1.0') + plt.xlabel('x') + plt.ylabel('y') + plt.show() + + References + ---------- + .. [1] http://ned.ipac.caltech.edu/level5/March05/Graham/Graham2.html + .. [2] https://ui.adsabs.harvard.edu/abs/1990MNRAS.245..130A/abstract + """ + + amplitude = Parameter(default=1, description="Surface brightness at r_eff") + r_eff = Parameter(default=1, description="Effective (half-light) radius") + n = Parameter(default=4, description="Sersic Index") + x_0 = Parameter(default=0, description="X position of the center") + y_0 = Parameter(default=0, description="Y position of the center") + ellip = Parameter(default=0, description="Ellipticity") + theta = Parameter( + default=0.0, + description=( + "Rotation angle either as a float (in radians) or a |Quantity| angle" + ), + ) + c = Parameter(default=0, description="Isophote shape parameter") + + class KingProjectedAnalytic1D(Fittable1DModel): """ Projected (surface density) analytic King Model. diff --git a/docs/changes/modeling/15545.feature.rst b/docs/changes/modeling/15545.feature.rst new file mode 100644 index 000000000000..4768112a91e8 --- /dev/null +++ b/docs/changes/modeling/15545.feature.rst @@ -0,0 +1,2 @@ +Added a ``GeneralSersic2D`` model that can have "boxy" or "disky" +isophotes. diff --git a/docs/modeling/predef_models2D.rst b/docs/modeling/predef_models2D.rst index 770a7e4a6620..c61e790020fd 100644 --- a/docs/modeling/predef_models2D.rst +++ b/docs/modeling/predef_models2D.rst @@ -54,6 +54,11 @@ an amplitude. a Sersic profile with an effective half-light radius, rotation, and Sersic index +- :class:`~astropy.modeling.functional_models.GeneralSersic2D` model + computes a generalized Sersic profile with an effective half-light + radius, rotation, Sersic index, and a parameter to control the shape of + the isophotes (e.g., boxy or disky) + - :class:`~astropy.modeling.functional_models.TrapezoidDisk2D` model computes a disk with a radius and slope @@ -69,7 +74,8 @@ an amplitude. from astropy.modeling.models import (AiryDisk2D, Box2D, Disk2D, Ellipse2D, Gaussian2D, Moffat2D, RickerWavelet2D, - Sersic2D, TrapezoidDisk2D, Ring2D) + Sersic2D, GeneralSersic2D, + TrapezoidDisk2D, Ring2D) x = np.linspace(-4.0, 6.0, num=100) r = np.logspace(-1.0, 2.0, num=100) @@ -95,18 +101,23 @@ an amplitude. Moffat2D(amplitude=10.0, x_0=1.0, y_0=2.0, alpha=3, gamma=4), RickerWavelet2D(amplitude=10.0, x_0=1.0, y_0=2.0, sigma=1.0), Sersic2D(amplitude=10.0, x_0=1.0, y_0=2.0, r_eff=1.0, ellip=0.5, theta=math.pi/4.), + GeneralSersic2D(amplitude=10.0, x_0=1.0, y_0=2.0, r_eff=1.0, ellip=0.5, theta=math.pi/4., c=-1), + GeneralSersic2D(amplitude=10.0, x_0=1.0, y_0=2.0, r_eff=1.0, ellip=0.5, theta=math.pi/4., c=1), TrapezoidDisk2D(amplitude=10.0, x_0=1.0, y_0=2.0, R_0=1.0, slope=5.0), Ring2D(amplitude=10.0, x_0=1.0, y_0=2.0, r_in=1.0, r_out=2.0)] for k, mod in enumerate(mods): cname = mod.__class__.__name__ - ax[k].set_title(cname) if cname == "AiryDisk2D": normfunc = LogNorm(vmin=0.001, vmax=10.) - elif cname in ["Gaussian2D", "Sersic2D"]: + elif cname in ["Gaussian2D", "Sersic2D", "GeneralSersic2D"]: normfunc = LogNorm(vmin=0.1, vmax=10.) else: normfunc = None + if cname == "GeneralSersic2D": + cname = f'{cname}, c={mod.c.value:.1f}' + ax[k].set_title(cname) + ax[k].imshow(mod(X, Y), extent=[x0, x1, y0, y1], origin="lower", cmap=plt.cm.gray_r, norm=normfunc) diff --git a/docs/whatsnew/6.0.rst b/docs/whatsnew/6.0.rst index 466e3e709b54..126e42dab79b 100644 --- a/docs/whatsnew/6.0.rst +++ b/docs/whatsnew/6.0.rst @@ -21,6 +21,8 @@ In particular, this release includes: * :ref:`whatsnew-6.0-model-annotation-in-votable` * :ref:`whatsnew-6.0-time-delta-quantity-str` * :ref:`whatsnew-6.0-votable-parquet-serialization` +* :ref:`whatsnew-6.0-fits-decompression` +* :ref:`whatsnew-6.0-general-sersic2d` In addition to these major changes, Astropy v6.0 includes a large number of smaller improvements and bug fixes, which are described in the :ref:`changelog`. @@ -443,6 +445,17 @@ decompressing the whole file at once. With the new keyword ``fits.open(..., decompress_in_memory=True)`` it is now possible to decompress the whole file in memory, which will be faster in some cases. +.. _whatsnew-6.0-general-sersic2d: + +New ``GeneralSersic2D`` model +============================= + +A new :class:`~astropy.modeling.functional_models.GeneralSersic2D` model +has been added to the modeling package. This model is a generalized two +dimensional Sersic surface brightness profile that allows for "boxy" or +"disky" (kite-like) isophote shapes. + + Full change log ===============

diff --git a/astropy/modeling/tests/example_models.py b/astropy/modeling/tests/example_models.py index ae79024f1bed..bf90be1e1c9a 100644 --- a/astropy/modeling/tests/example_models.py +++ b/astropy/modeling/tests/example_models.py @@ -66,6 +66,7 @@ Exponential1D, Gaussian1D, Gaussian2D, + GeneralSersic2D, KingProjectedAnalytic1D, Linear1D, Logarithmic1D, @@ -439,6 +440,15 @@ "x_lim": [1, 1e10], "y_lim": [1, 1e10], }, + GeneralSersic2D: { + "parameters": [1, 25, 4, 50, 50, 0.5, -1, 1.0], + "x_values": [0.0, 1, 10, 100], + "y_values": [1, 100, 0.0, 10], + "z_values": [0.01711221, 0.10471922, 0.02426327, 0.1201565], + "requires_scipy": True, + "x_lim": [1, 1e10], + "y_lim": [1, 1e10], + }, Planar2D: { "parameters": [1, 1, 0], "x_values": [0, np.pi, 42, -1], diff --git a/astropy/modeling/tests/test_models_quantities.py b/astropy/modeling/tests/test_models_quantities.py index 42bc409af0d3..404dc3b4c7c3 100644 --- a/astropy/modeling/tests/test_models_quantities.py +++ b/astropy/modeling/tests/test_models_quantities.py @@ -28,6 +28,7 @@ Exponential1D, Gaussian1D, Gaussian2D, + GeneralSersic2D, KingProjectedAnalytic1D, Linear1D, Logarithmic1D, @@ -405,6 +406,23 @@ "evaluation": [(3 * u.arcsec, 2.5 * u.arcsec, 2.829990489 * u.MJy / u.sr)], "bounding_box": False, }, + { + "class": GeneralSersic2D, + "parameters": { + "amplitude": 3 * u.MJy / u.sr, + "x_0": 1 * u.arcsec, + "y_0": 2 * u.arcsec, + "r_eff": 2 * u.arcsec, + "n": 4, + "c": 1, + "ellip": 0, + "theta": 0, + }, + "evaluation": [ + (3 * u.arcsec, 2.5 * u.arcsec, 2.9704014001846475 * u.MJy / u.sr) + ], + "bounding_box": False, + }, { "class": Planar2D, "parameters": {"slope_x": 2 * u.m, "slope_y": 3 * u.m, "intercept": 4 * u.m}, @@ -550,13 +568,14 @@ + POLY_MODELS ) -SCIPY_MODELS = {Sersic1D, Sersic2D, AiryDisk2D} +SCIPY_MODELS = {Sersic1D, Sersic2D, GeneralSersic2D, AiryDisk2D} # These models will fail fitting test, because built in fitting data # will produce non-finite values NON_FINITE_LevMar_MODELS = [ Sersic1D, Sersic2D, + GeneralSersic2D, ArcSine1D, ArcCosine1D, PowerLaw1D, @@ -572,6 +591,7 @@ ArcCosine1D, Sersic1D, Sersic2D, + GeneralSersic2D, PowerLaw1D, ExponentialCutoffPowerLaw1D, BrokenPowerLaw1D, @@ -587,12 +607,14 @@ Schechter1D, ExponentialCutoffPowerLaw1D, BrokenPowerLaw1D, + GeneralSersic2D, ] # These models will fail the DogBoxLSQFitter fitting test due to non-finite NON_FINITE_DogBox_MODELS = [ Sersic1D, Sersic2D, + GeneralSersic2D, ArcSine1D, ArcCosine1D, SmoothlyBrokenPowerLaw1D,

diff --git a/docs/changes/modeling/15545.feature.rst b/docs/changes/modeling/15545.feature.rst new file mode 100644 index 000000000000..4768112a91e8 --- /dev/null +++ b/docs/changes/modeling/15545.feature.rst @@ -0,0 +1,2 @@ +Added a ``GeneralSersic2D`` model that can have "boxy" or "disky" +isophotes. diff --git a/docs/modeling/predef_models2D.rst b/docs/modeling/predef_models2D.rst index 770a7e4a6620..c61e790020fd 100644 --- a/docs/modeling/predef_models2D.rst +++ b/docs/modeling/predef_models2D.rst @@ -54,6 +54,11 @@ an amplitude. a Sersic profile with an effective half-light radius, rotation, and Sersic index +- :class:`~astropy.modeling.functional_models.GeneralSersic2D` model + computes a generalized Sersic profile with an effective half-light + radius, rotation, Sersic index, and a parameter to control the shape of + the isophotes (e.g., boxy or disky) + - :class:`~astropy.modeling.functional_models.TrapezoidDisk2D` model computes a disk with a radius and slope @@ -69,7 +74,8 @@ an amplitude. from astropy.modeling.models import (AiryDisk2D, Box2D, Disk2D, Ellipse2D, Gaussian2D, Moffat2D, RickerWavelet2D, - Sersic2D, TrapezoidDisk2D, Ring2D) + Sersic2D, GeneralSersic2D, + TrapezoidDisk2D, Ring2D) x = np.linspace(-4.0, 6.0, num=100) r = np.logspace(-1.0, 2.0, num=100) @@ -95,18 +101,23 @@ an amplitude. Moffat2D(amplitude=10.0, x_0=1.0, y_0=2.0, alpha=3, gamma=4), RickerWavelet2D(amplitude=10.0, x_0=1.0, y_0=2.0, sigma=1.0), Sersic2D(amplitude=10.0, x_0=1.0, y_0=2.0, r_eff=1.0, ellip=0.5, theta=math.pi/4.), + GeneralSersic2D(amplitude=10.0, x_0=1.0, y_0=2.0, r_eff=1.0, ellip=0.5, theta=math.pi/4., c=-1), + GeneralSersic2D(amplitude=10.0, x_0=1.0, y_0=2.0, r_eff=1.0, ellip=0.5, theta=math.pi/4., c=1), TrapezoidDisk2D(amplitude=10.0, x_0=1.0, y_0=2.0, R_0=1.0, slope=5.0), Ring2D(amplitude=10.0, x_0=1.0, y_0=2.0, r_in=1.0, r_out=2.0)] for k, mod in enumerate(mods): cname = mod.__class__.__name__ - ax[k].set_title(cname) if cname == "AiryDisk2D": normfunc = LogNorm(vmin=0.001, vmax=10.) - elif cname in ["Gaussian2D", "Sersic2D"]: + elif cname in ["Gaussian2D", "Sersic2D", "GeneralSersic2D"]: normfunc = LogNorm(vmin=0.1, vmax=10.) else: normfunc = None + if cname == "GeneralSersic2D": + cname = f'{cname}, c={mod.c.value:.1f}' + ax[k].set_title(cname) + ax[k].imshow(mod(X, Y), extent=[x0, x1, y0, y1], origin="lower", cmap=plt.cm.gray_r, norm=normfunc) diff --git a/docs/whatsnew/6.0.rst b/docs/whatsnew/6.0.rst index 466e3e709b54..126e42dab79b 100644 --- a/docs/whatsnew/6.0.rst +++ b/docs/whatsnew/6.0.rst @@ -21,6 +21,8 @@ In particular, this release includes: * :ref:`whatsnew-6.0-model-annotation-in-votable` * :ref:`whatsnew-6.0-time-delta-quantity-str` * :ref:`whatsnew-6.0-votable-parquet-serialization` +* :ref:`whatsnew-6.0-fits-decompression` +* :ref:`whatsnew-6.0-general-sersic2d` In addition to these major changes, Astropy v6.0 includes a large number of smaller improvements and bug fixes, which are described in the :ref:`changelog`. @@ -443,6 +445,17 @@ decompressing the whole file at once. With the new keyword ``fits.open(..., decompress_in_memory=True)`` it is now possible to decompress the whole file in memory, which will be faster in some cases. +.. _whatsnew-6.0-general-sersic2d: + +New ``GeneralSersic2D`` model +============================= + +A new :class:`~astropy.modeling.functional_models.GeneralSersic2D` model +has been added to the modeling package. This model is a generalized two +dimensional Sersic surface brightness profile that allows for "boxy" or +"disky" (kite-like) isophote shapes. + + Full change log ===============

[ { "components": [ { "doc": "Generalized two dimensional Sersic surface brightness profile that\nallows for \"boxy\" or \"disky\" (kite-like) isophote shapes.\n\nParameters\n----------\namplitude : float\n Surface brightness at ``r_eff``.\nr_eff : float\n Effective (half-light) radius.\nn : f...

[ "astropy/modeling/tests/test_models_quantities.py::test_models_evaluate_without_units[model0]", "astropy/modeling/tests/test_models_quantities.py::test_models_evaluate_without_units[model2]", "astropy/modeling/tests/test_models_quantities.py::test_models_evaluate_without_units[model3]", "astropy/modeling/test...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add GeneralSersic2D model      ### Description    This PR adds a `GeneralSersic2D` model, which is a generalized two dimensional Sersic surface brightness profile that allows for "boxy" or "disky" (kite-like) isophote shapes.   - [x] By checking this box, the PR author has requested that maintainers do **NOT** use the "Squash and Merge" button. Maintainers should respect this when possible; however, the final decision is at the discretion of the maintainer that merges the PR. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in astropy/modeling/functional_models.py] (definition of GeneralSersic2D:) class GeneralSersic2D(Sersic2D): """Generalized two dimensional Sersic surface brightness profile that allows for "boxy" or "disky" (kite-like) isophote shapes. Parameters ---------- amplitude : float Surface brightness at ``r_eff``. r_eff : float Effective (half-light) radius. n : float Sersic index controlling the shape of the profile. Particular values of ``n`` are equivalent to the following profiles: * n=4 : `de Vaucouleurs <https://en.wikipedia.org/wiki/De_Vaucouleurs%27s_law>`_ :math:`r^{1/4}` profile * n=1 : Exponential profile * n=0.5 : Gaussian profile x_0 : float, optional x position of the center. y_0 : float, optional y position of the center. ellip : float, optional Ellipticity of the isophote, defined as 1.0 minus the ratio of the lengths of the semimajor and semiminor axes: .. math:: ellip = 1 - \frac{b}{a} theta : float or `~astropy.units.Quantity`, optional The rotation angle as an angular quantity (`~astropy.units.Quantity` or `~astropy.coordinates.Angle`) or a value in radians (as a float). The rotation angle increases counterclockwise from the positive x axis. c : float, optional Parameter controlling the shape of the generalized ellipses. Negative values correspond to disky (kite-like) isophotes and positive values correspond to boxy isophotes. Setting ``c=0`` provides perfectly elliptical isophotes (the same model as `Sersic2D`). See Also -------- Sersic2D, Gaussian2D, Moffat2D Notes ----- Model formula: .. math:: I(x, y) = I_{e} \exp\left\{ -b_{n} \left[\left(\frac{r(x, y)}{r_{e}}\right)^{(1/n)} -1\right]\right\} where :math:`I_{e}` is the ``amplitude``, :math:`r_{e}` is ``reff``, and :math:`r(x, y)` is a rotated "generalized" ellipse (see `Athanassoula et al. 1990 <https://ui.adsabs.harvard.edu/abs/1990MNRAS.245..130A/abstract>`_) defined as: .. math:: r(x, y)^2 = |A|^{c + 2} + \left(\frac{|B|}{1 - ellip}\right)^{c + 2} .. math:: A = (x - x_0) \cos(\theta) + (y - y_0) \sin(\theta) .. math:: B = -(x - x_0) \sin(\theta) + (y - y_0) \cos(\theta) The constant :math:`b_{n}` is defined such that :math:`r_{e}` contains half the total luminosity. It can be solved for numerically from the following equation: .. math:: \Gamma(2n) = 2\gamma (2n, b_{n}) where :math:`\Gamma(a)` is the `gamma function <https://en.wikipedia.org/wiki/Gamma_function>`_ and :math:`\gamma(a, x)` is the `lower incomplete gamma function <https://en.wikipedia.org/wiki/Incomplete_gamma_function>`_. Examples -------- .. plot:: :include-source: import numpy as np from astropy.modeling.models import GeneralSersic2D import matplotlib.pyplot as plt x, y = np.meshgrid(np.arange(100), np.arange(100)) mod = GeneralSersic2D(amplitude=1, r_eff=25, n=4, x_0=50, y_0=50, c=-1.0, ellip=0.5, theta=-1) img = mod(x, y) log_img = np.log10(img) fig, ax = plt.subplots() im = ax.imshow(log_img, origin='lower', interpolation='nearest', vmin=-1, vmax=2) cbar = fig.colorbar(im, ax=ax) cbar.set_label('Log Brightness', rotation=270, labelpad=25) cbar.set_ticks([-1, 0, 1, 2]) plt.title('Disky isophote with c=-1.0') plt.xlabel('x') plt.ylabel('y') plt.show() .. plot:: :include-source: import numpy as np from astropy.modeling.models import GeneralSersic2D import matplotlib.pyplot as plt x, y = np.meshgrid(np.arange(100), np.arange(100)) mod = GeneralSersic2D(amplitude=1, r_eff=25, n=4, x_0=50, y_0=50, c=1.0, ellip=0.5, theta=-1) img = mod(x, y) log_img = np.log10(img) fig, ax = plt.subplots() im = ax.imshow(log_img, origin='lower', interpolation='nearest', vmin=-1, vmax=2) cbar = fig.colorbar(im, ax=ax) cbar.set_label('Log Brightness', rotation=270, labelpad=25) cbar.set_ticks([-1, 0, 1, 2]) plt.title('Boxy isophote with c=1.0') plt.xlabel('x') plt.ylabel('y') plt.show() References ---------- .. [1] http://ned.ipac.caltech.edu/level5/March05/Graham/Graham2.html .. [2] https://ui.adsabs.harvard.edu/abs/1990MNRAS.245..130A/abstract""" [end of new definitions in astropy/modeling/functional_models.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

2d281019494aaebf522f6626c0dae37510c16688

tobymao__sqlglot-2467

2,467

tobymao/sqlglot

null

7407568a428e18de42ed6fe82a21a3958a2d8db3

2023-10-27T03:06:02Z

diff --git a/sqlglot/dialects/dialect.py b/sqlglot/dialects/dialect.py index 739e8d7254..acdd17eaf2 100644 --- a/sqlglot/dialects/dialect.py +++ b/sqlglot/dialects/dialect.py @@ -809,13 +809,6 @@ def isnull_to_is_null(args: t.List) -> exp.Expression: return exp.Paren(this=exp.Is(this=seq_get(args, 0), expression=exp.null())) -def move_insert_cte_sql(self: Generator, expression: exp.Insert) -> str: - if expression.expression.args.get("with"): - expression = expression.copy() - expression.set("with", expression.expression.args["with"].pop()) - return self.insert_sql(expression) - - def generatedasidentitycolumnconstraint_sql( self: Generator, expression: exp.GeneratedAsIdentityColumnConstraint ) -> str: diff --git a/sqlglot/dialects/hive.py b/sqlglot/dialects/hive.py index fee08578a1..e28b803f17 100644 --- a/sqlglot/dialects/hive.py +++ b/sqlglot/dialects/hive.py @@ -413,6 +413,7 @@ class Generator(generator.Generator): INDEX_ON = "ON TABLE" EXTRACT_ALLOWS_QUOTES = False NVL2_SUPPORTED = False + SUPPORTS_NESTED_CTES = False TYPE_MAPPING = { **generator.Generator.TYPE_MAPPING, diff --git a/sqlglot/dialects/spark.py b/sqlglot/dialects/spark.py index 8461920fe8..1abfce6151 100644 --- a/sqlglot/dialects/spark.py +++ b/sqlglot/dialects/spark.py @@ -63,6 +63,8 @@ def _parse_generated_as_identity( return this class Generator(Spark2.Generator): + SUPPORTS_NESTED_CTES = True + TYPE_MAPPING = { **Spark2.Generator.TYPE_MAPPING, exp.DataType.Type.MONEY: "DECIMAL(15, 4)", diff --git a/sqlglot/dialects/spark2.py b/sqlglot/dialects/spark2.py index 2fd4f4efca..515d03a5f0 100644 --- a/sqlglot/dialects/spark2.py +++ b/sqlglot/dialects/spark2.py @@ -7,7 +7,6 @@ binary_from_function, format_time_lambda, is_parse_json, - move_insert_cte_sql, pivot_column_names, rename_func, trim_sql, @@ -188,7 +187,6 @@ class Generator(Hive.Generator): exp.DayOfYear: rename_func("DAYOFYEAR"), exp.FileFormatProperty: lambda self, e: f"USING {e.name.upper()}", exp.From: transforms.preprocess([_unalias_pivot]), - exp.Insert: move_insert_cte_sql, exp.LogicalAnd: rename_func("BOOL_AND"), exp.LogicalOr: rename_func("BOOL_OR"), exp.Map: _map_sql, diff --git a/sqlglot/dialects/tsql.py b/sqlglot/dialects/tsql.py index 867e4e4792..f3ecc07d67 100644 --- a/sqlglot/dialects/tsql.py +++ b/sqlglot/dialects/tsql.py @@ -11,7 +11,6 @@ generatedasidentitycolumnconstraint_sql, max_or_greatest, min_or_least, - move_insert_cte_sql, parse_date_delta, rename_func, timestrtotime_sql, @@ -596,6 +595,8 @@ class Generator(generator.Generator): ALTER_TABLE_ADD_COLUMN_KEYWORD = False LIMIT_FETCH = "FETCH" COMPUTED_COLUMN_WITH_TYPE = False + SUPPORTS_NESTED_CTES = False + CTE_RECURSIVE_KEYWORD_REQUIRED = False TYPE_MAPPING = { **generator.Generator.TYPE_MAPPING, @@ -622,7 +623,6 @@ class Generator(generator.Generator): exp.GeneratedAsIdentityColumnConstraint: generatedasidentitycolumnconstraint_sql, exp.GroupConcat: _string_agg_sql, exp.If: rename_func("IIF"), - exp.Insert: move_insert_cte_sql, exp.Max: max_or_greatest, exp.MD5: lambda self, e: self.func("HASHBYTES", exp.Literal.string("MD5"), e.this), exp.Min: min_or_least, @@ -714,7 +714,7 @@ def create_sql(self, expression: exp.Create) -> str: elif expression.args.get("replace"): sql = sql.replace("CREATE OR REPLACE ", "CREATE OR ALTER ", 1) - return sql + return self.prepend_ctes(expression, sql) def offset_sql(self, expression: exp.Offset) -> str: return f"{super().offset_sql(expression)} ROWS" diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index 7740382d7c..b4275b104a 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -5168,7 +5168,7 @@ class Use(Expression): class Merge(Expression): - arg_types = {"this": True, "using": True, "on": True, "expressions": True} + arg_types = {"this": True, "using": True, "on": True, "expressions": True, "with": False} class When(Func): diff --git a/sqlglot/generator.py b/sqlglot/generator.py index e2d8edf750..6a3ba5ebdc 100644 --- a/sqlglot/generator.py +++ b/sqlglot/generator.py @@ -230,6 +230,12 @@ class Generator: # Whether or not data types support additional specifiers like e.g. CHAR or BYTE (oracle) DATA_TYPE_SPECIFIERS_ALLOWED = False + # Whether or not nested CTEs (e.g. defined inside of subqueries) are allowed + SUPPORTS_NESTED_CTES = True + + # Whether or not the "RECURSIVE" keyword is required when defining recursive CTEs + CTE_RECURSIVE_KEYWORD_REQUIRED = True + TYPE_MAPPING = { exp.DataType.Type.NCHAR: "CHAR", exp.DataType.Type.NVARCHAR: "VARCHAR", @@ -468,6 +474,20 @@ def generate( if cache is not None: self._cache = cache + # Some dialects only support CTEs at the top level expression, so we need to bubble up nested + # CTEs to that level in order to produce a syntactically valid expression. This transformation + # happens here to minimize code duplication, since many expressions support CTEs. + if ( + not self.SUPPORTS_NESTED_CTES + and isinstance(expression, exp.Expression) + and not expression.parent + and "with" in expression.arg_types + and any(node.parent is not expression for node in expression.find_all(exp.With)) + ): + from sqlglot.transforms import move_ctes_to_top_level + + expression = move_ctes_to_top_level(expression.copy()) + self.unsupported_messages = [] sql = self.sql(expression).strip() self._cache = None @@ -879,7 +899,11 @@ def prepend_ctes(self, expression: exp.Expression, sql: str) -> str: def with_sql(self, expression: exp.With) -> str: sql = self.expressions(expression, flat=True) - recursive = "RECURSIVE " if expression.args.get("recursive") else "" + recursive = ( + "RECURSIVE " + if self.CTE_RECURSIVE_KEYWORD_REQUIRED and expression.args.get("recursive") + else "" + ) return f"WITH {recursive}{sql}" @@ -2792,7 +2816,9 @@ def merge_sql(self, expression: exp.Merge) -> str: on = f"ON {self.sql(expression, 'on')}" expressions = self.expressions(expression, sep=" ") - return f"MERGE INTO {this}{table_alias} {using} {on} {expressions}" + return self.prepend_ctes( + expression, f"MERGE INTO {this}{table_alias} {using} {on} {expressions}" + ) def tochar_sql(self, expression: exp.ToChar) -> str: if expression.args.get("format"): diff --git a/sqlglot/transforms.py b/sqlglot/transforms.py index 80b6623337..c59d66fc1e 100644 --- a/sqlglot/transforms.py +++ b/sqlglot/transforms.py @@ -398,6 +398,36 @@ def eliminate_full_outer_join(expression: exp.Expression) -> exp.Expression: return expression +def move_ctes_to_top_level(expression: exp.Expression) -> exp.Expression: + """ + Some dialects (e.g. Hive, T-SQL, Spark prior to version 3) only allow CTEs to be + defined at the top-level, so for example queries like: + + SELECT * FROM (WITH t(c) AS (SELECT 1) SELECT * FROM t) AS subq + + are invalid in those dialects. This transformation can be used to ensure all CTEs are + moved to the top level so that the final SQL code is valid from a syntax standpoint. + + TODO: handle name clashes whilst moving CTEs (it can get quite tricky & costly). + """ + top_level_with = expression.args.get("with") + for node in expression.find_all(exp.With): + if node.parent is expression: + continue + + inner_with = node.pop() + if not top_level_with: + top_level_with = inner_with + expression.set("with", top_level_with) + else: + if inner_with.recursive: + top_level_with.set("recursive", True) + + top_level_with.expressions.extend(inner_with.expressions) + + return expression + + def preprocess( transforms: t.List[t.Callable[[exp.Expression], exp.Expression]], ) -> t.Callable[[Generator, exp.Expression], str]:

diff --git a/tests/dialects/test_dialect.py b/tests/dialects/test_dialect.py index 0d43b2aea1..7bf780f17d 100644 --- a/tests/dialects/test_dialect.py +++ b/tests/dialects/test_dialect.py @@ -1861,3 +1861,41 @@ def test_qualify(self): "tsql": "SELECT * FROM (SELECT *, COUNT(*) OVER () AS _w FROM t) AS _t WHERE _w > 1", }, ) + + def test_nested_ctes(self): + self.validate_all( + "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + write={ + "bigquery": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "clickhouse": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "databricks": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "duckdb": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "hive": "WITH t AS (SELECT 1 AS c) SELECT * FROM (SELECT c FROM t) AS subq", + "mysql": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "postgres": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "presto": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "redshift": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "snowflake": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "spark": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "spark2": "WITH t AS (SELECT 1 AS c) SELECT * FROM (SELECT c FROM t) AS subq", + "sqlite": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "trino": "SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq", + "tsql": "WITH t AS (SELECT 1 AS c) SELECT * FROM (SELECT c FROM t) AS subq", + }, + ) + self.validate_all( + "SELECT * FROM (SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq1) AS subq2", + write={ + "bigquery": "SELECT * FROM (SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq1) AS subq2", + "duckdb": "SELECT * FROM (SELECT * FROM (WITH t AS (SELECT 1 AS c) SELECT c FROM t) AS subq1) AS subq2", + "hive": "WITH t AS (SELECT 1 AS c) SELECT * FROM (SELECT * FROM (SELECT c FROM t) AS subq1) AS subq2", + "tsql": "WITH t AS (SELECT 1 AS c) SELECT * FROM (SELECT * FROM (SELECT c FROM t) AS subq1) AS subq2", + }, + ) + self.validate_all( + "WITH t1(x) AS (SELECT 1) SELECT * FROM (WITH t2(y) AS (SELECT 2) SELECT y FROM t2) AS subq", + write={ + "duckdb": "WITH t1(x) AS (SELECT 1) SELECT * FROM (WITH t2(y) AS (SELECT 2) SELECT y FROM t2) AS subq", + "tsql": "WITH t1(x) AS (SELECT 1), t2(y) AS (SELECT 2) SELECT * FROM (SELECT y FROM t2) AS subq", + }, + ) diff --git a/tests/dialects/test_spark.py b/tests/dialects/test_spark.py index e08915b75d..841a005365 100644 --- a/tests/dialects/test_spark.py +++ b/tests/dialects/test_spark.py @@ -592,9 +592,10 @@ def test_insert_cte(self): self.validate_all( "INSERT OVERWRITE TABLE table WITH cte AS (SELECT cola FROM other_table) SELECT cola FROM cte", write={ - "spark": "WITH cte AS (SELECT cola FROM other_table) INSERT OVERWRITE TABLE table SELECT cola FROM cte", + "databricks": "INSERT OVERWRITE TABLE table WITH cte AS (SELECT cola FROM other_table) SELECT cola FROM cte", + "hive": "WITH cte AS (SELECT cola FROM other_table) INSERT OVERWRITE TABLE table SELECT cola FROM cte", + "spark": "INSERT OVERWRITE TABLE table WITH cte AS (SELECT cola FROM other_table) SELECT cola FROM cte", "spark2": "WITH cte AS (SELECT cola FROM other_table) INSERT OVERWRITE TABLE table SELECT cola FROM cte", - "databricks": "WITH cte AS (SELECT cola FROM other_table) INSERT OVERWRITE TABLE table SELECT cola FROM cte", }, ) diff --git a/tests/dialects/test_tsql.py b/tests/dialects/test_tsql.py index 47750207f2..479f87b9e9 100644 --- a/tests/dialects/test_tsql.py +++ b/tests/dialects/test_tsql.py @@ -6,6 +6,36 @@ class TestTSQL(Validator): dialect = "tsql" def test_tsql(self): + self.validate_all( + "WITH t(c) AS (SELECT 1) SELECT * INTO foo FROM (SELECT c FROM t) AS temp", + read={ + "duckdb": "CREATE TABLE foo AS WITH t(c) AS (SELECT 1) SELECT c FROM t", + }, + ) + self.validate_all( + "WITH y AS (SELECT 2 AS c) INSERT INTO t SELECT * FROM y", + read={ + "duckdb": "WITH y AS (SELECT 2 AS c) INSERT INTO t SELECT * FROM y", + }, + ) + self.validate_all( + "WITH t(c) AS (SELECT 1) SELECT 1 AS c UNION (SELECT c FROM t)", + read={ + "duckdb": "SELECT 1 AS c UNION (WITH t(c) AS (SELECT 1) SELECT c FROM t)", + }, + ) + self.validate_all( + "WITH t(c) AS (SELECT 1) MERGE INTO x AS z USING (SELECT c FROM t) AS y ON a = b WHEN MATCHED THEN UPDATE SET a = y.b", + read={ + "postgres": "MERGE INTO x AS z USING (WITH t(c) AS (SELECT 1) SELECT c FROM t) AS y ON a = b WHEN MATCHED THEN UPDATE SET a = y.b", + }, + ) + self.validate_all( + "WITH t(n) AS (SELECT 1 AS n UNION ALL SELECT n + 1 AS n FROM t WHERE n < 4) SELECT * FROM (SELECT SUM(n) AS s4 FROM t) AS subq", + read={ + "duckdb": "SELECT * FROM (WITH RECURSIVE t(n) AS (SELECT 1 AS n UNION ALL SELECT n + 1 AS n FROM t WHERE n < 4) SELECT SUM(n) AS s4 FROM t) AS subq", + }, + ) self.validate_all( "CREATE TABLE #mytemptable (a INTEGER)", read={

[]

[ "tests/dialects/test_dialect.py::TestDialect::test_nested_ctes", "tests/dialects/test_spark.py::TestSpark::test_insert_cte", "tests/dialects/test_tsql.py::TestTSQL::test_tsql" ]

[ "tests/dialects/test_dialect.py::TestDialect::test_alias", "tests/dialects/test_dialect.py::TestDialect::test_array", "tests/dialects/test_dialect.py::TestDialect::test_cast", "tests/dialects/test_dialect.py::TestDialect::test_cast_to_user_defined_type", "tests/dialects/test_dialect.py::TestDialect::test_co...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat!(hive,tsql): move CTEs to top-level, fix T-SQL recursive CTEs This PR: - Moves all CTEs to the top-level expression for Hive, Spark2 and T-SQL, since they don't allow nested CTEs - Fixes a transpilation issue towards T-SQL related to recursive CTEs (the `RECURSIVE` keyword needs to be omitted) - Adds support for parsing & generating CTEs in `MERGE` statements The motivation behind touching `generate` instead of adding new entries in `TRANSFORMS` was mainly to avoid duplicating the same code for ~10 expressions that support CTEs x2 dialects (Hive, T-SQL). One downside of the current approach is that Hive and T-SQL suffer from an additional perf. hit due to the preemptive `copy` call that happens in `move_ctes_to_top_level` when the input expression is 1) at the root of the AST and 2) supports CTEs. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

ceb42fabad60312699e4b15936aeebac00e22e4d

boto__botocore-3044

3,044

boto/botocore

null

b0c6a7630fc612529037d17b6f16f70343c3d87e

2023-10-26T01:49:05Z

diff --git a/.changes/next-release/feature-ContainerProvider-78717.json b/.changes/next-release/feature-ContainerProvider-78717.json new file mode 100644 index 0000000000..0f856432a5 --- /dev/null +++ b/.changes/next-release/feature-ContainerProvider-78717.json @@ -0,0 +1,5 @@ +{ + "type": "feature", + "category": "ContainerProvider", + "description": "Added Support for EKS container credentials" +} diff --git a/botocore/credentials.py b/botocore/credentials.py index 6c2d72013c..2f3b969466 100644 --- a/botocore/credentials.py +++ b/botocore/credentials.py @@ -1886,6 +1886,7 @@ class ContainerProvider(CredentialProvider): ENV_VAR = 'AWS_CONTAINER_CREDENTIALS_RELATIVE_URI' ENV_VAR_FULL = 'AWS_CONTAINER_CREDENTIALS_FULL_URI' ENV_VAR_AUTH_TOKEN = 'AWS_CONTAINER_AUTHORIZATION_TOKEN' + ENV_VAR_AUTH_TOKEN_FILE = 'AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE' def __init__(self, environ=None, fetcher=None): if environ is None: @@ -1919,10 +1920,21 @@ def _retrieve_or_fail(self): ) def _build_headers(self): - auth_token = self._environ.get(self.ENV_VAR_AUTH_TOKEN) + auth_token = None + if self.ENV_VAR_AUTH_TOKEN_FILE in self._environ: + auth_token_file_path = self._environ[self.ENV_VAR_AUTH_TOKEN_FILE] + with open(auth_token_file_path) as token_file: + auth_token = token_file.read() + elif self.ENV_VAR_AUTH_TOKEN in self._environ: + auth_token = self._environ[self.ENV_VAR_AUTH_TOKEN] if auth_token is not None: + self._validate_auth_token(auth_token) return {'Authorization': auth_token} + def _validate_auth_token(self, auth_token): + if "\r" in auth_token or "\n" in auth_token: + raise ValueError("Auth token value is not a legal header value") + def _create_fetcher(self, full_uri, headers): def fetch_creds(): try: diff --git a/botocore/utils.py b/botocore/utils.py index 266d204629..6ce4f008fa 100644 --- a/botocore/utils.py +++ b/botocore/utils.py @@ -25,6 +25,7 @@ import time import warnings import weakref +from ipaddress import ip_address from pathlib import Path from urllib.request import getproxies, proxy_bypass @@ -2903,7 +2904,12 @@ class ContainerMetadataFetcher: RETRY_ATTEMPTS = 3 SLEEP_TIME = 1 IP_ADDRESS = '169.254.170.2' - _ALLOWED_HOSTS = [IP_ADDRESS, 'localhost', '127.0.0.1'] + _ALLOWED_HOSTS = [ + IP_ADDRESS, + '169.254.170.23', + 'fd00:ec2::23', + 'localhost', + ] def __init__(self, session=None, sleep=time.sleep): if session is None: @@ -2927,21 +2933,29 @@ def retrieve_full_uri(self, full_url, headers=None): def _validate_allowed_url(self, full_url): parsed = botocore.compat.urlparse(full_url) + if self._is_loopback_address(parsed.hostname): + return is_whitelisted_host = self._check_if_whitelisted_host(parsed.hostname) if not is_whitelisted_host: raise ValueError( - "Unsupported host '%s'. Can only " - "retrieve metadata from these hosts: %s" - % (parsed.hostname, ', '.join(self._ALLOWED_HOSTS)) + f"Unsupported host '{parsed.hostname}'. Can only retrieve metadata " + f"from a loopback address or one of these hosts: {', '.join(self._ALLOWED_HOSTS)}" ) + def _is_loopback_address(self, hostname): + try: + ip = ip_address(hostname) + return ip.is_loopback + except ValueError: + return False + def _check_if_whitelisted_host(self, host): if host in self._ALLOWED_HOSTS: return True return False def retrieve_uri(self, relative_uri): - """Retrieve JSON metadata from ECS metadata. + """Retrieve JSON metadata from container metadata. :type relative_uri: str :param relative_uri: A relative URI, e.g "/foo/bar?id=123" @@ -2983,22 +2997,20 @@ def _get_response(self, full_url, headers, timeout): if response.status_code != 200: raise MetadataRetrievalError( error_msg=( - "Received non 200 response (%s) from ECS metadata: %s" + f"Received non 200 response {response.status_code} " + f"from container metadata: {response_text}" ) - % (response.status_code, response_text) ) try: return json.loads(response_text) except ValueError: - error_msg = ( - "Unable to parse JSON returned from ECS metadata services" - ) + error_msg = "Unable to parse JSON returned from container metadata services" logger.debug('%s:%s', error_msg, response_text) raise MetadataRetrievalError(error_msg=error_msg) except RETRYABLE_HTTP_ERRORS as e: error_msg = ( "Received error when attempting to retrieve " - "ECS metadata: %s" % e + f"container metadata: {e}" ) raise MetadataRetrievalError(error_msg=error_msg)

diff --git a/tests/unit/test_credentials.py b/tests/unit/test_credentials.py index 4301b6446f..089fcc8695 100644 --- a/tests/unit/test_credentials.py +++ b/tests/unit/test_credentials.py @@ -2968,6 +2968,14 @@ def test_refresh_giving_expired_credentials_raises_exception(self): class TestContainerProvider(BaseEnvVar): + def setUp(self): + super().setUp() + self.tempdir = tempfile.mkdtemp() + + def tearDown(self): + super().tearDown() + shutil.rmtree(self.tempdir) + def test_noop_if_env_var_is_not_set(self): # The 'AWS_CONTAINER_CREDENTIALS_RELATIVE_URI' env var # is not present as an env var. @@ -3128,6 +3136,58 @@ def test_can_pass_basic_auth_token(self): self.assertEqual(creds.token, 'token') self.assertEqual(creds.method, 'container-role') + def test_can_pass_auth_token_from_file(self): + token_file_path = os.path.join(self.tempdir, 'token.jwt') + with open(token_file_path, 'w') as token_file: + token_file.write('Basic auth-token') + environ = { + 'AWS_CONTAINER_CREDENTIALS_FULL_URI': 'http://localhost/foo', + 'AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE': token_file_path, + } + fetcher = self.create_fetcher() + timeobj = datetime.now(tzlocal()) + timestamp = (timeobj + timedelta(hours=24)).isoformat() + fetcher.retrieve_full_uri.return_value = { + "AccessKeyId": "access_key", + "SecretAccessKey": "secret_key", + "Token": "token", + "Expiration": timestamp, + } + provider = credentials.ContainerProvider(environ, fetcher) + creds = provider.load() + + fetcher.retrieve_full_uri.assert_called_with( + 'http://localhost/foo', + headers={'Authorization': 'Basic auth-token'}, + ) + self.assertEqual(creds.access_key, 'access_key') + self.assertEqual(creds.secret_key, 'secret_key') + self.assertEqual(creds.token, 'token') + self.assertEqual(creds.method, 'container-role') + + def test_throws_error_on_invalid_token_file(self): + token_file_path = '/some/path/token.jwt' + environ = { + 'AWS_CONTAINER_CREDENTIALS_FULL_URI': 'http://localhost/foo', + 'AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE': token_file_path, + } + fetcher = self.create_fetcher() + provider = credentials.ContainerProvider(environ, fetcher) + + with self.assertRaises(FileNotFoundError): + provider.load() + + def test_throws_error_on_illegal_header(self): + environ = { + 'AWS_CONTAINER_CREDENTIALS_FULL_URI': 'http://localhost/foo', + 'AWS_CONTAINER_AUTHORIZATION_TOKEN': 'invalid\r\ntoken', + } + fetcher = self.create_fetcher() + provider = credentials.ContainerProvider(environ, fetcher) + + with self.assertRaises(ValueError): + provider.load() + class TestProcessProvider(BaseEnvVar): def setUp(self): diff --git a/tests/unit/test_utils.py b/tests/unit/test_utils.py index ddd3c80b34..d79976329f 100644 --- a/tests/unit/test_utils.py +++ b/tests/unit/test_utils.py @@ -2218,7 +2218,7 @@ def get_s3_accesspoint_request( self, accesspoint_name=None, accesspoint_context=None, - **s3_request_kwargs + **s3_request_kwargs, ): if not accesspoint_name: accesspoint_name = self.accesspoint_name @@ -2579,9 +2579,8 @@ def test_error_raised_on_no_json_response(self): self.assertEqual(self.http.send.call_count, fetcher.RETRY_ATTEMPTS) def test_can_retrieve_full_uri_with_fixed_ip(self): - self.assert_can_retrieve_metadata_from( - 'http://%s/foo?id=1' % ContainerMetadataFetcher.IP_ADDRESS - ) + uri = f'http://{ContainerMetadataFetcher.IP_ADDRESS}/foo?id=1' + self.assert_can_retrieve_metadata_from(uri) def test_localhost_http_is_allowed(self): self.assert_can_retrieve_metadata_from('http://localhost/foo') @@ -2598,6 +2597,21 @@ def test_can_use_127_ip_addr(self): def test_can_use_127_ip_addr_with_port(self): self.assert_can_retrieve_metadata_from('https://127.0.0.1:8080/foo') + def test_can_use_eks_ipv4_addr(self): + uri = 'http://169.254.170.23/credentials' + self.assert_can_retrieve_metadata_from(uri) + + def test_can_use_eks_ipv6_addr(self): + uri = 'http://[fd00:ec2::23]/credentials' + self.assert_can_retrieve_metadata_from(uri) + + def test_can_use_eks_ipv6_addr_with_port(self): + uri = 'https://[fd00:ec2::23]:8000' + self.assert_can_retrieve_metadata_from(uri) + + def test_can_use_loopback_v6_uri(self): + self.assert_can_retrieve_metadata_from('http://[::1]/credentials') + def test_link_local_http_is_not_allowed(self): self.assert_host_is_not_allowed('http://169.254.0.1/foo')

diff --git a/.changes/next-release/feature-ContainerProvider-78717.json b/.changes/next-release/feature-ContainerProvider-78717.json new file mode 100644 index 0000000000..0f856432a5 --- /dev/null +++ b/.changes/next-release/feature-ContainerProvider-78717.json @@ -0,0 +1,5 @@ +{ + "type": "feature", + "category": "ContainerProvider", + "description": "Added Support for EKS container credentials" +}

[ { "components": [ { "doc": "", "lines": [ 1934, 1936 ], "name": "ContainerProvider._validate_auth_token", "signature": "def _validate_auth_token(self, auth_token):", "type": "function" } ], "file": "botocore/credentials.py" ...

[ "tests/unit/test_credentials.py::TestContainerProvider::test_can_pass_auth_token_from_file", "tests/unit/test_credentials.py::TestContainerProvider::test_throws_error_on_illegal_header", "tests/unit/test_credentials.py::TestContainerProvider::test_throws_error_on_invalid_token_file", "tests/unit/test_utils.py...

[ "tests/unit/test_credentials.py::TestCredentials::test_detect_nonascii_character", "tests/unit/test_credentials.py::TestCredentials::test_unicode_input", "tests/unit/test_credentials.py::TestRefreshableCredentials::test_detect_nonascii_character", "tests/unit/test_credentials.py::TestRefreshableCredentials::t...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feature eks credentials This PR updates the existing container credential fetcher to support retrieving credentials from EKS ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in botocore/credentials.py] (definition of ContainerProvider._validate_auth_token:) def _validate_auth_token(self, auth_token): [end of new definitions in botocore/credentials.py] [start of new definitions in botocore/utils.py] (definition of ContainerMetadataFetcher._is_loopback_address:) def _is_loopback_address(self, hostname): [end of new definitions in botocore/utils.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

5e4b564dd0f9aab16a404251ebd3e675c9681492

sqlfluff__sqlfluff-5349

5,349

sqlfluff/sqlfluff

2.2

65328e6b701f46ebb25b758c10b7572111f130ab

2023-10-24T22:53:18Z

diff --git a/examples/05_simple_api_config.py b/examples/05_simple_api_config.py index 1f52f9e6018..a8dfe885d69 100644 --- a/examples/05_simple_api_config.py +++ b/examples/05_simple_api_config.py @@ -19,9 +19,17 @@ config = FluffConfig(configs={"core": {"dialect": "bigquery"}}) # 3b. FluffConfig objects can be created from a config file in a string. config = FluffConfig.from_string("[sqlfluff]\ndialect=bigquery\n") -# 3c. FluffConfig objects can be created from a path containing a config file. +# 3c. FluffConfig objects can be created from a config file in multiple strings +# to simulate the effect of multiple nested config strings. +config = FluffConfig.from_strings( + # NOTE: Given these two strings, the resulting dialect would be "mysql" + # as the later files take precedence. + "[sqlfluff]\ndialect=bigquery\n", + "[sqlfluff]\ndialect=mysql\n", +) +# 3d. FluffConfig objects can be created from a path containing a config file. config = FluffConfig.from_path("test/fixtures/") -# 3c. FluffConfig objects can be from keyword arguments +# 3e. FluffConfig objects can be from keyword arguments config = FluffConfig.from_kwargs(dialect="bigquery", rules=["LT01"]) # The FluffConfig is then provided via a config argument. diff --git a/src/sqlfluff/core/config.py b/src/sqlfluff/core/config.py index 997d537d8e7..14f3825ef40 100644 --- a/src/sqlfluff/core/config.py +++ b/src/sqlfluff/core/config.py @@ -1,5 +1,7 @@ """Module for loading config.""" +from __future__ import annotations + try: from importlib.resources import files except ImportError: # pragma: no cover @@ -359,7 +361,7 @@ def __init__(self) -> None: self._config_cache: Dict[str, Dict[str, Any]] = {} @classmethod - def get_global(cls) -> "ConfigLoader": + def get_global(cls) -> ConfigLoader: """Get the singleton loader.""" global global_loader if not global_loader: @@ -1022,7 +1024,7 @@ def from_root( ignore_local_config: bool = False, overrides: Optional[Dict[str, Any]] = None, **kw: Any, - ) -> "FluffConfig": + ) -> FluffConfig: """Loads a config object just based on the root directory.""" loader = ConfigLoader.get_global() c = loader.load_config_up_to_path( @@ -1046,8 +1048,8 @@ def from_string( ignore_local_config: bool = False, overrides: Optional[Dict[str, Any]] = None, plugin_manager: Optional[pluggy.PluginManager] = None, - ) -> "FluffConfig": - """Loads a config object given a particular path.""" + ) -> FluffConfig: + """Loads a config object from a single config string.""" loader = ConfigLoader.get_global() c = loader.load_config_string(config_string) return cls( @@ -1058,6 +1060,35 @@ def from_string( plugin_manager=plugin_manager, ) + @classmethod + def from_strings( + cls, + *config_strings: str, + extra_config_path: Optional[str] = None, + ignore_local_config: bool = False, + overrides: Optional[Dict[str, Any]] = None, + plugin_manager: Optional[pluggy.PluginManager] = None, + ) -> FluffConfig: + """Loads a config object given a series of nested config strings. + + Config strings are incorporated from first to last, treating the + first element as the "root" config, and then later config strings + will take precedence over any earlier values. + """ + loader = ConfigLoader.get_global() + config_state: Dict[str, Any] = {} + for config_string in config_strings: + config_state = loader.load_config_string( + config_string, configs=config_state + ) + return cls( + configs=config_state, + extra_config_path=extra_config_path, + ignore_local_config=ignore_local_config, + overrides=overrides, + plugin_manager=plugin_manager, + ) + @classmethod def from_path( cls, @@ -1066,7 +1097,7 @@ def from_path( ignore_local_config: bool = False, overrides: Optional[Dict[str, Any]] = None, plugin_manager: Optional[pluggy.PluginManager] = None, - ) -> "FluffConfig": + ) -> FluffConfig: """Loads a config object given a particular path.""" loader = ConfigLoader.get_global() c = loader.load_config_up_to_path( @@ -1085,12 +1116,12 @@ def from_path( @classmethod def from_kwargs( cls, - config: Optional["FluffConfig"] = None, + config: Optional[FluffConfig] = None, dialect: Optional[str] = None, rules: Optional[List[str]] = None, exclude_rules: Optional[List[str]] = None, require_dialect: bool = True, - ) -> "FluffConfig": + ) -> FluffConfig: """Instantiate a config from either an existing config or kwargs. This is a convenience method for the ways that the public classes @@ -1143,7 +1174,7 @@ def get_templater( "{}".format(templater_name, ", ".join(templater_lookup.keys())) ) - def make_child_from_path(self, path: str) -> "FluffConfig": + def make_child_from_path(self, path: str) -> FluffConfig: """Make a child config at a path but pass on overrides and extra_config_path.""" return self.from_path( path, @@ -1153,7 +1184,7 @@ def make_child_from_path(self, path: str) -> "FluffConfig": plugin_manager=self._plugin_manager, ) - def diff_to(self, other: "FluffConfig") -> Dict[str, Any]: + def diff_to(self, other: FluffConfig) -> Dict[str, Any]: """Compare this config to another. Args:

diff --git a/test/core/config_test.py b/test/core/config_test.py index 673b8061938..707f98bcb3f 100644 --- a/test/core/config_test.py +++ b/test/core/config_test.py @@ -100,6 +100,19 @@ def test__config__load_from_string(): assert cfg == config_a +def test__config__from_strings(): + """Test loading config from multiple strings.""" + strings = [ + "[sqlfluff]\ndialect=mysql\ntesting_val=foobar", + "[sqlfluff]\ndialect=postgres\ntesting_val2=bar", + "[sqlfluff]\ndialect=mysql\ntesting_val=foo", + ] + cfg = FluffConfig.from_strings(*strings) + assert cfg.get("dialect") == "mysql" + assert cfg.get("testing_val2") == "bar" + assert cfg.get("testing_val") == "foo" + + def test__config__load_file_f(): """Test loading config from a file path.""" c = ConfigLoader()

[ { "components": [ { "doc": "Loads a config object given a series of nested config strings.\n\nConfig strings are incorporated from first to last, treating the\nfirst element as the \"root\" config, and then later config strings\nwill take precedence over any earlier values.", "lines": [ ...

[ "test/core/config_test.py::test__config__from_strings" ]

[ "test/core/config_test.py::test__config__nested_combine", "test/core/config_test.py::test__config__dict_diff", "test/core/config_test.py::test__config__load_file_dir", "test/core/config_test.py::test__config__load_from_string", "test/core/config_test.py::test__config__load_file_f", "test/core/config_test....

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add a public API for nesting config strings. This PR resolves #5207. This mostly uses existing machinery to create nested configs, but exposes it in an easier way and includes an example in the API examples folder. Eventually we might want to deprecate `from_string` and only allow `from_strings`, but that turns this into a more breaking release than it needs to be. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/sqlfluff/core/config.py] (definition of FluffConfig.from_strings:) def from_strings( cls, *config_strings: str, extra_config_path: Optional[str] = None, ignore_local_config: bool = False, overrides: Optional[Dict[str, Any]] = None, plugin_manager: Optional[pluggy.PluginManager] = None, ) -> FluffConfig: """Loads a config object given a series of nested config strings. Config strings are incorporated from first to last, treating the first element as the "root" config, and then later config strings will take precedence over any earlier values.""" [end of new definitions in src/sqlfluff/core/config.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Public API to build nested configs ### Search before asking - [X] I searched the [issues](https://github.com/sqlfluff/sqlfluff/issues) and found no similar issues. ### Description I want to have a public API to be able to build `FluffConfig` instance from several config files which override one another, replicating the behaviour with nested `.sqlfluff` configs in the filesystem. ### Use case I'm building a lint functionality which uses SQLFluff. I want the user to be able to provide nested `.sqlfluff` config files in the service's virtual filesystem, so I need to build the config in my own code. I have tried using `nested_combine` like this: ```Python class LintConfigFile: content: str def build_config(config_files: Optional[List[LintConfigFile]]) -> FluffConfig: if not config_files: return None loader = ConfigLoader.get_global() config_dicts = [ loader.load_config_string(config_file.content) for config_file in config_files ] config = nested_combine(*config_dicts) return FluffConfig.from_kwargs(config=config) ``` However, this fails to combine contents of two different config files with this simple unit test: ``` def test_build_config_multiple(self): config = build_config( [ LintConfigFile( content=""" [sqlfluff] dialect = duckdb """ ), LintConfigFile( content=""" [sqlfluff] max_line_length = 120 """ ), ] ) > assert config.get("dialect") == "duckdb" E AssertionError: assert None == 'duckdb' ``` So I ended up using this: ```Python def build_config( config_files: Optional[List[LintConfigFile]], ) -> Optional[FluffConfig]: if not config_files: return None # We build a temporary directory with the config files to replicate sqlfluff # nesting config behavior with tempfile.TemporaryDirectory(dir=TMP_DIR) as temp_dir_path: cur_path = temp_dir_path for i, config_file in enumerate(config_files): cur_path = cur_path + f"/config-{i}" os.makedirs(cur_path) config_path = f"{cur_path}/.sqlfluff" with open(config_path, "w") as f: f.write(config_file.content) return FluffConfig.from_path(cur_path) ``` Which behaves exactly as I expect, but looks to be very unoptimal. ### Dialect not related to particular dialect ### Are you willing to work on and submit a PR to address the issue? - [X] Yes I am willing to submit a PR! ### Code of Conduct - [X] I agree to follow this project's [Code of Conduct](https://github.com/sqlfluff/sqlfluff/blob/main/CODE_OF_CONDUCT.md) ---------- With some experimentation, was able to find a way to achieve creating a config from multiple strings, though still relies on undocumented internals: ```python class LintConfigFile: content: str def build_config( config_files: Optional[List[LintConfigFile]], ) -> Optional[FluffConfig]: loader = ConfigLoader.get_global() configs = nested_combine(*[ loader.load_config_string(config_file.content) for config_file in config_files ]) return FluffConfig(configs=configs) ``` would still be nice to have a method off `FluffConfig` that does this for us. @golergka & @MasterOdin - thanks both for posting a great issue here. I think this should be fairly easy to do. So that I understand what you're thinking, would you imagine a nested combination of strings (i.e. nested combine of unparsed config files) or a nested combine of `FluffConfig` objects? I think the former is slightly easier, and that seems to be more like what you're suggesting in the example test cases, but I thought I should check. The former, where given a list of strings, we get back a `FluffConfig` with them parsed/combined. Rewriting my example function with a proposed API: ``` class LintConfigFile: content: str def build_config( config_files: List[LintConfigFile], ) -> FluffConfig: return FluffConfig.from_strings(config_strings=[config_file.content for config_file in config_files]) ``` -------------------- </issues>

65328e6b701f46ebb25b758c10b7572111f130ab

tobymao__sqlglot-2454

2,454

tobymao/sqlglot

null

c8e87b6cab18924b6fa307252f19e83eef4f2f03

2023-10-24T17:42:27Z

diff --git a/sqlglot/dataframe/sql/functions.py b/sqlglot/dataframe/sql/functions.py index 1abbef18a8..a424ea4516 100644 --- a/sqlglot/dataframe/sql/functions.py +++ b/sqlglot/dataframe/sql/functions.py @@ -84,11 +84,11 @@ def min(col: ColumnOrName) -> Column: def max_by(col: ColumnOrName, ord: ColumnOrName) -> Column: - return Column.invoke_anonymous_function(col, "MAX_BY", ord) + return Column.invoke_expression_over_column(col, expression.ArgMax, expression=ord) def min_by(col: ColumnOrName, ord: ColumnOrName) -> Column: - return Column.invoke_anonymous_function(col, "MIN_BY", ord) + return Column.invoke_expression_over_column(col, expression.ArgMin, expression=ord) def count(col: ColumnOrName) -> Column: diff --git a/sqlglot/dialects/bigquery.py b/sqlglot/dialects/bigquery.py index 8cb8698bd2..51baba2300 100644 --- a/sqlglot/dialects/bigquery.py +++ b/sqlglot/dialects/bigquery.py @@ -8,6 +8,7 @@ from sqlglot._typing import E from sqlglot.dialects.dialect import ( Dialect, + arg_max_or_min_no_count, binary_from_function, date_add_interval_sql, datestrtodate_sql, @@ -434,6 +435,8 @@ class Generator(generator.Generator): TRANSFORMS = { **generator.Generator.TRANSFORMS, exp.ApproxDistinct: rename_func("APPROX_COUNT_DISTINCT"), + exp.ArgMax: arg_max_or_min_no_count("MAX_BY"), + exp.ArgMin: arg_max_or_min_no_count("MIN_BY"), exp.ArraySize: rename_func("ARRAY_LENGTH"), exp.Cast: transforms.preprocess([transforms.remove_precision_parameterized_types]), exp.CollateProperty: lambda self, e: f"DEFAULT COLLATE {self.sql(e, 'this')}" diff --git a/sqlglot/dialects/clickhouse.py b/sqlglot/dialects/clickhouse.py index a935cce36a..30f728c796 100644 --- a/sqlglot/dialects/clickhouse.py +++ b/sqlglot/dialects/clickhouse.py @@ -5,6 +5,7 @@ from sqlglot import exp, generator, parser, tokens, transforms from sqlglot.dialects.dialect import ( Dialect, + arg_max_or_min_no_count, inline_array_sql, no_pivot_sql, rename_func, @@ -373,6 +374,8 @@ class Generator(generator.Generator): exp.Select: transforms.preprocess([transforms.eliminate_qualify]), exp.AnyValue: rename_func("any"), exp.ApproxDistinct: rename_func("uniq"), + exp.ArgMax: arg_max_or_min_no_count("argMax"), + exp.ArgMin: arg_max_or_min_no_count("argMin"), exp.Array: inline_array_sql, exp.CastToStrType: rename_func("CAST"), exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"), diff --git a/sqlglot/dialects/dialect.py b/sqlglot/dialects/dialect.py index ac6b42cb06..739e8d7254 100644 --- a/sqlglot/dialects/dialect.py +++ b/sqlglot/dialects/dialect.py @@ -822,3 +822,13 @@ def generatedasidentitycolumnconstraint_sql( start = self.sql(expression, "start") or "1" increment = self.sql(expression, "increment") or "1" return f"IDENTITY({start}, {increment})" + + +def arg_max_or_min_no_count(name: str) -> t.Callable[[Generator, exp.ArgMax | exp.ArgMin], str]: + def _arg_max_or_min_sql(self: Generator, expression: exp.ArgMax | exp.ArgMin) -> str: + if expression.args.get("count"): + self.unsupported(f"Only two arguments are supported in function {name}.") + + return self.func(name, expression.this, expression.expression) + + return _arg_max_or_min_sql diff --git a/sqlglot/dialects/duckdb.py b/sqlglot/dialects/duckdb.py index 7bbe4eecaf..287e03afd1 100644 --- a/sqlglot/dialects/duckdb.py +++ b/sqlglot/dialects/duckdb.py @@ -6,6 +6,7 @@ from sqlglot.dialects.dialect import ( Dialect, approx_count_distinct_sql, + arg_max_or_min_no_count, arrow_json_extract_scalar_sql, arrow_json_extract_sql, binary_from_function, @@ -249,6 +250,8 @@ class Generator(generator.Generator): if e.expressions and e.expressions[0].find(exp.Select) else inline_array_sql(self, e), exp.ArraySize: rename_func("ARRAY_LENGTH"), + exp.ArgMax: arg_max_or_min_no_count("ARG_MAX"), + exp.ArgMin: arg_max_or_min_no_count("ARG_MIN"), exp.ArraySort: _array_sort_sql, exp.ArraySum: rename_func("LIST_SUM"), exp.BitwiseXor: rename_func("XOR"), diff --git a/sqlglot/dialects/hive.py b/sqlglot/dialects/hive.py index 23a6f3e294..7bff553396 100644 --- a/sqlglot/dialects/hive.py +++ b/sqlglot/dialects/hive.py @@ -6,6 +6,7 @@ from sqlglot.dialects.dialect import ( Dialect, approx_count_distinct_sql, + arg_max_or_min_no_count, create_with_partitions_sql, format_time_lambda, if_sql, @@ -431,6 +432,8 @@ class Generator(generator.Generator): exp.Property: _property_sql, exp.AnyValue: rename_func("FIRST"), exp.ApproxDistinct: approx_count_distinct_sql, + exp.ArgMax: arg_max_or_min_no_count("MAX_BY"), + exp.ArgMin: arg_max_or_min_no_count("MIN_BY"), exp.ArrayConcat: rename_func("CONCAT"), exp.ArrayJoin: lambda self, e: self.func("CONCAT_WS", e.expression, e.this), exp.ArraySize: rename_func("SIZE"), diff --git a/sqlglot/dialects/presto.py b/sqlglot/dialects/presto.py index 791e82dc64..aac368cb70 100644 --- a/sqlglot/dialects/presto.py +++ b/sqlglot/dialects/presto.py @@ -280,6 +280,8 @@ class Generator(generator.Generator): exp.AnyValue: rename_func("ARBITRARY"), exp.ApproxDistinct: _approx_distinct_sql, exp.ApproxQuantile: rename_func("APPROX_PERCENTILE"), + exp.ArgMax: rename_func("MAX_BY"), + exp.ArgMin: rename_func("MIN_BY"), exp.Array: lambda self, e: f"ARRAY[{self.expressions(e, flat=True)}]", exp.ArrayConcat: rename_func("CONCAT"), exp.ArrayContains: rename_func("CONTAINS"), diff --git a/sqlglot/dialects/snowflake.py b/sqlglot/dialects/snowflake.py index 3ad170f2a4..07be65b95e 100644 --- a/sqlglot/dialects/snowflake.py +++ b/sqlglot/dialects/snowflake.py @@ -460,6 +460,8 @@ class Generator(generator.Generator): TRANSFORMS = { **generator.Generator.TRANSFORMS, + exp.ArgMax: rename_func("MAX_BY"), + exp.ArgMin: rename_func("MIN_BY"), exp.Array: inline_array_sql, exp.ArrayConcat: rename_func("ARRAY_CAT"), exp.ArrayJoin: rename_func("ARRAY_TO_STRING"), diff --git a/sqlglot/dialects/teradata.py b/sqlglot/dialects/teradata.py index 0aeb0d693a..152afa6a14 100644 --- a/sqlglot/dialects/teradata.py +++ b/sqlglot/dialects/teradata.py @@ -3,7 +3,7 @@ import typing as t from sqlglot import exp, generator, parser, tokens, transforms -from sqlglot.dialects.dialect import Dialect, max_or_greatest, min_or_least +from sqlglot.dialects.dialect import Dialect, max_or_greatest, min_or_least, rename_func from sqlglot.tokens import TokenType @@ -169,6 +169,8 @@ class Generator(generator.Generator): TRANSFORMS = { **generator.Generator.TRANSFORMS, + exp.ArgMax: rename_func("MAX_BY"), + exp.ArgMin: rename_func("MIN_BY"), exp.Max: max_or_greatest, exp.Min: min_or_least, exp.Select: transforms.preprocess( diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index 2d1ebc2d78..5b012b156b 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -4189,6 +4189,16 @@ class Abs(Func): pass +class ArgMax(AggFunc): + arg_types = {"this": True, "expression": True, "count": False} + _sql_names = ["ARG_MAX", "ARGMAX", "MAX_BY"] + + +class ArgMin(AggFunc): + arg_types = {"this": True, "expression": True, "count": False} + _sql_names = ["ARG_MIN", "ARGMIN", "MIN_BY"] + + class ApproxTopK(AggFunc): arg_types = {"this": True, "expression": False, "counters": False}

diff --git a/tests/dialects/test_presto.py b/tests/dialects/test_presto.py index 96a2512882..ed734b6da6 100644 --- a/tests/dialects/test_presto.py +++ b/tests/dialects/test_presto.py @@ -558,6 +558,37 @@ def test_presto(self, logger): "SELECT SPLIT_TO_MAP('a:1;b:2;a:3', ';', ':', (k, v1, v2) -> CONCAT(v1, v2))" ) + self.validate_all( + "SELECT MAX_BY(a.id, a.timestamp) FROM a", + read={ + "bigquery": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + "clickhouse": "SELECT argMax(a.id, a.timestamp) FROM a", + "duckdb": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + "snowflake": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + "spark": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + "teradata": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + }, + write={ + "bigquery": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + "clickhouse": "SELECT argMax(a.id, a.timestamp) FROM a", + "duckdb": "SELECT ARG_MAX(a.id, a.timestamp) FROM a", + "presto": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + "snowflake": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + "spark": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + "teradata": "SELECT MAX_BY(a.id, a.timestamp) FROM a", + }, + ) + self.validate_all( + "SELECT MIN_BY(a.id, a.timestamp, 3) FROM a", + write={ + "clickhouse": "SELECT argMin(a.id, a.timestamp) FROM a", + "duckdb": "SELECT ARG_MIN(a.id, a.timestamp) FROM a", + "presto": "SELECT MIN_BY(a.id, a.timestamp, 3) FROM a", + "snowflake": "SELECT MIN_BY(a.id, a.timestamp, 3) FROM a", + "spark": "SELECT MIN_BY(a.id, a.timestamp) FROM a", + "teradata": "SELECT MIN_BY(a.id, a.timestamp, 3) FROM a", + }, + ) self.validate_all( """JSON '"foo"'""", write={

[]

[ "tests/dialects/test_presto.py::TestPresto::test_presto" ]

[ "tests/dialects/test_presto.py::TestPresto::test_cast", "tests/dialects/test_presto.py::TestPresto::test_ddl", "tests/dialects/test_presto.py::TestPresto::test_encode_decode", "tests/dialects/test_presto.py::TestPresto::test_hex_unhex", "tests/dialects/test_presto.py::TestPresto::test_interval_plural_to_sin...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat: add ArgMax, ArgMin expressions, fix their transpilation Fixes #2453 References: - https://clickhouse.com/docs/en/sql-reference/aggregate-functions/reference/argmin - https://clickhouse.com/docs/en/sql-reference/aggregate-functions/reference/argmax - https://trino.io/docs/current/functions/aggregate.html?highlight=max_by#max_by - https://duckdb.org/docs/sql/aggregates.html - https://spark.apache.org/docs/latest/api/sql/index.html - https://teradata.github.io/presto/docs/0.167-t/functions/aggregate.html - https://docs.snowflake.com/en/sql-reference/functions/min_by - https://cloud.google.com/bigquery/docs/reference/standard-sql/aggregate_functions#max_by ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Clickhouse/Trino/Duckdb max_by() doesn't transpile Trino and Duckdb have an aggregate function `max_by` which returns the value corresponding to the maximum of the 2nd argument. Clickhouse calls their function `argMax`. sqlglot currently ignores this function instead of renaming it. ```python In [120]: import sqlglot In [121]: sql = "SELECT max_by(a.id, a.timestamp) FROM a" In [122]: sqlglot.transpile(sql, read="trino", write="clickhouse")[0] Out[122]: 'SELECT max_by(a.id, a.timestamp) FROM a' In [123]: sqlglot.transpile(sql, read="duckdb", write="clickhouse")[0] Out[123]: 'SELECT max_by(a.id, a.timestamp) FROM a' In [124]: sqlglot.transpile(sql, read="trino", write="duckdb")[0] Out[124]: 'SELECT MAX_BY(a.id, a.timestamp) FROM a' # NOTE this is valid because duckdb has an argmax alias for arg_max (also max_by). In [125]: sqlglot.transpile("SELECT argMax(a.id, a.timestamp) FROM a", read="clickhouse", write="duckdb")[0] Out[125]: 'SELECT ARGMAX(a.id, a.timestamp) FROM a' In [126]: sqlglot.transpile("SELECT argMax(a.id, a.timestamp) FROM a", read="clickhouse", write="trino")[0] Out[126]: 'SELECT ARGMAX(a.id, a.timestamp) FROM a' ``` **Official Documentation** Please include links to official SQL documentation related to your issue. https://clickhouse.com/docs/en/sql-reference/aggregate-functions/reference/argmax https://trino.io/docs/current/functions/aggregate.html?highlight=max_by#max_by https://duckdb.org/docs/sql/aggregates.html ---------- -------------------- </issues>

ceb42fabad60312699e4b15936aeebac00e22e4d

spec-first__connexion-1754

1,754

spec-first/connexion

null

1b72019b1bcd31191d4a37c2e4e7212dfe94566b

2023-10-23T22:27:23Z

diff --git a/connexion/apps/abstract.py b/connexion/apps/abstract.py index f70767984..c8912be1e 100644 --- a/connexion/apps/abstract.py +++ b/connexion/apps/abstract.py @@ -10,10 +10,12 @@ from starlette.types import ASGIApp, Receive, Scope, Send from connexion.jsonifier import Jsonifier +from connexion.lifecycle import ConnexionRequest, ConnexionResponse from connexion.middleware import ConnexionMiddleware, MiddlewarePosition, SpecMiddleware from connexion.middleware.lifespan import Lifespan from connexion.options import SwaggerUIOptions from connexion.resolver import Resolver +from connexion.types import MaybeAwaitable from connexion.uri_parsing import AbstractURIParser @@ -250,14 +252,18 @@ def decorator(func: t.Callable) -> t.Callable: @abc.abstractmethod def add_error_handler( - self, code_or_exception: t.Union[int, t.Type[Exception]], function: t.Callable + self, + code_or_exception: t.Union[int, t.Type[Exception]], + function: t.Callable[ + [ConnexionRequest, Exception], MaybeAwaitable[ConnexionResponse] + ], ) -> None: """ Register a callable to handle application errors. :param code_or_exception: An exception class or the status code of HTTP exceptions to handle. - :param function: Callable that will handle exception. + :param function: Callable that will handle exception, may be async. """ def test_client(self, **kwargs): diff --git a/connexion/apps/asynchronous.py b/connexion/apps/asynchronous.py index 9974381fd..9ab08a401 100644 --- a/connexion/apps/asynchronous.py +++ b/connexion/apps/asynchronous.py @@ -14,11 +14,13 @@ from connexion.apps.abstract import AbstractApp from connexion.decorators import StarletteDecorator from connexion.jsonifier import Jsonifier +from connexion.lifecycle import ConnexionRequest, ConnexionResponse from connexion.middleware.abstract import RoutedAPI, RoutedMiddleware from connexion.middleware.lifespan import Lifespan from connexion.operations import AbstractOperation from connexion.options import SwaggerUIOptions from connexion.resolver import Resolver +from connexion.types import MaybeAwaitable from connexion.uri_parsing import AbstractURIParser logger = logging.getLogger(__name__) @@ -88,7 +90,7 @@ def make_operation(self, operation: AbstractOperation) -> AsyncOperation: ) -class AsyncMiddlewareApp(RoutedMiddleware[AsyncApi]): +class AsyncASGIApp(RoutedMiddleware[AsyncApi]): api_cls = AsyncApi @@ -176,7 +178,7 @@ def __init__( :param security_map: A dictionary of security handlers to use. Defaults to :obj:`security.SECURITY_HANDLERS` """ - self._middleware_app: AsyncMiddlewareApp = AsyncMiddlewareApp() + self._middleware_app: AsyncASGIApp = AsyncASGIApp() super().__init__( import_name, @@ -205,6 +207,10 @@ def add_url_rule( ) def add_error_handler( - self, code_or_exception: t.Union[int, t.Type[Exception]], function: t.Callable + self, + code_or_exception: t.Union[int, t.Type[Exception]], + function: t.Callable[ + [ConnexionRequest, Exception], MaybeAwaitable[ConnexionResponse] + ], ) -> None: self.middleware.add_error_handler(code_or_exception, function) diff --git a/connexion/apps/flask.py b/connexion/apps/flask.py index a584c344b..98345ff8d 100644 --- a/connexion/apps/flask.py +++ b/connexion/apps/flask.py @@ -6,23 +6,22 @@ import typing as t import flask -import werkzeug.exceptions from a2wsgi import WSGIMiddleware from flask import Response as FlaskResponse -from flask import signals from starlette.types import Receive, Scope, Send from connexion.apps.abstract import AbstractApp from connexion.decorators import FlaskDecorator -from connexion.exceptions import InternalServerError, ProblemException, ResolverError +from connexion.exceptions import ResolverError from connexion.frameworks import flask as flask_utils from connexion.jsonifier import Jsonifier +from connexion.lifecycle import ConnexionRequest, ConnexionResponse from connexion.middleware.abstract import AbstractRoutingAPI, SpecMiddleware from connexion.middleware.lifespan import Lifespan from connexion.operations import AbstractOperation from connexion.options import SwaggerUIOptions -from connexion.problem import problem from connexion.resolver import Resolver +from connexion.types import MaybeAwaitable from connexion.uri_parsing import AbstractURIParser @@ -117,44 +116,20 @@ def add_url_rule( return self.blueprint.add_url_rule(rule, endpoint, view_func, **options) -class FlaskMiddlewareApp(SpecMiddleware): +class FlaskASGIApp(SpecMiddleware): def __init__(self, import_name, server_args: dict, **kwargs): self.app = flask.Flask(import_name, **server_args) self.app.json = flask_utils.FlaskJSONProvider(self.app) self.app.url_map.converters["float"] = flask_utils.NumberConverter self.app.url_map.converters["int"] = flask_utils.IntegerConverter - self.set_errors_handlers() + # Propagate Errors so we can handle them in the middleware + self.app.config["PROPAGATE_EXCEPTIONS"] = True + self.app.config["TRAP_BAD_REQUEST_ERRORS"] = True + self.app.config["TRAP_HTTP_EXCEPTIONS"] = True self.asgi_app = WSGIMiddleware(self.app.wsgi_app) - def set_errors_handlers(self): - for error_code in werkzeug.exceptions.default_exceptions: - self.app.register_error_handler(error_code, self.common_error_handler) - - self.app.register_error_handler(ProblemException, self.common_error_handler) - - def common_error_handler(self, exception: Exception) -> FlaskResponse: - """Default error handler.""" - if isinstance(exception, ProblemException): - response = exception.to_problem() - else: - if not isinstance(exception, werkzeug.exceptions.HTTPException): - exception = InternalServerError() - - response = problem( - title=exception.name, - detail=exception.description, - status=exception.code, - ) - - if response.status_code >= 500: - signals.got_request_exception.send(self.app, exception=exception) - - return flask.make_response( - (response.body, response.status_code, response.headers) - ) - def add_api(self, specification, *, name: str = None, **kwargs): api = FlaskApi(specification, **kwargs) @@ -177,7 +152,7 @@ async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None: class FlaskApp(AbstractApp): """Connexion Application based on ConnexionMiddleware wrapping a Flask application.""" - _middleware_app: FlaskMiddlewareApp + _middleware_app: FlaskASGIApp def __init__( self, @@ -237,7 +212,7 @@ def __init__( :param security_map: A dictionary of security handlers to use. Defaults to :obj:`security.SECURITY_HANDLERS` """ - self._middleware_app = FlaskMiddlewareApp(import_name, server_args or {}) + self._middleware_app = FlaskASGIApp(import_name, server_args or {}) self.app = self._middleware_app.app super().__init__( import_name, @@ -266,6 +241,10 @@ def add_url_rule( ) def add_error_handler( - self, code_or_exception: t.Union[int, t.Type[Exception]], function: t.Callable + self, + code_or_exception: t.Union[int, t.Type[Exception]], + function: t.Callable[ + [ConnexionRequest, Exception], MaybeAwaitable[ConnexionResponse] + ], ) -> None: self.app.register_error_handler(code_or_exception, function) diff --git a/connexion/context.py b/connexion/context.py index b72fa079d..e21128c70 100644 --- a/connexion/context.py +++ b/connexion/context.py @@ -3,7 +3,7 @@ from starlette.types import Receive, Scope from werkzeug.local import LocalProxy -from connexion.lifecycle import ASGIRequest +from connexion.lifecycle import ConnexionRequest from connexion.operations import AbstractOperation UNBOUND_MESSAGE = ( @@ -25,5 +25,5 @@ scope = LocalProxy(_scope, unbound_message=UNBOUND_MESSAGE) request = LocalProxy( - lambda: ASGIRequest(scope, receive), unbound_message=UNBOUND_MESSAGE + lambda: ConnexionRequest(scope, receive), unbound_message=UNBOUND_MESSAGE ) diff --git a/connexion/decorators/parameter.py b/connexion/decorators/parameter.py index 3ae1e0fb0..ea12a69bc 100644 --- a/connexion/decorators/parameter.py +++ b/connexion/decorators/parameter.py @@ -16,7 +16,7 @@ from connexion.context import context, operation from connexion.frameworks.abstract import Framework from connexion.http_facts import FORM_CONTENT_TYPES -from connexion.lifecycle import ASGIRequest, WSGIRequest +from connexion.lifecycle import ConnexionRequest, WSGIRequest from connexion.operations import AbstractOperation, Swagger2Operation from connexion.utils import ( deep_merge, @@ -43,7 +43,7 @@ def __init__( def _maybe_get_body( self, - request: t.Union[WSGIRequest, ASGIRequest], + request: t.Union[WSGIRequest, ConnexionRequest], *, arguments: t.List[str], has_kwargs: bool, @@ -95,7 +95,7 @@ def __call__(self, function: t.Callable) -> t.Callable: arguments, has_kwargs = inspect_function_arguments(unwrapped_function) @functools.wraps(function) - async def wrapper(request: ASGIRequest) -> t.Any: + async def wrapper(request: ConnexionRequest) -> t.Any: request_body = self._maybe_get_body( request, arguments=arguments, has_kwargs=has_kwargs ) @@ -118,7 +118,7 @@ async def wrapper(request: ASGIRequest) -> t.Any: def prep_kwargs( - request: t.Union[WSGIRequest, ASGIRequest], + request: t.Union[WSGIRequest, ConnexionRequest], *, request_body: t.Any, files: t.Dict[str, t.Any], diff --git a/connexion/frameworks/starlette.py b/connexion/frameworks/starlette.py index 702c7e48f..097c10e54 100644 --- a/connexion/frameworks/starlette.py +++ b/connexion/frameworks/starlette.py @@ -8,7 +8,7 @@ from starlette.types import Receive, Scope from connexion.frameworks.abstract import Framework -from connexion.lifecycle import ASGIRequest +from connexion.lifecycle import ConnexionRequest from connexion.uri_parsing import AbstractURIParser @@ -48,8 +48,8 @@ def build_response( ) @staticmethod - def get_request(*, scope: Scope, receive: Receive, uri_parser: AbstractURIParser, **kwargs) -> ASGIRequest: # type: ignore - return ASGIRequest(scope, receive, uri_parser=uri_parser) + def get_request(*, scope: Scope, receive: Receive, uri_parser: AbstractURIParser, **kwargs) -> ConnexionRequest: # type: ignore + return ConnexionRequest(scope, receive, uri_parser=uri_parser) PATH_PARAMETER = re.compile(r"\{([^}]*)\}") diff --git a/connexion/lifecycle.py b/connexion/lifecycle.py index e002207e0..a388d79e2 100644 --- a/connexion/lifecycle.py +++ b/connexion/lifecycle.py @@ -130,7 +130,7 @@ def __getattr__(self, item): return getattr(self._werkzeug_request, item) -class ASGIRequest(_RequestInterface): +class ConnexionRequest(_RequestInterface): """ Implementation of the Connexion :code:`_RequestInterface` representing an ASGI request. @@ -142,7 +142,9 @@ class ASGIRequest(_RequestInterface): """ def __init__(self, *args, uri_parser=None, **kwargs): - self._starlette_request = StarletteRequest(*args, **kwargs) + # Might be set in `from_starlette_request` class method + if not hasattr(self, "_starlette_request"): + self._starlette_request = StarletteRequest(*args, **kwargs) self.uri_parser = uri_parser self._context = None @@ -152,6 +154,16 @@ def __init__(self, *args, uri_parser=None, **kwargs): self._form = None self._files = None + @classmethod + def from_starlette_request( + cls, request: StarletteRequest, uri_parser=None + ) -> "ConnexionRequest": + # Instantiate the class, and set the `_starlette_request` property before initializing. + self = cls.__new__(cls) + self._starlette_request = request + self.__init__(uri_parser=uri_parser) # type: ignore + return self + @property def context(self): if self._context is None: @@ -226,7 +238,8 @@ async def get_body(self): return await self.body() or None def __getattr__(self, item): - return getattr(self._starlette_request, item) + if self.__getattribute__("_starlette_request"): + return getattr(self._starlette_request, item) class ConnexionResponse: diff --git a/connexion/middleware/exceptions.py b/connexion/middleware/exceptions.py index cba002d7b..e76f4b93e 100644 --- a/connexion/middleware/exceptions.py +++ b/connexion/middleware/exceptions.py @@ -1,68 +1,114 @@ +import asyncio import logging +import typing as t +import werkzeug.exceptions +from starlette.concurrency import run_in_threadpool from starlette.exceptions import HTTPException from starlette.middleware.exceptions import ( ExceptionMiddleware as StarletteExceptionMiddleware, ) from starlette.requests import Request as StarletteRequest -from starlette.responses import Response +from starlette.responses import Response as StarletteResponse from starlette.types import ASGIApp, Receive, Scope, Send from connexion.exceptions import InternalServerError, ProblemException, problem +from connexion.lifecycle import ConnexionRequest, ConnexionResponse +from connexion.types import MaybeAwaitable logger = logging.getLogger(__name__) -class ExceptionMiddleware(StarletteExceptionMiddleware): - """Subclass of starlette ExceptionMiddleware to change handling of HTTP exceptions to - existing connexion behavior.""" +def connexion_wrapper( + handler: t.Callable[ + [ConnexionRequest, Exception], MaybeAwaitable[ConnexionResponse] + ] +) -> t.Callable[[StarletteRequest, Exception], t.Awaitable[StarletteResponse]]: + """Wrapper that translates Starlette requests to Connexion requests before passing + them to the error handler, and translates the returned Connexion responses to + Starlette responses.""" - def __init__(self, next_app: ASGIApp): - super().__init__(next_app) - self.add_exception_handler(ProblemException, self.problem_handler) - self.add_exception_handler(Exception, self.common_error_handler) + async def wrapper(request: StarletteRequest, exc: Exception) -> StarletteResponse: + request = ConnexionRequest.from_starlette_request(request) - @staticmethod - def problem_handler(_request: StarletteRequest, exc: ProblemException): - logger.error("%r", exc) + if asyncio.iscoroutinefunction(handler): + response = await handler(request, exc) # type: ignore + else: + response = await run_in_threadpool(handler, request, exc) - response = exc.to_problem() - - return Response( + return StarletteResponse( content=response.body, status_code=response.status_code, media_type=response.mimetype, headers=response.headers, ) - @staticmethod - def http_exception(_request: StarletteRequest, exc: HTTPException) -> Response: - logger.error("%r", exc) + return wrapper + - headers = exc.headers +class ExceptionMiddleware(StarletteExceptionMiddleware): + """Subclass of starlette ExceptionMiddleware to change handling of HTTP exceptions to + existing connexion behavior.""" - connexion_response = problem( - title=exc.detail, detail=exc.detail, status=exc.status_code, headers=headers + def __init__(self, next_app: ASGIApp): + super().__init__(next_app) + self.add_exception_handler(ProblemException, self.problem_handler) # type: ignore + self.add_exception_handler( + werkzeug.exceptions.HTTPException, self.flask_error_handler ) + self.add_exception_handler(Exception, self.common_error_handler) - return Response( - content=connexion_response.body, - status_code=connexion_response.status_code, - media_type=connexion_response.mimetype, - headers=connexion_response.headers, + def add_exception_handler( + self, + exc_class_or_status_code: t.Union[int, t.Type[Exception]], + handler: t.Callable[[ConnexionRequest, Exception], StarletteResponse], + ) -> None: + super().add_exception_handler( + exc_class_or_status_code, handler=connexion_wrapper(handler) ) @staticmethod - def common_error_handler(_request: StarletteRequest, exc: Exception) -> Response: - logger.error("%r", exc, exc_info=exc) + def problem_handler(_request: ConnexionRequest, exc: ProblemException): + """Default handler for Connexion ProblemExceptions""" + logger.error("%r", exc) + return exc.to_problem() - response = InternalServerError().to_problem() + @staticmethod + @connexion_wrapper + def http_exception( + _request: StarletteRequest, exc: HTTPException, **kwargs + ) -> StarletteResponse: + """Default handler for Starlette HTTPException""" + logger.error("%r", exc) + return problem( + title=exc.detail, + detail=exc.detail, + status=exc.status_code, + headers=exc.headers, + ) - return Response( - content=response.body, - status_code=response.status_code, - media_type=response.mimetype, - headers=response.headers, + @staticmethod + def common_error_handler( + _request: StarletteRequest, exc: Exception + ) -> ConnexionResponse: + """Default handler for any unhandled Exception""" + logger.error("%r", exc, exc_info=exc) + return InternalServerError().to_problem() + + def flask_error_handler( + self, request: StarletteRequest, exc: werkzeug.exceptions.HTTPException + ) -> ConnexionResponse: + """Default handler for Flask / werkzeug HTTPException""" + # If a handler is registered for the received status_code, call it instead. + # This is only done automatically for Starlette HTTPExceptions + if handler := self._status_handlers.get(exc.code): + starlette_exception = HTTPException(exc.code, detail=exc.description) + return handler(request, starlette_exception) + + return problem( + title=exc.name, + detail=exc.description, + status=exc.code, ) async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None: diff --git a/connexion/middleware/main.py b/connexion/middleware/main.py index ded10d925..075fac664 100644 --- a/connexion/middleware/main.py +++ b/connexion/middleware/main.py @@ -12,6 +12,7 @@ from connexion import utils from connexion.handlers import ResolverErrorHandler from connexion.jsonifier import Jsonifier +from connexion.lifecycle import ConnexionRequest, ConnexionResponse from connexion.middleware.abstract import SpecMiddleware from connexion.middleware.context import ContextMiddleware from connexion.middleware.exceptions import ExceptionMiddleware @@ -23,6 +24,7 @@ from connexion.middleware.swagger_ui import SwaggerUIMiddleware from connexion.options import SwaggerUIOptions from connexion.resolver import Resolver +from connexion.types import MaybeAwaitable from connexion.uri_parsing import AbstractURIParser from connexion.utils import inspect_function_arguments @@ -419,14 +421,18 @@ def add_api( self.apis.append(api) def add_error_handler( - self, code_or_exception: t.Union[int, t.Type[Exception]], function: t.Callable + self, + code_or_exception: t.Union[int, t.Type[Exception]], + function: t.Callable[ + [ConnexionRequest, Exception], MaybeAwaitable[ConnexionResponse] + ], ) -> None: """ Register a callable to handle application errors. :param code_or_exception: An exception class or the status code of HTTP exceptions to handle. - :param function: Callable that will handle exception. + :param function: Callable that will handle exception, may be async. """ if self.middleware_stack is not None: raise RuntimeError( diff --git a/connexion/middleware/security.py b/connexion/middleware/security.py index 6c4d9010f..7180c56e6 100644 --- a/connexion/middleware/security.py +++ b/connexion/middleware/security.py @@ -5,7 +5,7 @@ from starlette.types import ASGIApp, Receive, Scope, Send from connexion.exceptions import ProblemException -from connexion.lifecycle import ASGIRequest +from connexion.lifecycle import ConnexionRequest from connexion.middleware.abstract import RoutedAPI, RoutedMiddleware from connexion.operations import AbstractOperation from connexion.security import SecurityHandlerFactory @@ -95,7 +95,7 @@ async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None: await self.next_app(scope, receive, send) return - request = ASGIRequest(scope) + request = ConnexionRequest(scope) await self.verification_fn(request) await self.next_app(scope, receive, send) diff --git a/connexion/security.py b/connexion/security.py index c9e273cd2..692d34d91 100644 --- a/connexion/security.py +++ b/connexion/security.py @@ -54,7 +54,7 @@ from connexion.decorators.parameter import inspect_function_arguments from connexion.exceptions import OAuthProblem, OAuthResponseProblem, OAuthScopeProblem -from connexion.lifecycle import ASGIRequest +from connexion.lifecycle import ConnexionRequest from connexion.utils import get_function_from_name logger = logging.getLogger(__name__) @@ -248,7 +248,7 @@ def get_fn(self, security_scheme, required_scopes): def _get_verify_func(self, api_key_info_func, loc, name): check_api_key_func = self.check_api_key(api_key_info_func) - def wrapper(request: ASGIRequest): + def wrapper(request: ConnexionRequest): if loc == "query": api_key = request.query_params.get(name) elif loc == "header": diff --git a/connexion/types.py b/connexion/types.py new file mode 100644 index 000000000..ee20ecfa3 --- /dev/null +++ b/connexion/types.py @@ -0,0 +1,4 @@ +import typing as t + +ReturnType = t.TypeVar("ReturnType") +MaybeAwaitable = t.Union[t.Awaitable[ReturnType], ReturnType] diff --git a/docs/context.rst b/docs/context.rst index 288fd56ea..de344674c 100644 --- a/docs/context.rst +++ b/docs/context.rst @@ -24,12 +24,13 @@ See below for an explanation of the different variables. request ------- -A ``Request`` object representing the incoming request. This is an instance of the ``ASGIRequest``. +A ``Request`` object representing the incoming request. This is an instance of the +``ConnexionRequest``. -.. dropdown:: View a detailed reference of the ``ASGIRequest`` class +.. dropdown:: View a detailed reference of the ``ConnexionRequest`` class :icon: eye - .. autoclass:: connexion.lifecycle.ASGIRequest + .. autoclass:: connexion.lifecycle.ConnexionRequest :noindex: :members: :undoc-members: diff --git a/docs/request.rst b/docs/request.rst index 18faaa3b1..308ad0df6 100644 --- a/docs/request.rst +++ b/docs/request.rst @@ -488,7 +488,7 @@ request. .. dropdown:: View a detailed reference of the ``connexion.request`` class :icon: eye - .. autoclass:: connexion.lifecycle.ASGIRequest + .. autoclass:: connexion.lifecycle.ConnexionRequest :members: :undoc-members: :inherited-members: diff --git a/docs/routing.rst b/docs/routing.rst index f01f97063..e12611700 100644 --- a/docs/routing.rst +++ b/docs/routing.rst @@ -59,7 +59,7 @@ operation: Note that :code:`HEAD` requests will be handled by the :code:`operationId` specified under the :code:`GET` operation in the specification. :code:`Connexion.request.method` can be used to -determine which request was made. See :class:`.ASGIRequest`. +determine which request was made. See :class:`.ConnexionRequest`. Automatic routing ----------------- diff --git a/docs/v3.rst b/docs/v3.rst index 8c8b4859b..578c62813 100644 --- a/docs/v3.rst +++ b/docs/v3.rst @@ -127,6 +127,8 @@ Smaller breaking changes has been added to work with Flask's ``MethodView`` specifically. * Built-in support for uWSGI has been removed. You can re-add this functionality using a custom middleware. * The request body is now passed through for ``GET``, ``HEAD``, ``DELETE``, ``CONNECT`` and ``OPTIONS`` methods as well. +* Error handlers registered on the on the underlying Flask app directly will be ignored. You + should register them on the Connexion app directly. Non-breaking changes

diff --git a/tests/decorators/test_security.py b/tests/decorators/test_security.py index 41695072d..abb88eb01 100644 --- a/tests/decorators/test_security.py +++ b/tests/decorators/test_security.py @@ -10,7 +10,7 @@ OAuthResponseProblem, OAuthScopeProblem, ) -from connexion.lifecycle import ASGIRequest +from connexion.lifecycle import ConnexionRequest from connexion.security import ( NO_VALUE, ApiKeySecurityHandler, @@ -61,7 +61,7 @@ def somefunc(token): somefunc, security_handler.validate_scope, ["admin"] ) - request = ASGIRequest(scope={"type": "http", "headers": []}) + request = ConnexionRequest(scope={"type": "http", "headers": []}) assert wrapped_func(request) is NO_VALUE @@ -83,7 +83,7 @@ async def get_tokeninfo_response(*args, **kwargs): token_info_func, security_handler.validate_scope, ["admin"] ) - request = ASGIRequest( + request = ConnexionRequest( scope={"type": "http", "headers": [[b"authorization", b"Bearer 123"]]} ) @@ -124,7 +124,7 @@ def somefunc(token): somefunc, security_handler.validate_scope, ["admin"] ) - request = ASGIRequest( + request = ConnexionRequest( scope={"type": "http", "headers": [[b"authorization", b"Bearer 123"]]} ) @@ -143,7 +143,7 @@ def token_info(token): token_info, security_handler.validate_scope, ["admin"] ) - request = ASGIRequest( + request = ConnexionRequest( scope={"type": "http", "headers": [[b"authorization", b"Bearer 123"]]} ) @@ -178,7 +178,7 @@ def somefunc(username, password, required_scopes=None): security_handler = BasicSecurityHandler() wrapped_func = security_handler._get_verify_func(somefunc) - request = ASGIRequest( + request = ConnexionRequest( scope={"type": "http", "headers": [[b"authorization", b"Bearer 123"]]} ) @@ -194,7 +194,7 @@ def basic_info(username, password, required_scopes=None): security_handler = BasicSecurityHandler() wrapped_func = security_handler._get_verify_func(basic_info) - request = ASGIRequest( + request = ConnexionRequest( scope={"type": "http", "headers": [[b"authorization", b"Basic Zm9vOmJhcg=="]]} ) @@ -212,7 +212,7 @@ def apikey_info(apikey, required_scopes=None): apikey_info, "query", "auth" ) - request = ASGIRequest(scope={"type": "http", "query_string": b"auth=foobar"}) + request = ConnexionRequest(scope={"type": "http", "query_string": b"auth=foobar"}) assert await wrapped_func(request) is not None @@ -228,7 +228,9 @@ def apikey_info(apikey, required_scopes=None): apikey_info, "header", "X-Auth" ) - request = ASGIRequest(scope={"type": "http", "headers": [[b"x-auth", b"foobar"]]}) + request = ConnexionRequest( + scope={"type": "http", "headers": [[b"x-auth", b"foobar"]]} + ) assert await wrapped_func(request) is not None @@ -259,16 +261,20 @@ def apikey2_info(apikey, required_scopes=None): wrapped_func = security_handler_factory.verify_multiple_schemes(schemes) # Single key does not succeed - request = ASGIRequest(scope={"type": "http", "headers": [[b"x-auth-1", b"foobar"]]}) + request = ConnexionRequest( + scope={"type": "http", "headers": [[b"x-auth-1", b"foobar"]]} + ) assert await wrapped_func(request) is NO_VALUE - request = ASGIRequest(scope={"type": "http", "headers": [[b"x-auth-2", b"bar"]]}) + request = ConnexionRequest( + scope={"type": "http", "headers": [[b"x-auth-2", b"bar"]]} + ) assert await wrapped_func(request) is NO_VALUE # Supplying both keys does succeed - request = ASGIRequest( + request = ConnexionRequest( scope={ "type": "http", "headers": [[b"x-auth-1", b"foobar"], [b"x-auth-2", b"bar"]], @@ -287,7 +293,7 @@ async def test_verify_security_oauthproblem(): security_handler_factory = SecurityHandlerFactory() security_func = security_handler_factory.verify_security([]) - request = MagicMock(spec_set=ASGIRequest) + request = MagicMock(spec_set=ConnexionRequest) with pytest.raises(OAuthProblem) as exc_info: await security_func(request)

diff --git a/docs/context.rst b/docs/context.rst index 288fd56ea..de344674c 100644 --- a/docs/context.rst +++ b/docs/context.rst @@ -24,12 +24,13 @@ See below for an explanation of the different variables. request ------- -A ``Request`` object representing the incoming request. This is an instance of the ``ASGIRequest``. +A ``Request`` object representing the incoming request. This is an instance of the +``ConnexionRequest``. -.. dropdown:: View a detailed reference of the ``ASGIRequest`` class +.. dropdown:: View a detailed reference of the ``ConnexionRequest`` class :icon: eye - .. autoclass:: connexion.lifecycle.ASGIRequest + .. autoclass:: connexion.lifecycle.ConnexionRequest :noindex: :members: :undoc-members: diff --git a/docs/request.rst b/docs/request.rst index 18faaa3b1..308ad0df6 100644 --- a/docs/request.rst +++ b/docs/request.rst @@ -488,7 +488,7 @@ request. .. dropdown:: View a detailed reference of the ``connexion.request`` class :icon: eye - .. autoclass:: connexion.lifecycle.ASGIRequest + .. autoclass:: connexion.lifecycle.ConnexionRequest :members: :undoc-members: :inherited-members: diff --git a/docs/routing.rst b/docs/routing.rst index f01f97063..e12611700 100644 --- a/docs/routing.rst +++ b/docs/routing.rst @@ -59,7 +59,7 @@ operation: Note that :code:`HEAD` requests will be handled by the :code:`operationId` specified under the :code:`GET` operation in the specification. :code:`Connexion.request.method` can be used to -determine which request was made. See :class:`.ASGIRequest`. +determine which request was made. See :class:`.ConnexionRequest`. Automatic routing ----------------- diff --git a/docs/v3.rst b/docs/v3.rst index 8c8b4859b..578c62813 100644 --- a/docs/v3.rst +++ b/docs/v3.rst @@ -127,6 +127,8 @@ Smaller breaking changes has been added to work with Flask's ``MethodView`` specifically. * Built-in support for uWSGI has been removed. You can re-add this functionality using a custom middleware. * The request body is now passed through for ``GET``, ``HEAD``, ``DELETE``, ``CONNECT`` and ``OPTIONS`` methods as well. +* Error handlers registered on the on the underlying Flask app directly will be ignored. You + should register them on the Connexion app directly. Non-breaking changes

[ { "components": [ { "doc": "", "lines": [ 93, 120 ], "name": "AsyncASGIApp", "signature": "class AsyncASGIApp(RoutedMiddleware[AsyncApi]):", "type": "class" }, { "doc": "", "lines": [ 97, 10...

[ "tests/decorators/test_security.py::test_get_tokeninfo_url", "tests/decorators/test_security.py::test_verify_oauth_missing_auth_header", "tests/decorators/test_security.py::test_verify_basic_missing_auth_header", "tests/decorators/test_security.py::test_raise_most_specific[errors0-OAuthProblem]", "tests/dec...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Centralize error handling in ExceptionMiddleware I was writing the documentation on exception handling, and I noticed that it was very hard to explain our current behavior. Error handlers can be registered either on the internal Flask app (not the Starlette one) or on the Connexion app, which leads to some undefined (actually just really hard to explain) behavior. Eg. - Registering error handlers on a status code would capture `starlette.HTTPException` errors on the Connexion app, and `werkzeug.HTTPException` errors on the Flask App, which means that registering an error handler on a status code doesn't catch all the errors with that status code. - Flask does some default error handling which leads to some exceptions never reaching the error handlers registered on the Connexion app. So I made the following changes: - Replaced the default error handlers we registered on the Flask app with a default handler on the `ExceptionMiddleware` that takes into account other handlers registered on status codes. - Configured Flask to propagate exceptions instead of catching them. - Abstracted away the Starlette `Request` and `Response` types, so users can and must now use `ConnexionRequest` and `ConnexionResponse` types in error handlers. - Renamed the `ASGIRequest` class to `ConnexionRequest` since it is the only Request class part of the high level Connexion interface. We could also rename `ConnexionRequest` and `ConnexionResponse` to just `Request` and `Response`. Wdyt? ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in connexion/apps/asynchronous.py] (definition of AsyncASGIApp:) class AsyncASGIApp(RoutedMiddleware[AsyncApi]): (definition of AsyncASGIApp.__init__:) def __init__(self) -> None: (definition of AsyncASGIApp.add_api:) def add_api(self, *args, name: str = None, **kwargs): (definition of AsyncASGIApp.add_url_rule:) def add_url_rule( self, rule, endpoint: str = None, view_func: t.Callable = None, methods: t.List[str] = None, **options, ): [end of new definitions in connexion/apps/asynchronous.py] [start of new definitions in connexion/apps/flask.py] (definition of FlaskASGIApp:) class FlaskASGIApp(SpecMiddleware): (definition of FlaskASGIApp.__init__:) def __init__(self, import_name, server_args: dict, **kwargs): (definition of FlaskASGIApp.add_api:) def add_api(self, specification, *, name: str = None, **kwargs): (definition of FlaskASGIApp.add_url_rule:) def add_url_rule( self, rule, endpoint: str = None, view_func: t.Callable = None, **options ): [end of new definitions in connexion/apps/flask.py] [start of new definitions in connexion/lifecycle.py] (definition of ConnexionRequest:) class ConnexionRequest(_RequestInterface): """Implementation of the Connexion :code:`_RequestInterface` representing an ASGI request. .. attribute:: _starlette_request This class wraps a Starlette `Request <https://www.starlette.io/requests/#request>`_, and provides access to its attributes by proxy.""" (definition of ConnexionRequest.__init__:) def __init__(self, *args, uri_parser=None, **kwargs): (definition of ConnexionRequest.from_starlette_request:) def from_starlette_request( cls, request: StarletteRequest, uri_parser=None ) -> "ConnexionRequest": (definition of ConnexionRequest.context:) def context(self): (definition of ConnexionRequest.content_type:) def content_type(self): (definition of ConnexionRequest.mimetype:) def mimetype(self): (definition of ConnexionRequest.path_params:) def path_params(self) -> t.Dict[str, t.Any]: (definition of ConnexionRequest.query_params:) def query_params(self): (definition of ConnexionRequest.__getattr__:) def __getattr__(self, item): [end of new definitions in connexion/lifecycle.py] [start of new definitions in connexion/middleware/exceptions.py] (definition of connexion_wrapper:) def connexion_wrapper( handler: t.Callable[ [ConnexionRequest, Exception], MaybeAwaitable[ConnexionResponse] ] ) -> t.Callable[[StarletteRequest, Exception], t.Awaitable[StarletteResponse]]: """Wrapper that translates Starlette requests to Connexion requests before passing them to the error handler, and translates the returned Connexion responses to Starlette responses.""" (definition of ExceptionMiddleware.add_exception_handler:) def add_exception_handler( self, exc_class_or_status_code: t.Union[int, t.Type[Exception]], handler: t.Callable[[ConnexionRequest, Exception], StarletteResponse], ) -> None: (definition of ExceptionMiddleware.flask_error_handler:) def flask_error_handler( self, request: StarletteRequest, exc: werkzeug.exceptions.HTTPException ) -> ConnexionResponse: """Default handler for Flask / werkzeug HTTPException""" [end of new definitions in connexion/middleware/exceptions.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

ee399fbfe627f86c461b353132e4d710f7127440

tobymao__sqlglot-2450

2,450

tobymao/sqlglot

null

7ded2536f348a0470af044b56fa0fd6cfb09bb0d

2023-10-23T18:49:30Z

diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index 67b4111047..7df8be234b 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -4174,6 +4174,10 @@ class Abs(Func): pass +class ApproxTopK(AggFunc): + arg_types = {"this": True, "expression": False, "counters": False} + + class Flatten(Func): pass

diff --git a/tests/dialects/test_snowflake.py b/tests/dialects/test_snowflake.py index 78dfabe5c1..65b77ea047 100644 --- a/tests/dialects/test_snowflake.py +++ b/tests/dialects/test_snowflake.py @@ -9,6 +9,10 @@ class TestSnowflake(Validator): dialect = "snowflake" def test_snowflake(self): + expr = parse_one("SELECT APPROX_TOP_K(C4, 3, 5) FROM t") + expr.selects[0].assert_is(exp.AggFunc) + self.assertEqual(expr.sql(dialect="snowflake"), "SELECT APPROX_TOP_K(C4, 3, 5) FROM t") + self.validate_identity("SELECT DAYOFMONTH(CURRENT_TIMESTAMP())") self.validate_identity("SELECT DAYOFYEAR(CURRENT_TIMESTAMP())") self.validate_identity("LISTAGG(data['some_field'], ',')")

[]

[ "tests/dialects/test_snowflake.py::TestSnowflake::test_snowflake" ]

[ "tests/dialects/test_snowflake.py::TestSnowflake::test_ddl", "tests/dialects/test_snowflake.py::TestSnowflake::test_describe_table", "tests/dialects/test_snowflake.py::TestSnowflake::test_flatten", "tests/dialects/test_snowflake.py::TestSnowflake::test_match_recognize", "tests/dialects/test_snowflake.py::Te...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat(snowflake): register APPROX_TOP_K as AggFunc Fixes #2449 Reference: https://docs.snowflake.com/en/sql-reference/functions/approx_top_k ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> approx_top_k is not recognized as an aggregation function in Snowflake **Fully reproducible code snippet** ```python from sqlglot import Dialects, exp, parse_one query = "SELECT approx_top_k(field, 5) FROM some_table" parsed_query = parse_one(query, read=Dialects.SNOWFLAKE.value) agg_funcs = parsed_query.find_all(exp.AggFunc) has_agg_funcs = any(agg_funcs) # getting False, expected True ``` **Official Documentation** https://docs.snowflake.com/en/sql-reference/functions/approx_top_k ---------- -------------------- </issues>

ceb42fabad60312699e4b15936aeebac00e22e4d

tobymao__sqlglot-2447

2,447

tobymao/sqlglot

null

00e3515ff3157105d84f21f56cfb64bae3267640

2023-10-23T15:56:49Z

diff --git a/sqlglot/dialects/snowflake.py b/sqlglot/dialects/snowflake.py index a1a1e3428a..3ad170f2a4 100644 --- a/sqlglot/dialects/snowflake.py +++ b/sqlglot/dialects/snowflake.py @@ -545,6 +545,12 @@ class Generator(generator.Generator): exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED, } + def log_sql(self, expression: exp.Log) -> str: + if not expression.expression: + return self.func("LN", expression.this) + + return super().log_sql(expression) + def unnest_sql(self, expression: exp.Unnest) -> str: selects = ["value"] unnest_alias = expression.args.get("alias") diff --git a/sqlglot/parser.py b/sqlglot/parser.py index 703ddff0c5..bc6e4c2915 100644 --- a/sqlglot/parser.py +++ b/sqlglot/parser.py @@ -3625,6 +3625,32 @@ def _parse_function( functions: t.Optional[t.Dict[str, t.Callable]] = None, anonymous: bool = False, optional_parens: bool = True, + ) -> t.Optional[exp.Expression]: + # This allows us to also parse {fn <function>} syntax (Snowflake, MySQL support this) + # See: https://community.snowflake.com/s/article/SQL-Escape-Sequences + fn_syntax = False + if ( + self._match(TokenType.L_BRACE, advance=False) + and self._next + and self._next.text.upper() == "FN" + ): + self._advance(2) + fn_syntax = True + + func = self._parse_function_call( + functions=functions, anonymous=anonymous, optional_parens=optional_parens + ) + + if fn_syntax: + self._match(TokenType.R_BRACE) + + return func + + def _parse_function_call( + self, + functions: t.Optional[t.Dict[str, t.Callable]] = None, + anonymous: bool = False, + optional_parens: bool = True, ) -> t.Optional[exp.Expression]: if not self._curr: return None

diff --git a/tests/dialects/test_snowflake.py b/tests/dialects/test_snowflake.py index 5f8948abd3..78dfabe5c1 100644 --- a/tests/dialects/test_snowflake.py +++ b/tests/dialects/test_snowflake.py @@ -61,6 +61,18 @@ def test_snowflake(self): "SELECT {'test': 'best'}::VARIANT", "SELECT CAST(OBJECT_CONSTRUCT('test', 'best') AS VARIANT)", ) + self.validate_identity( + "SELECT {fn DAYNAME('2022-5-13')}", + "SELECT DAYNAME('2022-5-13')", + ) + self.validate_identity( + "SELECT {fn LOG(5)}", + "SELECT LN(5)", + ) + self.validate_identity( + "SELECT {fn CEILING(5.3)}", + "SELECT CEIL(5.3)", + ) self.validate_all("CAST(x AS BYTEINT)", write={"snowflake": "CAST(x AS INT)"}) self.validate_all("CAST(x AS CHAR VARYING)", write={"snowflake": "CAST(x AS VARCHAR)"})

[]

[ "tests/dialects/test_snowflake.py::TestSnowflake::test_snowflake" ]

[ "tests/dialects/test_snowflake.py::TestSnowflake::test_ddl", "tests/dialects/test_snowflake.py::TestSnowflake::test_describe_table", "tests/dialects/test_snowflake.py::TestSnowflake::test_flatten", "tests/dialects/test_snowflake.py::TestSnowflake::test_match_recognize", "tests/dialects/test_snowflake.py::Te...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat: add support for {fn ...} function syntax Related Slack thread: https://tobiko-data.slack.com/archives/C0448SFS3PF/p1697922425207749 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

ceb42fabad60312699e4b15936aeebac00e22e4d

huggingface__datasets-6318

6,318

huggingface/datasets

null

3aeb078ba1afd713e901df43343c160877403d07

2023-10-19T12:19:13Z

diff --git a/src/datasets/utils/py_utils.py b/src/datasets/utils/py_utils.py index 912824fa7f3..243bc0f99c9 100644 --- a/src/datasets/utils/py_utils.py +++ b/src/datasets/utils/py_utils.py @@ -736,6 +736,29 @@ def proxy(func): return proxy +if config.DILL_VERSION < version.parse("0.3.6"): + + @pklregister(set) + def _save_set(pickler, obj): + dill._dill.log.info(f"Se: {obj}") + from datasets.fingerprint import Hasher + + args = (sorted(obj, key=Hasher.hash),) + pickler.save_reduce(set, args, obj=obj) + dill._dill.log.info("# Se") + +elif config.DILL_VERSION.release[:3] in [version.parse("0.3.6").release, version.parse("0.3.7").release]: + + @pklregister(set) + def _save_set(pickler, obj): + dill._dill.logger.trace(pickler, "Se: %s", obj) + from datasets.fingerprint import Hasher + + args = (sorted(obj, key=Hasher.hash),) + pickler.save_reduce(set, args, obj=obj) + dill._dill.logger.trace(pickler, "# Se") + + if config.DILL_VERSION < version.parse("0.3.6"): @pklregister(CodeType)

diff --git a/tests/test_fingerprint.py b/tests/test_fingerprint.py index 5538f27554e..f4d5d65744e 100644 --- a/tests/test_fingerprint.py +++ b/tests/test_fingerprint.py @@ -2,6 +2,7 @@ import os import pickle import subprocess +from functools import partial from hashlib import md5 from pathlib import Path from tempfile import gettempdir @@ -10,6 +11,7 @@ from unittest import TestCase from unittest.mock import patch +import numpy as np import pytest from multiprocess import Pool @@ -254,6 +256,22 @@ def test_hash_same_strings(self): self.assertEqual(hash1, hash2) self.assertEqual(hash1, hash3) + def test_set_stable(self): + rng = np.random.default_rng(42) + set_ = {rng.random() for _ in range(10_000)} + expected_hash = Hasher.hash(set_) + assert expected_hash == Pool(1).apply_async(partial(Hasher.hash, set(set_))).get() + + def test_set_doesnt_depend_on_order(self): + set_ = set("abc") + hash1 = md5(datasets.utils.py_utils.dumps(set_)).hexdigest() + set_ = set("def") + hash2 = md5(datasets.utils.py_utils.dumps(set_)).hexdigest() + set_ = set("cba") + hash3 = md5(datasets.utils.py_utils.dumps(set_)).hexdigest() + self.assertEqual(hash1, hash3) + self.assertNotEqual(hash1, hash2) + @require_tiktoken def test_hash_tiktoken_encoding(self): import tiktoken

[ { "components": [ { "doc": "", "lines": [ 753, 759 ], "name": "_save_set", "signature": "def _save_set(pickler, obj):", "type": "function" } ], "file": "src/datasets/utils/py_utils.py" } ]

[ "tests/test_fingerprint.py::HashingTest::test_set_stable" ]

[ "tests/test_fingerprint.py::RecurseDumpTest::test_dump_ignores_line_definition_of_function", "tests/test_fingerprint.py::RecurseDumpTest::test_dump_ipython_function", "tests/test_fingerprint.py::RecurseDumpTest::test_recurse_dump_for_class", "tests/test_fingerprint.py::RecurseDumpTest::test_recurse_dump_for_f...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Deterministic set hash Sort the items in a set according to their `datasets.fingerprint.Hasher.hash` hash to get a deterministic hash of sets. This is useful to get deterministic hashes of tokenizers that use a trie based on python sets. reported in https://github.com/huggingface/datasets/issues/3847 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/datasets/utils/py_utils.py] (definition of _save_set:) def _save_set(pickler, obj): [end of new definitions in src/datasets/utils/py_utils.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

5142a8cf61d8a4495eda3d91dc4283a6df01ea14

roboflow__supervision-500

500

roboflow/supervision

null

aed9221307104c0b0ffcf3f3dcffdbf971031e62

2023-10-18T22:30:42Z

diff --git a/supervision/__init__.py b/supervision/__init__.py index 16de484a3..816142b90 100644 --- a/supervision/__init__.py +++ b/supervision/__init__.py @@ -44,6 +44,7 @@ from supervision.detection.tools.smoother import DetectionsSmoother from supervision.detection.utils import ( box_iou_batch, + box_non_max_merge, box_non_max_suppression, calculate_masks_centroids, clip_boxes, diff --git a/supervision/detection/core.py b/supervision/detection/core.py index 0ba9e4f42..f85d403d7 100644 --- a/supervision/detection/core.py +++ b/supervision/detection/core.py @@ -8,6 +8,8 @@ from supervision.config import CLASS_NAME_DATA_FIELD, ORIENTED_BOX_COORDINATES from supervision.detection.utils import ( + box_iou_batch, + box_non_max_merge, box_non_max_suppression, calculate_masks_centroids, extract_ultralytics_masks, @@ -1150,3 +1152,193 @@ def with_nms( ) return self[indices] + + def with_nmm( + self, threshold: float = 0.5, class_agnostic: bool = False + ) -> Detections: + """ + Perform non-maximum merging on the current set of object detections. + + Args: + threshold (float, optional): The intersection-over-union threshold + to use for non-maximum merging. Defaults to 0.5. + class_agnostic (bool, optional): Whether to perform class-agnostic + non-maximum merging. If True, the class_id of each detection + will be ignored. Defaults to False. + + Returns: + Detections: A new Detections object containing the subset of detections + after non-maximum merging. + + Raises: + AssertionError: If `confidence` is None or `class_id` is None and + class_agnostic is False. + """ + if len(self) == 0: + return self + + assert ( + self.confidence is not None + ), "Detections confidence must be given for NMM to be executed." + + if class_agnostic: + predictions = np.hstack((self.xyxy, self.confidence.reshape(-1, 1))) + else: + assert self.class_id is not None, ( + "Detections class_id must be given for NMM to be executed. If you" + " intended to perform class agnostic NMM set class_agnostic=True." + ) + predictions = np.hstack( + ( + self.xyxy, + self.confidence.reshape(-1, 1), + self.class_id.reshape(-1, 1), + ) + ) + + merge_groups = box_non_max_merge( + predictions=predictions, iou_threshold=threshold + ) + + result = [] + for merge_group in merge_groups: + unmerged_detections = [self[i] for i in merge_group] + merged_detections = merge_inner_detections_objects( + unmerged_detections, threshold + ) + result.append(merged_detections) + + return Detections.merge(result) + + +def merge_inner_detection_object_pair( + detections_1: Detections, detections_2: Detections +) -> Detections: + """ + Merges two Detections object into a single Detections object. + Assumes each Detections contains exactly one object. + + A `winning` detection is determined based on the confidence score of the two + input detections. This winning detection is then used to specify which + `class_id`, `tracker_id`, and `data` to include in the merged Detections object. + + The resulting `confidence` of the merged object is calculated by the weighted + contribution of ea detection to the merged object. + The bounding boxes and masks of the two input detections are merged into a + single bounding box and mask, respectively. + + Args: + detections_1 (Detections): + The first Detections object + detections_2 (Detections): + The second Detections object + + Returns: + Detections: A new Detections object, with merged attributes. + + Raises: + ValueError: If the input Detections objects do not have exactly 1 detected + object. + + Example: + ```python + import cv2 + import supervision as sv + from inference import get_model + + image = cv2.imread(<SOURCE_IMAGE_PATH>) + model = get_model(model_id="yolov8s-640") + + result = model.infer(image)[0] + detections = sv.Detections.from_inference(result) + + merged_detections = merge_object_detection_pair( + detections[0], detections[1]) + ``` + """ + if len(detections_1) != 1 or len(detections_2) != 1: + raise ValueError("Both Detections should have exactly 1 detected object.") + + validate_fields_both_defined_or_none(detections_1, detections_2) + + xyxy_1 = detections_1.xyxy[0] + xyxy_2 = detections_2.xyxy[0] + if detections_1.confidence is None and detections_2.confidence is None: + merged_confidence = None + else: + detection_1_area = (xyxy_1[2] - xyxy_1[0]) * (xyxy_1[3] - xyxy_1[1]) + detections_2_area = (xyxy_2[2] - xyxy_2[0]) * (xyxy_2[3] - xyxy_2[1]) + merged_confidence = ( + detection_1_area * detections_1.confidence[0] + + detections_2_area * detections_2.confidence[0] + ) / (detection_1_area + detections_2_area) + merged_confidence = np.array([merged_confidence]) + + merged_x1, merged_y1 = np.minimum(xyxy_1[:2], xyxy_2[:2]) + merged_x2, merged_y2 = np.maximum(xyxy_1[2:], xyxy_2[2:]) + merged_xyxy = np.array([[merged_x1, merged_y1, merged_x2, merged_y2]]) + + if detections_1.mask is None and detections_2.mask is None: + merged_mask = None + else: + merged_mask = np.logical_or(detections_1.mask, detections_2.mask) + + if detections_1.confidence is None and detections_2.confidence is None: + winning_detection = detections_1 + elif detections_1.confidence[0] >= detections_2.confidence[0]: + winning_detection = detections_1 + else: + winning_detection = detections_2 + + return Detections( + xyxy=merged_xyxy, + mask=merged_mask, + confidence=merged_confidence, + class_id=winning_detection.class_id, + tracker_id=winning_detection.tracker_id, + data=winning_detection.data, + ) + + +def merge_inner_detections_objects( + detections: List[Detections], threshold=0.5 +) -> Detections: + """ + Given N detections each of length 1 (exactly one object inside), combine them into a + single detection object of length 1. The contained inner object will be the merged + result of all the input detections. + + For example, this lets you merge N boxes into one big box, N masks into one mask, + etc. + """ + detections_1 = detections[0] + for detections_2 in detections[1:]: + box_iou = box_iou_batch(detections_1.xyxy, detections_2.xyxy)[0] + if box_iou < threshold: + break + detections_1 = merge_inner_detection_object_pair(detections_1, detections_2) + return detections_1 + + +def validate_fields_both_defined_or_none( + detections_1: Detections, detections_2: Detections +) -> None: + """ + Verify that for each optional field in the Detections, both instances either have + the field set to None or both have it set to non-None values. + + `data` field is ignored. + + Raises: + ValueError: If one field is None and the other is not, for any of the fields. + """ + attributes = ["mask", "confidence", "class_id", "tracker_id"] + for attribute in attributes: + value_1 = getattr(detections_1, attribute) + value_2 = getattr(detections_2, attribute) + + if (value_1 is None) != (value_2 is None): + raise ValueError( + f"Field '{attribute}' should be consistently None or not None in both " + "Detections." + ) diff --git a/supervision/detection/utils.py b/supervision/detection/utils.py index 9232089e5..74726995e 100644 --- a/supervision/detection/utils.py +++ b/supervision/detection/utils.py @@ -3,6 +3,7 @@ import cv2 import numpy as np +import numpy.typing as npt from supervision.config import CLASS_NAME_DATA_FIELD @@ -274,6 +275,91 @@ def box_non_max_suppression( return keep[sort_index.argsort()] +def group_overlapping_boxes( + predictions: npt.NDArray[np.float64], iou_threshold: float = 0.5 +) -> List[List[int]]: + """ + Apply greedy version of non-maximum merging to avoid detecting too many + overlapping bounding boxes for a given object. + + Args: + predictions (npt.NDArray[np.float64]): An array of shape `(n, 5)` containing + the bounding boxes coordinates in format `[x1, y1, x2, y2]` + and the confidence scores. + iou_threshold (float, optional): The intersection-over-union threshold + to use for non-maximum suppression. Defaults to 0.5. + + Returns: + List[List[int]]: Groups of prediction indices be merged. + Each group may have 1 or more elements. + """ + merge_groups: List[List[int]] = [] + + scores = predictions[:, 4] + order = scores.argsort() + + while len(order) > 0: + idx = int(order[-1]) + + order = order[:-1] + if len(order) == 0: + merge_groups.append([idx]) + break + + merge_candidate = np.expand_dims(predictions[idx], axis=0) + ious = box_iou_batch(predictions[order][:, :4], merge_candidate[:, :4]) + ious = ious.flatten() + + above_threshold = ious >= iou_threshold + merge_group = [idx] + np.flip(order[above_threshold]).tolist() + merge_groups.append(merge_group) + order = order[~above_threshold] + return merge_groups + + +def box_non_max_merge( + predictions: npt.NDArray[np.float64], + iou_threshold: float = 0.5, +) -> List[List[int]]: + """ + Apply greedy version of non-maximum merging per category to avoid detecting + too many overlapping bounding boxes for a given object. + + Args: + predictions (npt.NDArray[np.float64]): An array of shape `(n, 5)` or `(n, 6)` + containing the bounding boxes coordinates in format `[x1, y1, x2, y2]`, + the confidence scores and class_ids. Omit class_id column to allow + detections of different classes to be merged. + iou_threshold (float, optional): The intersection-over-union threshold + to use for non-maximum suppression. Defaults to 0.5. + + Returns: + List[List[int]]: Groups of prediction indices be merged. + Each group may have 1 or more elements. + """ + if predictions.shape[1] == 5: + return group_overlapping_boxes(predictions, iou_threshold) + + category_ids = predictions[:, 5] + merge_groups = [] + for category_id in np.unique(category_ids): + curr_indices = np.where(category_ids == category_id)[0] + merge_class_groups = group_overlapping_boxes( + predictions[curr_indices], iou_threshold + ) + + for merge_class_group in merge_class_groups: + merge_groups.append(curr_indices[merge_class_group].tolist()) + + for merge_group in merge_groups: + if len(merge_group) == 0: + raise ValueError( + f"Empty group detected when non-max-merging " + f"detections: {merge_groups}" + ) + return merge_groups + + def clip_boxes(xyxy: np.ndarray, resolution_wh: Tuple[int, int]) -> np.ndarray: """ Clips bounding boxes coordinates to fit within the frame resolution. @@ -346,7 +432,7 @@ def mask_to_xyxy(masks: np.ndarray) -> np.ndarray: `(x_min, y_min, x_max, y_max)` for each mask """ n = masks.shape[0] - bboxes = np.zeros((n, 4), dtype=int) + xyxy = np.zeros((n, 4), dtype=int) for i, mask in enumerate(masks): rows, cols = np.where(mask) @@ -354,9 +440,9 @@ def mask_to_xyxy(masks: np.ndarray) -> np.ndarray: if len(rows) > 0 and len(cols) > 0: x_min, x_max = np.min(cols), np.max(cols) y_min, y_max = np.min(rows), np.max(rows) - bboxes[i, :] = [x_min, y_min, x_max, y_max] + xyxy[i, :] = [x_min, y_min, x_max, y_max] - return bboxes + return xyxy def mask_to_polygons(mask: np.ndarray) -> List[np.ndarray]: @@ -592,16 +678,18 @@ def process_roboflow_result( return xyxy, confidence, class_id, masks, tracker_id, data -def move_boxes(xyxy: np.ndarray, offset: np.ndarray) -> np.ndarray: +def move_boxes( + xyxy: npt.NDArray[np.float64], offset: npt.NDArray[np.int32] +) -> npt.NDArray[np.float64]: """ Parameters: - xyxy (np.ndarray): An array of shape `(n, 4)` containing the bounding boxes - coordinates in format `[x1, y1, x2, y2]` + xyxy (npt.NDArray[np.float64]): An array of shape `(n, 4)` containing the + bounding boxes coordinates in format `[x1, y1, x2, y2]` offset (np.array): An array of shape `(2,)` containing offset values in format is `[dx, dy]`. Returns: - np.ndarray: Repositioned bounding boxes. + npt.NDArray[np.float64]: Repositioned bounding boxes. Example: ```python @@ -622,24 +710,25 @@ def move_boxes(xyxy: np.ndarray, offset: np.ndarray) -> np.ndarray: def move_masks( - masks: np.ndarray, - offset: np.ndarray, - resolution_wh: Tuple[int, int] = None, -) -> np.ndarray: + masks: npt.NDArray[np.bool_], + offset: npt.NDArray[np.int32], + resolution_wh: Tuple[int, int], +) -> npt.NDArray[np.bool_]: """ Offset the masks in an array by the specified (x, y) amount. Args: - masks (np.ndarray): A 3D array of binary masks corresponding to the predictions. - Shape: `(N, H, W)`, where N is the number of predictions, and H, W are the - dimensions of each mask. - offset (np.ndarray): An array of shape `(2,)` containing non-negative int values - `[dx, dy]`. + masks (npt.NDArray[np.bool_]): A 3D array of binary masks corresponding to the + predictions. Shape: `(N, H, W)`, where N is the number of predictions, and + H, W are the dimensions of each mask. + offset (npt.NDArray[np.int32]): An array of shape `(2,)` containing non-negative + int values `[dx, dy]`. resolution_wh (Tuple[int, int]): The width and height of the desired mask resolution. Returns: - (np.ndarray) repositioned masks, optionally padded to the specified shape. + (npt.NDArray[np.bool_]) repositioned masks, optionally padded to the specified + shape. """ if offset[0] < 0 or offset[1] < 0: @@ -655,19 +744,21 @@ def move_masks( return mask_array -def scale_boxes(xyxy: np.ndarray, factor: float) -> np.ndarray: +def scale_boxes( + xyxy: npt.NDArray[np.float64], factor: float +) -> npt.NDArray[np.float64]: """ Scale the dimensions of bounding boxes. Parameters: - xyxy (np.ndarray): An array of shape `(n, 4)` containing the bounding boxes - coordinates in format `[x1, y1, x2, y2]` + xyxy (npt.NDArray[np.float64]): An array of shape `(n, 4)` containing the + bounding boxes coordinates in format `[x1, y1, x2, y2]` factor (float): A float value representing the factor by which the box dimensions are scaled. A factor greater than 1 enlarges the boxes, while a factor less than 1 shrinks them. Returns: - np.ndarray: Scaled bounding boxes. + npt.NDArray[np.float64]: Scaled bounding boxes. Example: ```python @@ -735,19 +826,19 @@ def is_data_equal(data_a: Dict[str, np.ndarray], data_b: Dict[str, np.ndarray]) def merge_data( - data_list: List[Dict[str, Union[np.ndarray, List]]], -) -> Dict[str, Union[np.ndarray, List]]: + data_list: List[Dict[str, Union[npt.NDArray[np.generic], List]]], +) -> Dict[str, Union[npt.NDArray[np.generic], List]]: """ Merges the data payloads of a list of Detections instances. Args: data_list: The data payloads of the Detections instances. Each data payload is a dictionary with the same keys, and the values are either lists or - np.ndarray. + npt.NDArray[np.generic]. Returns: A single data payload containing the merged data, preserving the original data - types (list or np.ndarray). + types (list or npt.NDArray[np.generic]). Raises: ValueError: If data values within a single object have different lengths or if

diff --git a/test/detection/test_core.py b/test/detection/test_core.py index 12f3de281..af1d58762 100644 --- a/test/detection/test_core.py +++ b/test/detection/test_core.py @@ -5,7 +5,7 @@ import numpy as np import pytest -from supervision.detection.core import Detections +from supervision.detection.core import Detections, merge_inner_detection_object_pair from supervision.geometry.core import Position PREDICTIONS = np.array( @@ -421,3 +421,172 @@ def test_equal( detections_a: Detections, detections_b: Detections, expected_result: bool ) -> None: assert (detections_a == detections_b) == expected_result + + +@pytest.mark.parametrize( + "detection_1, detection_2, expected_result, exception", + [ + ( + mock_detections( + xyxy=[[10, 10, 30, 30]], + ), + mock_detections( + xyxy=[[10, 10, 30, 30]], + ), + mock_detections( + xyxy=[[10, 10, 30, 30]], + ), + DoesNotRaise(), + ), # Merge with self + ( + mock_detections( + xyxy=[[10, 10, 30, 30]], + ), + Detections.empty(), + None, + pytest.raises(ValueError), + ), # merge with empty: error + ( + mock_detections( + xyxy=[[10, 10, 30, 30]], + ), + mock_detections( + xyxy=[[10, 10, 30, 30], [40, 40, 60, 60]], + ), + None, + pytest.raises(ValueError), + ), # merge with 2+ objects: error + ( + mock_detections( + xyxy=[[10, 10, 30, 30]], + confidence=[0.1], + class_id=[1], + mask=[np.array([[1, 1, 0], [1, 1, 0], [0, 0, 0]], dtype=bool)], + tracker_id=[1], + data={"key_1": [1]}, + ), + mock_detections( + xyxy=[[20, 20, 40, 40]], + confidence=[0.1], + class_id=[2], + mask=[np.array([[0, 0, 0], [0, 1, 1], [0, 1, 1]], dtype=bool)], + tracker_id=[2], + data={"key_2": [2]}, + ), + mock_detections( + xyxy=[[10, 10, 40, 40]], + confidence=[0.1], + class_id=[1], + mask=[np.array([[1, 1, 0], [1, 1, 1], [0, 1, 1]], dtype=bool)], + tracker_id=[1], + data={"key_1": [1]}, + ), + DoesNotRaise(), + ), # Same confidence - merge box & mask, tie-break to detection_1 + ( + mock_detections( + xyxy=[[0, 0, 20, 20]], + confidence=[0.1], + class_id=[1], + mask=[np.array([[1, 1, 0], [1, 1, 0], [0, 0, 0]], dtype=bool)], + tracker_id=[1], + data={"key_1": [1]}, + ), + mock_detections( + xyxy=[[10, 10, 50, 50]], + confidence=[0.2], + class_id=[2], + mask=[np.array([[0, 0, 0], [0, 1, 1], [0, 1, 1]], dtype=bool)], + tracker_id=[2], + data={"key_2": [2]}, + ), + mock_detections( + xyxy=[[0, 0, 50, 50]], + confidence=[(1 * 0.1 + 4 * 0.2) / 5], + class_id=[2], + mask=[np.array([[1, 1, 0], [1, 1, 1], [0, 1, 1]], dtype=bool)], + tracker_id=[2], + data={"key_2": [2]}, + ), + DoesNotRaise(), + ), # Different confidence, different area + ( + mock_detections( + xyxy=[[10, 10, 30, 30]], + confidence=None, + class_id=[1], + mask=[np.array([[1, 1, 0], [1, 1, 0], [0, 0, 0]], dtype=bool)], + tracker_id=[1], + data={"key_1": [1]}, + ), + mock_detections( + xyxy=[[20, 20, 40, 40]], + confidence=None, + class_id=[2], + mask=[np.array([[0, 0, 0], [0, 1, 1], [0, 1, 1]], dtype=bool)], + tracker_id=[2], + data={"key_2": [2]}, + ), + mock_detections( + xyxy=[[10, 10, 40, 40]], + confidence=None, + class_id=[1], + mask=[np.array([[1, 1, 0], [1, 1, 1], [0, 1, 1]], dtype=bool)], + tracker_id=[1], + data={"key_1": [1]}, + ), + DoesNotRaise(), + ), # No confidence at all + ( + mock_detections( + xyxy=[[0, 0, 20, 20]], + confidence=None, + ), + mock_detections( + xyxy=[[10, 10, 30, 30]], + confidence=[0.2], + ), + None, + pytest.raises(ValueError), + ), # confidence: None + [x] + ( + mock_detections( + xyxy=[[0, 0, 20, 20]], + mask=[np.array([[1, 1, 0], [1, 1, 0], [0, 0, 0]], dtype=bool)], + ), + mock_detections( + xyxy=[[10, 10, 30, 30]], + mask=None, + ), + None, + pytest.raises(ValueError), + ), # mask: None + [x] + ( + mock_detections(xyxy=[[0, 0, 20, 20]], tracker_id=[1]), + mock_detections( + xyxy=[[10, 10, 30, 30]], + tracker_id=None, + ), + None, + pytest.raises(ValueError), + ), # tracker_id: None + [] + ( + mock_detections(xyxy=[[0, 0, 20, 20]], class_id=[1]), + mock_detections( + xyxy=[[10, 10, 30, 30]], + class_id=None, + ), + None, + pytest.raises(ValueError), + ), # class_id: None + [] + ], +) +def test_merge_inner_detection_object_pair( + detection_1: Detections, + detection_2: Detections, + expected_result: Optional[Detections], + exception: Exception, +): + with exception: + result = merge_inner_detection_object_pair(detection_1, detection_2) + assert result == expected_result diff --git a/test/detection/test_utils.py b/test/detection/test_utils.py index 097c5c6e5..b62faa619 100644 --- a/test/detection/test_utils.py +++ b/test/detection/test_utils.py @@ -11,6 +11,7 @@ clip_boxes, filter_polygons_by_area, get_data_item, + group_overlapping_boxes, mask_non_max_suppression, merge_data, move_boxes, @@ -127,6 +128,133 @@ def test_box_non_max_suppression( assert np.array_equal(result, expected_result) +@pytest.mark.parametrize( + "predictions, iou_threshold, expected_result, exception", + [ + ( + np.empty(shape=(0, 5), dtype=float), + 0.5, + [], + DoesNotRaise(), + ), + ( + np.array([[0, 0, 10, 10, 1.0]]), + 0.5, + [[0]], + DoesNotRaise(), + ), + ( + np.array([[0, 0, 10, 10, 1.0], [0, 0, 9, 9, 1.0]]), + 0.5, + [[1, 0]], + DoesNotRaise(), + ), # High overlap, tie-break to second det + ( + np.array([[0, 0, 10, 10, 1.0], [0, 0, 9, 9, 0.99]]), + 0.5, + [[0, 1]], + DoesNotRaise(), + ), # High overlap, merge to high confidence + ( + np.array([[0, 0, 10, 10, 0.99], [0, 0, 9, 9, 1.0]]), + 0.5, + [[1, 0]], + DoesNotRaise(), + ), # (test symmetry) High overlap, merge to high confidence + ( + np.array([[0, 0, 10, 10, 0.90], [0, 0, 9, 9, 1.0]]), + 0.5, + [[1, 0]], + DoesNotRaise(), + ), # (test symmetry) High overlap, merge to high confidence + ( + np.array([[0, 0, 10, 10, 1.0], [0, 0, 9, 9, 1.0]]), + 1.0, + [[1], [0]], + DoesNotRaise(), + ), # High IOU required + ( + np.array([[0, 0, 10, 10, 1.0], [0, 0, 9, 9, 1.0]]), + 0.0, + [[1, 0]], + DoesNotRaise(), + ), # No IOU required + ( + np.array([[0, 0, 10, 10, 1.0], [0, 0, 5, 5, 0.9]]), + 0.25, + [[0, 1]], + DoesNotRaise(), + ), # Below IOU requirement + ( + np.array([[0, 0, 10, 10, 1.0], [0, 0, 5, 5, 0.9]]), + 0.26, + [[0], [1]], + DoesNotRaise(), + ), # Above IOU requirement + ( + np.array([[0, 0, 10, 10, 1.0], [0, 0, 9, 9, 1.0], [0, 0, 8, 8, 1.0]]), + 0.5, + [[2, 1, 0]], + DoesNotRaise(), + ), # 3 boxes + ( + np.array( + [ + [0, 0, 10, 10, 1.0], + [0, 0, 9, 9, 1.0], + [5, 5, 10, 10, 1.0], + [6, 6, 10, 10, 1.0], + [9, 9, 10, 10, 1.0], + ] + ), + 0.5, + [[4], [3, 2], [1, 0]], + DoesNotRaise(), + ), # 5 boxes, 2 merges, 1 separate + ( + np.array( + [ + [0, 0, 2, 1, 1.0], + [1, 0, 3, 1, 1.0], + [2, 0, 4, 1, 1.0], + [3, 0, 5, 1, 1.0], + [4, 0, 6, 1, 1.0], + ] + ), + 0.33, + [[4, 3], [2, 1], [0]], + DoesNotRaise(), + ), # sequential merge, half overlap + ( + np.array( + [ + [0, 0, 2, 1, 0.9], + [1, 0, 3, 1, 0.9], + [2, 0, 4, 1, 1.0], + [3, 0, 5, 1, 0.9], + [4, 0, 6, 1, 0.9], + ] + ), + 0.33, + [[2, 3, 1], [4], [0]], + DoesNotRaise(), + ), # confidence + ], +) +def test_group_overlapping_boxes( + predictions: np.ndarray, + iou_threshold: float, + expected_result: List[List[int]], + exception: Exception, +) -> None: + with exception: + result = group_overlapping_boxes( + predictions=predictions, iou_threshold=iou_threshold + ) + + assert result == expected_result + + @pytest.mark.parametrize( "predictions, masks, iou_threshold, expected_result, exception", [

[ { "components": [ { "doc": "Perform non-maximum merging on the current set of object detections.\n\nArgs:\n threshold (float, optional): The intersection-over-union threshold\n to use for non-maximum merging. Defaults to 0.5.\n class_agnostic (bool, optional): Whether to perform class...

[ "test/detection/test_core.py::test_getitem[detections0-index0-expected_result0-exception0]", "test/detection/test_core.py::test_getitem[detections1-index1-expected_result1-exception1]", "test/detection/test_core.py::test_getitem[detections2-index2-expected_result2-exception2]", "test/detection/test_core.py::t...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add Non-Maximum Merging (NMM) to Detections # Description Currently it is only possible to apply Non-Maximum Suppression (NMS) to Detections. In an attempt to increase the accuracy of object detection and segmentation, especially when using the InferenceSlicer, I added the ability to apply NMM instead of NMS to the merged Detections [merge_detections](https://github.com/mario-dg/supervision/blob/6f4704625b16ba69068b3a19f6d55bc21c80c434/supervision/detection/tools/inference_slicer.py#L125C8-L125C8). NMM merges bounding boxes and masks, that would have originally been discarded, when applying NMS. This results in more accurate detections/segmentations. The implementation of this algorithm closely follows the one from [SAHI](https://github.com/obss/sahi/blob/b115f08f0c0aeeb151adf24e47c222d3483cc931/sahi/postprocess/combine.py#L533). In addition, also inspired by SAHI, the InferenceSlicer can increase the detection accuracy of larger objects, by running inference on the whole image on top of all slices [perform_standard_pred](https://github.com/mario-dg/supervision/blob/6f4704625b16ba69068b3a19f6d55bc21c80c434/supervision/detection/tools/inference_slicer.py#L122C8-L122C8). The whole image detections will be merged with the sliced image detections. I would be happy to discuss implementation changes and design choices. This PR should serve as a first implementation and is far from perfect. Any ideas, critic or comments are more than welcome :) ## Type of change Please delete options that are not relevant. - [x] New feature (non-breaking change which adds functionality) - [x] This change requires a documentation update ## How has this change been tested, please provide a testcase or example of how you tested the change? NMS: ![nms](https://github.com/roboflow/supervision/assets/46304415/f932d262-a262-4221-a4ba-20cdaa42e4ba) NMM: ![nmm](https://github.com/roboflow/supervision/assets/46304415/52d213c6-335e-4ad1-83a5-11620ae4b9ad) SAHI: ![sahi](https://github.com/roboflow/supervision/assets/46304415/21ac5442-dcfa-4d77-8677-bb69bfca70ee) The code sample that was used to create these two images: ```python import cv2 import numpy as np import supervision as sv from supervision.detection.core import Detections from supervision.detection.tools.inference_slicer import InferenceSlicer from PIL import Image from ultralytics.models.yolo import YOLO model = YOLO("yolov8s.pt") def callback(x): result = model(x[:, :, ::-1])[0] dets = Detections.from_ultralytics(result) return dets[dets.confidence > 0.3] # get image from here: https://ultralytics.com/images/bus.jpg slicer = InferenceSlicer(callback=callback, slice_wh=(512, 512), overlap_ratio_wh=(0.4, 0.4), iou_threshold=0.1, merge_detections=True, perform_standard_pred=True) ba = sv.BoundingBoxAnnotator() la = sv.LabelAnnotator() image = np.array(Image.open("bus.jpg")) nmm_dets = slicer(image) nmm_ann = ba.annotate(scene=image.copy(), detections=nmm_dets) nmm_ann = la.annotate(scene=nmm_ann, detections=nmm_dets) cv2.imwrite("nmm.jpg", nmm_ann) slicer.merge_detections = False nms_dets = slicer(image) nms_ann = ba.annotate(scene=image.copy(), detections=nms_dets) nms_ann = la.annotate(scene=nms_ann, detections=nms_dets) cv2.imwrite("bms.jpg", nms_ann) ``` ## Any specific deployment considerations The two additional parameters that were added to InferenceSlicer are optional and default to `False`, thus neither breaking, nor changing the results of existing implementations. ## Docs - [ ] Docs updated? What were the changes: I will update the docs in the near future. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in supervision/detection/core.py] (definition of Detections.with_nmm:) def with_nmm( self, threshold: float = 0.5, class_agnostic: bool = False ) -> Detections: """Perform non-maximum merging on the current set of object detections. Args: threshold (float, optional): The intersection-over-union threshold to use for non-maximum merging. Defaults to 0.5. class_agnostic (bool, optional): Whether to perform class-agnostic non-maximum merging. If True, the class_id of each detection will be ignored. Defaults to False. Returns: Detections: A new Detections object containing the subset of detections after non-maximum merging. Raises: AssertionError: If `confidence` is None or `class_id` is None and class_agnostic is False.""" (definition of merge_inner_detection_object_pair:) def merge_inner_detection_object_pair( detections_1: Detections, detections_2: Detections ) -> Detections: """Merges two Detections object into a single Detections object. Assumes each Detections contains exactly one object. A `winning` detection is determined based on the confidence score of the two input detections. This winning detection is then used to specify which `class_id`, `tracker_id`, and `data` to include in the merged Detections object. The resulting `confidence` of the merged object is calculated by the weighted contribution of ea detection to the merged object. The bounding boxes and masks of the two input detections are merged into a single bounding box and mask, respectively. Args: detections_1 (Detections): The first Detections object detections_2 (Detections): The second Detections object Returns: Detections: A new Detections object, with merged attributes. Raises: ValueError: If the input Detections objects do not have exactly 1 detected object. Example: ```python import cv2 import supervision as sv from inference import get_model image = cv2.imread(<SOURCE_IMAGE_PATH>) model = get_model(model_id="yolov8s-640") result = model.infer(image)[0] detections = sv.Detections.from_inference(result) merged_detections = merge_object_detection_pair( detections[0], detections[1]) ```""" (definition of merge_inner_detections_objects:) def merge_inner_detections_objects( detections: List[Detections], threshold=0.5 ) -> Detections: """Given N detections each of length 1 (exactly one object inside), combine them into a single detection object of length 1. The contained inner object will be the merged result of all the input detections. For example, this lets you merge N boxes into one big box, N masks into one mask, etc.""" (definition of validate_fields_both_defined_or_none:) def validate_fields_both_defined_or_none( detections_1: Detections, detections_2: Detections ) -> None: """Verify that for each optional field in the Detections, both instances either have the field set to None or both have it set to non-None values. `data` field is ignored. Raises: ValueError: If one field is None and the other is not, for any of the fields.""" [end of new definitions in supervision/detection/core.py] [start of new definitions in supervision/detection/utils.py] (definition of group_overlapping_boxes:) def group_overlapping_boxes( predictions: npt.NDArray[np.float64], iou_threshold: float = 0.5 ) -> List[List[int]]: """Apply greedy version of non-maximum merging to avoid detecting too many overlapping bounding boxes for a given object. Args: predictions (npt.NDArray[np.float64]): An array of shape `(n, 5)` containing the bounding boxes coordinates in format `[x1, y1, x2, y2]` and the confidence scores. iou_threshold (float, optional): The intersection-over-union threshold to use for non-maximum suppression. Defaults to 0.5. Returns: List[List[int]]: Groups of prediction indices be merged. Each group may have 1 or more elements.""" (definition of box_non_max_merge:) def box_non_max_merge( predictions: npt.NDArray[np.float64], iou_threshold: float = 0.5, ) -> List[List[int]]: """Apply greedy version of non-maximum merging per category to avoid detecting too many overlapping bounding boxes for a given object. Args: predictions (npt.NDArray[np.float64]): An array of shape `(n, 5)` or `(n, 6)` containing the bounding boxes coordinates in format `[x1, y1, x2, y2]`, the confidence scores and class_ids. Omit class_id column to allow detections of different classes to be merged. iou_threshold (float, optional): The intersection-over-union threshold to use for non-maximum suppression. Defaults to 0.5. Returns: List[List[int]]: Groups of prediction indices be merged. Each group may have 1 or more elements.""" [end of new definitions in supervision/detection/utils.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

3eb5c0b024e3e46877b7fe4fd66e6177d1308ba0

joke2k__faker-1932

1,932

joke2k/faker

null

4cc139115e5201e353ccd662cfdefcbb50082c14

2023-10-18T05:32:20Z

diff --git a/faker/providers/color/cs_CZ/__init__.py b/faker/providers/color/cs_CZ/__init__.py new file mode 100644 index 0000000000..507f1451a5 --- /dev/null +++ b/faker/providers/color/cs_CZ/__init__.py @@ -0,0 +1,23 @@ +from .. import Provider as ColorProvider + + +class Provider(ColorProvider): + """Implement color provider for ``cs_CZ`` locale.""" + + safe_colors = ( + "černá", + "kaštanová", + "zelená", + "námořnická", + "olivová", + "fialová", + "zelenomodrá", + "limetková", + "modrá", + "stříbrná", + "šedá", + "žlutá", + "fuchsiová", + "aquamarinová", + "bílá", + )

diff --git a/tests/providers/test_color.py b/tests/providers/test_color.py index 608277eb8e..9c581e90a1 100644 --- a/tests/providers/test_color.py +++ b/tests/providers/test_color.py @@ -16,6 +16,7 @@ from faker.providers.color.hy_AM import Provider as HyAmColorProvider from faker.providers.color.id_ID import Provider as IdIdColorProvider from faker.providers.color.sk_SK import Provider as SkSkColorProvider +from faker.providers.color.cs_CZ import Provider as CsCzColorProvider class TestColorProvider: @@ -401,6 +402,15 @@ def test_safe_color_name(self, faker, num_samples): assert isinstance(safe_color_name, str) assert safe_color_name in SkSkColorProvider.safe_colors +class TestCsCz: + """Test cs_CZ color provider methods""" + + def test_safe_color_name(self, faker, num_samples): + for _ in range(num_samples): + safe_color_name = faker.safe_color_name() + assert isinstance(safe_color_name, str) + assert safe_color_name in CsCzColorProvider.safe_colors + class TestHeIl: """Test he_IL color provider methods"""

[ { "components": [ { "doc": "Implement color provider for ``cs_CZ`` locale.", "lines": [ 4, 22 ], "name": "Provider", "signature": "class Provider(ColorProvider):", "type": "class" } ], "file": "faker/providers/color/cs_CZ/__...

[ "tests/providers/test_color.py::TestColorProvider::test_safe_hex_color", "tests/providers/test_color.py::TestColorProvider::test_hex_color", "tests/providers/test_color.py::TestColorProvider::test_rgb_color", "tests/providers/test_color.py::TestColorProvider::test_rgb_css_color", "tests/providers/test_color...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Color for cs_CZ ### What does this change Add provider for color for cs_CZ ### What was wrong Missing color provider for cs_CZ ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in faker/providers/color/cs_CZ/__init__.py] (definition of Provider:) class Provider(ColorProvider): """Implement color provider for ``cs_CZ`` locale.""" [end of new definitions in faker/providers/color/cs_CZ/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

6edfdbf6ae90b0153309e3bf066aa3b2d16494a7

tobymao__sqlglot-2417

2,417

tobymao/sqlglot

null

77446481dd59c213368fe554e8011e9a7f5c0f71

2023-10-17T16:17:51Z

diff --git a/sqlglot/dataframe/sql/functions.py b/sqlglot/dataframe/sql/functions.py index d98feeec9e..7043086464 100644 --- a/sqlglot/dataframe/sql/functions.py +++ b/sqlglot/dataframe/sql/functions.py @@ -1113,7 +1113,7 @@ def reverse(col: ColumnOrName) -> Column: def flatten(col: ColumnOrName) -> Column: - return Column.invoke_anonymous_function(col, "FLATTEN") + return Column.invoke_expression_over_column(None, expression.Flatten, expressions=[col]) def map_keys(col: ColumnOrName) -> Column: diff --git a/sqlglot/dialects/snowflake.py b/sqlglot/dialects/snowflake.py index fc3e0faa93..e319ebb10d 100644 --- a/sqlglot/dialects/snowflake.py +++ b/sqlglot/dialects/snowflake.py @@ -262,6 +262,7 @@ class Parser(parser.Parser): ), "DATEDIFF": _parse_datediff, "DIV0": _div0_to_if, + "FLATTEN": exp.Explode.from_arg_list, "IFF": exp.If.from_arg_list, "LISTAGG": exp.GroupConcat.from_arg_list, "NULLIFZERO": _nullifzero_to_if, @@ -325,6 +326,22 @@ class Parser(parser.Parser): TokenType.MOD, TokenType.SLASH, } + FLATTEN_COLUMNS = ["SEQ", "KEY", "PATH", "INDEX", "VALUE", "THIS"] + + def _parse_lateral(self) -> t.Optional[exp.Lateral]: + lateral = super()._parse_lateral() + if not lateral: + return lateral + + if isinstance(lateral.this, exp.Explode): + table_alias = lateral.args.get("alias") + columns = [exp.to_identifier(col) for col in self.FLATTEN_COLUMNS] + if table_alias and not table_alias.args.get("columns"): + table_alias.set("columns", columns) + elif not table_alias: + exp.alias_(lateral, "_flattened", table=columns, copy=False) + + return lateral def _parse_table_parts(self, schema: bool = False) -> exp.Table: # https://docs.snowflake.com/en/user-guide/querying-stage @@ -452,6 +469,7 @@ class Generator(generator.Generator): exp.DateStrToDate: datestrtodate_sql, exp.DataType: _datatype_sql, exp.DayOfWeek: rename_func("DAYOFWEEK"), + exp.Explode: rename_func("FLATTEN"), exp.Extract: rename_func("DATE_PART"), exp.GenerateSeries: lambda self, e: self.func( "ARRAY_GENERATE_RANGE", e.args["start"], e.args["end"] + 1, e.args.get("step") diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index b94b1e13b6..897f5320ad 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -4168,6 +4168,11 @@ class Abs(Func): pass +class Flatten(Func): + arg_types = {"expressions": True} + is_var_len_args = True + + # https://spark.apache.org/docs/latest/api/sql/index.html#transform class Transform(Func): arg_types = {"this": True, "expression": True} @@ -4540,8 +4545,10 @@ class Exp(Func): pass +# https://docs.snowflake.com/en/sql-reference/functions/flatten class Explode(Func): - pass + arg_types = {"this": True, "expressions": False} + is_var_len_args = True class ExplodeOuter(Explode):

diff --git a/tests/dialects/test_snowflake.py b/tests/dialects/test_snowflake.py index 7c36bea494..532968636a 100644 --- a/tests/dialects/test_snowflake.py +++ b/tests/dialects/test_snowflake.py @@ -911,7 +911,23 @@ def test_flatten(self): f.value AS "Contact", f1.value['type'] AS "Type", f1.value['content'] AS "Details" -FROM persons AS p, LATERAL FLATTEN(input => p.c, path => 'contact') AS f, LATERAL FLATTEN(input => f.value['business']) AS f1""", +FROM persons AS p, LATERAL FLATTEN(input => p.c, path => 'contact') AS f(SEQ, KEY, PATH, INDEX, VALUE, THIS), LATERAL FLATTEN(input => f.value['business']) AS f1(SEQ, KEY, PATH, INDEX, VALUE, THIS)""", + }, + pretty=True, + ) + + self.validate_all( + """ + SELECT id as "ID", + value AS "Contact" + FROM persons p, + lateral flatten(input => p.c, path => 'contact') + """, + write={ + "snowflake": """SELECT + id AS "ID", + value AS "Contact" +FROM persons AS p, LATERAL FLATTEN(input => p.c, path => 'contact') AS _flattened(SEQ, KEY, PATH, INDEX, VALUE, THIS)""", }, pretty=True, ) diff --git a/tests/test_lineage.py b/tests/test_lineage.py index 0fd9da867d..c3378d7fd8 100644 --- a/tests/test_lineage.py +++ b/tests/test_lineage.py @@ -199,3 +199,22 @@ def test_lineage_union(self) -> None: "SELECT x FROM (SELECT ax AS x FROM a UNION SELECT bx FROM b UNION SELECT cx FROM c)", ) assert len(node.downstream) == 3 + + def test_lineage_lateral_flatten(self) -> None: + node = lineage( + "VALUE", + "SELECT FLATTENED.VALUE FROM TEST_TABLE, LATERAL FLATTEN(INPUT => RESULT, OUTER => TRUE) FLATTENED", + dialect="snowflake", + ) + self.assertEqual(node.name, "VALUE") + + downstream = node.downstream[0] + self.assertEqual(downstream.name, "FLATTENED.VALUE") + self.assertEqual( + downstream.source.sql(dialect="snowflake"), + "LATERAL FLATTEN(INPUT => TEST_TABLE.RESULT, OUTER => TRUE) AS FLATTENED(SEQ, KEY, PATH, INDEX, VALUE, THIS)", + ) + self.assertEqual( + downstream.expression.sql(dialect="snowflake"), + "VALUE", + )

[]

[ "tests/dialects/test_snowflake.py::TestSnowflake::test_flatten", "tests/test_lineage.py::TestLineage::test_lineage_lateral_flatten" ]

[ "tests/dialects/test_snowflake.py::TestSnowflake::test_ddl", "tests/dialects/test_snowflake.py::TestSnowflake::test_describe_table", "tests/dialects/test_snowflake.py::TestSnowflake::test_match_recognize", "tests/dialects/test_snowflake.py::TestSnowflake::test_minus", "tests/dialects/test_snowflake.py::Test...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat(optimizer): qualify lateral flatten for snowflake Adds columns created by the FLATTEN function in snowflake to the TableAlias created when using it in a FROM ..., LATERAL FLATTEN call following the solution suggested by @GeorgeSittas. To get the full lineage I had to make each column created by the function an alias of the flatten function so we could get the lineage back to the source column flatten was reading from. It seems a little gross, so also wanted to check if there should be a exp.Flatten AST node that encapsulates this behaviour instead. Closes #2413 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Support lineage through a LATERAL FLATTEN from clause in Snowflake **Is your feature request related to a problem? Please describe.** I have a Snowflake SQL query like `SELECT VALUE FROM TABLE_A, LATERAL FLATTEN(TABLE_A.VARIANT_COLUMN)`. I would like to be able to use the `lineage` function to get the lineage tree of the column "VALUE" (in case TABLE_A is actually a subquery, cte, etc). **Describe the solution you'd like** lineage should understand that VALUE's lineage is through TABLE_A.VARIANT_COLUMN (or through a subquery or CTE in place of TABLE_A). The `FLATTEN` function, when the Snowflake dialect is selected, should be treated as a select expression that adds the columns documented as [its output](https://docs.snowflake.com/en/sql-reference/functions/flatten#output). The lineage tree of value should look something like VALUE -> FLATTEN(TABLE_A>VARIANT_COLUMN) -> TABLE_A.VARIANT_COLUMN -> TABLE_A. **Describe alternatives you've considered** My plan was to have the Snowflake dialect parser produce a TableAlias expression when it parses a FLATTEN function populated with with the columns produces by the expression. Right now a TableAlias is produced, but it has no columns, so lineage fails raising a ValueError. I'm happy to work on this feature if it's something you want to support in sqlglot but wanted to open this issue to make sure my suggestion of an implementation strategy make sense and is something you'd accept. ---------- I see, what you're suggesting looks reasonable. Just one comment: > My plan was to have the Snowflake dialect parser produce a TableAlias expression when it parses a FLATTEN function populated with with the columns produces by the expression. Right now a TableAlias is produced, but it has no columns, so lineage fails raising a ValueError. I'm not sure if we want to touch Snowflake's parser for this, even though we could. My initial reaction was that this can be solved by adding extra logic to the `qualify_tables` rule in order to emit a `TableAlias` with additional info, i.e. the output columns specified in Snowflake's docs. The downside to this is that we pollute the rule with Snowflake-specific logic, because there's no other way easy way to parameterize how we do stuff per dialect in the optimizer currently. @tobymao what do you think? shouldn't this be done in qualify_columns? it already deals with table column aliases Not sure, what do we gain from doing it there? I figured that `qualify_tables` would allow it to just work for the rest of the optimizer rules. It also feels more natural because we're trying to add more info to a node associated with a table as opposed to, say, expanding stars etc which fits in `qualify_columns` better. Doing it in `qualify_tables` makes sense to me after a quick glance. I had looked at the parser since that seemed like the place to switch on dialect. @edpaget are you planning to work on this? -------------------- </issues>

ceb42fabad60312699e4b15936aeebac00e22e4d

pyvista__pyvista-5055

5,055

pyvista/pyvista

0.43

e574da02bb2c2d7aafb2e8e15f55024505087b56

2023-10-11T23:44:19Z

diff --git a/pyvista/plotting/text.py b/pyvista/plotting/text.py index b5e0292d364..492990d6ed0 100644 --- a/pyvista/plotting/text.py +++ b/pyvista/plotting/text.py @@ -250,6 +250,14 @@ class TextProperty(_vtk.vtkTextProperty): shadow : bool, optional If enable the shadow. + justification_horizontal : str, optional + Text's horizontal justification. + Should be either "left", "center" or "right". + + justification_vertical : str, optional + Text's vertical justification. + Should be either "bottom", "center" or "top". + Examples -------- Create a text's property. @@ -281,6 +289,8 @@ def __init__( font_size=None, font_file=None, shadow=False, + justification_horizontal=None, + justification_vertical=None, ): """Initialize text's property.""" super().__init__() @@ -300,6 +310,10 @@ def __init__( self.set_font_file(font_file) if shadow: self.enable_shadow() + if justification_horizontal is not None: + self.justification_horizontal = justification_horizontal + if justification_vertical is not None: + self.justification_vertical = justification_vertical @property def color(self) -> Color: @@ -486,3 +500,61 @@ def set_font_file(self, font_file: str): raise FileNotFoundError(f'Unable to locate {path}') self.SetFontFamily(_vtk.VTK_FONT_FILE) self.SetFontFile(str(path)) + + @property + def justification_horizontal(self) -> str: + """Text's justification horizontal. + + Returns + ------- + str + Text's horizontal justification. + Should be either "left", "center" or "right". + """ + justification = self.GetJustificationAsString().lower() + if justification == 'centered': + justification = 'center' + return justification + + @justification_horizontal.setter + def justification_horizontal(self, justification: str): # numpydoc ignore=GL08 + if justification.lower() == 'left': + self.SetJustificationToLeft() + elif justification.lower() == 'center': + self.SetJustificationToCentered() + elif justification.lower() == 'right': + self.SetJustificationToRight() + else: + raise ValueError( + f'Invalid {justification} for justification_horizontal. ' + 'Should be either "left", "center" or "right".' + ) + + @property + def justification_vertical(self) -> str: + """Text's vertical justification. + + Returns + ------- + str + Text's vertical justification. + Should be either "bottom", "center" or "top". + """ + justification = self.GetVerticalJustificationAsString().lower() + if justification == 'centered': + justification = 'center' + return justification + + @justification_vertical.setter + def justification_vertical(self, justification: str): # numpydoc ignore=GL08 + if justification.lower() == 'bottom': + self.SetVerticalJustificationToBottom() + elif justification.lower() == 'center': + self.SetVerticalJustificationToCentered() + elif justification.lower() == 'top': + self.SetVerticalJustificationToTop() + else: + raise ValueError( + f'Invalid {justification} for justification_vertical. ' + 'Should be either "bottom", "center" or "top".' + )

diff --git a/tests/plotting/test_text.py b/tests/plotting/test_text.py index 2a15cbb4d46..0046eec024c 100644 --- a/tests/plotting/test_text.py +++ b/tests/plotting/test_text.py @@ -129,3 +129,34 @@ def test_property_set_font_file(prop): prop.set_font_file(font_file) with pytest.raises(FileNotFoundError): prop.set_font_file("foo.ttf") + + +@pytest.mark.parametrize( + 'justification', [('left', 'left'), ('center', 'centered'), ('right', 'right')] +) +def test_property_justification_horizontal(prop, justification): + prop.justification_horizontal = justification[0] + assert prop.GetJustificationAsString().lower() == justification[1] + assert prop.justification_horizontal == justification[0] + prop = pv.TextProperty(justification_horizontal=justification[0]) + assert prop.GetJustificationAsString().lower() == justification[1] + assert prop.justification_horizontal == justification[0] + + +@pytest.mark.parametrize( + 'justification', [('bottom', 'bottom'), ('center', 'centered'), ('top', 'top')] +) +def test_property_justification_vertical(prop, justification): + prop.justification_vertical = justification[0] + assert prop.GetVerticalJustificationAsString().lower() == justification[1] + assert prop.justification_vertical == justification[0] + prop = pv.TextProperty(justification_vertical=justification[0]) + assert prop.GetVerticalJustificationAsString().lower() == justification[1] + assert prop.justification_vertical == justification[0] + + +def test_property_justification_invalid(prop): + with pytest.raises(ValueError): + prop.justification_horizontal = "invalid" + with pytest.raises(ValueError): + prop.justification_vertical = "invalid"

[ { "components": [ { "doc": "", "lines": [ 520, 529 ], "name": "TextProperty.justification_horizontal", "signature": "def justification_horizontal(self, justification: str):", "type": "function" }, { "doc": "", ...

[ "tests/plotting/test_text.py::test_property_justification_horizontal[justification0]", "tests/plotting/test_text.py::test_property_justification_horizontal[justification1]", "tests/plotting/test_text.py::test_property_justification_horizontal[justification2]", "tests/plotting/test_text.py::test_property_justi...

[ "tests/plotting/test_text.py::test_corner_annotation_text", "tests/plotting/test_text.py::test_corner_annotation_prop", "tests/plotting/test_text.py::test_text_input", "tests/plotting/test_text.py::test_text_prop", "tests/plotting/test_text.py::test_text_position", "tests/plotting/test_text.py::test_prope...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add `justification` property to `TextProperty` ### Overview  Add `justify` property to `TextProperty`. ```python >>> import pyvista as pv >>> prop = pv.TextProperty() >>> prop.justification_horizontal = "right" >>> prop.justification_vertical = "center" ```   ### Details - Follow-up of #5044 . ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pyvista/plotting/text.py] (definition of TextProperty.justification_horizontal:) def justification_horizontal(self, justification: str): (definition of TextProperty.justification_vertical:) def justification_vertical(self, justification: str): [end of new definitions in pyvista/plotting/text.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

25921025e45cafe97b2e274de39c3076b3c84681

scikit-learn__scikit-learn-27566

27,566

scikit-learn/scikit-learn

1.5

77f87316a19130c894445f98e910c95a6ae59004

2023-10-11T09:57:28Z

diff --git a/doc/metadata_routing.rst b/doc/metadata_routing.rst index 30f75bcec950a..d319b311dddd7 100644 --- a/doc/metadata_routing.rst +++ b/doc/metadata_routing.rst @@ -276,6 +276,7 @@ Meta-estimators and functions supporting metadata routing: - :class:`sklearn.calibration.CalibratedClassifierCV` - :class:`sklearn.compose.ColumnTransformer` +- :class:`sklearn.covariance.GraphicalLassoCV` - :class:`sklearn.ensemble.VotingClassifier` - :class:`sklearn.ensemble.VotingRegressor` - :class:`sklearn.ensemble.BaggingClassifier` @@ -313,7 +314,6 @@ Meta-estimators and functions supporting metadata routing: Meta-estimators and tools not supporting metadata routing yet: - :class:`sklearn.compose.TransformedTargetRegressor` -- :class:`sklearn.covariance.GraphicalLassoCV` - :class:`sklearn.ensemble.AdaBoostClassifier` - :class:`sklearn.ensemble.AdaBoostRegressor` - :class:`sklearn.ensemble.StackingClassifier` diff --git a/doc/whats_new/v1.5.rst b/doc/whats_new/v1.5.rst index 7a9318780b5b3..7aba612262822 100644 --- a/doc/whats_new/v1.5.rst +++ b/doc/whats_new/v1.5.rst @@ -79,6 +79,10 @@ more details. :class:`model_selection.GridSearchCV` object or the underlying scorer. :pr:`27560` by :user:`Omar Salman <OmarManzoor>`. +- |Feature| :class:`GraphicalLassoCV` now supports metadata routing in it's + `fit` method and routes metadata to the CV splitter. + :pr:`27566` by :user:`Omar Salman <OmarManzoor>`. + - |Feature| :class:`linear_model.RANSACRegressor` now supports metadata routing in its ``fit``, ``score`` and ``predict`` methods and route metadata to its underlying estimator's' ``fit``, ``score`` and ``predict`` methods. diff --git a/sklearn/covariance/_graph_lasso.py b/sklearn/covariance/_graph_lasso.py index fb40ffda162a4..75f79bf06ae91 100644 --- a/sklearn/covariance/_graph_lasso.py +++ b/sklearn/covariance/_graph_lasso.py @@ -21,8 +21,15 @@ from ..linear_model import _cd_fast as cd_fast # type: ignore from ..linear_model import lars_path_gram from ..model_selection import check_cv, cross_val_score +from ..utils import Bunch from ..utils._param_validation import Interval, StrOptions, validate_params -from ..utils.metadata_routing import _RoutingNotSupportedMixin +from ..utils.metadata_routing import ( + MetadataRouter, + MethodMapping, + _raise_for_params, + _routing_enabled, + process_routing, +) from ..utils.parallel import Parallel, delayed from ..utils.validation import ( _is_arraylike_not_scalar, @@ -721,7 +728,7 @@ def graphical_lasso_path( return covariances_, precisions_ -class GraphicalLassoCV(_RoutingNotSupportedMixin, BaseGraphicalLasso): +class GraphicalLassoCV(BaseGraphicalLasso): """Sparse inverse covariance w/ cross-validated choice of the l1 penalty. See glossary entry for :term:`cross-validation estimator`. @@ -942,7 +949,7 @@ def __init__( self.n_jobs = n_jobs @_fit_context(prefer_skip_nested_validation=True) - def fit(self, X, y=None): + def fit(self, X, y=None, **params): """Fit the GraphicalLasso covariance model to X. Parameters @@ -953,12 +960,25 @@ def fit(self, X, y=None): y : Ignored Not used, present for API consistency by convention. + **params : dict, default=None + Parameters to be passed to the CV splitter and the + cross_val_score function. + + .. versionadded:: 1.5 + Only available if `enable_metadata_routing=True`, + which can be set by using + ``sklearn.set_config(enable_metadata_routing=True)``. + See :ref:`Metadata Routing User Guide <metadata_routing>` for + more details. + Returns ------- self : object Returns the instance itself. """ # Covariance does not make sense for a single feature + _raise_for_params(params, self, "fit") + X = self._validate_data(X, ensure_min_features=2) if self.assume_centered: self.location_ = np.zeros(X.shape[1]) @@ -991,6 +1011,11 @@ def fit(self, X, y=None): alpha_0 = 1e-2 * alpha_1 alphas = np.logspace(np.log10(alpha_0), np.log10(alpha_1), n_alphas)[::-1] + if _routing_enabled(): + routed_params = process_routing(self, "fit", **params) + else: + routed_params = Bunch(splitter=Bunch(split={})) + t0 = time.time() for i in range(n_refinements): with warnings.catch_warnings(): @@ -1015,7 +1040,7 @@ def fit(self, X, y=None): verbose=inner_verbose, eps=self.eps, ) - for train, test in cv.split(X, y) + for train, test in cv.split(X, y, **routed_params.splitter.split) ) # Little danse to transform the list in what we need @@ -1081,6 +1106,7 @@ def fit(self, X, y=None): cv=cv, n_jobs=self.n_jobs, verbose=inner_verbose, + params=params, ) ) grid_scores = np.array(grid_scores) @@ -1108,3 +1134,23 @@ def fit(self, X, y=None): eps=self.eps, ) return self + + def get_metadata_routing(self): + """Get metadata routing of this object. + + Please check :ref:`User Guide <metadata_routing>` on how the routing + mechanism works. + + .. versionadded:: 1.5 + + Returns + ------- + routing : MetadataRouter + A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating + routing information. + """ + router = MetadataRouter(owner=self.__class__.__name__).add( + splitter=check_cv(self.cv), + method_mapping=MethodMapping().add(callee="split", caller="fit"), + ) + return router

diff --git a/sklearn/covariance/tests/test_graphical_lasso.py b/sklearn/covariance/tests/test_graphical_lasso.py index a7d251a5bbdfe..37ffd46290e22 100644 --- a/sklearn/covariance/tests/test_graphical_lasso.py +++ b/sklearn/covariance/tests/test_graphical_lasso.py @@ -16,6 +16,7 @@ graphical_lasso, ) from sklearn.datasets import make_sparse_spd_matrix +from sklearn.model_selection import GroupKFold from sklearn.utils import check_random_state from sklearn.utils._testing import ( _convert_container, @@ -254,12 +255,71 @@ def test_graphical_lasso_cv_scores(): X ) + _assert_graphical_lasso_cv_scores( + cov=cov, + n_splits=splits, + n_refinements=n_refinements, + n_alphas=n_alphas, + ) + + +# TODO(1.5): remove in 1.5 +def test_graphical_lasso_cov_init_deprecation(): + """Check that we raise a deprecation warning if providing `cov_init` in + `graphical_lasso`.""" + rng, dim, n_samples = np.random.RandomState(0), 20, 100 + prec = make_sparse_spd_matrix(dim, alpha=0.95, random_state=0) + cov = linalg.inv(prec) + X = rng.multivariate_normal(np.zeros(dim), cov, size=n_samples) + + emp_cov = empirical_covariance(X) + with pytest.warns(FutureWarning, match="cov_init parameter is deprecated"): + graphical_lasso(emp_cov, alpha=0.1, cov_init=emp_cov) + + +@pytest.mark.usefixtures("enable_slep006") +def test_graphical_lasso_cv_scores_with_routing(global_random_seed): + """Check that `GraphicalLassoCV` internally dispatches metadata to + the splitter. + """ + splits = 5 + n_alphas = 5 + n_refinements = 3 + true_cov = np.array( + [ + [0.8, 0.0, 0.2, 0.0], + [0.0, 0.4, 0.0, 0.0], + [0.2, 0.0, 0.3, 0.1], + [0.0, 0.0, 0.1, 0.7], + ] + ) + rng = np.random.RandomState(global_random_seed) + X = rng.multivariate_normal(mean=[0, 0, 0, 0], cov=true_cov, size=300) + n_samples = X.shape[0] + groups = rng.randint(0, 5, n_samples) + params = {"groups": groups} + cv = GroupKFold(n_splits=splits) + cv.set_split_request(groups=True) + + cov = GraphicalLassoCV(cv=cv, alphas=n_alphas, n_refinements=n_refinements).fit( + X, **params + ) + + _assert_graphical_lasso_cv_scores( + cov=cov, + n_splits=splits, + n_refinements=n_refinements, + n_alphas=n_alphas, + ) + + +def _assert_graphical_lasso_cv_scores(cov, n_splits, n_refinements, n_alphas): cv_results = cov.cv_results_ # alpha and one for each split total_alphas = n_refinements * n_alphas + 1 keys = ["alphas"] - split_keys = [f"split{i}_test_score" for i in range(splits)] + split_keys = [f"split{i}_test_score" for i in range(n_splits)] for key in keys + split_keys: assert key in cv_results assert len(cv_results[key]) == total_alphas @@ -270,17 +330,3 @@ def test_graphical_lasso_cv_scores(): assert_allclose(cov.cv_results_["mean_test_score"], expected_mean) assert_allclose(cov.cv_results_["std_test_score"], expected_std) - - -# TODO(1.5): remove in 1.5 -def test_graphical_lasso_cov_init_deprecation(): - """Check that we raise a deprecation warning if providing `cov_init` in - `graphical_lasso`.""" - rng, dim, n_samples = np.random.RandomState(0), 20, 100 - prec = make_sparse_spd_matrix(dim, alpha=0.95, random_state=0) - cov = linalg.inv(prec) - X = rng.multivariate_normal(np.zeros(dim), cov, size=n_samples) - - emp_cov = empirical_covariance(X) - with pytest.warns(FutureWarning, match="cov_init parameter is deprecated"): - graphical_lasso(emp_cov, alpha=0.1, cov_init=emp_cov) diff --git a/sklearn/tests/test_metaestimators_metadata_routing.py b/sklearn/tests/test_metaestimators_metadata_routing.py index 1e8a5e4d38acb..aa6af5bd09aac 100644 --- a/sklearn/tests/test_metaestimators_metadata_routing.py +++ b/sklearn/tests/test_metaestimators_metadata_routing.py @@ -356,6 +356,13 @@ def enable_slep006(): "cv_name": "cv", "cv_routing_methods": ["fit"], }, + { + "metaestimator": GraphicalLassoCV, + "X": X, + "y": y, + "cv_name": "cv", + "cv_routing_methods": ["fit"], + }, ] """List containing all metaestimators to be tested and their settings @@ -397,7 +404,6 @@ def enable_slep006(): UNSUPPORTED_ESTIMATORS = [ AdaBoostClassifier(), AdaBoostRegressor(), - GraphicalLassoCV(), RFE(ConsumingClassifier()), RFECV(ConsumingClassifier()), SelfTrainingClassifier(ConsumingClassifier()),

diff --git a/doc/metadata_routing.rst b/doc/metadata_routing.rst index 30f75bcec950a..d319b311dddd7 100644 --- a/doc/metadata_routing.rst +++ b/doc/metadata_routing.rst @@ -276,6 +276,7 @@ Meta-estimators and functions supporting metadata routing: - :class:`sklearn.calibration.CalibratedClassifierCV` - :class:`sklearn.compose.ColumnTransformer` +- :class:`sklearn.covariance.GraphicalLassoCV` - :class:`sklearn.ensemble.VotingClassifier` - :class:`sklearn.ensemble.VotingRegressor` - :class:`sklearn.ensemble.BaggingClassifier` @@ -313,7 +314,6 @@ Meta-estimators and functions supporting metadata routing: Meta-estimators and tools not supporting metadata routing yet: - :class:`sklearn.compose.TransformedTargetRegressor` -- :class:`sklearn.covariance.GraphicalLassoCV` - :class:`sklearn.ensemble.AdaBoostClassifier` - :class:`sklearn.ensemble.AdaBoostRegressor` - :class:`sklearn.ensemble.StackingClassifier` diff --git a/doc/whats_new/v1.5.rst b/doc/whats_new/v1.5.rst index 7a9318780b5b3..7aba612262822 100644 --- a/doc/whats_new/v1.5.rst +++ b/doc/whats_new/v1.5.rst @@ -79,6 +79,10 @@ more details. :class:`model_selection.GridSearchCV` object or the underlying scorer. :pr:`27560` by :user:`Omar Salman <OmarManzoor>`. +- |Feature| :class:`GraphicalLassoCV` now supports metadata routing in it's + `fit` method and routes metadata to the CV splitter. + :pr:`27566` by :user:`Omar Salman <OmarManzoor>`. + - |Feature| :class:`linear_model.RANSACRegressor` now supports metadata routing in its ``fit``, ``score`` and ``predict`` methods and route metadata to its underlying estimator's' ``fit``, ``score`` and ``predict`` methods.

[ { "components": [ { "doc": "Get metadata routing of this object.\n\nPlease check :ref:`User Guide <metadata_routing>` on how the routing\nmechanism works.\n\n.. versionadded:: 1.5\n\nReturns\n-------\nrouting : MetadataRouter\n A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsula...

[ "sklearn/covariance/tests/test_graphical_lasso.py::test_graphical_lasso_cv_scores_with_routing[42]", "sklearn/tests/test_metaestimators_metadata_routing.py::test_default_request[GraphicalLassoCV]", "sklearn/tests/test_metaestimators_metadata_routing.py::test_metadata_is_routed_correctly_to_splitter[GraphicalLas...

[ "sklearn/covariance/tests/test_graphical_lasso.py::test_graphical_lassos", "sklearn/covariance/tests/test_graphical_lasso.py::test_graphical_lasso_when_alpha_equals_0", "sklearn/covariance/tests/test_graphical_lasso.py::test_graphical_lasso_n_iter[cd]", "sklearn/covariance/tests/test_graphical_lasso.py::test_...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> FEA Add metadata routing to GraphicalLassoCV  #### Reference Issues/PRs  Towards #22893 #### What does this implement/fix? Explain your changes. - Adds metadata routing to GraphicalLassoCV and routes the corresponding metadata to the underlying cv splitter and the cross_val_score function. #### Any other comments? CC: @adrinjalali @glemaitre  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/covariance/_graph_lasso.py] (definition of GraphicalLassoCV.get_metadata_routing:) def get_metadata_routing(self): """Get metadata routing of this object. Please check :ref:`User Guide <metadata_routing>` on how the routing mechanism works. .. versionadded:: 1.5 Returns ------- routing : MetadataRouter A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating routing information.""" [end of new definitions in sklearn/covariance/_graph_lasso.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c799133710d518f5fba2958bb0e0765ee280df12

tobymao__sqlglot-2381

2,381

tobymao/sqlglot

null

ae27e46cf60bbbcb456997afe942a6e8ab9d03c1

2023-10-06T09:26:55Z

diff --git a/sqlglot/schema.py b/sqlglot/schema.py index f0b279b004..9301b2a40b 100644 --- a/sqlglot/schema.py +++ b/sqlglot/schema.py @@ -71,7 +71,7 @@ def column_names( def get_column_type( self, table: exp.Table | str, - column: exp.Column, + column: exp.Column | str, dialect: DialectType = None, normalize: t.Optional[bool] = None, ) -> exp.DataType: @@ -88,6 +88,28 @@ def get_column_type( The resulting column type. """ + def has_column( + self, + table: exp.Table | str, + column: exp.Column | str, + dialect: DialectType = None, + normalize: t.Optional[bool] = None, + ) -> bool: + """ + Returns whether or not `column` appears in `table`'s schema. + + Args: + table: the source table. + column: the target column. + dialect: the SQL dialect that will be used to parse `table` if it's a string. + normalize: whether to normalize identifiers according to the dialect of interest. + + Returns: + True if the column appears in the schema, False otherwise. + """ + name = column if isinstance(column, str) else column.name + return name in self.column_names(table, dialect=dialect, normalize=normalize) + @property @abc.abstractmethod def supported_table_args(self) -> t.Tuple[str, ...]: @@ -287,7 +309,7 @@ def column_names( def get_column_type( self, table: exp.Table | str, - column: exp.Column, + column: exp.Column | str, dialect: DialectType = None, normalize: t.Optional[bool] = None, ) -> exp.DataType: @@ -308,6 +330,22 @@ def get_column_type( return exp.DataType.build("unknown") + def has_column( + self, + table: exp.Table | str, + column: exp.Column | str, + dialect: DialectType = None, + normalize: t.Optional[bool] = None, + ) -> bool: + normalized_table = self._normalize_table(table, dialect=dialect, normalize=normalize) + + normalized_column_name = self._normalize_name( + column if isinstance(column, str) else column.this, dialect=dialect, normalize=normalize + ) + + table_schema = self.find(normalized_table, raise_on_missing=False) + return normalized_column_name in table_schema if table_schema else False + def _normalize(self, schema: t.Dict) -> t.Dict: """ Normalizes all identifiers in the schema.

diff --git a/tests/test_schema.py b/tests/test_schema.py index 626fa11e2a..34c507df46 100644 --- a/tests/test_schema.py +++ b/tests/test_schema.py @@ -272,3 +272,8 @@ def test_same_number_of_qualifiers(self): str(ctx.exception), "Table z must match the schema's nesting level: 2.", ) + + def test_has_column(self): + schema = MappingSchema({"x": {"c": "int"}}) + self.assertTrue(schema.has_column("x", exp.column("c"))) + self.assertFalse(schema.has_column("x", exp.column("k")))

[]

[ "tests/test_schema.py::TestSchema::test_has_column" ]

[ "tests/test_schema.py::TestSchema::test_same_number_of_qualifiers", "tests/test_schema.py::TestSchema::test_schema", "tests/test_schema.py::TestSchema::test_schema_add_table_with_and_without_mapping", "tests/test_schema.py::TestSchema::test_schema_catalog", "tests/test_schema.py::TestSchema::test_schema_db"...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat(schema): add method to check if column exists Thought something like this might be an improvement to the API ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

ceb42fabad60312699e4b15936aeebac00e22e4d

huggingface__accelerate-2034

2,034

huggingface/accelerate

null

956114ac92cfbdfe0874ca73aa37ac815326f040

2023-10-05T12:06:08Z

diff --git a/docs/source/package_reference/tracking.md b/docs/source/package_reference/tracking.md index 36719db683a..6845ca4bc05 100644 --- a/docs/source/package_reference/tracking.md +++ b/docs/source/package_reference/tracking.md @@ -31,3 +31,5 @@ rendered properly in your Markdown viewer. - __init__ [[autodoc]] tracking.MLflowTracker - __init__ +[[autodoc]] tracking.ClearMLTracker + - __init__ diff --git a/docs/source/usage_guides/tracking.md b/docs/source/usage_guides/tracking.md index fa123cde699..141fea6924b 100644 --- a/docs/source/usage_guides/tracking.md +++ b/docs/source/usage_guides/tracking.md @@ -20,12 +20,14 @@ There are a large number of experiment tracking API's available, however getting ## Integrated Trackers -Currently `Accelerate` supports four trackers out-of-the-box: +Currently `Accelerate` supports six trackers out-of-the-box: - TensorBoard - WandB - CometML +- Aim - MLFlow +- ClearML To use any of them, pass in the selected type(s) to the `log_with` parameter in [`Accelerate`]: ```python diff --git a/src/accelerate/tracking.py b/src/accelerate/tracking.py index aa2eb08b742..4f536d57812 100644 --- a/src/accelerate/tracking.py +++ b/src/accelerate/tracking.py @@ -28,6 +28,7 @@ from .utils import ( LoggerType, is_aim_available, + is_clearml_available, is_comet_ml_available, is_mlflow_available, is_tensorboard_available, @@ -53,6 +54,9 @@ if is_mlflow_available(): _available_trackers.append(LoggerType.MLFLOW) +if is_clearml_available(): + _available_trackers.append(LoggerType.CLEARML) + logger = get_logger(__name__) @@ -365,11 +369,11 @@ def log_table( Args: table_name (`str`): The name to give to the logged table on the wandb workspace - columns (List of `str`'s *optional*): + columns (list of `str`, *optional*): The name of the columns on the table - data (List of List of Any data type *optional*): + data (List of List of Any data type, *optional*): The data to be logged in the table - dataframe (Any data type *optional*): + dataframe (Any data type, *optional*): The data to be logged in the table step (`int`, *optional*): The run step. If included, the log will be affiliated with this step. @@ -681,12 +685,165 @@ def finish(self): mlflow.end_run() +class ClearMLTracker(GeneralTracker): + """ + A `Tracker` class that supports `clearml`. Should be initialized at the start of your script. + + Args: + run_name (`str`, *optional*): + Name of the experiment. Environment variables `CLEARML_PROJECT` and `CLEARML_TASK` have priority over this + argument. + kwargs: + Kwargs passed along to the `Task.__init__` method. + """ + + name = "clearml" + requires_logging_directory = False + + @on_main_process + def __init__(self, run_name: str = None, **kwargs): + from clearml import Task + + current_task = Task.current_task() + self._initialized_externally = False + if current_task: + self._initialized_externally = True + self.task = current_task + return + + kwargs.setdefault("project_name", os.environ.get("CLEARML_PROJECT", run_name)) + kwargs.setdefault("task_name", os.environ.get("CLEARML_TASK", run_name)) + self.task = Task.init(**kwargs) + + @property + def tracker(self): + return self.task + + @on_main_process + def store_init_configuration(self, values: dict): + """ + Connect configuration dictionary to the Task object. Should be run at the beginning of your experiment. + + Args: + values (`dict`): + Values to be stored as initial hyperparameters as key-value pairs. + """ + return self.task.connect_configuration(values) + + @on_main_process + def log(self, values: Dict[str, Union[int, float]], step: Optional[int] = None, **kwargs): + """ + Logs `values` dictionary to the current run. The dictionary keys must be strings. The dictionary values must be + ints or floats + + Args: + values (`Dict[str, Union[int, float]]`): + Values to be logged as key-value pairs. If the key starts with 'eval_'/'test_'/'train_', the value will + be reported under the 'eval'/'test'/'train' series and the respective prefix will be removed. + Otherwise, the value will be reported under the 'train' series, and no prefix will be removed. + step (`int`, *optional*): + If specified, the values will be reported as scalars, with the iteration number equal to `step`. + Otherwise they will be reported as single values. + kwargs: + Additional key word arguments passed along to the `clearml.Logger.report_single_value` or + `clearml.Logger.report_scalar` methods. + """ + clearml_logger = self.task.get_logger() + for k, v in values.items(): + if not isinstance(v, (int, float)): + logger.warning( + "Accelerator is attempting to log a value of " + f'"{v}" of type {type(v)} for key "{k}" as a scalar. ' + "This invocation of ClearML logger's report_scalar() " + "is incorrect so we dropped this attribute." + ) + continue + if step is None: + clearml_logger.report_single_value(name=k, value=v, **kwargs) + continue + title, series = ClearMLTracker._get_title_series(k) + clearml_logger.report_scalar(title=title, series=series, value=v, iteration=step, **kwargs) + + @on_main_process + def log_images(self, values: dict, step: Optional[int] = None, **kwargs): + """ + Logs `images` to the current run. + + Args: + values (`Dict[str, List[Union[np.ndarray, PIL.Image]]`): + Values to be logged as key-value pairs. The values need to have type `List` of `np.ndarray` or + step (`int`, *optional*): + The run step. If included, the log will be affiliated with this step. + kwargs: + Additional key word arguments passed along to the `clearml.Logger.report_image` method. + """ + clearml_logger = self.task.get_logger() + for k, v in values.items(): + title, series = ClearMLTracker._get_title_series(k) + clearml_logger.report_image(title=title, series=series, iteration=step, image=v, **kwargs) + + @on_main_process + def log_table( + self, + table_name: str, + columns: List[str] = None, + data: List[List[Any]] = None, + dataframe: Any = None, + step: Optional[int] = None, + **kwargs, + ): + """ + Log a Table to the task. Can be defined eitherwith `columns` and `data` or with `dataframe`. + + Args: + table_name (`str`): + The name of the table + columns (list of `str`, *optional*): + The name of the columns on the table + data (List of List of Any data type, *optional*): + The data to be logged in the table. If `columns` is not specified, then the first entry in data will be + the name of the columns of the table + dataframe (Any data type, *optional*): + The data to be logged in the table + step (`int`, *optional*): + The run step. If included, the log will be affiliated with this step. + kwargs: + Additional key word arguments passed along to the `clearml.Logger.report_table` method. + """ + to_report = dataframe + if dataframe is None: + if data is None: + raise ValueError( + "`ClearMLTracker.log_table` requires that `data` to be supplied if `dataframe` is `None`" + ) + to_report = [columns] + data if columns else data + title, series = ClearMLTracker._get_title_series(table_name) + self.task.get_logger().report_table(title=title, series=series, table_plot=to_report, iteration=step, **kwargs) + + @on_main_process + def finish(self): + """ + Close the ClearML task. If the task was initialized externally (e.g. by manually calling `Task.init`), this + function is a noop + """ + if self.task and not self._initialized_externally: + self.task.close() + + @staticmethod + def _get_title_series(name): + for prefix in ["eval", "test", "train"]: + if name.startswith(prefix + "_"): + return name[len(prefix) + 1 :], prefix + return name, "train" + + LOGGER_TYPE_TO_CLASS = { "aim": AimTracker, "comet_ml": CometMLTracker, "mlflow": MLflowTracker, "tensorboard": TensorBoardTracker, "wandb": WandBTracker, + "clearml": ClearMLTracker, } diff --git a/src/accelerate/utils/__init__.py b/src/accelerate/utils/__init__.py index 09a5ef42a7a..fc4aaff74f8 100644 --- a/src/accelerate/utils/__init__.py +++ b/src/accelerate/utils/__init__.py @@ -45,6 +45,7 @@ is_bnb_available, is_boto3_available, is_ccl_available, + is_clearml_available, is_comet_ml_available, is_cuda_available, is_datasets_available, @@ -55,6 +56,7 @@ is_mlflow_available, is_mps_available, is_npu_available, + is_pandas_available, is_rich_available, is_safetensors_available, is_sagemaker_available, diff --git a/src/accelerate/utils/dataclasses.py b/src/accelerate/utils/dataclasses.py index 6533ca36b68..43cd75c7370 100644 --- a/src/accelerate/utils/dataclasses.py +++ b/src/accelerate/utils/dataclasses.py @@ -343,6 +343,7 @@ class LoggerType(BaseEnum): WANDB = "wandb" COMETML = "comet_ml" MLFLOW = "mlflow" + CLEARML = "clearml" class PrecisionType(BaseEnum): diff --git a/src/accelerate/utils/imports.py b/src/accelerate/utils/imports.py index 44d5459c5be..3ff167aecf6 100644 --- a/src/accelerate/utils/imports.py +++ b/src/accelerate/utils/imports.py @@ -210,6 +210,14 @@ def is_tqdm_available(): return _is_package_available("tqdm") +def is_clearml_available(): + return _is_package_available("clearml") + + +def is_pandas_available(): + return _is_package_available("pandas") + + def is_mlflow_available(): if _is_package_available("mlflow"): return True

diff --git a/src/accelerate/test_utils/testing.py b/src/accelerate/test_utils/testing.py index 40afdac4813..bb887285954 100644 --- a/src/accelerate/test_utils/testing.py +++ b/src/accelerate/test_utils/testing.py @@ -31,10 +31,12 @@ from ..utils import ( gather, is_bnb_available, + is_clearml_available, is_comet_ml_available, is_datasets_available, is_deepspeed_available, is_mps_available, + is_pandas_available, is_safetensors_available, is_tensorboard_available, is_timm_available, @@ -231,6 +233,20 @@ def require_comet_ml(test_case): return unittest.skipUnless(is_comet_ml_available(), "test requires comet_ml")(test_case) +def require_clearml(test_case): + """ + Decorator marking a test that requires clearml installed. These tests are skipped when clearml isn't installed + """ + return unittest.skipUnless(is_clearml_available(), "test requires clearml")(test_case) + + +def require_pandas(test_case): + """ + Decorator marking a test that requires pandas installed. These tests are skipped when pandas isn't installed + """ + return unittest.skipUnless(is_pandas_available(), "test requires pandas")(test_case) + + _atleast_one_tracker_available = ( any([is_wandb_available(), is_tensorboard_available()]) and not is_comet_ml_available() ) diff --git a/tests/test_tracking.py b/tests/test_tracking.py index 5a0288232e8..545b51fefd4 100644 --- a/tests/test_tracking.py +++ b/tests/test_tracking.py @@ -25,6 +25,7 @@ from typing import Optional from unittest import mock +import numpy as np import torch # We use TF to parse the logs @@ -32,7 +33,9 @@ from accelerate.test_utils.testing import ( MockingTestCase, TempDirTestCase, + require_clearml, require_comet_ml, + require_pandas, require_tensorboard, require_wandb, skip, @@ -250,6 +253,147 @@ def test_log(self): self.assertEqual(self.get_value_from_key(list_of_json, "my_text"), "some_value") +@require_clearml +class ClearMLTest(TempDirTestCase, MockingTestCase): + def setUp(self): + super().setUp() + # ClearML offline session location is stored in CLEARML_CACHE_DIR + self.add_mocks(mock.patch.dict(os.environ, {"CLEARML_CACHE_DIR": self.tmpdir})) + + @staticmethod + def _get_offline_dir(accelerator): + from clearml.config import get_offline_dir + + return get_offline_dir(task_id=accelerator.get_tracker("clearml", unwrap=True).id) + + @staticmethod + def _get_metrics(offline_dir): + metrics = [] + with open(os.path.join(offline_dir, "metrics.jsonl")) as f: + json_lines = f.readlines() + for json_line in json_lines: + metrics.extend(json.loads(json_line)) + return metrics + + def test_init_trackers(self): + from clearml import Task + from clearml.utilities.config import text_to_config_dict + + Task.set_offline(True) + accelerator = Accelerator(log_with="clearml") + config = {"num_iterations": 12, "learning_rate": 1e-2, "some_boolean": False, "some_string": "some_value"} + accelerator.init_trackers("test_project_with_config", config) + + offline_dir = ClearMLTest._get_offline_dir(accelerator) + accelerator.end_training() + + with open(os.path.join(offline_dir, "task.json")) as f: + offline_session = json.load(f) + clearml_offline_config = text_to_config_dict(offline_session["configuration"]["General"]["value"]) + self.assertDictEqual(config, clearml_offline_config) + + def test_log(self): + from clearml import Task + + Task.set_offline(True) + accelerator = Accelerator(log_with="clearml") + accelerator.init_trackers("test_project_with_log") + values_with_iteration = {"should_be_under_train": 1, "eval_value": 2, "test_value": 3.1, "train_value": 4.1} + accelerator.log(values_with_iteration, step=1) + single_values = {"single_value_1": 1.1, "single_value_2": 2.2} + accelerator.log(single_values) + + offline_dir = ClearMLTest._get_offline_dir(accelerator) + accelerator.end_training() + + metrics = ClearMLTest._get_metrics(offline_dir) + self.assertEqual(len(values_with_iteration) + len(single_values), len(metrics)) + for metric in metrics: + if metric["metric"] == "Summary": + self.assertIn(metric["variant"], single_values) + self.assertEqual(metric["value"], single_values[metric["variant"]]) + elif metric["metric"] == "should_be_under_train": + self.assertEqual(metric["variant"], "train") + self.assertEqual(metric["iter"], 1) + self.assertEqual(metric["value"], values_with_iteration["should_be_under_train"]) + else: + values_with_iteration_key = metric["variant"] + "_" + metric["metric"] + self.assertIn(values_with_iteration_key, values_with_iteration) + self.assertEqual(metric["iter"], 1) + self.assertEqual(metric["value"], values_with_iteration[values_with_iteration_key]) + + def test_log_images(self): + from clearml import Task + + Task.set_offline(True) + accelerator = Accelerator(log_with="clearml") + accelerator.init_trackers("test_project_with_log_images") + + base_image = np.eye(256, 256, dtype=np.uint8) * 255 + base_image_3d = np.concatenate((np.atleast_3d(base_image), np.zeros((256, 256, 2), dtype=np.uint8)), axis=2) + images = { + "base_image": base_image, + "base_image_3d": base_image_3d, + } + accelerator.get_tracker("clearml").log_images(images, step=1) + + offline_dir = ClearMLTest._get_offline_dir(accelerator) + accelerator.end_training() + + images_saved = Path(os.path.join(offline_dir, "data")).rglob("*.jpeg") + self.assertEqual(len(list(images_saved)), len(images)) + + def test_log_table(self): + from clearml import Task + + Task.set_offline(True) + accelerator = Accelerator(log_with="clearml") + accelerator.init_trackers("test_project_with_log_table") + + accelerator.get_tracker("clearml").log_table( + "from lists with columns", columns=["A", "B", "C"], data=[[1, 3, 5], [2, 4, 6]] + ) + accelerator.get_tracker("clearml").log_table("from lists", data=[["A2", "B2", "C2"], [7, 9, 11], [8, 10, 12]]) + offline_dir = ClearMLTest._get_offline_dir(accelerator) + accelerator.end_training() + + metrics = ClearMLTest._get_metrics(offline_dir) + self.assertEqual(len(metrics), 2) + for metric in metrics: + self.assertIn(metric["metric"], ["from lists", "from lists with columns"]) + plot = json.loads(metric["plot_str"]) + if metric["metric"] == "from lists with columns": + print(plot["data"][0]) + self.assertCountEqual(plot["data"][0]["header"]["values"], ["A", "B", "C"]) + self.assertCountEqual(plot["data"][0]["cells"]["values"], [[1, 2], [3, 4], [5, 6]]) + else: + self.assertCountEqual(plot["data"][0]["header"]["values"], ["A2", "B2", "C2"]) + self.assertCountEqual(plot["data"][0]["cells"]["values"], [[7, 8], [9, 10], [11, 12]]) + + @require_pandas + def test_log_table_pandas(self): + import pandas as pd + from clearml import Task + + Task.set_offline(True) + accelerator = Accelerator(log_with="clearml") + accelerator.init_trackers("test_project_with_log_table_pandas") + + accelerator.get_tracker("clearml").log_table( + "from df", dataframe=pd.DataFrame({"A": [1, 2], "B": [3, 4], "C": [5, 6]}), step=1 + ) + + offline_dir = ClearMLTest._get_offline_dir(accelerator) + accelerator.end_training() + + metrics = ClearMLTest._get_metrics(offline_dir) + self.assertEqual(len(metrics), 1) + self.assertEqual(metrics[0]["metric"], "from df") + plot = json.loads(metrics[0]["plot_str"]) + self.assertCountEqual(plot["data"][0]["header"]["values"], [["A"], ["B"], ["C"]]) + self.assertCountEqual(plot["data"][0]["cells"]["values"], [[1, 2], [3, 4], [5, 6]]) + + class MyCustomTracker(GeneralTracker): "Basic tracker that writes to a csv for testing" _col_names = [

diff --git a/docs/source/package_reference/tracking.md b/docs/source/package_reference/tracking.md index 36719db683a..6845ca4bc05 100644 --- a/docs/source/package_reference/tracking.md +++ b/docs/source/package_reference/tracking.md @@ -31,3 +31,5 @@ rendered properly in your Markdown viewer. - __init__ [[autodoc]] tracking.MLflowTracker - __init__ +[[autodoc]] tracking.ClearMLTracker + - __init__ diff --git a/docs/source/usage_guides/tracking.md b/docs/source/usage_guides/tracking.md index fa123cde699..141fea6924b 100644 --- a/docs/source/usage_guides/tracking.md +++ b/docs/source/usage_guides/tracking.md @@ -20,12 +20,14 @@ There are a large number of experiment tracking API's available, however getting ## Integrated Trackers -Currently `Accelerate` supports four trackers out-of-the-box: +Currently `Accelerate` supports six trackers out-of-the-box: - TensorBoard - WandB - CometML +- Aim - MLFlow +- ClearML To use any of them, pass in the selected type(s) to the `log_with` parameter in [`Accelerate`]: ```python

[ { "components": [ { "doc": "A `Tracker` class that supports `clearml`. Should be initialized at the start of your script.\n\nArgs:\n run_name (`str`, *optional*):\n Name of the experiment. Environment variables `CLEARML_PROJECT` and `CLEARML_TASK` have priority over this\n argumen...

[ "tests/test_tracking.py::CustomTrackerTestCase::test_init_trackers", "tests/test_tracking.py::CustomTrackerTestCase::test_log" ]

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add ClearML tracker Adds ClearML to the supported trackers. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/accelerate/tracking.py] (definition of ClearMLTracker:) class ClearMLTracker(GeneralTracker): """A `Tracker` class that supports `clearml`. Should be initialized at the start of your script. Args: run_name (`str`, *optional*): Name of the experiment. Environment variables `CLEARML_PROJECT` and `CLEARML_TASK` have priority over this argument. kwargs: Kwargs passed along to the `Task.__init__` method.""" (definition of ClearMLTracker.__init__:) def __init__(self, run_name: str = None, **kwargs): (definition of ClearMLTracker.tracker:) def tracker(self): (definition of ClearMLTracker.store_init_configuration:) def store_init_configuration(self, values: dict): """Connect configuration dictionary to the Task object. Should be run at the beginning of your experiment. Args: values (`dict`): Values to be stored as initial hyperparameters as key-value pairs.""" (definition of ClearMLTracker.log:) def log(self, values: Dict[str, Union[int, float]], step: Optional[int] = None, **kwargs): """Logs `values` dictionary to the current run. The dictionary keys must be strings. The dictionary values must be ints or floats Args: values (`Dict[str, Union[int, float]]`): Values to be logged as key-value pairs. If the key starts with 'eval_'/'test_'/'train_', the value will be reported under the 'eval'/'test'/'train' series and the respective prefix will be removed. Otherwise, the value will be reported under the 'train' series, and no prefix will be removed. step (`int`, *optional*): If specified, the values will be reported as scalars, with the iteration number equal to `step`. Otherwise they will be reported as single values. kwargs: Additional key word arguments passed along to the `clearml.Logger.report_single_value` or `clearml.Logger.report_scalar` methods.""" (definition of ClearMLTracker.log_images:) def log_images(self, values: dict, step: Optional[int] = None, **kwargs): """Logs `images` to the current run. Args: values (`Dict[str, List[Union[np.ndarray, PIL.Image]]`): Values to be logged as key-value pairs. The values need to have type `List` of `np.ndarray` or step (`int`, *optional*): The run step. If included, the log will be affiliated with this step. kwargs: Additional key word arguments passed along to the `clearml.Logger.report_image` method.""" (definition of ClearMLTracker.log_table:) def log_table( self, table_name: str, columns: List[str] = None, data: List[List[Any]] = None, dataframe: Any = None, step: Optional[int] = None, **kwargs, ): """Log a Table to the task. Can be defined eitherwith `columns` and `data` or with `dataframe`. Args: table_name (`str`): The name of the table columns (list of `str`, *optional*): The name of the columns on the table data (List of List of Any data type, *optional*): The data to be logged in the table. If `columns` is not specified, then the first entry in data will be the name of the columns of the table dataframe (Any data type, *optional*): The data to be logged in the table step (`int`, *optional*): The run step. If included, the log will be affiliated with this step. kwargs: Additional key word arguments passed along to the `clearml.Logger.report_table` method.""" (definition of ClearMLTracker.finish:) def finish(self): """Close the ClearML task. If the task was initialized externally (e.g. by manually calling `Task.init`), this function is a noop""" (definition of ClearMLTracker._get_title_series:) def _get_title_series(name): [end of new definitions in src/accelerate/tracking.py] [start of new definitions in src/accelerate/utils/imports.py] (definition of is_clearml_available:) def is_clearml_available(): (definition of is_pandas_available:) def is_pandas_available(): [end of new definitions in src/accelerate/utils/imports.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

08101b9dde2b1a9658c2e363e3e9f5663ba06073

tobymao__sqlglot-2375

2,375

tobymao/sqlglot

null

347ac51da6a553a7904739f0f3ad6b4bb4db01c6

2023-10-04T22:12:33Z

diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index 1dd73f5e26..5edf785c0d 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -4778,6 +4778,11 @@ class Posexplode(Func): pass +# https://cloud.google.com/bigquery/docs/reference/standard-sql/bigqueryml-syntax-predict#mlpredict_function +class Predict(Func): + arg_types = {"this": True, "expression": True, "params_struct": False} + + class Pow(Binary, Func): _sql_names = ["POWER", "POW"] diff --git a/sqlglot/generator.py b/sqlglot/generator.py index 3cf4a7bd04..216e9c088e 100644 --- a/sqlglot/generator.py +++ b/sqlglot/generator.py @@ -2887,6 +2887,14 @@ def columnprefix_sql(self, expression: exp.ColumnPrefix) -> str: def opclass_sql(self, expression: exp.Opclass) -> str: return f"{self.sql(expression, 'this')} {self.sql(expression, 'expression')}" + def predict_sql(self, expression: exp.Predict) -> str: + model = self.sql(expression, "this") + model = f"MODEL {model}" + table = self.sql(expression, "expression") + table = f"TABLE {table}" if not isinstance(expression.expression, exp.Subquery) else table + parameters = self.sql(expression, "params_struct") + return self.func("PREDICT", model, table, parameters or None) + def cached_generator( cache: t.Optional[t.Dict[int, str]] = None diff --git a/sqlglot/parser.py b/sqlglot/parser.py index ddaa9d6ebe..76b6ee51e1 100644 --- a/sqlglot/parser.py +++ b/sqlglot/parser.py @@ -789,6 +789,7 @@ class Parser(metaclass=_Parser): "MATCH": lambda self: self._parse_match_against(), "OPENJSON": lambda self: self._parse_open_json(), "POSITION": lambda self: self._parse_position(), + "PREDICT": lambda self: self._parse_predict(), "SAFE_CAST": lambda self: self._parse_cast(False), "STRING_AGG": lambda self: self._parse_string_agg(), "SUBSTRING": lambda self: self._parse_substring(), @@ -4407,6 +4408,20 @@ def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition: exp.StrPosition, this=haystack, substr=needle, position=seq_get(args, 2) ) + def _parse_predict(self) -> exp.Predict: + self._match_text_seq("MODEL") + this = self._parse_table() + + self._match(TokenType.COMMA) + self._match_text_seq("TABLE") + + return self.expression( + exp.Predict, + this=this, + expression=self._parse_table(), + params_struct=self._match(TokenType.COMMA) and self._parse_bitwise(), + ) + def _parse_join_hint(self, func_name: str) -> exp.JoinHint: args = self._parse_csv(self._parse_table) return exp.JoinHint(this=func_name.upper(), expressions=args)

diff --git a/tests/dialects/test_bigquery.py b/tests/dialects/test_bigquery.py index 8d172eaec8..5d17cc90a5 100644 --- a/tests/dialects/test_bigquery.py +++ b/tests/dialects/test_bigquery.py @@ -85,6 +85,24 @@ def test_bigquery(self): self.validate_identity("ROLLBACK TRANSACTION") self.validate_identity("CAST(x AS BIGNUMERIC)") self.validate_identity("SELECT y + 1 FROM x GROUP BY y + 1 ORDER BY 1") + self.validate_identity( + "SELECT * FROM ML.PREDICT(MODEL mydataset.mymodel, (SELECT label, column1, column2 FROM mydataset.mytable))" + ) + self.validate_identity( + "SELECT label, predicted_label1, predicted_label AS predicted_label2 FROM ML.PREDICT(MODEL mydataset.mymodel2, (SELECT * EXCEPT (predicted_label), predicted_label AS predicted_label1 FROM ML.PREDICT(MODEL mydataset.mymodel1, TABLE mydataset.mytable)))" + ) + self.validate_identity( + "SELECT * FROM ML.PREDICT(MODEL mydataset.mymodel, (SELECT custom_label, column1, column2 FROM mydataset.mytable), STRUCT(0.55 AS threshold))" + ) + self.validate_identity( + "SELECT * FROM ML.PREDICT(MODEL `my_project`.my_dataset.my_model, (SELECT * FROM input_data))" + ) + self.validate_identity( + "SELECT * FROM ML.PREDICT(MODEL my_dataset.vision_model, (SELECT uri, ML.RESIZE_IMAGE(ML.DECODE_IMAGE(data), 480, 480, FALSE) AS input FROM my_dataset.object_table))" + ) + self.validate_identity( + "SELECT * FROM ML.PREDICT(MODEL my_dataset.vision_model, (SELECT uri, ML.CONVERT_COLOR_SPACE(ML.RESIZE_IMAGE(ML.DECODE_IMAGE(data), 224, 280, TRUE), 'YIQ') AS input FROM my_dataset.object_table WHERE content_type = 'image/jpeg'))" + ) self.validate_identity( "DATE(CAST('2016-12-25 05:30:00+07' AS DATETIME), 'America/Los_Angeles')" )

[]

[ "tests/dialects/test_bigquery.py::TestBigQuery::test_bigquery" ]

[ "tests/dialects/test_bigquery.py::TestBigQuery::test_group_concat", "tests/dialects/test_bigquery.py::TestBigQuery::test_json_object", "tests/dialects/test_bigquery.py::TestBigQuery::test_merge", "tests/dialects/test_bigquery.py::TestBigQuery::test_pushdown_cte_column_names", "tests/dialects/test_bigquery.p...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat(bigquery): add support for ML.PREDICT function Reference: https://cloud.google.com/bigquery/docs/reference/standard-sql/bigqueryml-syntax-predict#mlpredict_function ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

ceb42fabad60312699e4b15936aeebac00e22e4d

slackapi__python-slack-sdk-1406

1,406

slackapi/python-slack-sdk

null

398923a417525ed5014bb0695a5a21ad0420815a

2023-10-03T04:53:03Z

diff --git a/slack_sdk/models/blocks/__init__.py b/slack_sdk/models/blocks/__init__.py index 3dfd87d3f..87febae70 100644 --- a/slack_sdk/models/blocks/__init__.py +++ b/slack_sdk/models/blocks/__init__.py @@ -32,6 +32,7 @@ from .block_elements import InteractiveElement from .block_elements import LinkButtonElement from .block_elements import OverflowMenuElement +from .block_elements import RichTextInputElement from .block_elements import PlainTextInputElement from .block_elements import EmailInputElement from .block_elements import UrlInputElement @@ -81,6 +82,7 @@ "InteractiveElement", "LinkButtonElement", "OverflowMenuElement", + "RichTextInputElement", "PlainTextInputElement", "EmailInputElement", "UrlInputElement", diff --git a/slack_sdk/models/blocks/block_elements.py b/slack_sdk/models/blocks/block_elements.py index 4cf1519c2..c65bd7f8a 100644 --- a/slack_sdk/models/blocks/block_elements.py +++ b/slack_sdk/models/blocks/block_elements.py @@ -3,7 +3,7 @@ import re import warnings from abc import ABCMeta -from typing import Iterator, List, Optional, Set, Type, Union, Sequence +from typing import Iterator, List, Optional, Set, Type, Union, Sequence, Dict, Any from slack_sdk.models import show_unknown_key_warning from slack_sdk.models.basic_objects import ( @@ -1331,6 +1331,45 @@ def __init__( self.max_selected_items = max_selected_items +# ------------------------------------------------- +# Rich Text Input Element +# ------------------------------------------------- + + +class RichTextInputElement(InputInteractiveElement): + type = "rich_text_input" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union( + { + "initial_value", + "dispatch_action_config", + } + ) + + def __init__( + self, + *, + action_id: Optional[str] = None, + placeholder: Optional[Union[str, dict, TextObject]] = None, + initial_value: Optional[Dict[str, Any]] = None, # TODO: Add rich_text block class and its element classes + dispatch_action_config: Optional[Union[dict, DispatchActionConfig]] = None, + focus_on_load: Optional[bool] = None, + **others: dict, + ): + super().__init__( + type=self.type, + action_id=action_id, + placeholder=TextObject.parse(placeholder, PlainTextObject.type), + focus_on_load=focus_on_load, + ) + show_unknown_key_warning(self, others) + + self.initial_value = initial_value + self.dispatch_action_config = dispatch_action_config + + # ------------------------------------------------- # Plain Text Input Element # -------------------------------------------------

diff --git a/tests/slack_sdk/models/test_elements.py b/tests/slack_sdk/models/test_elements.py index 1b246b0a6..fe63d5fc0 100644 --- a/tests/slack_sdk/models/test_elements.py +++ b/tests/slack_sdk/models/test_elements.py @@ -34,6 +34,7 @@ NumberInputElement, UrlInputElement, WorkflowButtonElement, + RichTextInputElement, ) from . import STRING_3001_CHARS, STRING_301_CHARS @@ -1013,6 +1014,26 @@ def test_document(self): # ------------------------------------------------- +class RichTextInputElementTests(unittest.TestCase): + def test_simple(self): + input = { + "type": "rich_text_input", + "action_id": "rich_input", + "placeholder": {"type": "plain_text", "text": "Enter some plain text"}, + } + self.assertDictEqual(input, RichTextInputElement(**input).to_dict()) + + def test_document(self): + input = { + "type": "rich_text_input", + "action_id": "rich_text_input-action", + "dispatch_action_config": {"trigger_actions_on": ["on_character_entered"]}, + "focus_on_load": True, + "placeholder": {"type": "plain_text", "text": "Enter text"}, + } + self.assertDictEqual(input, RichTextInputElement(**input).to_dict()) + + class PlainTextInputElementTests(unittest.TestCase): def test_document_1(self): input = {

[ { "components": [ { "doc": "", "lines": [ 1339, 1370 ], "name": "RichTextInputElement", "signature": "class RichTextInputElement(InputInteractiveElement):", "type": "class" }, { "doc": "", "lines": [ ...

[ "tests/slack_sdk/models/test_elements.py::BlockElementTests::test_eq", "tests/slack_sdk/models/test_elements.py::BlockElementTests::test_parse_timepicker", "tests/slack_sdk/models/test_elements.py::InteractiveElementTests::test_with_input_interactive_element", "tests/slack_sdk/models/test_elements.py::Interac...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add RichTextInputElement to slack_sdk.models ## Summary This pull request adds RichTextInputElement to slack_sdk.models utilities. references: * https://api.slack.com/reference/block-kit/block-elements#rich_text_input ### Category (place an `x` in each of the `[ ]`) - [ ] **slack_sdk.web.WebClient (sync/async)** (Web API client) - [ ] **slack_sdk.webhook.WebhookClient (sync/async)** (Incoming Webhook, response_url sender) - [ ] **slack_sdk.socket_mode** (Socket Mode client) - [ ] **slack_sdk.signature** (Request Signature Verifier) - [ ] **slack_sdk.oauth** (OAuth Flow Utilities) - [x] **slack_sdk.models** (UI component builders) - [ ] **slack_sdk.scim** (SCIM API client) - [ ] **slack_sdk.audit_logs** (Audit Logs API client) - [ ] **slack_sdk.rtm_v2** (RTM client) - [ ] `/docs-src` (Documents, have you run `./scripts/docs.sh`?) - [ ] `/docs-src-v2` (Documents, have you run `./scripts/docs-v2.sh`?) - [ ] `/tutorial` (PythOnBoardingBot tutorial) - [ ] `tests`/`integration_tests` (Automated tests for this library) ## Requirements (place an `x` in each `[ ]`) - [x] I've read and understood the [Contributing Guidelines](https://github.com/slackapi/python-slack-sdk/blob/main/.github/contributing.md) and have done my best effort to follow them. - [x] I've read and agree to the [Code of Conduct](https://slackhq.github.io/code-of-conduct). - [x] I've run `python3 -m venv .venv && source .venv/bin/activate && ./scripts/run_validation.sh` after making the changes. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in slack_sdk/models/blocks/block_elements.py] (definition of RichTextInputElement:) class RichTextInputElement(InputInteractiveElement): (definition of RichTextInputElement.attributes:) def attributes(self) -> Set[str]: (definition of RichTextInputElement.__init__:) def __init__( self, *, action_id: Optional[str] = None, placeholder: Optional[Union[str, dict, TextObject]] = None, initial_value: Optional[Dict[str, Any]] = None, [end of new definitions in slack_sdk/models/blocks/block_elements.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

2997a1786c4fd969b00ce69af888ebae8e8ebed0

Textualize__textual-3410

3,410

Textualize/textual

null

3b170b074802fab825a698ca66be2196871700cf

2023-09-27T08:55:29Z

diff --git a/CHANGELOG.md b/CHANGELOG.md index 995286f9bd..9f4411e2f0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/). - Fixed `DataTable` not scrolling to rows that were just added https://github.com/Textualize/textual/pull/3552 - Fixed cache bug with `DataTable.update_cell` https://github.com/Textualize/textual/pull/3551 +### Added + +- Add Document `get_index_from_location` / `get_location_from_index` https://github.com/Textualize/textual/pull/3410 + ### Changed - Buttons will now display multiple lines, and have auto height https://github.com/Textualize/textual/pull/3539 diff --git a/src/textual/document/_document.py b/src/textual/document/_document.py index 5e8e37d8d0..6fa2341911 100644 --- a/src/textual/document/_document.py +++ b/src/textual/document/_document.py @@ -320,6 +320,42 @@ def line_count(self) -> int: """Returns the number of lines in the document.""" return len(self._lines) + def get_index_from_location(self, location: Location) -> int: + """Given a location, returns the index from the document's text. + + Args: + location: The location in the document. + + Returns: + The index in the document's text. + """ + row, column = location + index = row * len(self.newline) + column + for line_index in range(row): + index += len(self.get_line(line_index)) + return index + + def get_location_from_index(self, index: int) -> Location: + """Given an index in the document's text, returns the corresponding location. + + Args: + index: The index in the document's text. + + Returns: + The corresponding location. + """ + column_index = 0 + newline_length = len(self.newline) + for line_index in range(self.line_count): + next_column_index = ( + column_index + len(self.get_line(line_index)) + newline_length + ) + if index < next_column_index: + return (line_index, index - column_index) + elif index == next_column_index: + return (line_index + 1, 0) + column_index = next_column_index + def get_line(self, index: int) -> str: """Returns the line with the given index from the document.

diff --git a/tests/document/test_document.py b/tests/document/test_document.py index b6e9952782..ad1c82b834 100644 --- a/tests/document/test_document.py +++ b/tests/document/test_document.py @@ -98,3 +98,42 @@ def test_get_selected_text_no_newline_at_end_of_file_windows(): document = Document(TEXT_WINDOWS) selection = document.get_text_range((0, 0), (2, 0)) assert selection == TEXT_WINDOWS + + +@pytest.mark.parametrize( + "text", [TEXT, TEXT_NEWLINE, TEXT_WINDOWS, TEXT_WINDOWS_NEWLINE] +) +def test_index_from_location(text): + document = Document(text) + lines = text.split(document.newline) + assert document.get_index_from_location((0, 0)) == 0 + assert document.get_index_from_location((0, len(lines[0]))) == len(lines[0]) + assert document.get_index_from_location((1, 0)) == len(lines[0]) + len( + document.newline + ) + assert document.get_index_from_location((len(lines) - 1, len(lines[-1]))) == len( + text + ) + + +@pytest.mark.parametrize( + "text", [TEXT, TEXT_NEWLINE, TEXT_WINDOWS, TEXT_WINDOWS_NEWLINE] +) +def test_location_from_index(text): + document = Document(text) + lines = text.split(document.newline) + assert document.get_location_from_index(0) == (0, 0) + assert document.get_location_from_index(len(lines[0])) == (0, len(lines[0])) + if len(document.newline) > 1: + assert document.get_location_from_index(len(lines[0]) + 1) == ( + 0, + len(lines[0]) + 1, + ) + assert document.get_location_from_index(len(lines[0]) + len(document.newline)) == ( + 1, + 0, + ) + assert document.get_location_from_index(len(text)) == ( + len(lines) - 1, + len(lines[-1]), + )

diff --git a/CHANGELOG.md b/CHANGELOG.md index 995286f9bd..9f4411e2f0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/). - Fixed `DataTable` not scrolling to rows that were just added https://github.com/Textualize/textual/pull/3552 - Fixed cache bug with `DataTable.update_cell` https://github.com/Textualize/textual/pull/3551 +### Added + +- Add Document `get_index_from_location` / `get_location_from_index` https://github.com/Textualize/textual/pull/3410 + ### Changed - Buttons will now display multiple lines, and have auto height https://github.com/Textualize/textual/pull/3539

[ { "components": [ { "doc": "Given a location, returns the index from the document's text.\n\nArgs:\n location: The location in the document.\n\nReturns:\n The index in the document's text.", "lines": [ 323, 336 ], "name": "Document.get_index_from_l...

[ "tests/document/test_document.py::test_index_from_location[I", "tests/document/test_document.py::test_location_from_index[I" ]

[ "tests/document/test_document.py::test_text[I", "tests/document/test_document.py::test_lines_newline_eof", "tests/document/test_document.py::test_lines_no_newline_eof", "tests/document/test_document.py::test_lines_windows", "tests/document/test_document.py::test_lines_windows_newline", "tests/document/tes...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add Document get_index_from_location / get_location_from_index **Please review the following checklist.** - [x] Docstrings on all new or modified functions / classes - [ ] Updated documentation - [x] Updated CHANGELOG.md (where appropriate) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/textual/document/_document.py] (definition of Document.get_index_from_location:) def get_index_from_location(self, location: Location) -> int: """Given a location, returns the index from the document's text. Args: location: The location in the document. Returns: The index in the document's text.""" (definition of Document.get_location_from_index:) def get_location_from_index(self, index: int) -> Location: """Given an index in the document's text, returns the corresponding location. Args: index: The index in the document's text. Returns: The corresponding location.""" [end of new definitions in src/textual/document/_document.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

86e93536b991014e0ea4bf993068202b446bb698

pvlib__pvlib-python-1876

1,876

pvlib/pvlib-python

0.9

46851d91bb70e9b5521feb7ec119b057ec3d7f70

2023-09-26T18:06:02Z

diff --git a/docs/sphinx/source/reference/irradiance/transposition.rst b/docs/sphinx/source/reference/irradiance/transposition.rst index 4749b5d5b9..7b3624e692 100644 --- a/docs/sphinx/source/reference/irradiance/transposition.rst +++ b/docs/sphinx/source/reference/irradiance/transposition.rst @@ -10,6 +10,7 @@ Transposition models irradiance.get_sky_diffuse irradiance.isotropic irradiance.perez + irradiance.perez_driesse irradiance.haydavies irradiance.klucher irradiance.reindl diff --git a/docs/sphinx/source/whatsnew/v0.10.3.rst b/docs/sphinx/source/whatsnew/v0.10.3.rst index 30b9f576b0..0853254983 100644 --- a/docs/sphinx/source/whatsnew/v0.10.3.rst +++ b/docs/sphinx/source/whatsnew/v0.10.3.rst @@ -7,6 +7,8 @@ v0.10.3 (Anticipated December, 2023) Enhancements ~~~~~~~~~~~~ +* Added the continuous Perez-Driesse transposition model. + :py:func:`pvlib.irradiance.perez_driesse` (:issue:`1841`, :pull:`1876`) * :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance` and :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance_poa` now include shaded fraction in returned variables. (:pull:`1871`) @@ -28,4 +30,5 @@ Contributors ~~~~~~~~~~~~ * Arjan Keeman (:ghuser:`akeeman`) * Miguel Sánchez de León Peque (:ghuser:`Peque`) -* Will Hobbs (:ghuser:`williamhobbs`) \ No newline at end of file +* Will Hobbs (:ghuser:`williamhobbs`) +* Anton Driesse (:ghuser:`adriesse`) diff --git a/pvlib/irradiance.py b/pvlib/irradiance.py index 7e66281974..efae7f6236 100644 --- a/pvlib/irradiance.py +++ b/pvlib/irradiance.py @@ -10,6 +10,7 @@ import numpy as np import pandas as pd +from scipy.interpolate import splev from pvlib import atmosphere, solarposition, tools import pvlib # used to avoid dni name collision in complete_irradiance @@ -323,6 +324,7 @@ def get_total_irradiance(surface_tilt, surface_azimuth, * reindl * king * perez + * perez-driesse Parameters ---------- @@ -351,7 +353,8 @@ def get_total_irradiance(surface_tilt, surface_azimuth, the list of accepted values. model : str, default 'isotropic' Irradiance model. Can be one of ``'isotropic'``, ``'klucher'``, - ``'haydavies'``, ``'reindl'``, ``'king'``, ``'perez'``. + ``'haydavies'``, ``'reindl'``, ``'king'``, ``'perez'``, + ``'perez-driesse'``. model_perez : str, default 'allsitescomposite1990' Used only if ``model='perez'``. See :py:func:`~pvlib.irradiance.perez`. @@ -363,13 +366,13 @@ def get_total_irradiance(surface_tilt, surface_azimuth, Notes ----- - Models ``'haydavies'``, ``'reindl'``, or ``'perez'`` require - ``'dni_extra'``. Values can be calculated using + Models ``'haydavies'``, ``'reindl'``, ``'perez'`` and ``'perez-driesse'`` + require ``'dni_extra'``. Values can be calculated using :py:func:`~pvlib.irradiance.get_extra_radiation`. - The ``'perez'`` model requires relative airmass (``airmass``) as input. If - ``airmass`` is not provided, it is calculated using the defaults in - :py:func:`~pvlib.atmosphere.get_relative_airmass`. + The ``'perez'`` and ``'perez-driesse'`` models require relative airmass + (``airmass``) as input. If ``airmass`` is not provided, it is calculated + using the defaults in :py:func:`~pvlib.atmosphere.get_relative_airmass`. """ poa_sky_diffuse = get_sky_diffuse( @@ -400,6 +403,7 @@ def get_sky_diffuse(surface_tilt, surface_azimuth, * reindl * king * perez + * perez-driesse Parameters ---------- @@ -423,7 +427,8 @@ def get_sky_diffuse(surface_tilt, surface_azimuth, Relative airmass (not adjusted for pressure). [unitless] model : str, default 'isotropic' Irradiance model. Can be one of ``'isotropic'``, ``'klucher'``, - ``'haydavies'``, ``'reindl'``, ``'king'``, ``'perez'``. + ``'haydavies'``, ``'reindl'``, ``'king'``, ``'perez'``, + ``'perez-driesse'``. model_perez : str, default 'allsitescomposite1990' Used only if ``model='perez'``. See :py:func:`~pvlib.irradiance.perez`. @@ -440,18 +445,19 @@ def get_sky_diffuse(surface_tilt, surface_azimuth, Notes ----- - Models ``'haydavies'``, ``'reindl'``, and ``'perez``` require 'dni_extra'. - Values can be calculated using + Models ``'haydavies'``, ``'reindl'``, ``'perez'`` and ``'perez-driesse'`` + require ``'dni_extra'``. Values can be calculated using :py:func:`~pvlib.irradiance.get_extra_radiation`. - The ``'perez'`` model requires relative airmass (``airmass``) as input. If - ``airmass`` is not provided, it is calculated using the defaults in - :py:func:`~pvlib.atmosphere.get_relative_airmass`. + The ``'perez'`` and ``'perez-driesse'`` models require relative airmass + (``airmass``) as input. If ``airmass`` is not provided, it is calculated + using the defaults in :py:func:`~pvlib.atmosphere.get_relative_airmass`. """ model = model.lower() - if (model in {'haydavies', 'reindl', 'perez'}) and (dni_extra is None): + if dni_extra is None and model in {'haydavies', 'reindl', + 'perez', 'perez-driesse'}: raise ValueError(f'dni_extra is required for model {model}') if model == 'isotropic': @@ -473,6 +479,10 @@ def get_sky_diffuse(surface_tilt, surface_azimuth, sky = perez(surface_tilt, surface_azimuth, dhi, dni, dni_extra, solar_zenith, solar_azimuth, airmass, model=model_perez) + elif model == 'perez-driesse': + # perez_driesse will calculate its own airmass if needed + sky = perez_driesse(surface_tilt, surface_azimuth, dhi, dni, dni_extra, + solar_zenith, solar_azimuth, airmass) else: raise ValueError(f'invalid model selection {model}') @@ -1212,6 +1222,228 @@ def perez(surface_tilt, surface_azimuth, dhi, dni, dni_extra, return sky_diffuse +def _calc_delta(dhi, dni_extra, solar_zenith, airmass=None): + ''' + Compute the delta parameter, which represents sky dome "brightness" + in the Perez and Perez-Driesse models. + + Helper function for perez_driesse transposition. + ''' + if airmass is None: + # use the same airmass model as in the original perez work + airmass = atmosphere.get_relative_airmass(solar_zenith, + 'kastenyoung1989') + + max_airmass = atmosphere.get_relative_airmass(90, 'kastenyoung1989') + airmass = np.where(solar_zenith >= 90, max_airmass, airmass) + + return dhi / (dni_extra / airmass) + + +def _calc_zeta(dhi, dni, zenith): + ''' + Compute the zeta parameter, which represents sky dome "clearness" + in the Perez-Driesse model. + + Helper function for perez_driesse transposition. + ''' + dhi = np.asarray(dhi) + dni = np.asarray(dni) + + # first calculate what zeta would be without the kappa correction + # using eq. 5 and eq. 13 + with np.errstate(invalid='ignore'): + zeta = dni / (dhi + dni) + + zeta = np.where(dhi == 0, 0.0, zeta) + + # then apply the kappa correction in a manner analogous to eq. 7 + kappa = 1.041 + kterm = kappa * np.radians(zenith) ** 3 + zeta = zeta / (1 - kterm * (zeta - 1)) + + return zeta + + +def _f(i, j, zeta): + ''' + Evaluate the quadratic splines corresponding to the + allsitescomposite1990 Perez model look-up table. + + Helper function for perez_driesse transposition. + ''' + knots = np.array( + [0.000, 0.000, 0.000, + 0.061, 0.187, 0.333, 0.487, 0.643, 0.778, 0.839, + 1.000, 1.000, 1.000]) + + coefs = np.array( + [[-0.053, +0.529, -0.028, -0.071, +0.061, -0.019], + [-0.008, +0.588, -0.062, -0.060, +0.072, -0.022], + [+0.131, +0.770, -0.167, -0.026, +0.106, -0.032], + [+0.328, +0.471, -0.216, +0.069, -0.105, -0.028], + [+0.557, +0.241, -0.300, +0.086, -0.085, -0.012], + [+0.861, -0.323, -0.355, +0.240, -0.467, -0.008], + [ 1.212, -1.239, -0.444, +0.305, -0.797, +0.047], + [ 1.099, -1.847, -0.365, +0.275, -1.132, +0.124], + [+0.544, +0.157, -0.213, +0.118, -1.455, +0.292], + [+0.544, +0.157, -0.213, +0.118, -1.455, +0.292], + [+0.000, +0.000, +0.000, +0.000, +0.000, +0.000], + [+0.000, +0.000, +0.000, +0.000, +0.000, +0.000], + [+0.000, +0.000, +0.000, +0.000, +0.000, +0.000]]) + + coefs = coefs.T.reshape((2, 3, 13)) + + tck = (knots, coefs[i-1, j-1], 2) + + return splev(zeta, tck) + + +def perez_driesse(surface_tilt, surface_azimuth, dhi, dni, dni_extra, + solar_zenith, solar_azimuth, airmass=None, + return_components=False): + ''' + Determine diffuse irradiance from the sky on a tilted surface using + the continuous Perez-Driesse model. + + The Perez-Driesse model [1]_ is a reformulation of the 1990 Perez + model [2]_ that provides continuity of the function and of its first + derivatives. This is achieved by replacing the look-up table of + coefficients with quadratic splines. + + Parameters + ---------- + surface_tilt : numeric + Surface tilt angles in decimal degrees. surface_tilt must be >=0 + and <=180. The tilt angle is defined as degrees from horizontal + (e.g. surface facing up = 0, surface facing horizon = 90) + + surface_azimuth : numeric + Surface azimuth angles in decimal degrees. surface_azimuth must + be >=0 and <=360. The azimuth convention is defined as degrees + east of north (e.g. North = 0, South=180 East = 90, West = 270). + + dhi : numeric + Diffuse horizontal irradiance in W/m^2. dhi must be >=0. + + dni : numeric + Direct normal irradiance in W/m^2. dni must be >=0. + + dni_extra : numeric + Extraterrestrial normal irradiance in W/m^2. + + solar_zenith : numeric + apparent (refraction-corrected) zenith angles in decimal + degrees. solar_zenith must be >=0 and <=180. + + solar_azimuth : numeric + Sun azimuth angles in decimal degrees. solar_azimuth must be >=0 + and <=360. The azimuth convention is defined as degrees east of + north (e.g. North = 0, East = 90, West = 270). + + airmass : numeric (optional, default None) + Relative (not pressure-corrected) airmass values. If airmass is a + DataFrame it must be of the same size as all other DataFrame + inputs. The kastenyoung1989 airmass calculation is used internally + and is also recommended when pre-calculating airmass because + it was used in the original model development. + + return_components: bool (optional, default=False) + Flag used to decide whether to return the calculated diffuse components + or not. + + Returns + -------- + numeric, OrderedDict, or DataFrame + Return type controlled by `return_components` argument. + If ``return_components=False``, `sky_diffuse` is returned. + If ``return_components=True``, `diffuse_components` is returned. + + sky_diffuse : numeric + The sky diffuse component of the solar radiation on a tilted + surface. + + diffuse_components : OrderedDict (array input) or DataFrame (Series input) + Keys/columns are: + * sky_diffuse: Total sky diffuse + * isotropic + * circumsolar + * horizon + + Notes + ----- + The Perez-Driesse model can be considered a plug-in replacement for the + 1990 Perez model using the ``'allsitescomposite1990'`` coefficient set. + Deviations between the two are very small, as demonstrated in [1]_. + Other coefficient sets are not supported because the 1990 set is + based on the largest and most diverse set of empirical data. + + References + ---------- + .. [1] A. Driesse, A. Jensen, R. Perez, A Continuous Form of the Perez + Diffuse Sky Model for Forward and Reverse Transposition, accepted + for publication in the Solar Energy Journal. + + .. [2] Perez, R., Ineichen, P., Seals, R., Michalsky, J., Stewart, R., + 1990. Modeling daylight availability and irradiance components from + direct and global irradiance. Solar Energy 44 (5), 271-289. + + See also + -------- + perez + isotropic + haydavies + klucher + reindl + king + ''' + # Contributed by Anton Driesse (@adriesse), PV Performance Labs. Oct., 2023 + + delta = _calc_delta(dhi, dni_extra, solar_zenith, airmass) + zeta = _calc_zeta(dhi, dni, solar_zenith) + + z = np.radians(solar_zenith) + + F1 = _f(1, 1, zeta) + _f(1, 2, zeta) * delta + _f(1, 3, zeta) * z + F2 = _f(2, 1, zeta) + _f(2, 2, zeta) * delta + _f(2, 3, zeta) * z + + # note the newly recommended upper limit on F1 + F1 = np.clip(F1, 0, 0.9) + + # lines after this point are identical to the original perez function + # with some checks removed + + A = aoi_projection(surface_tilt, surface_azimuth, + solar_zenith, solar_azimuth) + A = np.maximum(A, 0) + + B = tools.cosd(solar_zenith) + B = np.maximum(B, tools.cosd(85)) + + # Calculate Diffuse POA from sky dome + term1 = 0.5 * (1 - F1) * (1 + tools.cosd(surface_tilt)) + term2 = F1 * A / B + term3 = F2 * tools.sind(surface_tilt) + + sky_diffuse = np.maximum(dhi * (term1 + term2 + term3), 0) + + if return_components: + diffuse_components = OrderedDict() + diffuse_components['sky_diffuse'] = sky_diffuse + + # Calculate the different components + diffuse_components['isotropic'] = dhi * term1 + diffuse_components['circumsolar'] = dhi * term2 + diffuse_components['horizon'] = dhi * term3 + + if isinstance(sky_diffuse, pd.Series): + diffuse_components = pd.DataFrame(diffuse_components) + + return diffuse_components + else: + return sky_diffuse + + def clearsky_index(ghi, clearsky_ghi, max_clearsky_index=2.0): """ Calculate the clearsky index. @@ -2350,6 +2582,8 @@ def erbs_driesse(ghi, zenith, datetime_or_doy=None, dni_extra=None, orgill_hollands boland """ + # Contributed by Anton Driesse (@adriesse), PV Performance Labs. Aug., 2023 + # central polynomial coefficients with float64 precision p = [+12.26911439571261000, -16.47050842469730700,

diff --git a/pvlib/tests/test_irradiance.py b/pvlib/tests/test_irradiance.py index 2f660d5c97..8f24e7a605 100644 --- a/pvlib/tests/test_irradiance.py +++ b/pvlib/tests/test_irradiance.py @@ -273,6 +273,31 @@ def test_perez(irrad_data, ephem_data, dni_et, relative_airmass): assert_series_equal(out, expected, check_less_precise=2) +def test_perez_driesse(irrad_data, ephem_data, dni_et, relative_airmass): + dni = irrad_data['dni'].copy() + dni.iloc[2] = np.nan + out = irradiance.perez_driesse(40, 180, irrad_data['dhi'], dni, + dni_et, ephem_data['apparent_zenith'], + ephem_data['azimuth'], relative_airmass) + expected = pd.Series(np.array( + [0., 29.991, np.nan, 47.397]), + index=irrad_data.index) + assert_series_equal(out, expected, check_less_precise=2) + + +def test_perez_driesse_airmass(irrad_data, ephem_data, dni_et): + dni = irrad_data['dni'].copy() + dni.iloc[2] = np.nan + out = irradiance.perez_driesse(40, 180, irrad_data['dhi'], dni, + dni_et, ephem_data['apparent_zenith'], + ephem_data['azimuth'], airmass=None) + print(out) + expected = pd.Series(np.array( + [0., 29.991, np.nan, 47.397]), + index=irrad_data.index) + assert_series_equal(out, expected, check_less_precise=2) + + def test_perez_components(irrad_data, ephem_data, dni_et, relative_airmass): dni = irrad_data['dni'].copy() dni.iloc[2] = np.nan @@ -297,6 +322,32 @@ def test_perez_components(irrad_data, ephem_data, dni_et, relative_airmass): assert_series_equal(sum_components, expected_for_sum, check_less_precise=2) +def test_perez_driesse_components(irrad_data, ephem_data, dni_et, + relative_airmass): + dni = irrad_data['dni'].copy() + dni.iloc[2] = np.nan + out = irradiance.perez_driesse(40, 180, irrad_data['dhi'], dni, + dni_et, ephem_data['apparent_zenith'], + ephem_data['azimuth'], relative_airmass, + return_components=True) + + expected = pd.DataFrame(np.array( + [[0., 29.991, np.nan, 47.397], + [0., 25.806, np.nan, 33.181], + [0., 0.000, np.nan, 4.197], + [0., 4.184, np.nan, 10.018]]).T, + columns=['sky_diffuse', 'isotropic', 'circumsolar', 'horizon'], + index=irrad_data.index + ) + expected_for_sum = expected['sky_diffuse'].copy() + expected_for_sum.iloc[2] = 0 + sum_components = out.iloc[:, 1:].sum(axis=1) + sum_components.name = 'sky_diffuse' + + assert_frame_equal(out, expected, check_less_precise=2) + assert_series_equal(sum_components, expected_for_sum, check_less_precise=2) + + def test_perez_negative_horizon(): times = pd.date_range(start='20190101 11:30:00', freq='1H', periods=5, tz='US/Central') @@ -356,6 +407,21 @@ def test_perez_arrays(irrad_data, ephem_data, dni_et, relative_airmass): assert isinstance(out, np.ndarray) +def test_perez_driesse_arrays(irrad_data, ephem_data, dni_et, + relative_airmass): + dni = irrad_data['dni'].copy() + dni.iloc[2] = np.nan + out = irradiance.perez_driesse(40, 180, irrad_data['dhi'].values, + dni.values, dni_et, + ephem_data['apparent_zenith'].values, + ephem_data['azimuth'].values, + relative_airmass.values) + expected = np.array( + [0., 29.990, np.nan, 47.396]) + assert_allclose(out, expected, atol=1e-2) + assert isinstance(out, np.ndarray) + + def test_perez_scalar(): # copied values from fixtures out = irradiance.perez(40, 180, 118.45831879, 939.95469881, @@ -366,8 +432,17 @@ def test_perez_scalar(): assert_allclose(out, 109.084332) +def test_perez_driesse_scalar(): + # copied values from fixtures + out = irradiance.perez_driesse(40, 180, 118.458, 939.954, + 1321.165, 10.564, 144.765, 1.016) + # this will fail. out is ndarry with ndim == 0. fix in future version. + # assert np.isscalar(out) + assert_allclose(out, 110.341, atol=1e-2) + + @pytest.mark.parametrize('model', ['isotropic', 'klucher', 'haydavies', - 'reindl', 'king', 'perez']) + 'reindl', 'king', 'perez', 'perez-driesse']) def test_sky_diffuse_zenith_close_to_90(model): # GH 432 sky_diffuse = irradiance.get_sky_diffuse( @@ -419,7 +494,7 @@ def test_campbell_norman(): def test_get_total_irradiance(irrad_data, ephem_data, dni_et, relative_airmass): models = ['isotropic', 'klucher', - 'haydavies', 'reindl', 'king', 'perez'] + 'haydavies', 'reindl', 'king', 'perez', 'perez-driesse'] for model in models: total = irradiance.get_total_irradiance( @@ -437,7 +512,8 @@ def test_get_total_irradiance(irrad_data, ephem_data, dni_et, @pytest.mark.parametrize('model', ['isotropic', 'klucher', - 'haydavies', 'reindl', 'king', 'perez']) + 'haydavies', 'reindl', 'king', + 'perez', 'perez-driesse']) def test_get_total_irradiance_albedo( irrad_data, ephem_data, dni_et, relative_airmass, model): albedo = pd.Series(0.2, index=ephem_data.index) @@ -456,7 +532,8 @@ def test_get_total_irradiance_albedo( @pytest.mark.parametrize('model', ['isotropic', 'klucher', - 'haydavies', 'reindl', 'king', 'perez']) + 'haydavies', 'reindl', 'king', + 'perez', 'perez-driesse']) def test_get_total_irradiance_scalars(model): total = irradiance.get_total_irradiance( 32, 180,

diff --git a/docs/sphinx/source/reference/irradiance/transposition.rst b/docs/sphinx/source/reference/irradiance/transposition.rst index 4749b5d5b9..7b3624e692 100644 --- a/docs/sphinx/source/reference/irradiance/transposition.rst +++ b/docs/sphinx/source/reference/irradiance/transposition.rst @@ -10,6 +10,7 @@ Transposition models irradiance.get_sky_diffuse irradiance.isotropic irradiance.perez + irradiance.perez_driesse irradiance.haydavies irradiance.klucher irradiance.reindl diff --git a/docs/sphinx/source/whatsnew/v0.10.3.rst b/docs/sphinx/source/whatsnew/v0.10.3.rst index 30b9f576b0..0853254983 100644 --- a/docs/sphinx/source/whatsnew/v0.10.3.rst +++ b/docs/sphinx/source/whatsnew/v0.10.3.rst @@ -7,6 +7,8 @@ v0.10.3 (Anticipated December, 2023) Enhancements ~~~~~~~~~~~~ +* Added the continuous Perez-Driesse transposition model. + :py:func:`pvlib.irradiance.perez_driesse` (:issue:`1841`, :pull:`1876`) * :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance` and :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance_poa` now include shaded fraction in returned variables. (:pull:`1871`) @@ -28,4 +30,5 @@ Contributors ~~~~~~~~~~~~ * Arjan Keeman (:ghuser:`akeeman`) * Miguel Sánchez de León Peque (:ghuser:`Peque`) -* Will Hobbs (:ghuser:`williamhobbs`) \ No newline at end of file +* Will Hobbs (:ghuser:`williamhobbs`) +* Anton Driesse (:ghuser:`adriesse`)

[ { "components": [ { "doc": "Compute the delta parameter, which represents sky dome \"brightness\"\nin the Perez and Perez-Driesse models.\n\nHelper function for perez_driesse transposition.", "lines": [ 1225, 1240 ], "name": "_calc_delta", "signa...

[ "pvlib/tests/test_irradiance.py::test_perez_driesse", "pvlib/tests/test_irradiance.py::test_perez_driesse_airmass", "pvlib/tests/test_irradiance.py::test_perez_driesse_components", "pvlib/tests/test_irradiance.py::test_perez_driesse_arrays", "pvlib/tests/test_irradiance.py::test_perez_driesse_scalar", "pv...

[ "pvlib/tests/test_irradiance.py::test_get_extra_radiation[asce-300-1383.636203]", "pvlib/tests/test_irradiance.py::test_get_extra_radiation[asce-300.0-1383.636203]", "pvlib/tests/test_irradiance.py::test_get_extra_radiation[asce-testval2-1383.636203]", "pvlib/tests/test_irradiance.py::test_get_extra_radiation...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Continuous version of the Perez transposition model implementation  - [x] Closes #1841 - [x] I am familiar with the [contributing guidelines](https://pvlib-python.readthedocs.io/en/latest/contributing.html) - [x] Tests added - [x] Updates entries in [`docs/sphinx/source/reference`](https://github.com/pvlib/pvlib-python/blob/main/docs/sphinx/source/reference) for API changes. - [x] Adds description and name entries in the appropriate "what's new" file in [`docs/sphinx/source/whatsnew`](https://github.com/pvlib/pvlib-python/tree/main/docs/sphinx/source/whatsnew) for all changes. Includes link to the GitHub Issue with `` :issue:`num` `` or this Pull Request with `` :pull:`num` ``. Includes contributor name and/or GitHub username (link with `` :ghuser:`user` ``). - [x] New code is fully documented. Includes [numpydoc](https://numpydoc.readthedocs.io/en/latest/format.html) compliant docstrings, examples, and comments where necessary. - [x] Pull request is nearly complete and ready for detailed review. - [x] Maintainer: Appropriate GitHub Labels (including `remote-data`) and Milestone are assigned to the Pull Request and linked Issue. Create a new version of the Perez model having smooth transitions, but without changing the overall performance w.r.t. the original. The solution uses quadratic splines as described in recent presentations and posters, and documented in a paper just accepted for publication in the Solar Energy Journal. (Link will be provided later; the pre-print is available to PR reviewers on request.) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pvlib/irradiance.py] (definition of _calc_delta:) def _calc_delta(dhi, dni_extra, solar_zenith, airmass=None): """Compute the delta parameter, which represents sky dome "brightness" in the Perez and Perez-Driesse models. Helper function for perez_driesse transposition.""" (definition of _calc_zeta:) def _calc_zeta(dhi, dni, zenith): """Compute the zeta parameter, which represents sky dome "clearness" in the Perez-Driesse model. Helper function for perez_driesse transposition.""" (definition of _f:) def _f(i, j, zeta): """Evaluate the quadratic splines corresponding to the allsitescomposite1990 Perez model look-up table. Helper function for perez_driesse transposition.""" (definition of perez_driesse:) def perez_driesse(surface_tilt, surface_azimuth, dhi, dni, dni_extra, solar_zenith, solar_azimuth, airmass=None, return_components=False): """Determine diffuse irradiance from the sky on a tilted surface using the continuous Perez-Driesse model. The Perez-Driesse model [1]_ is a reformulation of the 1990 Perez model [2]_ that provides continuity of the function and of its first derivatives. This is achieved by replacing the look-up table of coefficients with quadratic splines. Parameters ---------- surface_tilt : numeric Surface tilt angles in decimal degrees. surface_tilt must be >=0 and <=180. The tilt angle is defined as degrees from horizontal (e.g. surface facing up = 0, surface facing horizon = 90) surface_azimuth : numeric Surface azimuth angles in decimal degrees. surface_azimuth must be >=0 and <=360. The azimuth convention is defined as degrees east of north (e.g. North = 0, South=180 East = 90, West = 270). dhi : numeric Diffuse horizontal irradiance in W/m^2. dhi must be >=0. dni : numeric Direct normal irradiance in W/m^2. dni must be >=0. dni_extra : numeric Extraterrestrial normal irradiance in W/m^2. solar_zenith : numeric apparent (refraction-corrected) zenith angles in decimal degrees. solar_zenith must be >=0 and <=180. solar_azimuth : numeric Sun azimuth angles in decimal degrees. solar_azimuth must be >=0 and <=360. The azimuth convention is defined as degrees east of north (e.g. North = 0, East = 90, West = 270). airmass : numeric (optional, default None) Relative (not pressure-corrected) airmass values. If airmass is a DataFrame it must be of the same size as all other DataFrame inputs. The kastenyoung1989 airmass calculation is used internally and is also recommended when pre-calculating airmass because it was used in the original model development. return_components: bool (optional, default=False) Flag used to decide whether to return the calculated diffuse components or not. Returns -------- numeric, OrderedDict, or DataFrame Return type controlled by `return_components` argument. If ``return_components=False``, `sky_diffuse` is returned. If ``return_components=True``, `diffuse_components` is returned. sky_diffuse : numeric The sky diffuse component of the solar radiation on a tilted surface. diffuse_components : OrderedDict (array input) or DataFrame (Series input) Keys/columns are: * sky_diffuse: Total sky diffuse * isotropic * circumsolar * horizon Notes ----- The Perez-Driesse model can be considered a plug-in replacement for the 1990 Perez model using the ``'allsitescomposite1990'`` coefficient set. Deviations between the two are very small, as demonstrated in [1]_. Other coefficient sets are not supported because the 1990 set is based on the largest and most diverse set of empirical data. References ---------- .. [1] A. Driesse, A. Jensen, R. Perez, A Continuous Form of the Perez Diffuse Sky Model for Forward and Reverse Transposition, accepted for publication in the Solar Energy Journal. .. [2] Perez, R., Ineichen, P., Seals, R., Michalsky, J., Stewart, R., 1990. Modeling daylight availability and irradiance components from direct and global irradiance. Solar Energy 44 (5), 271-289. See also -------- perez isotropic haydavies klucher reindl king""" [end of new definitions in pvlib/irradiance.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Continuous version of the Perez transposition model **Is your feature request related to a problem? Please describe.** Due to the empirical look-up tables, the Perez transposition model produces small jumps in tilted irradiance under gradually evolving sky conditions, and creates a difficult challenge for reverse transposition algorithms. **Describe the solution you'd like** Create a new version of the model having smooth transitions, but without changing the overall performance w.r.t. the original. **Additional context** A publication describing a solution has been accepted for publication in the Solar Energy Journal, and this solution will be implemented here. ---------- -------------------- </issues>

d53f97e984bfdd268aa92f8bf482ced0edda0110

sqlfluff__sqlfluff-5234

5,234

sqlfluff/sqlfluff

2.2

5ea25f5681fafa04ac45117ee8db9af1fa3941bb

2023-09-25T11:53:56Z

diff --git a/src/sqlfluff/dialects/dialect_ansi.py b/src/sqlfluff/dialects/dialect_ansi.py index b81b91b91b9..4fd91847490 100644 --- a/src/sqlfluff/dialects/dialect_ansi.py +++ b/src/sqlfluff/dialects/dialect_ansi.py @@ -120,6 +120,18 @@ class CompositeComparisonOperatorSegment(BaseSegment): type = "comparison_operator" +class WordSegment(CodeSegment): + """A generic (likely letters only) segment. + + Defined here for type inheritance. + + This is the base segment for things like keywords and + naked identifiers. + """ + + type = "word" + + ansi_dialect = Dialect("ansi", root_segment_name="FileSegment") ansi_dialect.set_lexer_matchers( @@ -206,14 +218,7 @@ class CompositeComparisonOperatorSegment(BaseSegment): StringLexer("colon", ":", CodeSegment), StringLexer("semicolon", ";", CodeSegment), # This is the "fallback" lexer for anything else which looks like SQL. - RegexLexer( - # NOTE: CodeSegment doesn't automatically add the `type` "code". - # This will be resolved soon, but until then we need to specify it here. - "code", - r"[0-9a-zA-Z_]+", - CodeSegment, - segment_kwargs={"type": "code"}, - ), + RegexLexer("word", r"[0-9a-zA-Z_]+", WordSegment), ] ) @@ -339,7 +344,7 @@ class CompositeComparisonOperatorSegment(BaseSegment): r"\"?[A-Z][A-Z0-9_]*\"?", CodeSegment, type="parameter" ), FunctionNameIdentifierSegment=TypedParser( - "code", CodeSegment, type="function_name_identifier" + "word", WordSegment, type="function_name_identifier" ), # Maybe data types should be more restrictive? DatatypeIdentifierSegment=SegmentGenerator( @@ -4244,7 +4249,7 @@ class PathSegment(BaseSegment): Sequence( Ref("SlashSegment"), Delimited( - TypedParser("code", CodeSegment, type="path_segment"), + TypedParser("word", WordSegment, type="path_segment"), delimiter=Ref("SlashSegment"), allow_gaps=False, ), diff --git a/src/sqlfluff/dialects/dialect_db2.py b/src/sqlfluff/dialects/dialect_db2.py index 80f2e0572a0..6b2350ff287 100644 --- a/src/sqlfluff/dialects/dialect_db2.py +++ b/src/sqlfluff/dialects/dialect_db2.py @@ -78,9 +78,7 @@ CodeSegment, ), # In Db2, a field could have a # pound/hash sign - RegexLexer( - "code", r"[0-9a-zA-Z_#]+", CodeSegment, segment_kwargs={"type": "code"} - ), + RegexLexer("word", r"[0-9a-zA-Z_#]+", ansi.WordSegment), ] ) diff --git a/src/sqlfluff/dialects/dialect_mysql.py b/src/sqlfluff/dialects/dialect_mysql.py index 4de2289703b..688e8a00c99 100644 --- a/src/sqlfluff/dialects/dialect_mysql.py +++ b/src/sqlfluff/dialects/dialect_mysql.py @@ -935,7 +935,7 @@ class IntervalExpressionSegment(BaseSegment): segment_kwargs={"type": "at_sign_literal", "trim_chars": ("@",)}, ), ], - before="code", + before="word", ) diff --git a/src/sqlfluff/dialects/dialect_oracle.py b/src/sqlfluff/dialects/dialect_oracle.py index 3824c56a662..307a18faa3a 100644 --- a/src/sqlfluff/dialects/dialect_oracle.py +++ b/src/sqlfluff/dialects/dialect_oracle.py @@ -73,12 +73,7 @@ oracle_dialect.patch_lexer_matchers( [ - RegexLexer( - "code", - r"[a-zA-Z][0-9a-zA-Z_$#]*", - CodeSegment, - segment_kwargs={"type": "code"}, - ), + RegexLexer("word", r"[a-zA-Z][0-9a-zA-Z_$#]*", ansi.WordSegment), ] ) @@ -91,7 +86,7 @@ ), StringLexer("at_sign", "@", CodeSegment), ], - before="code", + before="word", ) oracle_dialect.insert_lexer_matchers( diff --git a/src/sqlfluff/dialects/dialect_postgres.py b/src/sqlfluff/dialects/dialect_postgres.py index 0243ca005fa..1b467c6ee75 100644 --- a/src/sqlfluff/dialects/dialect_postgres.py +++ b/src/sqlfluff/dialects/dialect_postgres.py @@ -151,7 +151,7 @@ ansi.LiteralSegment, ), ], - before="code", # Final thing to search for - as psql specific + before="word", # Final thing to search for - as psql specific ) postgres_dialect.patch_lexer_matchers( @@ -175,12 +175,7 @@ r'(?s)".+?"', CodeSegment, ), - RegexLexer( - "code", - r"[a-zA-Z_][0-9a-zA-Z_$]*", - CodeSegment, - segment_kwargs={"type": "code"}, - ), + RegexLexer("word", r"[a-zA-Z_][0-9a-zA-Z_$]*", ansi.WordSegment), ] ) @@ -249,12 +244,12 @@ ), # Add a Full equivalent which also allow keywords NakedIdentifierFullSegment=TypedParser( - "code", + "word", ansi.IdentifierSegment, type="naked_identifier_all", ), PropertiesNakedIdentifierSegment=TypedParser( # allows reserved keywords - "code", + "word", CodeSegment, type="properties_naked_identifier", ), diff --git a/src/sqlfluff/dialects/dialect_redshift.py b/src/sqlfluff/dialects/dialect_redshift.py index fad246ec8ff..bb840b536f0 100644 --- a/src/sqlfluff/dialects/dialect_redshift.py +++ b/src/sqlfluff/dialects/dialect_redshift.py @@ -10,7 +10,6 @@ Anything, BaseSegment, Bracketed, - CodeSegment, Dedent, Delimited, Indent, @@ -194,12 +193,11 @@ redshift_dialect.patch_lexer_matchers( [ - # add optional leading # to code for temporary tables + # add optional leading # to word for temporary tables RegexLexer( - "code", + "word", r"#?[0-9a-zA-Z_]+[0-9a-zA-Z_$]*", - CodeSegment, - segment_kwargs={"type": "code"}, + ansi.WordSegment, ), ] ) diff --git a/src/sqlfluff/dialects/dialect_sparksql.py b/src/sqlfluff/dialects/dialect_sparksql.py index a368676fe9f..2a7b25665ee 100644 --- a/src/sqlfluff/dialects/dialect_sparksql.py +++ b/src/sqlfluff/dialects/dialect_sparksql.py @@ -145,7 +145,7 @@ CodeSegment, ), ], - before="code", + before="word", ) sparksql_dialect.insert_lexer_matchers( [ diff --git a/src/sqlfluff/dialects/dialect_tsql.py b/src/sqlfluff/dialects/dialect_tsql.py index 22055837256..d6c721c9176 100644 --- a/src/sqlfluff/dialects/dialect_tsql.py +++ b/src/sqlfluff/dialects/dialect_tsql.py @@ -221,7 +221,7 @@ ), ), RegexLexer( - "code", r"[0-9a-zA-Z_#@]+", CodeSegment + "word", r"[0-9a-zA-Z_#@]+", ansi.WordSegment ), # overriding to allow hash mark and at-sign in code ] )

diff --git a/test/core/parser/lexer_test.py b/test/core/parser/lexer_test.py index 2762e3305a8..7685cb36b0d 100644 --- a/test/core/parser/lexer_test.py +++ b/test/core/parser/lexer_test.py @@ -223,7 +223,7 @@ def _load_result(*args, **kwargs): "placeholder", ), ("\n", None, None, "newline"), - ("select", None, None, "raw"), + ("select", None, None, "word"), (" ", None, None, "whitespace"), ("2", None, None, "literal"), ("\n", None, None, "newline"), @@ -252,18 +252,18 @@ def _load_result(*args, **kwargs): ("", None, None, "dedent"), ("", "{% endmacro %}", "block_end", "placeholder"), ("\n", None, None, "newline"), - ("SELECT", None, None, "raw"), + ("SELECT", None, None, "word"), ("\n", None, None, "newline"), (" ", None, None, "whitespace"), ("\n", None, None, "newline"), (" ", None, None, "whitespace"), ("'Sir. foo'", None, None, "raw"), (" ", None, None, "whitespace"), - ("as", None, None, "raw"), + ("as", None, None, "word"), (" ", None, None, "whitespace"), ("\n", None, None, "newline"), (" ", None, None, "whitespace"), - ("bar", None, None, "raw"), + ("bar", None, None, "word"), ("\n", None, None, "newline"), (" ", None, None, "whitespace"), ("\n", None, None, "newline"), @@ -271,9 +271,9 @@ def _load_result(*args, **kwargs): ("", None, None, "dedent"), ("", "{% endcall %}", "block_end", "placeholder"), ("\n", None, None, "newline"), - ("FROM", None, None, "raw"), + ("FROM", None, None, "word"), (" ", None, None, "whitespace"), - ("baz", None, None, "raw"), + ("baz", None, None, "word"), ("\n", None, None, "newline"), ("", None, None, "end_of_file"), ], @@ -352,7 +352,7 @@ class _LexerSlicingTemplateFileCase(NamedTuple): ], ), expected_segments=[ - ("SELECT", None, None, "raw"), + ("SELECT", None, None, "word"), (" ", None, None, "whitespace"), ("", "{# comment #}", "comment", "placeholder"), ("1", None, None, "literal"), @@ -380,7 +380,7 @@ class _LexerSlicingTemplateFileCase(NamedTuple): ], ), expected_segments=[ - ("SELECT", None, None, "raw"), + ("SELECT", None, None, "word"), (" ", None, None, "whitespace"), ("", "", "special_type", "placeholder"), ("1", None, None, "literal"),

[ { "components": [ { "doc": "A generic (likely letters only) segment.\n\nDefined here for type inheritance.\n\nThis is the base segment for things like keywords and\nnaked identifiers.", "lines": [ 123, 132 ], "name": "WordSegment", "signature": "...

[ "test/core/parser/lexer_test.py::test__parser__lexer_slicing_calls[call", "test/core/parser/lexer_test.py::test__parser__lexer_slicing_from_template_file[very", "test/core/parser/lexer_test.py::test__parser__lexer_slicing_from_template_file[special" ]

[ "test/core/parser/lexer_test.py::test__parser__lexer_obj[a", "test/core/parser/lexer_test.py::test__parser__lexer_obj[b.c-res1]", "test/core/parser/lexer_test.py::test__parser__lexer_obj[abc", "test/core/parser/lexer_test.py::test__parser__lexer_obj[abc'\\n", "test/core/parser/lexer_test.py::test__parser__l...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Introduce "word" segment **This is a follow-on from #5232.** We've got a bit of a rats nest around the `CodeSegment` currently. It doesn't define a `type` but some segments look for it in the `TypedParser`. This raises some really gnarly bugs when trying to enable reparsing of segments cleanly (which have arisen as part of #5230). This resolves that by introducing a `WordSegment` which _inherits from_ `CodeSegment` but allows us to distinguish better between things that look like words (such as keywords etc...) and things that don't (like symbols or quotes). NOTE: There are some dependency changes we should make, in particular that `KeywordSegment` should inherit from `WordSegment` - but that's not supported by the current layout of `KeywordSegment` being part of `sqlfluff.core.parser` and `WordSegment` (and others) being withing `sqlfluff.dialects.ansi`. I'll address that as another PR because it makes it very hard to see the changes already in this PR. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/sqlfluff/dialects/dialect_ansi.py] (definition of WordSegment:) class WordSegment(CodeSegment): """A generic (likely letters only) segment. Defined here for type inheritance. This is the base segment for things like keywords and naked identifiers.""" [end of new definitions in src/sqlfluff/dialects/dialect_ansi.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

65328e6b701f46ebb25b758c10b7572111f130ab

pvlib__pvlib-python-1875

1,875

pvlib/pvlib-python

0.9

12ba8ee00dbe1cae3d4b4b4d8c0098f9144156e3

2023-09-25T04:23:07Z

diff --git a/docs/sphinx/source/reference/iotools.rst b/docs/sphinx/source/reference/iotools.rst index b41a30b203..05100e9d17 100644 --- a/docs/sphinx/source/reference/iotools.rst +++ b/docs/sphinx/source/reference/iotools.rst @@ -46,6 +46,10 @@ of sources and file formats relevant to solar energy modeling. iotools.get_acis_station_data iotools.get_acis_available_stations iotools.read_panond + iotools.get_solcast_tmy + iotools.get_solcast_historic + iotools.get_solcast_forecast + iotools.get_solcast_live A :py:class:`~pvlib.location.Location` object may be created from metadata diff --git a/docs/sphinx/source/whatsnew/v0.10.3.rst b/docs/sphinx/source/whatsnew/v0.10.3.rst index 30fd46648f..29aa59a543 100644 --- a/docs/sphinx/source/whatsnew/v0.10.3.rst +++ b/docs/sphinx/source/whatsnew/v0.10.3.rst @@ -15,6 +15,9 @@ Enhancements * :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance` and :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance_poa` now include shaded fraction in returned variables. (:pull:`1871`) +* Added :py:func:`~pvlib.iotools.get_solcast_tmy`, :py:func:`~pvlib.iotools.get_solcast_historic`, + :py:func:`~pvlib.iotools.get_solcast_forecast` and :py:func:`~pvlib.iotools.get_solcast_live` to + read data from the Solcast API. (:issue:`1313`, :pull:`1875`) * Added :py:func:`~pvlib.iam.convert` and :py:func:`~pvlib.iam.fit` that convert between IAM models, and that fit an IAM model to data. (:issue:`1824`, :pull:`1827`) @@ -59,4 +62,5 @@ Contributors * :ghuser:`matsuobasho` * Harry Jack (:ghuser:`harry-solcast`) * Kevin Anderson (:ghuser:`kandersolar`) +* Lorenzo Riches (:ghuser:`lorenzo-solcast`) * Cliff Hansen (:ghuser:`cwhanse`) diff --git a/pvlib/iotools/__init__.py b/pvlib/iotools/__init__.py index 9935719b29..6a4991ee7b 100644 --- a/pvlib/iotools/__init__.py +++ b/pvlib/iotools/__init__.py @@ -27,3 +27,7 @@ from pvlib.iotools.acis import get_acis_mpe # noqa: F401 from pvlib.iotools.acis import get_acis_station_data # noqa: F401 from pvlib.iotools.acis import get_acis_available_stations # noqa: F401 +from pvlib.iotools.solcast import get_solcast_forecast # noqa: F401 +from pvlib.iotools.solcast import get_solcast_live # noqa: F401 +from pvlib.iotools.solcast import get_solcast_historic # noqa: F401 +from pvlib.iotools.solcast import get_solcast_tmy # noqa: F401 diff --git a/pvlib/iotools/solcast.py b/pvlib/iotools/solcast.py new file mode 100644 index 0000000000..4fcee40050 --- /dev/null +++ b/pvlib/iotools/solcast.py @@ -0,0 +1,488 @@ +""" Functions to access data from the Solcast API. +""" + +import requests +import pandas as pd +from dataclasses import dataclass + + +BASE_URL = "https://api.solcast.com.au/data" + + +@dataclass +class ParameterMap: + solcast_name: str + pvlib_name: str + conversion: callable = lambda x: x + + +# define the conventions between Solcast and pvlib nomenclature and units +VARIABLE_MAP = [ + # air_temp -> temp_air (deg C) + ParameterMap("air_temp", "temp_air"), + # surface_pressure (hPa) -> pressure (Pa) + ParameterMap("surface_pressure", "pressure", lambda x: x*100), + # dewpoint_temp -> temp_dew (deg C) + ParameterMap("dewpoint_temp", "temp_dew"), + # gti (W/m^2) -> poa_global (W/m^2) + ParameterMap("gti", "poa_global"), + # wind_speed_10m (m/s) -> wind_speed (m/s) + ParameterMap("wind_speed_10m", "wind_speed"), + # wind_direction_10m (deg) -> wind_direction (deg) + ParameterMap("wind_direction_10m", "wind_direction"), + # azimuth -> solar_azimuth (degrees) (different convention) + ParameterMap( + "azimuth", "solar_azimuth", lambda x: -x % 360 + ), + # precipitable_water (kg/m2) -> precipitable_water (cm) + ParameterMap("precipitable_water", "precipitable_water", lambda x: x*10), + # zenith -> solar_zenith + ParameterMap("zenith", "solar_zenith"), + # clearsky + ParameterMap("clearsky_dhi", "dhi_clear"), + ParameterMap("clearsky_dni", "dni_clear"), + ParameterMap("clearsky_ghi", "ghi_clear"), + ParameterMap("clearsky_gti", "poa_global_clear") +] + + +def get_solcast_tmy( + latitude, longitude, api_key, map_variables=True, **kwargs +): + """Get irradiance and weather for a + Typical Meteorological Year (TMY) at a requested location. + + Data is derived from a multi-year time series selected to present the + unique weather phenomena with annual averages that are consistent with + long term averages. See [1]_ for details on the calculation. + + Parameters + ---------- + latitude : float + in decimal degrees, between -90 and 90, north is positive + longitude : float + in decimal degrees, between -180 and 180, east is positive + api_key : str + To access Solcast data you will need an API key [2]_. + map_variables: bool, default: True + When true, renames columns of the DataFrame to pvlib variable names + where applicable. See variable :const:`VARIABLE_MAP`. + Time is the index shifted to the midpoint of each interval + from Solcast's "period end" convention. + kwargs: + Optional parameters passed to the API. + See [3]_ for full list of parameters. + + Returns + ------- + data : pandas.DataFrame + containing the values for the parameters requested. The times + in the DataFrame index indicate the midpoint of each interval. + metadata: dict + latitude and longitude of the request. + + Examples + -------- + >>> df, meta = pvlib.iotools.solcast.get_solcast_tmy( + >>> latitude=-33.856784, + >>> longitude=151.215297, + >>> api_key="your-key" + >>> ) + + you can pass any of the parameters listed in the API docs, + like ``time_zone``. Here we set the value of 10 for + "10 hours ahead of UTC": + + >>> df, meta = pvlib.iotools.solcast.get_solcast_tmy( + >>> latitude=-33.856784, + >>> longitude=151.215297, + >>> time_zone=10, + >>> api_key="your-key" + >>> ) + + References + ---------- + .. [1] `Solcast TMY Docs <https://solcast.com/tmy>`_ + .. [2] `Get an API Key <https://toolkit.solcast.com.au/register>`_ + .. [3] `Solcast API Docs <https://docs.solcast.com.au/>`_ + + See Also + -------- + pvlib.iotools.get_solcast_historic, pvlib.iotools.get_solcast_forecast, + pvlib.iotools.get_solcast_live + """ + + params = dict( + latitude=latitude, + longitude=longitude, + format="json", + **kwargs + ) + + data = _get_solcast( + endpoint="tmy/radiation_and_weather", + params=params, + api_key=api_key, + map_variables=map_variables + ) + + return data, {"latitude": latitude, "longitude": longitude} + + +def get_solcast_historic( + latitude, + longitude, + start, + api_key, + end=None, + duration=None, + map_variables=True, + **kwargs +): + """Get historical irradiance and weather estimates. + + for up to 31 days of data at a time for a requested location, + derived from satellite (clouds and irradiance + over non-polar continental areas) and + numerical weather models (other data). + Data is available from 2007-01-01T00:00Z up to real time estimated actuals. + + Parameters + ---------- + latitude : float + in decimal degrees, between -90 and 90, north is positive + longitude : float + in decimal degrees, between -180 and 180, east is positive + start : datetime-like + First day of the requested period + end : optional, datetime-like + Last day of the requested period. + Must include one of ``end`` or ``duration``. + duration : optional, ISO 8601 compliant duration + Must include either ``end`` or ``duration``. + ISO 8601 compliant duration for the historic data, + like "P1D" for one day of data. + Must be within 31 days of ``start``. + map_variables: bool, default: True + When true, renames columns of the DataFrame to pvlib variable names + where applicable. See variable :const:`VARIABLE_MAP`. + Time is the index shifted to the midpoint of each interval + from Solcast's "period end" convention. + api_key : str + To access Solcast data you will need an API key [1]_. + kwargs: + Optional parameters passed to the API. + See [2]_ for full list of parameters. + + Returns + ------- + data : pandas.DataFrame + containing the values for the parameters requested. The times + in the DataFrame index indicate the midpoint of each interval. + metadata: dict + latitude and longitude of the request. + + Examples + -------- + >>> df, meta = pvlib.iotools.solcast.get_solcast_historic( + >>> latitude=-33.856784, + >>> longitude=151.215297, + >>> start='2007-01-01T00:00Z', + >>> duration='P1D', + >>> api_key="your-key" + >>> ) + + you can pass any of the parameters listed in the API docs, + for example using the ``end`` parameter instead + + >>> df, meta = pvlib.iotools.solcast.get_solcast_historic( + >>> latitude=-33.856784, + >>> longitude=151.215297, + >>> start='2007-01-01T00:00Z', + >>> end='2007-01-02T00:00Z', + >>> api_key="your-key" + >>> ) + + References + ---------- + .. [1] `Get an API Key <https://toolkit.solcast.com.au/register>`_ + .. [2] `Solcast API Docs <https://docs.solcast.com.au/>`_ + + See Also + -------- + pvlib.iotools.get_solcast_tmy, pvlib.iotools.get_solcast_forecast, + pvlib.iotools.get_solcast_live + """ + + params = dict( + latitude=latitude, + longitude=longitude, + start=start, + end=end, + duration=duration, + api_key=api_key, + format="json", + **kwargs + ) + + data = _get_solcast( + endpoint="historic/radiation_and_weather", + params=params, + api_key=api_key, + map_variables=map_variables + ) + + return data, {"latitude": latitude, "longitude": longitude} + + +def get_solcast_forecast( + latitude, longitude, api_key, map_variables=True, **kwargs +): + """Get irradiance and weather forecasts from the present time + up to 14 days ahead. + + Parameters + ---------- + latitude : float + in decimal degrees, between -90 and 90, north is positive + longitude : float + in decimal degrees, between -180 and 180, east is positive + api_key : str + To access Solcast data you will need an API key [1]_. + map_variables: bool, default: True + When true, renames columns of the DataFrame to pvlib variable names + where applicable. See variable :const:`VARIABLE_MAP`. + Time is the index shifted to the midpoint of each interval + from Solcast's "period end" convention. + kwargs: + Optional parameters passed to the API. + See [2]_ for full list of parameters. + + Returns + ------- + data : pandas.DataFrame + Contains the values for the parameters requested. The times + in the DataFrame index indicate the midpoint of each interval. + metadata: dict + latitude and longitude of the request. + + Examples + -------- + >>> df, meta = pvlib.iotools.solcast.get_solcast_forecast( + >>> latitude=-33.856784, + >>> longitude=151.215297, + >>> api_key="your-key" + >>> ) + + you can pass any of the parameters listed in the API docs, + like asking for specific variables for a specific time horizon: + + >>> df, meta = pvlib.iotools.solcast.get_solcast_forecast( + >>> latitude=-33.856784, + >>> longitude=151.215297, + >>> output_parameters=['dni', 'clearsky_dni', 'snow_soiling_rooftop'], + >>> hours=24, + >>> api_key="your-key" + >>> ) + + References + ---------- + .. [1] `Get an API Key <https://toolkit.solcast.com.au/register>`_ + .. [2] `Solcast API Docs <https://docs.solcast.com.au/>`_ + + See Also + -------- + pvlib.iotools.get_solcast_tmy, pvlib.iotools.get_solcast_historic, + pvlib.iotools.get_solcast_live + """ + + params = dict( + latitude=latitude, + longitude=longitude, + format="json", + **kwargs + ) + + data = _get_solcast( + endpoint="forecast/radiation_and_weather", + params=params, + api_key=api_key, + map_variables=map_variables + ) + + return data, {"latitude": latitude, "longitude": longitude} + + +def get_solcast_live( + latitude, longitude, api_key, map_variables=True, **kwargs +): + """Get irradiance and weather estimated actuals for near real-time + and past 7 days. + + Parameters + ---------- + latitude : float + in decimal degrees, between -90 and 90, north is positive + longitude : float + in decimal degrees, between -180 and 180, east is positive + api_key : str + To access Solcast data you will need an API key [1]_. + map_variables: bool, default: True + When true, renames columns of the DataFrame to pvlib variable names + where applicable. See variable :const:`VARIABLE_MAP`. + Time is the index shifted to the midpoint of each interval + from Solcast's "period end" convention. + kwargs: + Optional parameters passed to the API. + See [2]_ for full list of parameters. + + Returns + ------- + data : pandas.DataFrame + containing the values for the parameters requested. The times + in the DataFrame index indicate the midpoint of each interval. + metadata: dict + latitude and longitude of the request. + + Examples + -------- + >>> df, meta = pvlib.iotools.solcast.get_solcast_live( + >>> latitude=-33.856784, + >>> longitude=151.215297, + >>> api_key="your-key" + >>> ) + + you can pass any of the parameters listed in the API docs, like + + >>> df, meta = pvlib.iotools.solcast.get_solcast_live( + >>> latitude=-33.856784, + >>> longitude=151.215297, + >>> terrain_shading=True, + >>> output_parameters=['ghi', 'clearsky_ghi', 'snow_soiling_rooftop'], + >>> api_key="your-key" + >>> ) + + use ``map_variables=False`` to avoid converting the data + to PVLib's conventions. + + >>> df, meta = pvlib.iotools.solcast.get_solcast_live( + >>> latitude=-33.856784, + >>> longitude=151.215297, + >>> map_variables=False, + >>> api_key="your-key" + >>> ) + + References + ---------- + .. [1] `Get an API Key <https://toolkit.solcast.com.au/register>`_ + .. [2] `Solcast API Docs <https://docs.solcast.com.au/>`_ + + See Also + -------- + pvlib.iotools.get_solcast_tmy, pvlib.iotools.get_solcast_historic, + pvlib.iotools.get_solcast_forecast + """ + + params = dict( + latitude=latitude, + longitude=longitude, + format="json", + **kwargs + ) + + data = _get_solcast( + endpoint="live/radiation_and_weather", + params=params, + api_key=api_key, + map_variables=map_variables + ) + + return data, {"latitude": latitude, "longitude": longitude} + + +def _solcast2pvlib(data): + """Format the data from Solcast to pvlib's conventions. + + Parameters + ---------- + data : pandas.DataFrame + contains the data returned from the Solcast API + + Returns + ------- + a pandas.DataFrame with the data cast to pvlib's conventions + """ + # move from period_end to period_middle as per pvlib convention + # to support Pandas 0.25 we cast PTXX to XX as ISO8601 + # durations without days aren't supported: + # https://github.com/pandas-dev/pandas/pull/37159\ + # Can remove once minimum supported Pandas version is >=1.2 + periods = data.period.str.replace("PT", "").str.replace("M", "m") + + data["period_mid"] = pd.to_datetime( + data.period_end) - pd.to_timedelta(periods) / 2 + data = data.set_index("period_mid").drop(columns=["period_end", "period"]) + + # rename and convert variables + for variable in VARIABLE_MAP: + if variable.solcast_name in data.columns: + data.rename( + columns={variable.solcast_name: variable.pvlib_name}, + inplace=True + ) + data[variable.pvlib_name] = data[ + variable.pvlib_name].apply(variable.conversion) + return data + + +def _get_solcast( + endpoint, + params, + api_key, + map_variables +): + """Retrieve weather, irradiance and power data from the Solcast API. + + Parameters + ---------- + endpoint : str + one of Solcast API endpoint: + - live/radiation_and_weather + - forecast/radiation_and_weather + - historic/radiation_and_weather + - tmy/radiation_and_weather + params : dict + parameters to be passed to the API + api_key : str + To access Solcast data you will need an API key [1]_. + map_variables: bool, default: True + When true, renames columns of the DataFrame to pvlib's variable names + where applicable. See variable :const:`VARIABLE_MAP`. + Time is the index shifted to the midpoint of each interval + from Solcast's "period end" convention. + + Returns + ------- + A pandas.DataFrame with the data if the request is successful, + an error message otherwise + + References + ---------- + .. [1] `register <https://toolkit.solcast.com.au/register>` + """ + + response = requests.get( + url='/'.join([BASE_URL, endpoint]), + params=params, + headers={"Authorization": f"Bearer {api_key}"} + ) + + if response.status_code == 200: + j = response.json() + df = pd.DataFrame.from_dict(j[list(j.keys())[0]]) + if map_variables: + return _solcast2pvlib(df) + else: + return df + else: + raise Exception(response.json())

diff --git a/pvlib/tests/iotools/test_solcast.py b/pvlib/tests/iotools/test_solcast.py new file mode 100644 index 0000000000..19b00b8611 --- /dev/null +++ b/pvlib/tests/iotools/test_solcast.py @@ -0,0 +1,324 @@ +from unittest.mock import patch +import pandas as pd +import pvlib +import pytest + + +@pytest.mark.parametrize("endpoint,params,api_key,json_response", [ + ( + "live/radiation_and_weather", + dict( + latitude=-33.856784, + longitude=151.215297, + output_parameters='dni,ghi' + ), + "1234", + {'estimated_actuals': + [{'dni': 836, 'ghi': 561, + 'period_end': '2023-09-18T05:00:00.0000000Z', 'period': 'PT30M'}, + {'dni': 866, 'ghi': 643, + 'period_end': '2023-09-18T04:30:00.0000000Z', 'period': 'PT30M'}, + {'dni': 890, 'ghi': 713, + 'period_end': '2023-09-18T04:00:00.0000000Z', 'period': 'PT30M'}, + {'dni': 909, 'ghi': 768, + 'period_end': '2023-09-18T03:30:00.0000000Z', 'period': 'PT30M'}] + } + ), +]) +def test__get_solcast(requests_mock, endpoint, params, api_key, json_response): + mock_url = f"https://api.solcast.com.au/data/{endpoint}?" \ + f"latitude={params['latitude']}&" \ + f"longitude={params['longitude']}&" \ + f"output_parameters={params['output_parameters']}" + + requests_mock.get(mock_url, json=json_response) + + # with variables remapping + pd.testing.assert_frame_equal( + pvlib.iotools.solcast._get_solcast( + endpoint, params, api_key, True + ), + pvlib.iotools.solcast._solcast2pvlib( + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]]) + ) + ) + + # no remapping of variables + pd.testing.assert_frame_equal( + pvlib.iotools.solcast._get_solcast( + endpoint, params, api_key, False + ), + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]]) + ) + + +@pytest.mark.parametrize("map_variables", [True, False]) +@pytest.mark.parametrize("endpoint,function,params,json_response", [ + ( + "live/radiation_and_weather", + pvlib.iotools.get_solcast_live, + dict( + api_key="1234", + latitude=-33.856784, + longitude=151.215297, + output_parameters='dni,ghi' + ), + {'estimated_actuals': + [{'dni': 836, 'ghi': 561, + 'period_end': '2023-09-18T05:00:00.0000000Z', 'period': 'PT30M'}, + {'dni': 866, 'ghi': 643, + 'period_end': '2023-09-18T04:30:00.0000000Z', 'period': 'PT30M'}, + {'dni': 890, 'ghi': 713, + 'period_end': '2023-09-18T04:00:00.0000000Z', 'period': 'PT30M'}, + {'dni': 909, 'ghi': 768, + 'period_end': '2023-09-18T03:30:00.0000000Z', 'period': 'PT30M'}] + } + ), +]) +def test_get_solcast_live( + requests_mock, endpoint, function, params, json_response, map_variables +): + mock_url = ( + f"https://api.solcast.com.au/data/{endpoint}?" + f"&latitude={params['latitude']}&" + f"longitude={params['longitude']}&" + f"output_parameters={params['output_parameters']}&format=json" + ) + + requests_mock.get(mock_url, json=json_response) + + if map_variables: + pd.testing.assert_frame_equal( + function(**params, map_variables=map_variables)[0], + pvlib.iotools.solcast._solcast2pvlib( + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]] + ) + ), + ) + else: + pd.testing.assert_frame_equal( + function(**params, map_variables=map_variables)[0], + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]] + ), + ) + + +@pytest.mark.parametrize("map_variables", [True, False]) +@pytest.mark.parametrize("endpoint,function,params,json_response", [ + ( + "tmy/radiation_and_weather", + pvlib.iotools.get_solcast_tmy, + dict( + api_key="1234", + latitude=-33.856784, + longitude=51.215297 + ), + {'estimated_actuals': [ + {'dni': 151, 'ghi': 609, + 'period_end': '2059-01-01T01:00:00.0000000Z', 'period': 'PT60M'}, + {'dni': 0, 'ghi': 404, + 'period_end': '2059-01-01T02:00:00.0000000Z', 'period': 'PT60M'}, + {'dni': 0, 'ghi': 304, + 'period_end': '2059-01-01T03:00:00.0000000Z', 'period': 'PT60M'}, + {'dni': 0, 'ghi': 174, + 'period_end': '2059-01-01T04:00:00.0000000Z', 'period': 'PT60M'}, + {'dni': 0, 'ghi': 111, + 'period_end': '2059-01-01T05:00:00.0000000Z', 'period': 'PT60M'}] + } + ), +]) +def test_get_solcast_tmy( + requests_mock, endpoint, function, params, json_response, map_variables +): + + mock_url = f"https://api.solcast.com.au/data/{endpoint}?" \ + f"&latitude={params['latitude']}&" \ + f"longitude={params['longitude']}&format=json" + + requests_mock.get(mock_url, json=json_response) + + if map_variables: + pd.testing.assert_frame_equal( + function(**params, map_variables=map_variables)[0], + pvlib.iotools.solcast._solcast2pvlib( + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]] + ) + ), + ) + else: + pd.testing.assert_frame_equal( + function(**params, map_variables=map_variables)[0], + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]] + ), + ) + + +@pytest.mark.parametrize("in_df,out_df", [ + ( + pd.DataFrame( + [[942, 843, 1017.4, 30, 7.8, 316, 1010, -2, 4.6, 16.4, + '2023-09-20T02:00:00.0000000Z', 'PT30M', 90], + [936, 832, 1017.9, 30, 7.9, 316, 996, -14, 4.5, 16.3, + '2023-09-20T01:30:00.0000000Z', 'PT30M', 0]], + columns=[ + 'dni', 'ghi', 'surface_pressure', 'air_temp', 'wind_speed_10m', + 'wind_direction_10m', 'gti', 'azimuth', 'dewpoint_temp', + 'precipitable_water', 'period_end', 'period', 'zenith'], + index=pd.RangeIndex(start=0, stop=2, step=1) + ), + pd.DataFrame( + [[9.4200e+02, 8.4300e+02, 1.0174e+05, 3.0000e+01, 7.8000e+00, + 3.1600e+02, 1.0100e+03, 2.0000e+00, 4.6000e+00, 1.6400e+02, 90], + [9.3600e+02, 8.3200e+02, 1.0179e+05, 3.0000e+01, 7.9000e+00, + 3.1600e+02, 9.9600e+02, 1.4000e+01, 4.5000e+00, 1.6300e+02, 0]], + columns=[ + 'dni', 'ghi', 'pressure', 'temp_air', 'wind_speed', + 'wind_direction', 'poa_global', 'solar_azimuth', + 'temp_dew', 'precipitable_water', 'solar_zenith'], + index=pd.DatetimeIndex( + ['2023-09-20 01:45:00+00:00', '2023-09-20 01:15:00+00:00'], + dtype='datetime64[ns, UTC]', name='period_mid', freq=None) + ) + ) +]) +def test_solcast2pvlib(in_df, out_df): + df = pvlib.iotools.solcast._solcast2pvlib(in_df) + pd.testing.assert_frame_equal(df.astype(float), out_df.astype(float)) + + +@pytest.mark.parametrize("map_variables", [True, False]) +@pytest.mark.parametrize("endpoint,function,params,json_response", [ + ( + "historic/radiation_and_weather", + pvlib.iotools.get_solcast_historic, + dict( + api_key="1234", + latitude=-33.856784, + longitude=51.215297, + start="2023-01-01T08:00", + duration="P1D", + period="PT1H", + output_parameters='dni' + ), {'estimated_actuals': [ + {'dni': 822, 'period_end': '2023-01-01T09:00:00.0000000Z', + 'period': 'PT60M'}, + {'dni': 918, 'period_end': '2023-01-01T10:00:00.0000000Z', + 'period': 'PT60M'}, + {'dni': 772, 'period_end': '2023-01-01T11:00:00.0000000Z', + 'period': 'PT60M'}, + {'dni': 574, 'period_end': '2023-01-01T12:00:00.0000000Z', + 'period': 'PT60M'}, + {'dni': 494, 'period_end': '2023-01-01T13:00:00.0000000Z', + 'period': 'PT60M'} + ]} + ), +]) +def test_get_solcast_historic( + requests_mock, endpoint, function, params, json_response, map_variables +): + mock_url = f"https://api.solcast.com.au/data/{endpoint}?" \ + f"&latitude={params['latitude']}&" \ + f"longitude={params['longitude']}&format=json" + + requests_mock.get(mock_url, json=json_response) + + if map_variables: + pd.testing.assert_frame_equal( + function(**params, map_variables=map_variables)[0], + pvlib.iotools.solcast._solcast2pvlib( + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]] + ) + ), + ) + else: + pd.testing.assert_frame_equal( + function(**params, map_variables=map_variables)[0], + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]] + ), + ) + + +@pytest.mark.parametrize("map_variables", [True, False]) +@pytest.mark.parametrize("endpoint,function,params,json_response", [ + ( + "forecast/radiation_and_weather", + pvlib.iotools.get_solcast_forecast, + dict( + api_key="1234", + latitude=-33.856784, + longitude=51.215297, + hours="5", + period="PT1H", + output_parameters='dni' + ), { + 'forecast': [ + {'dni': 0, 'period_end': '2023-12-13T01:00:00.0000000Z', + 'period': 'PT1H'}, + {'dni': 1, 'period_end': '2023-12-13T02:00:00.0000000Z', + 'period': 'PT1H'}, + {'dni': 2, 'period_end': '2023-12-13T03:00:00.0000000Z', + 'period': 'PT1H'}, + {'dni': 3, 'period_end': '2023-12-13T04:00:00.0000000Z', + 'period': 'PT1H'}, + {'dni': 4, 'period_end': '2023-12-13T05:00:00.0000000Z', + 'period': 'PT1H'}, + {'dni': 5, 'period_end': '2023-12-13T06:00:00.0000000Z', + 'period': 'PT1H'} + ]} + ), +]) +def test_get_solcast_forecast( + requests_mock, endpoint, function, params, json_response, map_variables +): + mock_url = f"https://api.solcast.com.au/data/{endpoint}?" \ + f"&latitude={params['latitude']}&" \ + f"longitude={params['longitude']}&format=json" + + requests_mock.get(mock_url, json=json_response) + + if map_variables: + pd.testing.assert_frame_equal( + function(**params, map_variables=map_variables)[0], + pvlib.iotools.solcast._solcast2pvlib( + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]] + ) + ), + ) + else: + pd.testing.assert_frame_equal( + function(**params, map_variables=map_variables)[0], + pd.DataFrame.from_dict( + json_response[list(json_response.keys())[0]] + ), + ) + + +@pytest.mark.parametrize( + "function", + [ + pvlib.iotools.get_solcast_forecast, + pvlib.iotools.get_solcast_live, + pvlib.iotools.get_solcast_tmy, + pvlib.iotools.get_solcast_historic, + ], +) +@patch("requests.api.request") +def test_raises_exception(mock_response, function): + dummy_args = { + "latitude": 0, + "longitude": 0, + "api_key": "", + } + with patch.object(mock_response, "status_code", return_value=404): + with pytest.raises(Exception): + function(**dummy_args) + mock_response.json.assert_called_once()

diff --git a/docs/sphinx/source/reference/iotools.rst b/docs/sphinx/source/reference/iotools.rst index b41a30b203..05100e9d17 100644 --- a/docs/sphinx/source/reference/iotools.rst +++ b/docs/sphinx/source/reference/iotools.rst @@ -46,6 +46,10 @@ of sources and file formats relevant to solar energy modeling. iotools.get_acis_station_data iotools.get_acis_available_stations iotools.read_panond + iotools.get_solcast_tmy + iotools.get_solcast_historic + iotools.get_solcast_forecast + iotools.get_solcast_live A :py:class:`~pvlib.location.Location` object may be created from metadata diff --git a/docs/sphinx/source/whatsnew/v0.10.3.rst b/docs/sphinx/source/whatsnew/v0.10.3.rst index 30fd46648f..29aa59a543 100644 --- a/docs/sphinx/source/whatsnew/v0.10.3.rst +++ b/docs/sphinx/source/whatsnew/v0.10.3.rst @@ -15,6 +15,9 @@ Enhancements * :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance` and :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance_poa` now include shaded fraction in returned variables. (:pull:`1871`) +* Added :py:func:`~pvlib.iotools.get_solcast_tmy`, :py:func:`~pvlib.iotools.get_solcast_historic`, + :py:func:`~pvlib.iotools.get_solcast_forecast` and :py:func:`~pvlib.iotools.get_solcast_live` to + read data from the Solcast API. (:issue:`1313`, :pull:`1875`) * Added :py:func:`~pvlib.iam.convert` and :py:func:`~pvlib.iam.fit` that convert between IAM models, and that fit an IAM model to data. (:issue:`1824`, :pull:`1827`) @@ -59,4 +62,5 @@ Contributors * :ghuser:`matsuobasho` * Harry Jack (:ghuser:`harry-solcast`) * Kevin Anderson (:ghuser:`kandersolar`) +* Lorenzo Riches (:ghuser:`lorenzo-solcast`) * Cliff Hansen (:ghuser:`cwhanse`)

[ { "components": [ { "doc": "", "lines": [ 13, 16 ], "name": "ParameterMap", "signature": "class ParameterMap:", "type": "class" }, { "doc": "Get irradiance and weather for a\nTypical Meteorological Year (TMY) at a requ...

[ "pvlib/tests/iotools/test_solcast.py::test__get_solcast[live/radiation_and_weather-params0-1234-json_response0]", "pvlib/tests/iotools/test_solcast.py::test_get_solcast_live[live/radiation_and_weather-get_solcast_live-params0-json_response0-True]", "pvlib/tests/iotools/test_solcast.py::test_get_solcast_live[liv...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> add functionality to load Solcast API data to `iotools` - [x] Closes #1313 - [x] I am familiar with the [contributing guidelines](https://pvlib-python.readthedocs.io/en/latest/contributing.html) - [x] Tests added - [x] Updates entries in [`docs/sphinx/source/reference`](https://github.com/pvlib/pvlib-python/blob/main/docs/sphinx/source/reference) for API changes. - [x] Adds description and name entries in the appropriate "what's new" file in [`docs/sphinx/source/whatsnew`](https://github.com/pvlib/pvlib-python/tree/main/docs/sphinx/source/whatsnew) for all changes. Includes link to the GitHub Issue with `` :issue:`num` `` or this Pull Request with `` :pull:`num` ``. Includes contributor name and/or GitHub username (link with `` :ghuser:`user` ``). - [x] New code is fully documented. Includes [numpydoc](https://numpydoc.readthedocs.io/en/latest/format.html) compliant docstrings, examples, and comments where necessary. - [x] Pull request is nearly complete and ready for detailed review. - [x] Maintainer: Appropriate GitHub Labels (including `remote-data`) and Milestone are assigned to the Pull Request and linked Issue. With this PR we are proposing to add a module `iotools.solcast` with functions to get irradiation and weather data for live, forecast, historic and tmy from the Solcast API. We noticed the demand for such functionality and many of our users use PVLib with Solcast data. Note that Solcast has a free tier for radiation and weather data which you can access immediately by using a company email address when [signing up](https://toolkit.solcast.com.au/register). We also have unlimited requests at [unmetered locations](https://docs.solcast.com.au/#unmetered-locations) and additional free data is also [available](https://solcast.com/data-for-researchers) for researchers and students. This is a first iteration and are looking for feedback, in particular about the following design decisions: 1. following the pattern in the other `iotools` modules, we have created a mapping to translate variables form Solcast's definition to PVLibs that is applied when `map_variables` is `True`. This is a 1-way translation so the user would still query the Solcast API with Solcast's definitions and get the variables in a `pd.DataFrame` with the variables converted to PVLib's. We could make the interface only using PVLib's definitions but that may cause confusion with the API documentation. 2. testing is currently using `mocks`. If you prefer we can provide an API key to test directly against the API. 3. the function signatures have only the required parameters declared with all optional as `kwargs`. The intention is to avoid docstrings that are too verbose. Some tests have been added but we'll add more after a first review. Thanks! ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pvlib/iotools/solcast.py] (definition of ParameterMap:) class ParameterMap: (definition of get_solcast_tmy:) def get_solcast_tmy( latitude, longitude, api_key, map_variables=True, **kwargs ): """Get irradiance and weather for a Typical Meteorological Year (TMY) at a requested location. Data is derived from a multi-year time series selected to present the unique weather phenomena with annual averages that are consistent with long term averages. See [1]_ for details on the calculation. Parameters ---------- latitude : float in decimal degrees, between -90 and 90, north is positive longitude : float in decimal degrees, between -180 and 180, east is positive api_key : str To access Solcast data you will need an API key [2]_. map_variables: bool, default: True When true, renames columns of the DataFrame to pvlib variable names where applicable. See variable :const:`VARIABLE_MAP`. Time is the index shifted to the midpoint of each interval from Solcast's "period end" convention. kwargs: Optional parameters passed to the API. See [3]_ for full list of parameters. Returns ------- data : pandas.DataFrame containing the values for the parameters requested. The times in the DataFrame index indicate the midpoint of each interval. metadata: dict latitude and longitude of the request. Examples -------- >>> df, meta = pvlib.iotools.solcast.get_solcast_tmy( >>> latitude=-33.856784, >>> longitude=151.215297, >>> api_key="your-key" >>> ) you can pass any of the parameters listed in the API docs, like ``time_zone``. Here we set the value of 10 for "10 hours ahead of UTC": >>> df, meta = pvlib.iotools.solcast.get_solcast_tmy( >>> latitude=-33.856784, >>> longitude=151.215297, >>> time_zone=10, >>> api_key="your-key" >>> ) References ---------- .. [1] `Solcast TMY Docs <https://solcast.com/tmy>`_ .. [2] `Get an API Key <https://toolkit.solcast.com.au/register>`_ .. [3] `Solcast API Docs <https://docs.solcast.com.au/>`_ See Also -------- pvlib.iotools.get_solcast_historic, pvlib.iotools.get_solcast_forecast, pvlib.iotools.get_solcast_live""" (definition of get_solcast_historic:) def get_solcast_historic( latitude, longitude, start, api_key, end=None, duration=None, map_variables=True, **kwargs ): """Get historical irradiance and weather estimates. for up to 31 days of data at a time for a requested location, derived from satellite (clouds and irradiance over non-polar continental areas) and numerical weather models (other data). Data is available from 2007-01-01T00:00Z up to real time estimated actuals. Parameters ---------- latitude : float in decimal degrees, between -90 and 90, north is positive longitude : float in decimal degrees, between -180 and 180, east is positive start : datetime-like First day of the requested period end : optional, datetime-like Last day of the requested period. Must include one of ``end`` or ``duration``. duration : optional, ISO 8601 compliant duration Must include either ``end`` or ``duration``. ISO 8601 compliant duration for the historic data, like "P1D" for one day of data. Must be within 31 days of ``start``. map_variables: bool, default: True When true, renames columns of the DataFrame to pvlib variable names where applicable. See variable :const:`VARIABLE_MAP`. Time is the index shifted to the midpoint of each interval from Solcast's "period end" convention. api_key : str To access Solcast data you will need an API key [1]_. kwargs: Optional parameters passed to the API. See [2]_ for full list of parameters. Returns ------- data : pandas.DataFrame containing the values for the parameters requested. The times in the DataFrame index indicate the midpoint of each interval. metadata: dict latitude and longitude of the request. Examples -------- >>> df, meta = pvlib.iotools.solcast.get_solcast_historic( >>> latitude=-33.856784, >>> longitude=151.215297, >>> start='2007-01-01T00:00Z', >>> duration='P1D', >>> api_key="your-key" >>> ) you can pass any of the parameters listed in the API docs, for example using the ``end`` parameter instead >>> df, meta = pvlib.iotools.solcast.get_solcast_historic( >>> latitude=-33.856784, >>> longitude=151.215297, >>> start='2007-01-01T00:00Z', >>> end='2007-01-02T00:00Z', >>> api_key="your-key" >>> ) References ---------- .. [1] `Get an API Key <https://toolkit.solcast.com.au/register>`_ .. [2] `Solcast API Docs <https://docs.solcast.com.au/>`_ See Also -------- pvlib.iotools.get_solcast_tmy, pvlib.iotools.get_solcast_forecast, pvlib.iotools.get_solcast_live""" (definition of get_solcast_forecast:) def get_solcast_forecast( latitude, longitude, api_key, map_variables=True, **kwargs ): """Get irradiance and weather forecasts from the present time up to 14 days ahead. Parameters ---------- latitude : float in decimal degrees, between -90 and 90, north is positive longitude : float in decimal degrees, between -180 and 180, east is positive api_key : str To access Solcast data you will need an API key [1]_. map_variables: bool, default: True When true, renames columns of the DataFrame to pvlib variable names where applicable. See variable :const:`VARIABLE_MAP`. Time is the index shifted to the midpoint of each interval from Solcast's "period end" convention. kwargs: Optional parameters passed to the API. See [2]_ for full list of parameters. Returns ------- data : pandas.DataFrame Contains the values for the parameters requested. The times in the DataFrame index indicate the midpoint of each interval. metadata: dict latitude and longitude of the request. Examples -------- >>> df, meta = pvlib.iotools.solcast.get_solcast_forecast( >>> latitude=-33.856784, >>> longitude=151.215297, >>> api_key="your-key" >>> ) you can pass any of the parameters listed in the API docs, like asking for specific variables for a specific time horizon: >>> df, meta = pvlib.iotools.solcast.get_solcast_forecast( >>> latitude=-33.856784, >>> longitude=151.215297, >>> output_parameters=['dni', 'clearsky_dni', 'snow_soiling_rooftop'], >>> hours=24, >>> api_key="your-key" >>> ) References ---------- .. [1] `Get an API Key <https://toolkit.solcast.com.au/register>`_ .. [2] `Solcast API Docs <https://docs.solcast.com.au/>`_ See Also -------- pvlib.iotools.get_solcast_tmy, pvlib.iotools.get_solcast_historic, pvlib.iotools.get_solcast_live""" (definition of get_solcast_live:) def get_solcast_live( latitude, longitude, api_key, map_variables=True, **kwargs ): """Get irradiance and weather estimated actuals for near real-time and past 7 days. Parameters ---------- latitude : float in decimal degrees, between -90 and 90, north is positive longitude : float in decimal degrees, between -180 and 180, east is positive api_key : str To access Solcast data you will need an API key [1]_. map_variables: bool, default: True When true, renames columns of the DataFrame to pvlib variable names where applicable. See variable :const:`VARIABLE_MAP`. Time is the index shifted to the midpoint of each interval from Solcast's "period end" convention. kwargs: Optional parameters passed to the API. See [2]_ for full list of parameters. Returns ------- data : pandas.DataFrame containing the values for the parameters requested. The times in the DataFrame index indicate the midpoint of each interval. metadata: dict latitude and longitude of the request. Examples -------- >>> df, meta = pvlib.iotools.solcast.get_solcast_live( >>> latitude=-33.856784, >>> longitude=151.215297, >>> api_key="your-key" >>> ) you can pass any of the parameters listed in the API docs, like >>> df, meta = pvlib.iotools.solcast.get_solcast_live( >>> latitude=-33.856784, >>> longitude=151.215297, >>> terrain_shading=True, >>> output_parameters=['ghi', 'clearsky_ghi', 'snow_soiling_rooftop'], >>> api_key="your-key" >>> ) use ``map_variables=False`` to avoid converting the data to PVLib's conventions. >>> df, meta = pvlib.iotools.solcast.get_solcast_live( >>> latitude=-33.856784, >>> longitude=151.215297, >>> map_variables=False, >>> api_key="your-key" >>> ) References ---------- .. [1] `Get an API Key <https://toolkit.solcast.com.au/register>`_ .. [2] `Solcast API Docs <https://docs.solcast.com.au/>`_ See Also -------- pvlib.iotools.get_solcast_tmy, pvlib.iotools.get_solcast_historic, pvlib.iotools.get_solcast_forecast""" (definition of _solcast2pvlib:) def _solcast2pvlib(data): """Format the data from Solcast to pvlib's conventions. Parameters ---------- data : pandas.DataFrame contains the data returned from the Solcast API Returns ------- a pandas.DataFrame with the data cast to pvlib's conventions""" (definition of _get_solcast:) def _get_solcast( endpoint, params, api_key, map_variables ): """Retrieve weather, irradiance and power data from the Solcast API. Parameters ---------- endpoint : str one of Solcast API endpoint: - live/radiation_and_weather - forecast/radiation_and_weather - historic/radiation_and_weather - tmy/radiation_and_weather params : dict parameters to be passed to the API api_key : str To access Solcast data you will need an API key [1]_. map_variables: bool, default: True When true, renames columns of the DataFrame to pvlib's variable names where applicable. See variable :const:`VARIABLE_MAP`. Time is the index shifted to the midpoint of each interval from Solcast's "period end" convention. Returns ------- A pandas.DataFrame with the data if the request is successful, an error message otherwise References ---------- .. [1] `register <https://toolkit.solcast.com.au/register>`""" [end of new definitions in pvlib/iotools/solcast.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Integrate Solcast API into iotools **Is your feature request related to a problem? Please describe.** Get irradiance via Solcast API https://solcast.com/solar-data-api/api/ **Describe the solution you'd like** Use iotools to get irradiance data from Solcast **Describe alternatives you've considered** Solcast already has an API toolkit. Is irons redundant? **Additional context** * https://docs.solcast.com.au/#introduction * https://solcast.com/solar-data-api/api-toolkit/ * icymi @AdamRJensen ---------- This could be expanded to include other APIs, such as Solargis (https://solargis.com/products/api/data-delivery-web-service/overview) and SolarAnywhere (https://developers.cleanpower.com/irradiance-and-weather-data/). A bit of relevant discussion here: https://github.com/pvlib/pvlib-python/discussions/1310 Hi @kanderso-nrel is this issue superceded by the Engerer PR #1366 ? @mikofski Solcast and Engerer don't seem related to me, what's the connection? Or maybe you meant another issue? [Nick Engerer is the CTO and a co-founders of Solcast](https://www.linkedin.com/in/dr-nick-engerer/), so I thought maybe their software uses his methods? But TBH that's just an assumption. Ha, of course! I think #1366 does not supercede this one: decomposition function in `pvlib.irradiance` vs data fetching function in `pvlib.iotools`. -------------------- </issues>

d53f97e984bfdd268aa92f8bf482ced0edda0110

gradio-app__gradio-5668

5,668

gradio-app/gradio

null

09ac63e818dd2a2fc569f4338f77986c5d3c92df

2023-09-24T01:14:53Z

diff --git a/.changeset/some-forks-raise.md b/.changeset/some-forks-raise.md new file mode 100644 index 0000000000..5d3a64aa6e --- /dev/null +++ b/.changeset/some-forks-raise.md @@ -0,0 +1,5 @@ +--- +"gradio": patch +--- + +fix:Fully resolve generated filepaths when running on Hugging Face Spaces with multiple replicas diff --git a/gradio/route_utils.py b/gradio/route_utils.py index b79058820d..1b3d846edc 100644 --- a/gradio/route_utils.py +++ b/gradio/route_utils.py @@ -1,9 +1,11 @@ from __future__ import annotations +import copy import json from typing import TYPE_CHECKING, Optional, Union import fastapi +import httpx from gradio_client.documentation import document, set_documentation_group from gradio import utils @@ -244,3 +246,25 @@ async def call_process_api( output["data"] = output["data"][0] return output + + +def set_replica_url_in_config(config: dict, replica_url: str) -> dict: + """ + If the Gradio app is running on Hugging Face Spaces and the machine has multiple replicas, + we pass in the direct URL to the replica so that we have the fully resolved path to any files + on that machine. This direct URL can be shared with other users and the path will still work. + """ + parsed_url = httpx.URL(replica_url) + stripped_url = parsed_url.copy_with(query=None) + stripped_url = str(stripped_url) + if not stripped_url.endswith("/"): + stripped_url += "/" + + config_ = copy.deepcopy(config) + for component in config_["components"]: + if ( + component.get("props") is not None + and component["props"].get("root_url") is None + ): + component["props"]["root_url"] = stripped_url + return config_ diff --git a/gradio/routes.py b/gradio/routes.py index ff6886a4e8..1035c3fe4a 100644 --- a/gradio/routes.py +++ b/gradio/routes.py @@ -53,7 +53,7 @@ from gradio.exceptions import Error from gradio.oauth import attach_oauth from gradio.queueing import Estimation, Event -from gradio.route_utils import Request # noqa: F401 +from gradio.route_utils import Request, set_replica_url_in_config # noqa: F401 from gradio.state_holder import StateHolder from gradio.utils import ( cancel_tasks, @@ -124,6 +124,9 @@ def __init__(self, **kwargs): self.uploaded_file_dir = os.environ.get("GRADIO_TEMP_DIR") or str( Path(tempfile.gettempdir()) / "gradio" ) + self.replica_urls = ( + set() + ) # these are the full paths to the replicas if running on a Hugging Face Space with multiple replicas self.change_event: None | threading.Event = None # Allow user to manually set `docs_url` and `redoc_url` # when instantiating an App; when they're not set, disable docs and redoc. @@ -158,9 +161,10 @@ def build_proxy_request(self, url_path): assert self.blocks # Don't proxy a URL unless it's a URL specifically loaded by the user using # gr.load() to prevent SSRF or harvesting of HF tokens by malicious Spaces. - is_safe_url = any( - url.host == httpx.URL(root).host for root in self.blocks.root_urls - ) + safe_urls = {httpx.URL(root).host for root in self.blocks.root_urls} | { + httpx.URL(root).host for root in self.replica_urls + } + is_safe_url = url.host in safe_urls if not is_safe_url: raise PermissionError("This URL cannot be proxied.") is_hf_url = url.host.endswith(".hf.space") @@ -307,6 +311,13 @@ def main(request: fastapi.Request, user: str = Depends(get_current_user)): if app.auth is None or user is not None: config = app.get_blocks().config config["root"] = root_path + + # Handles the case where the app is running on Hugging Face Spaces with + # multiple replicas. See `set_replica_url_in_config` for more details. + replica_url = request.headers.get("X-Direct-Url") + if utils.get_space() and replica_url: + app.replica_urls.add(replica_url) + config = set_replica_url_in_config(config, replica_url) else: config = { "auth_required": True, @@ -344,8 +355,16 @@ def api_info(serialize: bool = True): @app.get("/config/", dependencies=[Depends(login_check)]) @app.get("/config", dependencies=[Depends(login_check)]) def get_config(request: fastapi.Request): - root_path = request.scope.get("root_path", "") config = app.get_blocks().config + + # Handles the case where the app is running on Hugging Face Spaces with + # multiple replicas. See `set_replica_url_in_config` for more details. + replica_url = request.headers.get("X-Direct-Url") + if utils.get_space() and replica_url: + app.replica_urls.add(replica_url) + config = set_replica_url_in_config(config, replica_url) + + root_path = request.scope.get("root_path", "") config["root"] = root_path return config

diff --git a/test/test_route_utils.py b/test/test_route_utils.py new file mode 100644 index 0000000000..66ebd751ba --- /dev/null +++ b/test/test_route_utils.py @@ -0,0 +1,27 @@ +from gradio.route_utils import set_replica_url_in_config + + +def test_set_replica_url(): + config = { + "components": [{"props": {}}, {"props": {"root_url": "existing_url/"}}, {}] + } + replica_url = "https://abidlabs-test-client-replica--fttzk.hf.space?__theme=light" + + config = set_replica_url_in_config(config, replica_url) + assert ( + config["components"][0]["props"]["root_url"] + == "https://abidlabs-test-client-replica--fttzk.hf.space/" + ) + assert config["components"][1]["props"]["root_url"] == "existing_url/" + assert "props" not in config["components"][2] + + +def test_url_without_trailing_slash(): + config = {"components": [{"props": {}}]} + replica_url = "https://abidlabs-test-client-replica--fttzk.hf.space" + + config = set_replica_url_in_config(config, replica_url) + assert ( + config["components"][0]["props"]["root_url"] + == "https://abidlabs-test-client-replica--fttzk.hf.space/" + )

diff --git a/.changeset/some-forks-raise.md b/.changeset/some-forks-raise.md new file mode 100644 index 0000000000..5d3a64aa6e --- /dev/null +++ b/.changeset/some-forks-raise.md @@ -0,0 +1,5 @@ +--- +"gradio": patch +--- + +fix:Fully resolve generated filepaths when running on Hugging Face Spaces with multiple replicas

[ { "components": [ { "doc": "If the Gradio app is running on Hugging Face Spaces and the machine has multiple replicas,\nwe pass in the direct URL to the replica so that we have the fully resolved path to any files\non that machine. This direct URL can be shared with other users and the path will s...

[ "test/test_route_utils.py::test_set_replica_url", "test/test_route_utils.py::test_url_without_trailing_slash" ]

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Fully resolve generated filepaths when running on Hugging Face Spaces with multiple replicas This PR makes a change to how we serve filepaths when running on Hugging Face Spaces with multiple replicas. When a Gradio app is running on a Space with $N$ replicas (e.g. https://huggingface.co/spaces/abidlabs/test-client-replica), then the "real URL" of the Gradio app can be one of $N$ different URL strings. A user is directed to a particular URL string based on a hash of their IP address. This means that when a file is generated on that Space (e.g. `https://huggingface.co/spaces/abidlabs/test-client-replica/file=cheetah.jpg`, it is actually only generated on one specific machine. This is fine for that user, because they will still be directed to that machine. However, if they try sharing this file with another user, the other user may get a 404 since the Spaces machine they are redirected to may be different than the original user's, and so the file may not actually exist for them. This PR leverages our existing `root_url` and `/proxy` routes to fully resolve any generated files. Meaning that instead of generated files having this filepath: ``` https://huggingface.co/spaces/abidlabs/test-client-replica/file=cheetah.jpg ``` they'll have: ``` https://abidlabs-test-client-replica.hf.space/proxy=https://abidlabs-test-client-replica--fttzk.hf.space/file=/tmp/gradio/4884a6ee81331aa870d691096911b279c8808bc9/cheetah.jpg ``` Notice the hash at the end of this: `https://abidlabs-test-client-replica--fttzk.hf.space` This means that this URL should always work for all users. I've installed this PR on this Space: https://huggingface.co/spaces/abidlabs/test-client-replica for testing purposes. cc @XciD @freddyaboulton ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in gradio/route_utils.py] (definition of set_replica_url_in_config:) def set_replica_url_in_config(config: dict, replica_url: str) -> dict: """If the Gradio app is running on Hugging Face Spaces and the machine has multiple replicas, we pass in the direct URL to the replica so that we have the fully resolved path to any files on that machine. This direct URL can be shared with other users and the path will still work.""" [end of new definitions in gradio/route_utils.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

9c6d83d12e4b67c5638ba67281c6f018052c5b3e

pyvista__pyvista-4954

4,954

pyvista/pyvista

0.43

b7737bd1ec44ae6ff86ca59642da29ea71d62900

2023-09-24T00:47:31Z

diff --git a/doc/source/api/utilities/geometric.rst b/doc/source/api/utilities/geometric.rst index af2d82c85c7..d753930731d 100644 --- a/doc/source/api/utilities/geometric.rst +++ b/doc/source/api/utilities/geometric.rst @@ -84,3 +84,4 @@ Geometric sources are closer to the actual VTK pipeline. They serve as the ConeSource CylinderSource + MultipleLinesSource diff --git a/pyvista/core/utilities/__init__.py b/pyvista/core/utilities/__init__.py index 7f9aacfd472..4bdc8addec2 100644 --- a/pyvista/core/utilities/__init__.py +++ b/pyvista/core/utilities/__init__.py @@ -81,7 +81,7 @@ Wavelet, translate, ) -from .geometric_sources import ConeSource, CylinderSource +from .geometric_sources import ConeSource, CylinderSource, MultipleLinesSource from .helpers import axis_rotation, generate_plane, is_inside_bounds, is_pyvista_dataset, wrap from .misc import ( AnnotatedIntEnum, diff --git a/pyvista/core/utilities/geometric_objects.py b/pyvista/core/utilities/geometric_objects.py index cedbcc3bb1a..7181bea4a74 100644 --- a/pyvista/core/utilities/geometric_objects.py +++ b/pyvista/core/utilities/geometric_objects.py @@ -26,7 +26,7 @@ from pyvista.core.errors import PyVistaDeprecationWarning from .arrays import _coerce_pointslike_arg -from .geometric_sources import ConeSource, CylinderSource, translate +from .geometric_sources import ConeSource, CylinderSource, MultipleLinesSource, translate from .helpers import wrap from .misc import check_valid_vector @@ -495,14 +495,7 @@ def MultipleLines(points=[[-0.5, 0.0, 0.0], [0.5, 0.0, 0.0]]): >>> plotter.camera.zoom(0.8) >>> plotter.show() """ - points, _ = _coerce_pointslike_arg(points) - src = _vtk.vtkLineSource() - if not (len(points) >= 2): - raise ValueError('>=2 points need to define multiple lines.') - src.SetPoints(pyvista.vtk_points(points)) - src.Update() - multiple_lines = wrap(src.GetOutput()) - return multiple_lines + return MultipleLinesSource(points=points).output def Tube(pointa=(-0.5, 0.0, 0.0), pointb=(0.5, 0.0, 0.0), resolution=1, radius=1.0, n_sides=15): diff --git a/pyvista/core/utilities/geometric_sources.py b/pyvista/core/utilities/geometric_sources.py index 55d77db56e8..e4260a370f4 100644 --- a/pyvista/core/utilities/geometric_sources.py +++ b/pyvista/core/utilities/geometric_sources.py @@ -7,9 +7,11 @@ import numpy as np +import pyvista from pyvista.core import _vtk_core as _vtk from pyvista.core.utilities.misc import no_new_attr +from .arrays import _coerce_pointslike_arg from .helpers import wrap @@ -500,3 +502,58 @@ def output(self): output.rotate_z(-90, inplace=True) translate(output, self.center, self.direction) return output + + +@no_new_attr +class MultipleLinesSource(_vtk.vtkLineSource): + """Multiple lines source algorithm class. + + Parameters + ---------- + points : array_like[float], default: [[-0.5, 0.0, 0.0], [0.5, 0.0, 0.0]] + List of points defining a broken line. + """ + + _new_attr_exceptions = ['points'] + + def __init__(self, points=[[-0.5, 0.0, 0.0], [0.5, 0.0, 0.0]]): + """Initialize the multiple lines source class.""" + super().__init__() + self.points = points + + @property + def points(self) -> np.ndarray: + """Get the list of points defining a broken line. + + Returns + ------- + np.ndarray + List of points defining a broken line. + """ + return _vtk.vtk_to_numpy(self.GetPoints().GetData()) + + @points.setter + def points(self, points: Sequence[Sequence[float]]): + """Set the list of points defining a broken line. + + Parameters + ---------- + points : array_like[float] + List of points defining a broken line. + """ + points, _ = _coerce_pointslike_arg(points) + if not (len(points) >= 2): + raise ValueError('>=2 points need to define multiple lines.') + self.SetPoints(pyvista.vtk_points(points)) + + @property + def output(self): + """Get the output data object for a port on this algorithm. + + Returns + ------- + pyvista.PolyData + Line mesh. + """ + self.Update() + return wrap(self.GetOutput())

diff --git a/tests/core/test_geometric_sources.py b/tests/core/test_geometric_sources.py index 4b3c64dbb2a..7dcb303397f 100644 --- a/tests/core/test_geometric_sources.py +++ b/tests/core/test_geometric_sources.py @@ -32,3 +32,16 @@ def test_cylinder_source(): algo.direction = direction assert np.array_equal(algo.center, center) assert np.array_equal(algo.direction, direction) + + +def test_multiple_lines_source(): + algo = pv.MultipleLinesSource() + points = np.array([[-0.5, 0.0, 0.0], [0.5, 0.0, 0.0]]) + assert np.array_equal(algo.points, points) + points = np.array([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0], [0.0, 0.0, 1.0]]) + algo = pv.MultipleLinesSource(points=points) + assert np.array_equal(algo.points, points) + with pytest.raises(ValueError, match='Array of points must have three values per point'): + algo.points = points[:, :1] + with pytest.raises(ValueError, match='>=2 points need to define multiple lines.'): + algo.points = points[0, :]

diff --git a/doc/source/api/utilities/geometric.rst b/doc/source/api/utilities/geometric.rst index af2d82c85c7..d753930731d 100644 --- a/doc/source/api/utilities/geometric.rst +++ b/doc/source/api/utilities/geometric.rst @@ -84,3 +84,4 @@ Geometric sources are closer to the actual VTK pipeline. They serve as the ConeSource CylinderSource + MultipleLinesSource

[ { "components": [ { "doc": "Multiple lines source algorithm class.\n\nParameters\n----------\npoints : array_like[float], default: [[-0.5, 0.0, 0.0], [0.5, 0.0, 0.0]]\n List of points defining a broken line.", "lines": [ 508, 559 ], "name": "MultipleL...

[ "tests/core/test_geometric_sources.py::test_multiple_lines_source" ]

[ "tests/core/test_geometric_sources.py::test_cone_source", "tests/core/test_geometric_sources.py::test_cylinder_source" ]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add `MultipleLinesSource` class ### Overview  - Follow-up PR of #4860 . Add `CylinderSource` class. - ~~Inspired by https://github.com/pyvista/pyvista/discussions/4945 .~~   ### Details - [x] ~~Add sin wave line animation example.~~ (In the next PR.) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pyvista/core/utilities/geometric_sources.py] (definition of MultipleLinesSource:) class MultipleLinesSource(_vtk.vtkLineSource): """Multiple lines source algorithm class. Parameters ---------- points : array_like[float], default: [[-0.5, 0.0, 0.0], [0.5, 0.0, 0.0]] List of points defining a broken line.""" (definition of MultipleLinesSource.__init__:) def __init__(self, points=[[-0.5, 0.0, 0.0], [0.5, 0.0, 0.0]]): """Initialize the multiple lines source class.""" (definition of MultipleLinesSource.points:) def points(self, points: Sequence[Sequence[float]]): """Set the list of points defining a broken line. Parameters ---------- points : array_like[float] List of points defining a broken line.""" (definition of MultipleLinesSource.output:) def output(self): """Get the output data object for a port on this algorithm. Returns ------- pyvista.PolyData Line mesh.""" [end of new definitions in pyvista/core/utilities/geometric_sources.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

25921025e45cafe97b2e274de39c3076b3c84681

pyvista__pyvista-4890

4,890

pyvista/pyvista

0.43

bc912e9f40462204aa8f0c3c2e9eec7068dd40d7

2023-09-16T08:59:59Z

diff --git a/doc/source/api/utilities/geometric.rst b/doc/source/api/utilities/geometric.rst index 9e6bbc65f1b..af2d82c85c7 100644 --- a/doc/source/api/utilities/geometric.rst +++ b/doc/source/api/utilities/geometric.rst @@ -83,3 +83,4 @@ Geometric sources are closer to the actual VTK pipeline. They serve as the :toctree: _autosummary ConeSource + CylinderSource diff --git a/pyvista/core/utilities/__init__.py b/pyvista/core/utilities/__init__.py index 48e469edba5..7f9aacfd472 100644 --- a/pyvista/core/utilities/__init__.py +++ b/pyvista/core/utilities/__init__.py @@ -81,7 +81,7 @@ Wavelet, translate, ) -from .geometric_sources import ConeSource +from .geometric_sources import ConeSource, CylinderSource from .helpers import axis_rotation, generate_plane, is_inside_bounds, is_pyvista_dataset, wrap from .misc import ( AnnotatedIntEnum, diff --git a/pyvista/core/utilities/geometric_objects.py b/pyvista/core/utilities/geometric_objects.py index c15ffcb2fb0..cedbcc3bb1a 100644 --- a/pyvista/core/utilities/geometric_objects.py +++ b/pyvista/core/utilities/geometric_objects.py @@ -2,7 +2,7 @@ **CONTAINS** vtkArrowSource -vtkCylinderSource +CylinderSource vtkSphereSource vtkPlaneSource vtkLineSource @@ -26,7 +26,7 @@ from pyvista.core.errors import PyVistaDeprecationWarning from .arrays import _coerce_pointslike_arg -from .geometric_sources import ConeSource +from .geometric_sources import ConeSource, CylinderSource, translate from .helpers import wrap from .misc import check_valid_vector @@ -40,47 +40,6 @@ } -def translate(surf, center=(0.0, 0.0, 0.0), direction=(1.0, 0.0, 0.0)): - """Translate and orient a mesh to a new center and direction. - - By default, the input mesh is considered centered at the origin - and facing in the x direction. - - Parameters - ---------- - surf : pyvista.core.pointset.PolyData - Mesh to be translated and oriented. - center : tuple, optional, default: (0.0, 0.0, 0.0) - Center point to which the mesh should be translated. - direction : tuple, optional, default: (1.0, 0.0, 0.0) - Direction vector along which the mesh should be oriented. - - """ - normx = np.array(direction) / np.linalg.norm(direction) - normy_temp = [0.0, 1.0, 0.0] - - # Adjust normy if collinear with normx since cross-product will - # be zero otherwise - if np.allclose(normx, [0, 1, 0]): - normy_temp = [-1.0, 0.0, 0.0] - elif np.allclose(normx, [0, -1, 0]): - normy_temp = [1.0, 0.0, 0.0] - - normz = np.cross(normx, normy_temp) - normz /= np.linalg.norm(normz) - normy = np.cross(normz, normx) - - trans = np.zeros((4, 4)) - trans[:3, 0] = normx - trans[:3, 1] = normy - trans[:3, 2] = normz - trans[3, 3] = 1 - - surf.transform(trans) - if not np.allclose(center, [0.0, 0.0, 0.0]): - surf.points += np.array(center) - - def Cylinder( center=(0.0, 0.0, 0.0), direction=(1.0, 0.0, 0.0), @@ -127,16 +86,15 @@ def Cylinder( ... ) >>> cylinder.plot(show_edges=True, line_width=5, cpos='xy') """ - cylinderSource = _vtk.vtkCylinderSource() - cylinderSource.SetRadius(radius) - cylinderSource.SetHeight(height) - cylinderSource.SetCapping(capping) - cylinderSource.SetResolution(resolution) - cylinderSource.Update() - surf = wrap(cylinderSource.GetOutput()) - surf.rotate_z(-90, inplace=True) - translate(surf, center, direction) - return surf + algo = CylinderSource( + center=center, + direction=direction, + radius=radius, + height=height, + capping=capping, + resolution=resolution, + ) + return algo.output def CylinderStructured( diff --git a/pyvista/core/utilities/geometric_sources.py b/pyvista/core/utilities/geometric_sources.py index 6226dbf97f6..55d77db56e8 100644 --- a/pyvista/core/utilities/geometric_sources.py +++ b/pyvista/core/utilities/geometric_sources.py @@ -5,12 +5,55 @@ """ from typing import Sequence +import numpy as np + from pyvista.core import _vtk_core as _vtk from pyvista.core.utilities.misc import no_new_attr from .helpers import wrap +def translate(surf, center=(0.0, 0.0, 0.0), direction=(1.0, 0.0, 0.0)): + """Translate and orient a mesh to a new center and direction. + + By default, the input mesh is considered centered at the origin + and facing in the x direction. + + Parameters + ---------- + surf : pyvista.core.pointset.PolyData + Mesh to be translated and oriented. + center : tuple, optional, default: (0.0, 0.0, 0.0) + Center point to which the mesh should be translated. + direction : tuple, optional, default: (1.0, 0.0, 0.0) + Direction vector along which the mesh should be oriented. + + """ + normx = np.array(direction) / np.linalg.norm(direction) + normy_temp = [0.0, 1.0, 0.0] + + # Adjust normy if collinear with normx since cross-product will + # be zero otherwise + if np.allclose(normx, [0, 1, 0]): + normy_temp = [-1.0, 0.0, 0.0] + elif np.allclose(normx, [0, -1, 0]): + normy_temp = [1.0, 0.0, 0.0] + + normz = np.cross(normx, normy_temp) + normz /= np.linalg.norm(normz) + normy = np.cross(normz, normx) + + trans = np.zeros((4, 4)) + trans[:3, 0] = normx + trans[:3, 1] = normy + trans[:3, 2] = normz + trans[3, 3] = 1 + + surf.transform(trans) + if not np.allclose(center, [0.0, 0.0, 0.0]): + surf.points += np.array(center) + + @no_new_attr class ConeSource(_vtk.vtkConeSource): """Cone source algorithm class. @@ -252,3 +295,208 @@ def output(self): """ self.Update() return wrap(self.GetOutput()) + + +@no_new_attr +class CylinderSource(_vtk.vtkCylinderSource): + """Cylinder source algorithm class. + + Parameters + ---------- + center : sequence[float], default: (0.0, 0.0, 0.0) + Location of the centroid in ``[x, y, z]``. + + direction : sequence[float], default: (1.0, 0.0, 0.0) + Direction cylinder points to in ``[x, y, z]``. + + radius : float, default: 0.5 + Radius of the cylinder. + + height : float, default: 1.0 + Height of the cylinder. + + capping : bool, default: True + Cap cylinder ends with polygons. + + resolution : int, default: 100 + Number of points on the circular face of the cylinder. + + Examples + -------- + Create a default CylinderSource. + + >>> import pyvista + >>> source = pyvista.CylinderSource() + >>> source.output.plot(show_edges=True, line_width=5) + """ + + _new_attr_exceptions = ['_center', '_direction'] + + def __init__( + self, + center=(0.0, 0.0, 0.0), + direction=(1.0, 0.0, 0.0), + radius=0.5, + height=1.0, + capping=True, + resolution=100, + ): + """Initialize the cylinder source class.""" + super().__init__() + self._center = center + self._direction = direction + self.radius = radius + self.height = height + self.resolution = resolution + self.capping = capping + + @property + def center(self) -> Sequence[float]: + """Get location of the centroid in ``[x, y, z]``. + + Returns + ------- + sequence[float] + Center in ``[x, y, z]``. Axis of the cylinder passes through this + point. + """ + return self._center + + @center.setter + def center(self, center: Sequence[float]): + """Set location of the centroid in ``[x, y, z]``. + + Parameters + ---------- + center : sequence[float] + Center in ``[x, y, z]``. Axis of the cylinder passes through this + point. + """ + self._center = center + + @property + def direction(self) -> Sequence[float]: + """Get the direction vector in ``[x, y, z]``. Orientation vector of the cylinder. + + Returns + ------- + sequence[float] + Direction vector in ``[x, y, z]``. Orientation vector of the + cylinder. + """ + return self._direction + + @direction.setter + def direction(self, direction: Sequence[float]): + """Set the direction in ``[x, y, z]``. Axis of the cylinder passes through this point. + + Parameters + ---------- + direction : sequence[float] + Direction vector in ``[x, y, z]``. Orientation vector of the + cylinder. + """ + self._direction = direction + + @property + def radius(self) -> bool: + """Get radius of the cylinder. + + Returns + ------- + float + Radius of the cylinder. + """ + return self.GetRadius() + + @radius.setter + def radius(self, radius: float): + """Set radius of the cylinder. + + Parameters + ---------- + radius : float + Radius of the cylinder. + """ + self.SetRadius(radius) + + @property + def height(self) -> float: + """Get the height of the cylinder. + + Returns + ------- + float + Height of the cylinder. + """ + return self.GetHeight() + + @height.setter + def height(self, height: float): + """Set the height of the cylinder. + + Parameters + ---------- + height : float + Height of the cylinder. + """ + self.SetHeight(height) + + @property + def resolution(self) -> int: + """Get number of points on the circular face of the cylinder. + + Returns + ------- + int + Number of points on the circular face of the cone. + """ + return self.GetResolution() + + @resolution.setter + def resolution(self, resolution: int): + """Set number of points on the circular face of the cone. + + Parameters + ---------- + resolution : int + Number of points on the circular face of the cone. + """ + self.SetResolution(resolution) + + @property + def capping(self) -> bool: + """Get cap cylinder ends with polygons. + + Returns + ------- + bool + Cap cylinder ends with polygons. + """ + return self.GetCapping() + + @capping.setter + def capping(self, capping: bool): + """Set cap cylinder ends with polygons. + + Parameters + ---------- + capping : bool, optional + Cap cylinder ends with polygons. + """ + self.SetCapping(capping) + + @property + def output(self): + """Get the output data object for a port on this algorithm. + + Returns + ------- + pyvista.PolyData + Cylinder surface. + """ + self.Update() + output = wrap(self.GetOutput()) + output.rotate_z(-90, inplace=True) + translate(output, self.center, self.direction) + return output

diff --git a/tests/core/test_geometric_sources.py b/tests/core/test_geometric_sources.py index 9562ade64cc..4b3c64dbb2a 100644 --- a/tests/core/test_geometric_sources.py +++ b/tests/core/test_geometric_sources.py @@ -18,3 +18,17 @@ def test_cone_source(): assert algo.angle == 0.0 algo = pv.ConeSource(radius=0.0) assert algo.radius == 0.0 + + +def test_cylinder_source(): + algo = pv.CylinderSource() + assert algo.radius == 0.5 + assert algo.height == 1.0 + assert algo.capping + assert algo.resolution == 100 + center = np.random.rand(3) + direction = np.random.rand(3) + algo.center = center + algo.direction = direction + assert np.array_equal(algo.center, center) + assert np.array_equal(algo.direction, direction)

diff --git a/doc/source/api/utilities/geometric.rst b/doc/source/api/utilities/geometric.rst index 9e6bbc65f1b..af2d82c85c7 100644 --- a/doc/source/api/utilities/geometric.rst +++ b/doc/source/api/utilities/geometric.rst @@ -83,3 +83,4 @@ Geometric sources are closer to the actual VTK pipeline. They serve as the :toctree: _autosummary ConeSource + CylinderSource

[ { "components": [ { "doc": "Translate and orient a mesh to a new center and direction.\n\nBy default, the input mesh is considered centered at the origin\nand facing in the x direction.\n\nParameters\n----------\nsurf : pyvista.core.pointset.PolyData\n Mesh to be translated and oriented.\ncente...

[ "tests/core/test_geometric_sources.py::test_cylinder_source" ]

[ "tests/core/test_geometric_sources.py::test_cone_source" ]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add `CylinderSource` class ### Overview  - Follow-up PR of #4860 . Add `CylinderSource` class. - Move `translate` function from `geometric_objects.py` to `geometric_sources.py` .   ### Details - None ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pyvista/core/utilities/geometric_sources.py] (definition of translate:) def translate(surf, center=(0.0, 0.0, 0.0), direction=(1.0, 0.0, 0.0)): """Translate and orient a mesh to a new center and direction. By default, the input mesh is considered centered at the origin and facing in the x direction. Parameters ---------- surf : pyvista.core.pointset.PolyData Mesh to be translated and oriented. center : tuple, optional, default: (0.0, 0.0, 0.0) Center point to which the mesh should be translated. direction : tuple, optional, default: (1.0, 0.0, 0.0) Direction vector along which the mesh should be oriented.""" (definition of CylinderSource:) class CylinderSource(_vtk.vtkCylinderSource): """Cylinder source algorithm class. Parameters ---------- center : sequence[float], default: (0.0, 0.0, 0.0) Location of the centroid in ``[x, y, z]``. direction : sequence[float], default: (1.0, 0.0, 0.0) Direction cylinder points to in ``[x, y, z]``. radius : float, default: 0.5 Radius of the cylinder. height : float, default: 1.0 Height of the cylinder. capping : bool, default: True Cap cylinder ends with polygons. resolution : int, default: 100 Number of points on the circular face of the cylinder. Examples -------- Create a default CylinderSource. >>> import pyvista >>> source = pyvista.CylinderSource() >>> source.output.plot(show_edges=True, line_width=5)""" (definition of CylinderSource.__init__:) def __init__( self, center=(0.0, 0.0, 0.0), direction=(1.0, 0.0, 0.0), radius=0.5, height=1.0, capping=True, resolution=100, ): """Initialize the cylinder source class.""" (definition of CylinderSource.center:) def center(self, center: Sequence[float]): """Set location of the centroid in ``[x, y, z]``. Parameters ---------- center : sequence[float] Center in ``[x, y, z]``. Axis of the cylinder passes through this point.""" (definition of CylinderSource.direction:) def direction(self, direction: Sequence[float]): """Set the direction in ``[x, y, z]``. Axis of the cylinder passes through this point. Parameters ---------- direction : sequence[float] Direction vector in ``[x, y, z]``. Orientation vector of the cylinder.""" (definition of CylinderSource.radius:) def radius(self, radius: float): """Set radius of the cylinder. Parameters ---------- radius : float Radius of the cylinder.""" (definition of CylinderSource.height:) def height(self, height: float): """Set the height of the cylinder. Parameters ---------- height : float Height of the cylinder.""" (definition of CylinderSource.resolution:) def resolution(self, resolution: int): """Set number of points on the circular face of the cone. Parameters ---------- resolution : int Number of points on the circular face of the cone.""" (definition of CylinderSource.capping:) def capping(self, capping: bool): """Set cap cylinder ends with polygons. Parameters ---------- capping : bool, optional Cap cylinder ends with polygons.""" (definition of CylinderSource.output:) def output(self): """Get the output data object for a port on this algorithm. Returns ------- pyvista.PolyData Cylinder surface.""" [end of new definitions in pyvista/core/utilities/geometric_sources.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

25921025e45cafe97b2e274de39c3076b3c84681

conan-io__conan-14743

14,743

conan-io/conan

null

e9b13cff49fa0e991f179343ebf3c807e89938f5

2023-09-14T23:10:36Z

diff --git a/conan/cli/commands/profile.py b/conan/cli/commands/profile.py index bb3254fe523..27abff00d1f 100644 --- a/conan/cli/commands/profile.py +++ b/conan/cli/commands/profile.py @@ -1,3 +1,4 @@ +import json import os from conan.api.output import ConanOutput, cli_out_write @@ -22,7 +23,14 @@ def profiles_list_cli_output(profiles): cli_out_write(p) -@conan_subcommand(formatters={"text": print_profiles}) +def json_profiles(profiles): + host, build = profiles + result = {"host": host.serialize(), + "build": build.serialize()} + cli_out_write(json.dumps(result)) + + +@conan_subcommand(formatters={"text": print_profiles, "json": json_profiles}) def profile_show(conan_api, parser, subparser, *args): """ Show aggregated profiles from the passed arguments.

diff --git a/conans/test/integration/command/test_profile.py b/conans/test/integration/command/test_profile.py index 2cc252e3ce2..86207bb4678 100644 --- a/conans/test/integration/command/test_profile.py +++ b/conans/test/integration/command/test_profile.py @@ -1,3 +1,4 @@ +import json import os from conans.test.utils.tools import TestClient @@ -28,3 +29,13 @@ def test_ignore_paths_when_listing_profiles(): c.run("profile list") assert ignore_path not in c.out + + +def test_profile_show_json(): + c = TestClient() + c.save({"myprofilewin": "[settings]\nos=Windows", + "myprofilelinux": "[settings]\nos=Linux"}) + c.run("profile show -pr:b=myprofilewin -pr:h=myprofilelinux --format=json") + profile = json.loads(c.stdout) + assert profile["build"]["settings"] == {"os": "Windows"} + assert profile["host"]["settings"] == {"os": "Linux"}

[ { "components": [ { "doc": "", "lines": [ 26, 30 ], "name": "json_profiles", "signature": "def json_profiles(profiles):", "type": "function" } ], "file": "conan/cli/commands/profile.py" } ]

[ "conans/test/integration/command/test_profile.py::test_profile_show_json" ]

[ "conans/test/integration/command/test_profile.py::test_profile_path", "conans/test/integration/command/test_profile.py::test_profile_path_missing", "conans/test/integration/command/test_profile.py::test_ignore_paths_when_listing_profiles" ]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> profile show --format=json Changelog: Feature: Add ``--format=json`` formatter to ``conan profile show`` command Docs: https://github.com/conan-io/docs/pull/3388 Implement https://github.com/conan-io/conan/issues/14742 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conan/cli/commands/profile.py] (definition of json_profiles:) def json_profiles(profiles): [end of new definitions in conan/cli/commands/profile.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

4a5b19a75db9225316c8cb022a2dfb9705a2af34

conan-io__conan-14731

14,731

conan-io/conan

null

98b5c6acda0bdde4fb9a1a99496265b10dc827f5

2023-09-13T22:48:27Z

diff --git a/conan/tools/cmake/toolchain/blocks.py b/conan/tools/cmake/toolchain/blocks.py index 07a0f8efa89..c42c6186b89 100644 --- a/conan/tools/cmake/toolchain/blocks.py +++ b/conan/tools/cmake/toolchain/blocks.py @@ -840,8 +840,23 @@ def __init__(self, conanfile, toolchain, items=None): for name, block in items: self._blocks[name] = block(conanfile, toolchain) - def remove(self, name): + def keys(self): + return self._blocks.keys() + + def items(self): + return self._blocks.items() + + def remove(self, name, *args): del self._blocks[name] + for arg in args: + del self._blocks[arg] + + def select(self, name, *args): + """ + keep the blocks provided as arguments, remove the others + """ + to_keep = [name] + list(args) + self._blocks = OrderedDict((k, v) for k, v in self._blocks.items() if k in to_keep) def __setitem__(self, name, block_type): # Create a new class inheriting Block with the elements of the provided one

diff --git a/conans/test/unittests/tools/cmake/test_cmaketoolchain.py b/conans/test/unittests/tools/cmake/test_cmaketoolchain.py index a5e2bec1a9f..3c6e42458f6 100644 --- a/conans/test/unittests/tools/cmake/test_cmaketoolchain.py +++ b/conans/test/unittests/tools/cmake/test_cmaketoolchain.py @@ -49,6 +49,40 @@ def test_remove(conanfile): toolchain.blocks.remove("generic_system") content = toolchain.content assert 'CMAKE_SYSTEM_NAME' not in content + assert "CMAKE_CXX_FLAGS_INIT" in content + assert "_CMAKE_IN_TRY_COMPILE" in content + + # remove multiple + toolchain = CMakeToolchain(conanfile) + toolchain.blocks.remove("generic_system", "cmake_flags_init") + content = toolchain.content + assert 'CMAKE_SYSTEM_NAME' not in content + assert "CMAKE_CXX_FLAGS_INIT" not in content + assert "_CMAKE_IN_TRY_COMPILE" in content + + +def test_filter(conanfile): + toolchain = CMakeToolchain(conanfile) + toolchain.blocks.select("generic_system") + content = toolchain.content + assert 'CMAKE_SYSTEM_NAME' in content + assert "CMAKE_CXX_FLAGS_INIT" not in content + assert "_CMAKE_IN_TRY_COMPILE" not in content + + # remove multiple + toolchain = CMakeToolchain(conanfile) + toolchain.blocks.select("generic_system", "cmake_flags_init") + content = toolchain.content + assert 'CMAKE_SYSTEM_NAME' in content + assert "CMAKE_CXX_FLAGS_INIT" in content + assert "_CMAKE_IN_TRY_COMPILE" not in content + + +def test_dict_keys(conanfile): + toolchain = CMakeToolchain(conanfile) + assert "generic_system" in toolchain.blocks.keys() + items = dict(toolchain.blocks.items()) + assert "generic_system" in items def test_template_remove(conanfile):

[ { "components": [ { "doc": "", "lines": [ 843, 844 ], "name": "ToolchainBlocks.keys", "signature": "def keys(self):", "type": "function" }, { "doc": "", "lines": [ 846, 847 ], ...

[ "conans/test/unittests/tools/cmake/test_cmaketoolchain.py::test_remove", "conans/test/unittests/tools/cmake/test_cmaketoolchain.py::test_filter", "conans/test/unittests/tools/cmake/test_cmaketoolchain.py::test_dict_keys" ]

[ "conans/test/unittests/tools/cmake/test_cmaketoolchain.py::test_cmake_toolchain", "conans/test/unittests/tools/cmake/test_cmaketoolchain.py::test_template_remove", "conans/test/unittests/tools/cmake/test_cmaketoolchain.py::test_template_change", "conans/test/unittests/tools/cmake/test_cmaketoolchain.py::test_...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> better CMakeToolchain blocks filter Changelog: Feature: Better ``CMakeToolchain`` blocks interface. Added new ``.blocks.select()``, ``.blocks.keys()``. Docs: https://github.com/conan-io/docs/pull/3384 Close https://github.com/conan-io/conan/issues/14640 Close https://github.com/conan-io/conan/issues/14641 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conan/tools/cmake/toolchain/blocks.py] (definition of ToolchainBlocks.keys:) def keys(self): (definition of ToolchainBlocks.items:) def items(self): (definition of ToolchainBlocks.select:) def select(self, name, *args): """keep the blocks provided as arguments, remove the others""" [end of new definitions in conan/tools/cmake/toolchain/blocks.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

4a5b19a75db9225316c8cb022a2dfb9705a2af34

conan-io__conan-14727

14,727

conan-io/conan

null

48656d8556dd71736f0f07f5c73170d6dd17b742

2023-09-13T13:24:58Z

diff --git a/conan/api/subapi/profiles.py b/conan/api/subapi/profiles.py index b2a2c54269d..2c3b9bbd54c 100644 --- a/conan/api/subapi/profiles.py +++ b/conan/api/subapi/profiles.py @@ -57,8 +57,8 @@ def get_default_build(self): return default_profile def get_profiles_from_args(self, args): - build = [self.get_default_build()] if not args.profile_build else args.profile_build - host = [self.get_default_host()] if not args.profile_host else args.profile_host + build_profiles = args.profile_build or [self.get_default_build()] + host_profiles = args.profile_host or [self.get_default_host()] cache = ClientCache(self._conan_api.cache_folder) global_conf = cache.new_config @@ -66,12 +66,11 @@ def get_profiles_from_args(self, args): cache_settings = self._settings() profile_plugin = self._load_profile_plugin() cwd = os.getcwd() - profile_build = self._get_profile(build, args.settings_build, args.options_build, + profile_build = self._get_profile(build_profiles, args.settings_build, args.options_build, args.conf_build, cwd, cache_settings, profile_plugin, global_conf) - profile_host = self._get_profile(host, args.settings_host, args.options_host, args.conf_host, + profile_host = self._get_profile(host_profiles, args.settings_host, args.options_host, args.conf_host, cwd, cache_settings, profile_plugin, global_conf) - return profile_host, profile_build def get_profile(self, profiles, settings=None, options=None, conf=None, cwd=None): diff --git a/conan/cli/args.py b/conan/cli/args.py index 6c9eb9b9d16..2b65c498506 100644 --- a/conan/cli/args.py +++ b/conan/cli/args.py @@ -1,3 +1,5 @@ +import argparse + from conan.cli.command import OnceArgument from conan.errors import ConanException @@ -56,45 +58,47 @@ def add_common_install_arguments(parser): def add_profiles_args(parser): - def profile_args(machine, short_suffix="", long_suffix=""): - parser.add_argument("-pr{}".format(short_suffix), - "--profile{}".format(long_suffix), - default=None, action="append", - dest='profile_{}'.format(machine), - help='Apply the specified profile to the {} machine'.format(machine)) - - def settings_args(machine, short_suffix="", long_suffix=""): - parser.add_argument("-s{}".format(short_suffix), - "--settings{}".format(long_suffix), - action="append", - dest='settings_{}'.format(machine), - help='Settings to build the package, overwriting the defaults' - ' ({} machine). e.g.: -s{} compiler=gcc'.format(machine, - short_suffix)) - - def options_args(machine, short_suffix="", long_suffix=""): - parser.add_argument("-o{}".format(short_suffix), - "--options{}".format(long_suffix), - action="append", - dest="options_{}".format(machine), - help='Define options values ({} machine), e.g.:' - ' -o{} Pkg:with_qt=true'.format(machine, short_suffix)) + contexts = ["build", "host"] + + # This comes from the _AppendAction code but modified to add to the contexts + class ContextAllAction(argparse.Action): + + def __call__(self, action_parser, namespace, values, option_string=None): + for context in contexts: + items = getattr(namespace, self.dest + "_" + context, None) + items = items[:] if items else [] + items.append(values) + setattr(namespace, self.dest + "_" + context, items) - def conf_args(machine, short_suffix="", long_suffix=""): - parser.add_argument("-c{}".format(short_suffix), - "--conf{}".format(long_suffix), + def create_config(short, long, example=None): + parser.add_argument(f"-{short}", f"--{long}", + default=None, action="append", - dest='conf_{}'.format(machine), - help='Configuration to build the package, overwriting the defaults' - ' ({} machine). e.g.: -c{} ' - 'tools.cmake.cmaketoolchain:generator=Xcode'.format(machine, - short_suffix)) - - for item_fn in [options_args, profile_args, settings_args, conf_args]: - item_fn("host", "", - "") # By default it is the HOST, the one we are building binaries for - item_fn("build", ":b", ":build") - item_fn("host", ":h", ":host") + dest=f"{long}_host", + metavar=long.upper(), + help='Apply the specified profile. ' + f'By default, or if specifying -{short}:h (--{long}:host), it applies to the host context. ' + f'Use -{short}:b (--{long}:build) to specify the build context, ' + f'or -{short}:a (--{long}:all) to specify both contexts at once' + + ('' if not example else f". Example: {example}")) + for context in contexts: + parser.add_argument(f"-{short}:{context[0]}", f"--{long}:{context}", + default=None, + action="append", + dest=f"{long}_{context}", + help="") + + parser.add_argument(f"-{short}:a", f"--{long}:all", + default=None, + action=ContextAllAction, + dest=long, + metavar=f"{long.upper()}_ALL", + help="") + + create_config("pr", "profile") + create_config("o", "options", "-o pkg:with_qt=true") + create_config("s", "settings", "-s compiler=gcc") + create_config("c", "conf", "-c tools.cmake.cmaketoolchain:generator=Xcode") def add_reference_args(parser):

diff --git a/conans/test/integration/command/test_profile.py b/conans/test/integration/command/test_profile.py index 86207bb4678..8490f435c43 100644 --- a/conans/test/integration/command/test_profile.py +++ b/conans/test/integration/command/test_profile.py @@ -1,5 +1,6 @@ import json import os +import textwrap from conans.test.utils.tools import TestClient @@ -31,11 +32,110 @@ def test_ignore_paths_when_listing_profiles(): assert ignore_path not in c.out +def test_shorthand_syntax(): + tc = TestClient() + tc.save({"profile": "[conf]\nuser.profile=True"}) + tc.run("profile show -h") + assert "[-pr:b" in tc.out + assert "[-pr:h" in tc.out + assert "[-pr:a" in tc.out + + tc.run( + "profile show -o:a=both_options=True -pr:a=profile -s:a=os=WindowsCE -s:a=os.platform=conan -c:a=user.conf.cli=True -f=json") + + out = json.loads(tc.out) + assert out == {'build': {'build_env': '', + 'conf': {'user.conf.cli': True, 'user.profile': True}, + 'options': {'both_options': 'True'}, + 'package_settings': {}, + 'settings': {'os': 'WindowsCE', 'os.platform': 'conan'}, + 'tool_requires': {}}, + 'host': {'build_env': '', + 'conf': {'user.conf.cli': True, 'user.profile': True}, + 'options': {'both_options': 'True'}, + 'package_settings': {}, + 'settings': {'os': 'WindowsCE', 'os.platform': 'conan'}, + 'tool_requires': {}}} + + tc.save({"pre": textwrap.dedent(""" + [settings] + os=Linux + compiler=gcc + compiler.version=11 + """), + "mid": textwrap.dedent(""" + [settings] + compiler=clang + compiler.version=14 + """), + "post": textwrap.dedent(""" + [settings] + compiler.version=13 + """)}) + + tc.run("profile show -pr:a=pre -pr:a=mid -pr:a=post -f=json") + out = json.loads(tc.out) + assert out == {'build': {'build_env': '', + 'conf': {}, + 'options': {}, + 'package_settings': {}, + 'settings': {'compiler': 'clang', + 'compiler.version': '13', + 'os': 'Linux'}, + 'tool_requires': {}}, + 'host': {'build_env': '', + 'conf': {}, + 'options': {}, + 'package_settings': {}, + 'settings': {'compiler': 'clang', + 'compiler.version': '13', + 'os': 'Linux'}, + 'tool_requires': {}}} + + tc.run("profile show -pr:a=pre -pr:h=post -f=json") + out = json.loads(tc.out) + assert out == {'build': {'build_env': '', + 'conf': {}, + 'options': {}, + 'package_settings': {}, + 'settings': {'compiler': 'gcc', + 'compiler.version': '11', + 'os': 'Linux'}, + 'tool_requires': {}}, + 'host': {'build_env': '', + 'conf': {}, + 'options': {}, + 'package_settings': {}, + 'settings': {'compiler': 'gcc', + 'compiler.version': '13', + 'os': 'Linux'}, + 'tool_requires': {}}} + + tc.run("profile show -pr:a=pre -o:b foo=False -o:a foo=True -o:h foo=False -f=json") + out = json.loads(tc.out) + assert out == {'build': {'build_env': '', + 'conf': {}, + 'options': {'foo': 'True'}, + 'package_settings': {}, + 'settings': {'compiler': 'gcc', + 'compiler.version': '11', + 'os': 'Linux'}, + 'tool_requires': {}}, + 'host': {'build_env': '', + 'conf': {}, + 'options': {'foo': 'False'}, + 'package_settings': {}, + 'settings': {'compiler': 'gcc', + 'compiler.version': '11', + 'os': 'Linux'}, + 'tool_requires': {}}} + + def test_profile_show_json(): c = TestClient() c.save({"myprofilewin": "[settings]\nos=Windows", "myprofilelinux": "[settings]\nos=Linux"}) c.run("profile show -pr:b=myprofilewin -pr:h=myprofilelinux --format=json") profile = json.loads(c.stdout) - assert profile["build"]["settings"] == {"os": "Windows"} + assert profile["build"]["settings"] == {"os": "Windows"} assert profile["host"]["settings"] == {"os": "Linux"} diff --git a/conans/test/unittests/cli/common_test.py b/conans/test/unittests/cli/common_test.py index 9353ba5599a..79b30e70f19 100644 --- a/conans/test/unittests/cli/common_test.py +++ b/conans/test/unittests/cli/common_test.py @@ -23,12 +23,16 @@ def argparse_args(): return MagicMock( profile_build=None, profile_host=None, + profile_all=None, settings_build=None, settings_host=None, + settings_all=None, options_build=None, options_host=None, + options_all=None, conf_build=None, - conf_host=None + conf_host=None, + conf_all=None, )

[ { "components": [ { "doc": "", "lines": [ 64, 71 ], "name": "add_profiles_args.ContextAllAction", "signature": "class ContextAllAction(argparse.Action):", "type": "class" }, { "doc": "", "lines": [ 66...

[ "conans/test/integration/command/test_profile.py::test_shorthand_syntax" ]

[ "conans/test/integration/command/test_profile.py::test_profile_path", "conans/test/integration/command/test_profile.py::test_profile_path_missing", "conans/test/integration/command/test_profile.py::test_ignore_paths_when_listing_profiles", "conans/test/integration/command/test_profile.py::test_profile_show_js...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add shorthand syntax in cli to specify host and build in 1 argument Changelog: Feature: Add shorthand syntax in cli to specify host and build in 1 argument Docs: https://github.com/conan-io/docs/pull/3439 There's some split preferences between possible names. This pr implements (for `-pr`, `-s`, `-o`, `-c`) `-s:a` (`--settings:all`), but other possible names we discussed are: * `-s:hb` (`settings:hostbuild`): Makes it more clear that this affects the host and build profiles * `-s:h,b` (`settings:host,build`): Separates both names with a comma (Which is not a special char in any terminal as far as I can see), maybe easier to read? I'm open to change it to whatever everyone feels like a better one The new profile args read like this: ``` $ conan build -h usage: conan build [-h] [-v [V]] [--name NAME] [--version VERSION] [--user USER] [--channel CHANNEL] [-g GENERATOR] [-of OUTPUT_FOLDER] [-d DEPLOYER] [--deployer-folder DEPLOYER_FOLDER] [--build-require] [-b BUILD] [-r REMOTE | -nr] [-u] [-pr PROFILE] [-pr:b PROFILE_BUILD] [-pr:h PROFILE_HOST] [-pr:a PROFILE_ALL] [-o OPTIONS] [-o:b OPTIONS_BUILD] [-o:h OPTIONS_HOST] [-o:a OPTIONS_ALL] [-s SETTINGS] [-s:b SETTINGS_BUILD] [-s:h SETTINGS_HOST] [-s:a SETTINGS_ALL] [-c CONF] [-c:b CONF_BUILD] [-c:h CONF_HOST] [-c:a CONF_ALL] [-l LOCKFILE] [--lockfile-partial] [--lockfile-out LOCKFILE_OUT] [--lockfile-packages] [--lockfile-clean] [--lockfile-overrides LOCKFILE_OVERRIDES] [path] Install dependencies and call the build() method. positional arguments: path Path to a python-based recipe file or a folder containing a conanfile.py recipe. conanfile.txt cannot be used with conan build. options: -h, --help show this help message and exit -v [V] Level of detail of the output. Valid options from less verbose to more verbose: -vquiet, -verror, -vwarning, -vnotice, -vstatus, -v or -vverbose, -vv or -vdebug, -vvv or -vtrace --name NAME Provide a package name if not specified in conanfile --version VERSION Provide a package version if not specified in conanfile --user USER Provide a user if not specified in conanfile --channel CHANNEL Provide a channel if not specified in conanfile -g GENERATOR, --generator GENERATOR Generators to use -of OUTPUT_FOLDER, --output-folder OUTPUT_FOLDER The root output folder for generated and build files -d DEPLOYER, --deployer DEPLOYER Deploy using the provided deployer to the output folder --deployer-folder DEPLOYER_FOLDER Deployer output folder, base build folder by default if not set --build-require Whether the provided path is a build-require -b BUILD, --build BUILD Optional, specify which packages to build from source. Combining multiple '--build' options on one command line is allowed. Possible values: --build="*" Force build from source for all packages. --build=never Disallow build for all packages, use binary packages or fail if a binary package is not found, it cannot be combined with other '--build' options. --build=missing Build packages from source whose binary package is not found. --build=cascade Build packages from source that have at least one dependency being built from source. --build=[pattern] Build packages from source whose package reference matches the pattern. The pattern uses 'fnmatch' style wildcards. --build=~[pattern] Excluded packages, which will not be built from the source, whose package reference matches the pattern. The pattern uses 'fnmatch' style wildcards. --build=missing:[pattern] Build from source if a compatible binary does not exist, only for packages matching pattern. -r REMOTE, --remote REMOTE Look in the specified remote or remotes server -nr, --no-remote Do not use remote, resolve exclusively in the cache -u, --update Will check the remote and in case a newer version and/or revision of the dependencies exists there, it will install those in the local cache. When using version ranges, it will install the latest version that satisfies the range. Also, if using revisions, it will update to the latest revision for the resolved version range. -pr PROFILE, --profile PROFILE Apply the specified profile. By default, or if specifying -pr:h (--profile:host), it applies to the host context. Use -pr:b (--profile:build) to specify the build context, or -pr:a (--profile:all) to specify both contexts at once -pr:b PROFILE_BUILD, --pr:build PROFILE_BUILD -pr:h PROFILE_HOST, --pr:host PROFILE_HOST -pr:a PROFILE_ALL, --profile:all PROFILE_ALL -o OPTIONS, --options OPTIONS Apply the specified profile. By default, or if specifying -o:h (--options:host), it applies to the host context. Use -o:b (--options:build) to specify the build context, or -o:a (--options:all) to specify both contexts at once. Example: -o pkg:with_qt=true -o:b OPTIONS_BUILD, --o:build OPTIONS_BUILD -o:h OPTIONS_HOST, --o:host OPTIONS_HOST -o:a OPTIONS_ALL, --options:all OPTIONS_ALL -s SETTINGS, --settings SETTINGS Apply the specified profile. By default, or if specifying -s:h (--settings:host), it applies to the host context. Use -s:b (--settings:build) to specify the build context, or -s:a (--settings:all) to specify both contexts at once. Example: -s compiler=gcc -s:b SETTINGS_BUILD, --s:build SETTINGS_BUILD -s:h SETTINGS_HOST, --s:host SETTINGS_HOST -s:a SETTINGS_ALL, --settings:all SETTINGS_ALL -c CONF, --conf CONF Apply the specified profile. By default, or if specifying -c:h (--conf:host), it applies to the host context. Use -c:b (--conf:build) to specify the build context, or -c:a (--conf:all) to specify both contexts at once. Example: -c tools.cmake.cmaketoolchain:generator=Xcode -c:b CONF_BUILD, --c:build CONF_BUILD -c:h CONF_HOST, --c:host CONF_HOST -c:a CONF_ALL, --conf:all CONF_ALL -l LOCKFILE, --lockfile LOCKFILE Path to a lockfile. Use --lockfile="" to avoid automatic use of existing 'conan.lock' file --lockfile-partial Do not raise an error if some dependency is not found in lockfile --lockfile-out LOCKFILE_OUT Filename of the updated lockfile --lockfile-packages Lock package-id and package-revision information --lockfile-clean Remove unused entries from the lockfile --lockfile-overrides LOCKFILE_OVERRIDES Overwrite lockfile overrides ``` Closes #14696 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conan/cli/args.py] (definition of add_profiles_args.ContextAllAction:) class ContextAllAction(argparse.Action): (definition of add_profiles_args.ContextAllAction.__call__:) def __call__(self, action_parser, namespace, values, option_string=None): (definition of add_profiles_args.create_config:) def create_config(short, long, example=None): [end of new definitions in conan/cli/args.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> [feature] Same host and build profile option? ### What is your suggestion? In "developer mode sitting at my desk" mode, i.e. when building and running code on the same machine and manually typing `conan install ....` often, I'd find it useful to save some typing by adding a command line option to set both profiles the same easily. So far I've not had a problem with only using `--profile`, but that merging of profiles makes me a bit nervous depending on what might be in `default` vs. what I really want (not specifying any profiles and just relying on `default` for both is not what I'm after, as I have multiple differing profiles). Not sure if I'm missing something obvious or it's a really bad idea for some reason I'm not aware of, but in case it's a reasonable idea I hacked something up at: https://github.com/lukester1975/conan/commit/d554a6ad84015007e0005d8aa027d7877b64bef2 Thanks! ### Have you read the CONTRIBUTING guide? - [X] I've read the CONTRIBUTING guide ---------- Hi @lukester1975 Thanks for your comments > I'd find it useful to save some typing by adding a command line option to set both profiles the same easily. This is generally not intended as a normal development flow. Because changing your "host" profile doesn't really mean wanting to change the "build" profile. For example, changing the host build_type to ``Debug``, almost always doesn't mean that you want to run your "build" tools like ``cmake`` in Debug mode. Same happens for practically all settings, like wanting to compile your code with ``gcc`` (mingw in Windows) doesn't really mean that you want to build your tools with mingw, maybe those tools does not even work with mingw. So the "build" profile is understood as something very static, and in theory it should be possible to use the "default" most of the time. And that happens for normal "native" builds, for every cross-build, it is directly impossible to use same profiles, of course. What are your use cases? what ``tool_requires`` are you managing that you want to change the way they are compiled so often? What profiles are you using? OK not to worry, I wouldn't want to waste your time trying to help me understand better! Could take a while 😀 I do have some further wacky suggestions but I'll separate issues for them then. Thanks No prob, happy to help! Don't hesitate to ask as much as you want, and open new tickets for any further question 🙂 I have seen some duplicated command lines, that could benefit from this syntax, and at the end of the day is almost cero risk, ux seems clear, so why not. I am re-opening this, to give it a second chance and propose it to the team to see what they think. I guess I should open a separate issue for this, but it's somewhat related... Has consideration been given for specifying profiles on that command line that don't mean the default is not used? E.g. something like `conan install . -pr +my_libcxx_profile` being the same as `conan install . -pr default -pr my_libcxx_profile`. (Can't see anything in issues but a difficult thing to search for, so sorry if I missed something.) `my_libcxx_profile` here is (mostly) orthogonal to any compiler selection type profile, so `include()`ing isn't really the right thing to do without getting combinatorially onerous and ending up with too many profiles... Thanks Not sure if I understood, but multiple profiles can be defined for both host and build, and they are dynamically composed on the fly, with precedence from left to right (right is the highest priority), so you can compose profiles without using ``include()``, but adding them in the command line. By default profiles in Conan 2.0 no longer compose with the ``default`` one, which is no longer needed if you specify your own profile, so a special syntax for it wouldn't be needed if I understood it correctly. Yeah I think you misunderstood a bit. What I was after is *to* be able to compose with the default profile without specifying it, but it sounds like you're saying that was the v1 behaviour :) I.e. it would be nice not to have to add `-pr=default` before `-pr=my_libcxx_profile` in the example above, somehow... but not possible IIUC. Although "by default" ... so it's maybe possible? I can step through and see if I can find how to do that, I don't want to take up your time. What can I say, I get through a lot of keyboards. Had a look, I guess not possible to change the default behaviour and somehow compose with the default: ```py build = [self.get_default_build()] if not args.profile_build else args.profile_build host = [self.get_default_host()] if not args.profile_host else args.profile_host ``` As a quick POC of a `+` ugly syntax hack: ```py def get_profiles_from_args(self, args): def _get_profiles(get_default, profiles): if not profiles: return [get_default()] elif (profiles[0].startswith("+")): return [get_default(), profiles[0].removeprefix("+"), *profiles[1:]] else: return profiles build = _get_profiles(self.get_default_build, args.profile_build) host = _get_profiles(self.get_default_host, args.profile_host) profile_build = self.get_profile(profiles=build, settings=args.settings_build, options=args.options_build, conf=args.conf_build) profile_host = self.get_profile(profiles=host, settings=args.settings_host, options=args.options_host, conf=args.conf_host) return profile_host, profile_build ``` Doesn't appear to break any existing tests... > I.e. it would be nice not to have to add -pr=default before -pr=my_libcxx_profile in the example above, somehow... but not possible IIUC. Yes, this is not possible, this is exactly what we had in Conan 1.X, and it was explicitly requested, and we had a lot of cases where the implicit use of the ``default`` was being problematic. So as similar to other cases, we opted for the "better explicit than implicit", and now it is necessary to do the ``include(default)`` or pass ``-pr=default -pr=myprofile`` Makes sense, though not exactly the same as 1.x presumably? What I was suggesting is still explicit just with a more terse syntax :) I.e `-pr=+my_profile`. Best of both worlds? Anyway no big deal if it's a hard no. Thanks -------------------- </issues>

4a5b19a75db9225316c8cb022a2dfb9705a2af34

sqlfluff__sqlfluff-5187

5,187

sqlfluff/sqlfluff

2.2

48ab0cac22e27352a1e3b94b35525db6eb814053

2023-09-11T10:42:11Z

diff --git a/src/sqlfluff/core/parser/grammar/anyof.py b/src/sqlfluff/core/parser/grammar/anyof.py index b57a00a97d0..8294b0e2aba 100644 --- a/src/sqlfluff/core/parser/grammar/anyof.py +++ b/src/sqlfluff/core/parser/grammar/anyof.py @@ -11,15 +11,59 @@ ) from sqlfluff.core.parser.grammar.sequence import Bracketed, Sequence from sqlfluff.core.parser.helpers import trim_non_code_segments +from sqlfluff.core.parser.match_algorithms import greedy_match from sqlfluff.core.parser.match_result import MatchResult from sqlfluff.core.parser.match_wrapper import match_wrapper -from sqlfluff.core.parser.segments import BaseSegment -from sqlfluff.core.parser.types import MatchableType, SimpleHintType +from sqlfluff.core.parser.segments import BaseSegment, UnparsableSegment +from sqlfluff.core.parser.types import MatchableType, ParseMode, SimpleHintType + + +def _parse_mode_match_result( + matched_segments: Tuple[BaseSegment, ...], + unmatched_segments: Tuple[BaseSegment, ...], + tail: Tuple[BaseSegment, ...], + parse_mode: ParseMode, +) -> MatchResult: + """A helper function for the return values of AnyNumberOf. + + This method creates UnparsableSegments as appropriate + depending on the parse mode and return values. + """ + # If we're being strict, just return. + if parse_mode == ParseMode.STRICT: + return MatchResult(matched_segments, unmatched_segments + tail) + + # Nothing in unmatched anyway? + if not unmatched_segments or all(not s.is_code for s in unmatched_segments): + return MatchResult(matched_segments, unmatched_segments + tail) + + _trim_idx = 0 + for _trim_idx in range(len(unmatched_segments)): + if unmatched_segments[_trim_idx].is_code: + break + + # Create an unmatched segment + _expected = "Nothing else" + if tail: + _expected += f" before {tail[0].raw!r}" + + unmatched_seg = UnparsableSegment( + unmatched_segments[_trim_idx:], expected=_expected + ) + return MatchResult( + matched_segments + unmatched_segments[:_trim_idx] + (unmatched_seg,), + tail, + ) class AnyNumberOf(BaseGrammar): """A more configurable version of OneOf.""" + supported_parse_modes = { + ParseMode.STRICT, + ParseMode.GREEDY, + } + def __init__( self, *args: Union[MatchableType, str], @@ -31,6 +75,7 @@ def __init__( reset_terminators: bool = False, allow_gaps: bool = True, optional: bool = False, + parse_mode: ParseMode = ParseMode.STRICT, ) -> None: self.max_times = max_times self.min_times = min_times @@ -43,6 +88,7 @@ def __init__( optional=optional, terminators=terminators, reset_terminators=reset_terminators, + parse_mode=parse_mode, ) @cached_method_for_parse_context @@ -117,31 +163,51 @@ def match( if self.exclude.match(segments, ctx): return MatchResult.from_unmatched(segments) - # Match on each of the options matched_segments: MatchResult = MatchResult.from_empty() unmatched_segments: Tuple[BaseSegment, ...] = segments - n_matches = 0 + tail: Tuple[BaseSegment, ...] = () + + # Secondly, if we're in a greedy mode, handle that first. + if self.parse_mode == ParseMode.GREEDY: + _terminators = [*self.terminators, *parse_context.terminators] + _term_match = greedy_match( + segments, + parse_context, + matchers=_terminators, + ) + if _term_match: + # If we found a terminator, trim off the tail of the available + # segments to match on. + unmatched_segments = _term_match.matched_segments + tail = _term_match.unmatched_segments # Keep track of the number of times each option has been matched. + n_matches = 0 option_counter = {elem.cache_key(): 0 for elem in self._elements} while True: if self.max_times and n_matches >= self.max_times: # We've matched as many times as we can - return MatchResult( - matched_segments.matched_segments, unmatched_segments + return _parse_mode_match_result( + matched_segments.matched_segments, + unmatched_segments, + tail, + self.parse_mode, ) # Is there anything left to match? if len(unmatched_segments) == 0: # No... if n_matches >= self.min_times: - return MatchResult( - matched_segments.matched_segments, unmatched_segments + return _parse_mode_match_result( + matched_segments.matched_segments, + unmatched_segments, + tail, + self.parse_mode, ) else: # pragma: no cover TODO? # We didn't meet the hurdle - return MatchResult.from_unmatched(unmatched_segments) + return MatchResult.from_unmatched(segments) # If we've already matched once... if n_matches > 0 and self.allow_gaps: @@ -165,8 +231,11 @@ def match( self.max_times_per_element and option_counter[matched_key] > self.max_times_per_element ): - return MatchResult( - matched_segments.matched_segments, unmatched_segments + return _parse_mode_match_result( + matched_segments.matched_segments, + pre_seg + unmatched_segments, + tail, + self.parse_mode, ) if match: @@ -178,12 +247,22 @@ def match( # unmatched segments are meaningful, i.e. they're not what we're # looking for. if n_matches >= self.min_times: - return MatchResult( - matched_segments.matched_segments, pre_seg + unmatched_segments + return _parse_mode_match_result( + matched_segments.matched_segments, + pre_seg + unmatched_segments, + tail, + self.parse_mode, ) else: # We didn't meet the hurdle - return MatchResult.from_unmatched(unmatched_segments) + return _parse_mode_match_result( + (), + matched_segments.matched_segments + + pre_seg + + unmatched_segments, + tail, + self.parse_mode, + ) class OneOf(AnyNumberOf): @@ -201,6 +280,7 @@ def __init__( reset_terminators: bool = False, allow_gaps: bool = True, optional: bool = False, + parse_mode: ParseMode = ParseMode.STRICT, ) -> None: super().__init__( *args, @@ -211,6 +291,7 @@ def __init__( reset_terminators=reset_terminators, allow_gaps=allow_gaps, optional=optional, + parse_mode=parse_mode, ) @@ -228,6 +309,7 @@ def __init__( terminators: SequenceType[Union[MatchableType, str]] = (), reset_terminators: bool = False, optional: bool = False, + parse_mode: ParseMode = ParseMode.STRICT, ) -> None: super().__init__( Bracketed(*args), @@ -237,6 +319,7 @@ def __init__( terminators=terminators, reset_terminators=reset_terminators, optional=optional, + parse_mode=parse_mode, ) @@ -253,6 +336,7 @@ def __init__( reset_terminators: bool = False, allow_gaps: bool = True, optional: bool = False, + parse_mode: ParseMode = ParseMode.STRICT, ) -> None: super().__init__( *args, @@ -264,4 +348,5 @@ def __init__( reset_terminators=reset_terminators, allow_gaps=allow_gaps, optional=optional, + parse_mode=parse_mode, ) diff --git a/src/sqlfluff/core/parser/grammar/base.py b/src/sqlfluff/core/parser/grammar/base.py index bcac5d9b6cf..3ca3f5e28ca 100644 --- a/src/sqlfluff/core/parser/grammar/base.py +++ b/src/sqlfluff/core/parser/grammar/base.py @@ -255,8 +255,11 @@ def _longest_trimmed_match( return MatchResult.from_unmatched(segments), None # Prune available options, based on their simple representation for efficiency. + # NOTE: We're also passing in terminators as options. available_options = prune_options( - matchers, segments, parse_context=parse_context + matchers, + segments, + parse_context=parse_context, ) # If we've pruned all the options, return no match @@ -271,9 +274,6 @@ def _longest_trimmed_match( # than only being used in a per-grammar basis. if parse_context.terminators: parse_context.increment("ltm_calls_w_ctx_terms") - terminators = parse_context.terminators - else: - terminators = () # If gaps are allowed, trim the ends. if trim_noncode: @@ -315,6 +315,10 @@ def _longest_trimmed_match( # Cache it for later to for performance. parse_context.put_parse_cache(loc_key, matcher_key, res_match) + # No match. Skip this one. + if not res_match: + continue + if res_match.is_complete(): # Just return it! (WITH THE RIGHT OTHER STUFF) parse_context.increment("complete_match") @@ -342,11 +346,11 @@ def _longest_trimmed_match( # We're going to end anyway, so we can skip that step. terminated = True break - elif terminators: + elif parse_context.terminators: _, segs, _ = trim_non_code_segments( best_match[0].unmatched_segments ) - for terminator in terminators: + for terminator in parse_context.terminators: terminator_match: MatchResult = terminator.match( segs, parse_context ) diff --git a/src/sqlfluff/dialects/dialect_bigquery.py b/src/sqlfluff/dialects/dialect_bigquery.py index 9e4c9122448..7e82b06705c 100644 --- a/src/sqlfluff/dialects/dialect_bigquery.py +++ b/src/sqlfluff/dialects/dialect_bigquery.py @@ -17,7 +17,6 @@ CodeSegment, Dedent, Delimited, - GreedyUntil, Indent, Matchable, MultiStringParser, @@ -488,8 +487,7 @@ class ForInStatementsSegment(BaseSegment): """ type = "for_in_statements" - match_grammar = GreedyUntil(Sequence("END", "FOR")) - parse_grammar = AnyNumberOf( + match_grammar = AnyNumberOf( Sequence( OneOf( Ref("StatementSegment"), @@ -497,6 +495,8 @@ class ForInStatementsSegment(BaseSegment): ), Ref("DelimiterGrammar"), ), + terminators=[Sequence("END", "FOR")], + parse_mode=ParseMode.GREEDY, ) @@ -530,8 +530,7 @@ class RepeatStatementsSegment(BaseSegment): """ type = "repeat_statements" - match_grammar = GreedyUntil(Ref.keyword("UNTIL")) - parse_grammar = AnyNumberOf( + match_grammar = AnyNumberOf( Sequence( OneOf( Ref("StatementSegment"), @@ -539,6 +538,8 @@ class RepeatStatementsSegment(BaseSegment): ), Ref("DelimiterGrammar"), ), + terminators=["UNTIL"], + parse_mode=ParseMode.GREEDY, ) @@ -568,8 +569,7 @@ class IfStatementsSegment(BaseSegment): """ type = "if_statements" - match_grammar = GreedyUntil(OneOf("ELSE", "ELSEIF", Sequence("END", "IF"))) - parse_grammar = AnyNumberOf( + match_grammar = AnyNumberOf( Sequence( OneOf( Ref("StatementSegment"), @@ -577,6 +577,12 @@ class IfStatementsSegment(BaseSegment): ), Ref("DelimiterGrammar"), ), + terminators=[ + "ELSE", + "ELSEIF", + Sequence("END", "IF"), + ], + parse_mode=ParseMode.GREEDY, ) @@ -623,8 +629,7 @@ class LoopStatementsSegment(BaseSegment): """ type = "loop_statements" - match_grammar = GreedyUntil(Sequence("END", "LOOP")) - parse_grammar = AnyNumberOf( + match_grammar = AnyNumberOf( Sequence( OneOf( Ref("StatementSegment"), @@ -632,6 +637,8 @@ class LoopStatementsSegment(BaseSegment): ), Ref("DelimiterGrammar"), ), + terminators=[Sequence("END", "LOOP")], + parse_mode=ParseMode.GREEDY, ) @@ -659,12 +666,13 @@ class WhileStatementsSegment(BaseSegment): """ type = "while_statements" - match_grammar = GreedyUntil(Sequence("END", "WHILE")) - parse_grammar = AnyNumberOf( + match_grammar = AnyNumberOf( Sequence( Ref("StatementSegment"), Ref("DelimiterGrammar"), ), + terminators=[Sequence("END", "WHILE")], + parse_mode=ParseMode.GREEDY, ) @@ -1735,8 +1743,11 @@ class PivotForClauseSegment(BaseSegment): """ type = "pivot_for_clause" - match_grammar = GreedyUntil("IN") - parse_grammar = Ref("BaseExpressionElementGrammar") + match_grammar = Sequence( + Ref("BaseExpressionElementGrammar"), + terminators=["IN"], + parse_mode=ParseMode.GREEDY, + ) class FromPivotExpressionSegment(BaseSegment): @@ -2084,12 +2095,13 @@ class ProcedureStatements(BaseSegment): """ type = "procedure_statements" - match_grammar = GreedyUntil("END") - parse_grammar = AnyNumberOf( + match_grammar = AnyNumberOf( Sequence( Ref("StatementSegment"), Ref("DelimiterGrammar"), ), + terminators=["END"], + parse_mode=ParseMode.GREEDY, )

diff --git a/test/core/parser/grammar/grammar_anyof_test.py b/test/core/parser/grammar/grammar_anyof_test.py index 602511a4534..ec9af082aef 100644 --- a/test/core/parser/grammar/grammar_anyof_test.py +++ b/test/core/parser/grammar/grammar_anyof_test.py @@ -7,13 +7,14 @@ from sqlfluff.core.parser import ( KeywordSegment, + ParseMode, RegexParser, StringParser, WhitespaceSegment, ) from sqlfluff.core.parser.context import ParseContext from sqlfluff.core.parser.grammar import OneOf, Sequence -from sqlfluff.core.parser.grammar.anyof import AnySetOf +from sqlfluff.core.parser.grammar.anyof import AnyNumberOf, AnySetOf def test__parser__grammar__oneof__copy(): @@ -140,3 +141,106 @@ def test__parser__grammar_anysetof(generate_test_segments): ) # Check with a bit of whitespace assert not g.match(seg_list[1:], parse_context=ctx) + + +@pytest.mark.parametrize( + "mode,sequence,terminators,input_slice,kwargs,output_tuple", + [ + # ##### + # Strict matches + # ##### + # 1. Match once + (ParseMode.STRICT, ["a"], [], slice(None, None), {}, (("keyword", "a"),)), + # 2. Match none + (ParseMode.STRICT, ["b"], [], slice(None, None), {}, ()), + # 3. Match twice + ( + ParseMode.STRICT, + ["b", "a"], + [], + slice(None, None), + {}, + ( + ("keyword", "a"), + ("whitespace", " "), + ("keyword", "b"), + ), + ), + # 4. Limited match + ( + ParseMode.STRICT, + ["b", "a"], + [], + slice(None, None), + {"max_times": 1}, + (("keyword", "a"),), + ), + # ##### + # Greedy matches + # ##### + # 1. Terminated match + ( + ParseMode.GREEDY, + ["b", "a"], + ["b"], + slice(None, None), + {}, + (("keyword", "a"),), + ), + # 2. Terminated, but not matching the first element. + ( + ParseMode.GREEDY, + ["b"], + ["b"], + slice(None, None), + {}, + (("unparsable", (("raw", "a"),)),), + ), + # 3. Terminated, but only a partial match. + ( + ParseMode.GREEDY, + ["a"], + ["c"], + slice(None, None), + {}, + ( + ("keyword", "a"), + ("whitespace", " "), + ("unparsable", (("raw", "b"),)), + ), + ), + ], +) +def test__parser__grammar_anyof_modes( + mode, + sequence, + terminators, + input_slice, + kwargs, + output_tuple, + generate_test_segments, + fresh_ansi_dialect, +): + """Test the Sequence grammar with various parse modes. + + In particular here we're testing the treatment of unparsable + sections. + """ + segments = generate_test_segments(["a", " ", "b", " ", "c", "d", " ", "d"]) + # Dialect is required here only to have access to bracket segments. + ctx = ParseContext(dialect=fresh_ansi_dialect) + + _seq = AnyNumberOf( + *(StringParser(e, KeywordSegment) for e in sequence), + parse_mode=mode, + terminators=[StringParser(e, KeywordSegment) for e in terminators], + **kwargs, + ) + _match = _seq.match(segments[input_slice], ctx) + # If we're expecting an output tuple, assert the match is truthy. + if output_tuple: + assert _match + _result = tuple( + e.to_tuple(show_raw=True, code_only=False) for e in _match.matched_segments + ) + assert _result == output_tuple

[ { "components": [ { "doc": "A helper function for the return values of AnyNumberOf.\n\nThis method creates UnparsableSegments as appropriate\ndepending on the parse mode and return values.", "lines": [ 21, 55 ], "name": "_parse_mode_match_result", ...

[ "test/core/parser/grammar/grammar_anyof_test.py::test__parser__grammar_anyof_modes[ParseMode.STRICT-sequence0-terminators0-input_slice0-kwargs0-output_tuple0]", "test/core/parser/grammar/grammar_anyof_test.py::test__parser__grammar_anyof_modes[ParseMode.STRICT-sequence1-terminators1-input_slice1-kwargs1-output_tu...

[ "test/core/parser/grammar/grammar_anyof_test.py::test__parser__grammar__oneof__copy", "test/core/parser/grammar/grammar_anyof_test.py::test__parser__grammar_oneof[True]", "test/core/parser/grammar/grammar_anyof_test.py::test__parser__grammar_oneof[False]", "test/core/parser/grammar/grammar_anyof_test.py::test...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Parse modes for `AnyNumberOf` Another step on #5124 . Combined with #5186 , this removes the last parts of `parse_grammar` (apart from the `FileSegment` which is the final puzzle piece and will come last). We do this by adding greedy support to `AnyNumberOf` (and therefore to `OneOf` and all the other similar grammars). Interestingly, most of the effects of this are in the `bigquery` dialect. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/sqlfluff/core/parser/grammar/anyof.py] (definition of _parse_mode_match_result:) def _parse_mode_match_result( matched_segments: Tuple[BaseSegment, ...], unmatched_segments: Tuple[BaseSegment, ...], tail: Tuple[BaseSegment, ...], parse_mode: ParseMode, ) -> MatchResult: """A helper function for the return values of AnyNumberOf. This method creates UnparsableSegments as appropriate depending on the parse mode and return values.""" [end of new definitions in src/sqlfluff/core/parser/grammar/anyof.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

65328e6b701f46ebb25b758c10b7572111f130ab

slackapi__python-slack-sdk-1399

1,399

slackapi/python-slack-sdk

null

d468b354ca8d37702198c1c26ee6fd77133dfb71

2023-09-08T06:20:01Z

diff --git a/slack_sdk/models/blocks/basic_components.py b/slack_sdk/models/blocks/basic_components.py index 1e708ffa6..3999b9119 100644 --- a/slack_sdk/models/blocks/basic_components.py +++ b/slack_sdk/models/blocks/basic_components.py @@ -524,3 +524,38 @@ def to_dict(self) -> Dict[str, Any]: # skipcq: PYL-W0221 if self._trigger_actions_on: json["trigger_actions_on"] = self._trigger_actions_on return json + + +class WorkflowTrigger(JsonObject): + attributes = {"trigger"} + + def __init__(self, *, url: str, customizable_input_parameters: Optional[List[Dict[str, str]]] = None): + self._url = url + self._customizable_input_parameters = customizable_input_parameters + + def to_dict(self) -> Dict[str, Any]: # skipcq: PYL-W0221 + self.validate_json() + json = {"url": self._url} + if self._customizable_input_parameters is not None: + json.update({"customizable_input_parameters": self._customizable_input_parameters}) + return json + + +class Workflow(JsonObject): + attributes = {"trigger"} + + def __init__( + self, + *, + trigger: Union[WorkflowTrigger, dict], + ): + self._trigger = trigger + + def to_dict(self) -> Dict[str, Any]: # skipcq: PYL-W0221 + self.validate_json() + json = {} + if isinstance(self._trigger, WorkflowTrigger): + json["trigger"] = self._trigger.to_dict() + else: + json["trigger"] = self._trigger + return json diff --git a/slack_sdk/models/blocks/block_elements.py b/slack_sdk/models/blocks/block_elements.py index 65157e1ec..4cf1519c2 100644 --- a/slack_sdk/models/blocks/block_elements.py +++ b/slack_sdk/models/blocks/block_elements.py @@ -11,7 +11,7 @@ JsonValidator, EnumValidator, ) -from .basic_components import ButtonStyles +from .basic_components import ButtonStyles, Workflow from .basic_components import ConfirmObject from .basic_components import DispatchActionConfig from .basic_components import MarkdownTextObject @@ -1689,3 +1689,60 @@ def __init__( @JsonValidator(f"options attribute must have between {options_min_length} " f"and {options_max_length} items") def _validate_options_length(self) -> bool: return self.options_min_length <= len(self.options) <= self.options_max_length + + +# ------------------------------------------------- +# Workflow Button +# ------------------------------------------------- + + +class WorkflowButtonElement(InteractiveElement): + type = "workflow_button" + + @property + def attributes(self) -> Set[str]: + return super().attributes.union({"text", "workflow", "style", "accessibility_label"}) + + def __init__( + self, + *, + text: Union[str, dict, TextObject], + action_id: Optional[str] = None, + workflow: Optional[Union[dict, Workflow]] = None, + style: Optional[str] = None, # primary, danger + accessibility_label: Optional[str] = None, + **others: dict, + ): + """Allows users to run a link trigger with customizable inputs + Interactive component - but interactions with workflow button elements will not send block_actions events, + since these are used to start new workflow runs. + https://api.slack.com/reference/block-kit/block-elements#workflow_button + + Args: + text (required): A text object that defines the button's text. + Can only be of type: plain_text. text may truncate with ~30 characters. + Maximum length for the text in this field is 75 characters. + action_id (required): An identifier for this action. + You can use this when you receive an interaction payload to identify the source of the action. + Should be unique among all other action_ids in the containing block. + Maximum length for this field is 255 characters. + workflow: A workflow object that contains details about the workflow + that will run when the button is clicked. + style: Decorates buttons with alternative visual color schemes. Use this option with restraint. + "primary" gives buttons a green outline and text, ideal for affirmation or confirmation actions. + "primary" should only be used for one button within a set. + "danger" gives buttons a red outline and text, and should be used when the action is destructive. + Use "danger" even more sparingly than "primary". + If you don't include this field, the default button style will be used. + accessibility_label: A label for longer descriptive text about a button element. + This label will be read out by screen readers instead of the button text object. + Maximum length for this field is 75 characters. + """ + super().__init__(action_id=action_id, type=self.type) + show_unknown_key_warning(self, others) + + # NOTE: default_type=PlainTextObject.type here is only for backward-compatibility with version 2.5.0 + self.text = TextObject.parse(text, default_type=PlainTextObject.type) + self.workflow = workflow + self.style = style + self.accessibility_label = accessibility_label

diff --git a/tests/slack_sdk/models/test_elements.py b/tests/slack_sdk/models/test_elements.py index 906147c1c..1b246b0a6 100644 --- a/tests/slack_sdk/models/test_elements.py +++ b/tests/slack_sdk/models/test_elements.py @@ -33,6 +33,7 @@ EmailInputElement, NumberInputElement, UrlInputElement, + WorkflowButtonElement, ) from . import STRING_3001_CHARS, STRING_301_CHARS @@ -1213,3 +1214,26 @@ def test_focus_on_load(self): "focus_on_load": True, } self.assertDictEqual(input, RadioButtonsElement(**input).to_dict()) + + +# ------------------------------------------------- +# Workflow Button +# ------------------------------------------------- + + +class WorkflowButtonElementTests(unittest.TestCase): + def test_load(self): + input = { + "type": "workflow_button", + "text": {"type": "plain_text", "text": "Run Workflow"}, + "workflow": { + "trigger": { + "url": "https://slack.com/shortcuts/Ft0123ABC456/xyz...zyx", + "customizable_input_parameters": [ + {"name": "input_parameter_a", "value": "Value for input param A"}, + {"name": "input_parameter_b", "value": "Value for input param B"}, + ], + } + }, + } + self.assertDictEqual(input, WorkflowButtonElement(**input).to_dict()) diff --git a/tests/slack_sdk/models/test_objects.py b/tests/slack_sdk/models/test_objects.py index 532cddd6b..383abee7c 100644 --- a/tests/slack_sdk/models/test_objects.py +++ b/tests/slack_sdk/models/test_objects.py @@ -11,6 +11,7 @@ OptionGroup, PlainTextObject, ) +from slack_sdk.models.blocks.basic_components import Workflow, WorkflowTrigger from slack_sdk.models.messages import ( ChannelLink, DateLink, @@ -566,3 +567,28 @@ def test_confirm_style_validation(self): "style": "something-wrong", } ).validate_json() + + +class WorkflowTests(unittest.TestCase): + def test_creation(self): + workflow = Workflow( + trigger=WorkflowTrigger( + url="https://slack.com/shortcuts/Ft0123ABC456/xyz...zyx", + customizable_input_parameters=[ + {"name": "input_parameter_a", "value": "Value for input param A"}, + {"name": "input_parameter_b", "value": "Value for input param B"}, + ], + ) + ) + self.assertDictEqual( + workflow.to_dict(), + { + "trigger": { + "url": "https://slack.com/shortcuts/Ft0123ABC456/xyz...zyx", + "customizable_input_parameters": [ + {"name": "input_parameter_a", "value": "Value for input param A"}, + {"name": "input_parameter_b", "value": "Value for input param B"}, + ], + } + }, + )

[ { "components": [ { "doc": "", "lines": [ 529, 541 ], "name": "WorkflowTrigger", "signature": "class WorkflowTrigger(JsonObject):", "type": "class" }, { "doc": "", "lines": [ 532, 534 ...

[ "tests/slack_sdk/models/test_elements.py::BlockElementTests::test_eq", "tests/slack_sdk/models/test_elements.py::BlockElementTests::test_parse_timepicker", "tests/slack_sdk/models/test_elements.py::InteractiveElementTests::test_with_input_interactive_element", "tests/slack_sdk/models/test_elements.py::Interac...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add workflow_button block element ## Summary This pull request adds a new block element (https://api.slack.com/reference/block-kit/block-elements#workflow_button) to slack_sdk.models package. ### Category (place an `x` in each of the `[ ]`) - [ ] **slack_sdk.web.WebClient (sync/async)** (Web API client) - [ ] **slack_sdk.webhook.WebhookClient (sync/async)** (Incoming Webhook, response_url sender) - [ ] **slack_sdk.socket_mode** (Socket Mode client) - [ ] **slack_sdk.signature** (Request Signature Verifier) - [ ] **slack_sdk.oauth** (OAuth Flow Utilities) - [x] **slack_sdk.models** (UI component builders) - [ ] **slack_sdk.scim** (SCIM API client) - [ ] **slack_sdk.audit_logs** (Audit Logs API client) - [ ] **slack_sdk.rtm_v2** (RTM client) - [ ] `/docs-src` (Documents, have you run `./scripts/docs.sh`?) - [ ] `/docs-src-v2` (Documents, have you run `./scripts/docs-v2.sh`?) - [ ] `/tutorial` (PythOnBoardingBot tutorial) - [x] `tests`/`integration_tests` (Automated tests for this library) ## Requirements (place an `x` in each `[ ]`) - [x] I've read and understood the [Contributing Guidelines](https://github.com/slackapi/python-slack-sdk/blob/main/.github/contributing.md) and have done my best effort to follow them. - [x] I've read and agree to the [Code of Conduct](https://slackhq.github.io/code-of-conduct). - [x] I've run `python3 -m venv .venv && source .venv/bin/activate && ./scripts/run_validation.sh` after making the changes. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in slack_sdk/models/blocks/basic_components.py] (definition of WorkflowTrigger:) class WorkflowTrigger(JsonObject): (definition of WorkflowTrigger.__init__:) def __init__(self, *, url: str, customizable_input_parameters: Optional[List[Dict[str, str]]] = None): (definition of WorkflowTrigger.to_dict:) def to_dict(self) -> Dict[str, Any]: (definition of Workflow:) class Workflow(JsonObject): (definition of Workflow.__init__:) def __init__( self, *, trigger: Union[WorkflowTrigger, dict], ): (definition of Workflow.to_dict:) def to_dict(self) -> Dict[str, Any]: [end of new definitions in slack_sdk/models/blocks/basic_components.py] [start of new definitions in slack_sdk/models/blocks/block_elements.py] (definition of WorkflowButtonElement:) class WorkflowButtonElement(InteractiveElement): (definition of WorkflowButtonElement.attributes:) def attributes(self) -> Set[str]: (definition of WorkflowButtonElement.__init__:) def __init__( self, *, text: Union[str, dict, TextObject], action_id: Optional[str] = None, workflow: Optional[Union[dict, Workflow]] = None, style: Optional[str] = None, """Allows users to run a link trigger with customizable inputs Interactive component - but interactions with workflow button elements will not send block_actions events, since these are used to start new workflow runs. https://api.slack.com/reference/block-kit/block-elements#workflow_button Args: text (required): A text object that defines the button's text. Can only be of type: plain_text. text may truncate with ~30 characters. Maximum length for the text in this field is 75 characters. action_id (required): An identifier for this action. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. workflow: A workflow object that contains details about the workflow that will run when the button is clicked. style: Decorates buttons with alternative visual color schemes. Use this option with restraint. "primary" gives buttons a green outline and text, ideal for affirmation or confirmation actions. "primary" should only be used for one button within a set. "danger" gives buttons a red outline and text, and should be used when the action is destructive. Use "danger" even more sparingly than "primary". If you don't include this field, the default button style will be used. accessibility_label: A label for longer descriptive text about a button element. This label will be read out by screen readers instead of the button text object. Maximum length for this field is 75 characters.""" [end of new definitions in slack_sdk/models/blocks/block_elements.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

2997a1786c4fd969b00ce69af888ebae8e8ebed0

scikit-learn__scikit-learn-27308

27,308

scikit-learn/scikit-learn

1.4

93e22cdd8dff96fa3870475f40e435083bce8ad0

2023-09-06T20:11:59Z

diff --git a/doc/metadata_routing.rst b/doc/metadata_routing.rst index 61fc7a8f72b65..12d64eab8217c 100644 --- a/doc/metadata_routing.rst +++ b/doc/metadata_routing.rst @@ -260,6 +260,9 @@ Meta-estimators and functions supporting metadata routing: - :func:`sklearn.model_selection.cross_validate` - :func:`sklearn.model_selection.cross_val_score` - :func:`sklearn.model_selection.cross_val_predict` +- :class:`sklearn.multiclass.OneVsOneClassifier` +- :class:`sklearn.multiclass.OneVsRestClassifier` +- :class:`sklearn.multiclass.OutputCodeClassifier` - :class:`sklearn.multioutput.ClassifierChain` - :class:`sklearn.multioutput.MultiOutputClassifier` - :class:`sklearn.multioutput.MultiOutputRegressor` @@ -296,8 +299,5 @@ Meta-estimators and tools not supporting metadata routing yet: - :class:`sklearn.model_selection.learning_curve` - :class:`sklearn.model_selection.permutation_test_score` - :class:`sklearn.model_selection.validation_curve` -- :class:`sklearn.multiclass.OneVsOneClassifier` -- :class:`sklearn.multiclass.OneVsRestClassifier` -- :class:`sklearn.multiclass.OutputCodeClassifier` - :class:`sklearn.pipeline.FeatureUnion` - :class:`sklearn.semi_supervised.SelfTrainingClassifier` diff --git a/doc/whats_new/v1.4.rst b/doc/whats_new/v1.4.rst index 6afc5011ded30..250496182752f 100644 --- a/doc/whats_new/v1.4.rst +++ b/doc/whats_new/v1.4.rst @@ -40,6 +40,13 @@ The following models now support metadata routing in one or more or their methods. Refer to the :ref:`Metadata Routing User Guide <metadata_routing>` for more details. +- |Feature| :class:`multiclass.OneVsRestClassifier`, + :class:`multiclass.OneVsOneClassifier` and + :class:`multiclass.OutputCodeClassifier` now support metadata routing in + their ``fit`` and ``partial_fit``, and route metadata to the underlying + estimator's ``fit`` and ``partial_fit``. :pr:`27308` by :user:`Stefanie + Senger <StefanieSenger>`. + - |Feature| :class:`pipeline.Pipeline` now supports metadata routing according to :ref:`metadata routing user guide <metadata_routing>`. :pr:`26789` by `Adrin Jalali`_. diff --git a/sklearn/multiclass.py b/sklearn/multiclass.py index f73802f0c701c..07b19115f0912 100644 --- a/sklearn/multiclass.py +++ b/sklearn/multiclass.py @@ -56,7 +56,12 @@ from .utils import check_random_state from .utils._param_validation import HasMethods, Interval from .utils._tags import _safe_tags -from .utils.metadata_routing import _RoutingNotSupportedMixin +from .utils.metadata_routing import ( + MetadataRouter, + MethodMapping, + _raise_for_params, + process_routing, +) from .utils.metaestimators import _safe_split, available_if from .utils.multiclass import ( _check_partial_fit_first_call, @@ -64,7 +69,7 @@ check_classification_targets, ) from .utils.parallel import Parallel, delayed -from .utils.validation import _num_samples, check_is_fitted +from .utils.validation import _check_method_params, _num_samples, check_is_fitted __all__ = [ "OneVsRestClassifier", @@ -73,7 +78,7 @@ ] -def _fit_binary(estimator, X, y, classes=None): +def _fit_binary(estimator, X, y, fit_params, classes=None): """Fit a single binary estimator.""" unique_y = np.unique(y) if len(unique_y) == 1: @@ -88,13 +93,13 @@ def _fit_binary(estimator, X, y, classes=None): estimator = _ConstantPredictor().fit(X, unique_y) else: estimator = clone(estimator) - estimator.fit(X, y) + estimator.fit(X, y, **fit_params) return estimator -def _partial_fit_binary(estimator, X, y): +def _partial_fit_binary(estimator, X, y, partial_fit_params): """Partially fit a single binary estimator.""" - estimator.partial_fit(X, y, np.array((0, 1))) + estimator.partial_fit(X, y, classes=np.array((0, 1)), **partial_fit_params) return estimator @@ -120,6 +125,8 @@ def _threshold_for_binary_predict(estimator): class _ConstantPredictor(BaseEstimator): + """Helper predictor to be used when only one class is present.""" + def fit(self, X, y): check_params = dict( force_all_finite=False, dtype=None, ensure_2d=False, accept_sparse=True @@ -183,7 +190,6 @@ def _estimators_has(attr): class OneVsRestClassifier( - _RoutingNotSupportedMixin, MultiOutputMixin, ClassifierMixin, MetaEstimatorMixin, @@ -312,7 +318,7 @@ def __init__(self, estimator, *, n_jobs=None, verbose=0): # OneVsRestClassifier.estimator is not validated yet prefer_skip_nested_validation=False ) - def fit(self, X, y): + def fit(self, X, y, **fit_params): """Fit underlying estimators. Parameters @@ -324,11 +330,27 @@ def fit(self, X, y): Multi-class targets. An indicator matrix turns on multilabel classification. + **fit_params : dict + Parameters passed to the ``estimator.fit`` method of each + sub-estimator. + + .. versionadded:: 1.4 + Only available if `enable_metadata_routing=True`. See + :ref:`Metadata Routing User Guide <metadata_routing>` for more + details. + Returns ------- self : object Instance of fitted estimator. """ + _raise_for_params(fit_params, self, "fit") + + routed_params = process_routing( + self, + "fit", + **fit_params, + ) # A sparse LabelBinarizer, with sparse_output=True, has been shown to # outperform or match a dense label binarizer in all cases and has also # resulted in less or equal memory consumption in the fit_ovr function @@ -346,6 +368,7 @@ def fit(self, X, y): self.estimator, X, column, + fit_params=routed_params.estimator.fit, classes=[ "not %s" % self.label_binarizer_.classes_[i], self.label_binarizer_.classes_[i], @@ -366,11 +389,11 @@ def fit(self, X, y): # OneVsRestClassifier.estimator is not validated yet prefer_skip_nested_validation=False ) - def partial_fit(self, X, y, classes=None): + def partial_fit(self, X, y, classes=None, **partial_fit_params): """Partially fit underlying estimators. Should be used when memory is inefficient to train all data. - Chunks of data can be passed in several iteration. + Chunks of data can be passed in several iterations. Parameters ---------- @@ -388,11 +411,28 @@ def partial_fit(self, X, y, classes=None): This argument is only required in the first call of partial_fit and can be omitted in the subsequent calls. + **partial_fit_params : dict + Parameters passed to the ``estimator.partial_fit`` method of each + sub-estimator. + + .. versionadded:: 1.4 + Only available if `enable_metadata_routing=True`. See + :ref:`Metadata Routing User Guide <metadata_routing>` for more + details. + Returns ------- self : object Instance of partially fitted estimator. """ + _raise_for_params(partial_fit_params, self, "partial_fit") + + routed_params = process_routing( + self, + "partial_fit", + **partial_fit_params, + ) + if _check_partial_fit_first_call(self, classes): if not hasattr(self.estimator, "partial_fit"): raise ValueError( @@ -421,7 +461,12 @@ def partial_fit(self, X, y, classes=None): columns = (col.toarray().ravel() for col in Y.T) self.estimators_ = Parallel(n_jobs=self.n_jobs)( - delayed(_partial_fit_binary)(estimator, X, column) + delayed(_partial_fit_binary)( + estimator, + X, + column, + partial_fit_params=routed_params.estimator.partial_fit, + ) for estimator, column in zip(self.estimators_, columns) ) @@ -552,8 +597,35 @@ def _more_tags(self): """Indicate if wrapped estimator is using a precomputed Gram matrix""" return {"pairwise": _safe_tags(self.estimator, key="pairwise")} + def get_metadata_routing(self): + """Get metadata routing of this object. + + Please check :ref:`User Guide <metadata_routing>` on how the routing + mechanism works. -def _fit_ovo_binary(estimator, X, y, i, j): + .. versionadded:: 1.4 + + Returns + ------- + routing : MetadataRouter + A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating + routing information. + """ + + router = ( + MetadataRouter(owner=self.__class__.__name__) + .add_self_request(self) + .add( + estimator=self.estimator, + method_mapping=MethodMapping() + .add(callee="fit", caller="fit") + .add(callee="partial_fit", caller="partial_fit"), + ) + ) + return router + + +def _fit_ovo_binary(estimator, X, y, i, j, fit_params): """Fit a single binary estimator (one-vs-one).""" cond = np.logical_or(y == i, y == j) y = y[cond] @@ -561,18 +633,21 @@ def _fit_ovo_binary(estimator, X, y, i, j): y_binary[y == i] = 0 y_binary[y == j] = 1 indcond = np.arange(_num_samples(X))[cond] + + fit_params_subset = _check_method_params(X, params=fit_params, indices=indcond) return ( _fit_binary( estimator, _safe_split(estimator, X, None, indices=indcond)[0], y_binary, + fit_params=fit_params_subset, classes=[i, j], ), indcond, ) -def _partial_fit_ovo_binary(estimator, X, y, i, j): +def _partial_fit_ovo_binary(estimator, X, y, i, j, partial_fit_params): """Partially fit a single binary estimator(one-vs-one).""" cond = np.logical_or(y == i, y == j) @@ -580,13 +655,16 @@ def _partial_fit_ovo_binary(estimator, X, y, i, j): if len(y) != 0: y_binary = np.zeros_like(y) y_binary[y == j] = 1 - return _partial_fit_binary(estimator, X[cond], y_binary) + partial_fit_params_subset = _check_method_params( + X, params=partial_fit_params, indices=cond + ) + return _partial_fit_binary( + estimator, X[cond], y_binary, partial_fit_params=partial_fit_params_subset + ) return estimator -class OneVsOneClassifier( - _RoutingNotSupportedMixin, MetaEstimatorMixin, ClassifierMixin, BaseEstimator -): +class OneVsOneClassifier(MetaEstimatorMixin, ClassifierMixin, BaseEstimator): """One-vs-one multiclass strategy. This strategy consists in fitting one classifier per class pair. @@ -677,7 +755,7 @@ def __init__(self, estimator, *, n_jobs=None): # OneVsOneClassifier.estimator is not validated yet prefer_skip_nested_validation=False ) - def fit(self, X, y): + def fit(self, X, y, **fit_params): """Fit underlying estimators. Parameters @@ -688,11 +766,28 @@ def fit(self, X, y): y : array-like of shape (n_samples,) Multi-class targets. + **fit_params : dict + Parameters passed to the ``estimator.fit`` method of each + sub-estimator. + + .. versionadded:: 1.4 + Only available if `enable_metadata_routing=True`. See + :ref:`Metadata Routing User Guide <metadata_routing>` for more + details. + Returns ------- self : object The fitted underlying estimator. """ + _raise_for_params(fit_params, self, "fit") + + routed_params = process_routing( + self, + "fit", + **fit_params, + ) + # We need to validate the data because we do a safe_indexing later. X, y = self._validate_data( X, y, accept_sparse=["csr", "csc"], force_all_finite=False @@ -710,7 +805,12 @@ def fit(self, X, y): *( Parallel(n_jobs=self.n_jobs)( delayed(_fit_ovo_binary)( - self.estimator, X, y, self.classes_[i], self.classes_[j] + self.estimator, + X, + y, + self.classes_[i], + self.classes_[j], + fit_params=routed_params.estimator.fit, ) for i in range(n_classes) for j in range(i + 1, n_classes) @@ -731,7 +831,7 @@ def fit(self, X, y): # OneVsOneClassifier.estimator is not validated yet prefer_skip_nested_validation=False ) - def partial_fit(self, X, y, classes=None): + def partial_fit(self, X, y, classes=None, **partial_fit_params): """Partially fit underlying estimators. Should be used when memory is inefficient to train all data. Chunks @@ -753,11 +853,28 @@ def partial_fit(self, X, y, classes=None): This argument is only required in the first call of partial_fit and can be omitted in the subsequent calls. + **partial_fit_params : dict + Parameters passed to the ``estimator.partial_fit`` method of each + sub-estimator. + + .. versionadded:: 1.4 + Only available if `enable_metadata_routing=True`. See + :ref:`Metadata Routing User Guide <metadata_routing>` for more + details. + Returns ------- self : object The partially fitted underlying estimator. """ + _raise_for_params(partial_fit_params, self, "partial_fit") + + routed_params = process_routing( + self, + "partial_fit", + **partial_fit_params, + ) + first_call = _check_partial_fit_first_call(self, classes) if first_call: self.estimators_ = [ @@ -783,7 +900,12 @@ def partial_fit(self, X, y, classes=None): combinations = itertools.combinations(range(self.n_classes_), 2) self.estimators_ = Parallel(n_jobs=self.n_jobs)( delayed(_partial_fit_ovo_binary)( - estimator, X, y, self.classes_[i], self.classes_[j] + estimator, + X, + y, + self.classes_[i], + self.classes_[j], + partial_fit_params=routed_params.estimator.partial_fit, ) for estimator, (i, j) in zip(self.estimators_, (combinations)) ) @@ -874,10 +996,35 @@ def _more_tags(self): """Indicate if wrapped estimator is using a precomputed Gram matrix""" return {"pairwise": _safe_tags(self.estimator, key="pairwise")} + def get_metadata_routing(self): + """Get metadata routing of this object. -class OutputCodeClassifier( - _RoutingNotSupportedMixin, MetaEstimatorMixin, ClassifierMixin, BaseEstimator -): + Please check :ref:`User Guide <metadata_routing>` on how the routing + mechanism works. + + .. versionadded:: 1.4 + + Returns + ------- + routing : MetadataRouter + A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating + routing information. + """ + + router = ( + MetadataRouter(owner=self.__class__.__name__) + .add_self_request(self) + .add( + estimator=self.estimator, + method_mapping=MethodMapping() + .add(callee="fit", caller="fit") + .add(callee="partial_fit", caller="partial_fit"), + ) + ) + return router + + +class OutputCodeClassifier(MetaEstimatorMixin, ClassifierMixin, BaseEstimator): """(Error-Correcting) Output-Code multiclass strategy. Output-code based strategies consist in representing each class with a @@ -924,7 +1071,7 @@ class OutputCodeClassifier( classes_ : ndarray of shape (n_classes,) Array containing labels. - code_book_ : ndarray of shape (n_classes, code_size) + code_book_ : ndarray of shape (n_classes, `len(estimators_)`) Binary array containing the code of each class. n_features_in_ : int @@ -997,7 +1144,7 @@ def __init__(self, estimator, *, code_size=1.5, random_state=None, n_jobs=None): # OutputCodeClassifier.estimator is not validated yet prefer_skip_nested_validation=False ) - def fit(self, X, y): + def fit(self, X, y, **fit_params): """Fit underlying estimators. Parameters @@ -1008,11 +1155,28 @@ def fit(self, X, y): y : array-like of shape (n_samples,) Multi-class targets. + **fit_params : dict + Parameters passed to the ``estimator.fit`` method of each + sub-estimator. + + .. versionadded:: 1.4 + Only available if `enable_metadata_routing=True`. See + :ref:`Metadata Routing User Guide <metadata_routing>` for more + details. + Returns ------- self : object Returns a fitted instance of self. """ + _raise_for_params(fit_params, self, "fit") + + routed_params = process_routing( + self, + "fit", + **fit_params, + ) + y = self._validate_data(X="no_validation", y=y) random_state = check_random_state(self.random_state) @@ -1024,11 +1188,11 @@ def fit(self, X, y): raise ValueError( "OutputCodeClassifier can not be fit when no class is present." ) - code_size_ = int(n_classes * self.code_size) + n_estimators = int(n_classes * self.code_size) # FIXME: there are more elaborate methods than generating the codebook # randomly. - self.code_book_ = random_state.uniform(size=(n_classes, code_size_)) + self.code_book_ = random_state.uniform(size=(n_classes, n_estimators)) self.code_book_[self.code_book_ > 0.5] = 1.0 if hasattr(self.estimator, "decision_function"): @@ -1044,7 +1208,10 @@ def fit(self, X, y): ) self.estimators_ = Parallel(n_jobs=self.n_jobs)( - delayed(_fit_binary)(self.estimator, X, Y[:, i]) for i in range(Y.shape[1]) + delayed(_fit_binary)( + self.estimator, X, Y[:, i], fit_params=routed_params.estimator.fit + ) + for i in range(Y.shape[1]) ) if hasattr(self.estimators_[0], "n_features_in_"): @@ -1078,3 +1245,24 @@ def predict(self, X): ).T pred = pairwise_distances_argmin(Y, self.code_book_, metric="euclidean") return self.classes_[pred] + + def get_metadata_routing(self): + """Get metadata routing of this object. + + Please check :ref:`User Guide <metadata_routing>` on how the routing + mechanism works. + + .. versionadded:: 1.4 + + Returns + ------- + routing : MetadataRouter + A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating + routing information. + """ + + router = MetadataRouter(owner=self.__class__.__name__).add( + estimator=self.estimator, + method_mapping=MethodMapping().add(callee="fit", caller="fit"), + ) + return router

diff --git a/sklearn/tests/metadata_routing_common.py b/sklearn/tests/metadata_routing_common.py index 2bc7a00aae585..14bf037ae9054 100644 --- a/sklearn/tests/metadata_routing_common.py +++ b/sklearn/tests/metadata_routing_common.py @@ -20,6 +20,7 @@ MetadataRouter, process_routing, ) +from sklearn.utils.multiclass import _check_partial_fit_first_call def record_metadata(obj, method, record_default=True, **kwargs): @@ -46,6 +47,10 @@ def check_recorded_metadata(obj, method, split_params=tuple(), **kwargs): Parameters ---------- + obj : estimator object + sub-estimator to check routed params for + method : str + sub-estimator's method where metadata is routed to split_params : tuple, default=empty specifies any parameters which are to be checked as being a subset of the original values. @@ -170,7 +175,7 @@ def fit(self, X, y): if self.registry is not None: self.registry.append(self) - self.classes_ = [0, 1] + self.classes_ = np.unique(y) return self def predict(self, X): @@ -197,14 +202,16 @@ def __init__(self, registry=None, alpha=0.0): self.alpha = alpha self.registry = registry - def partial_fit(self, X, y, sample_weight="default", metadata="default"): + def partial_fit( + self, X, y, classes=None, sample_weight="default", metadata="default" + ): if self.registry is not None: self.registry.append(self) record_metadata_not_default( self, "partial_fit", sample_weight=sample_weight, metadata=metadata ) - self.classes_ = [0, 1] + _check_partial_fit_first_call(self, classes) return self def fit(self, X, y, sample_weight="default", metadata="default"): @@ -214,7 +221,7 @@ def fit(self, X, y, sample_weight="default", metadata="default"): record_metadata_not_default( self, "fit", sample_weight=sample_weight, metadata=metadata ) - self.classes_ = [0, 1] + self.classes_ = np.unique(y) return self def predict(self, X, sample_weight="default", metadata="default"): diff --git a/sklearn/tests/test_metaestimators_metadata_routing.py b/sklearn/tests/test_metaestimators_metadata_routing.py index 7956ed5f3726e..dfe57d7682da6 100644 --- a/sklearn/tests/test_metaestimators_metadata_routing.py +++ b/sklearn/tests/test_metaestimators_metadata_routing.py @@ -76,8 +76,10 @@ rng = np.random.RandomState(42) N, M = 100, 4 X = rng.rand(N, M) -y = rng.randint(0, 2, size=N) -y_multi = rng.randint(0, 2, size=(N, 3)) +y = rng.randint(0, 3, size=N) +classes = np.unique(y) +y_multi = rng.randint(0, 3, size=(N, 3)) +classes_multi = [np.unique(y_multi[:, i]) for i in range(y_multi.shape[1])] metadata = rng.randint(0, 10, size=N) sample_weight = rng.rand(N) groups = np.array([0, 1] * (len(y) // 2)) @@ -106,6 +108,7 @@ def enable_slep006(): "X": X, "y": y_multi, "estimator_routing_methods": ["fit", "partial_fit"], + "method_args": {"partial_fit": {"classes": classes_multi}}, }, { "metaestimator": CalibratedClassifierCV, @@ -197,6 +200,34 @@ def enable_slep006(): "cv_name": "cv", "cv_routing_methods": ["fit"], }, + { + "metaestimator": OneVsRestClassifier, + "estimator_name": "estimator", + "estimator": ConsumingClassifier, + "X": X, + "y": y, + "estimator_routing_methods": ["fit", "partial_fit"], + "method_args": {"partial_fit": {"classes": classes}}, + }, + { + "metaestimator": OneVsOneClassifier, + "estimator_name": "estimator", + "estimator": ConsumingClassifier, + "X": X, + "y": y, + "estimator_routing_methods": ["fit", "partial_fit"], + "preserves_metadata": "subset", + "method_args": {"partial_fit": {"classes": classes}}, + }, + { + "metaestimator": OutputCodeClassifier, + "estimator_name": "estimator", + "estimator": ConsumingClassifier, + "init_args": {"random_state": 42}, + "X": X, + "y": y, + "estimator_routing_methods": ["fit"], + }, ] """List containing all metaestimators to be tested and their settings @@ -225,6 +256,8 @@ def enable_slep006(): - cv_name: The name of the argument for the CV splitter - cv_routing_methods: list of all methods to check for routing metadata to the splitter +- method_args: a dict of dicts, defining extra arguments needed to be passed to + methods, such as passing `classes` to `partial_fit`. """ # IDs used by pytest to get meaningful verbose messages when running the tests @@ -244,10 +277,7 @@ def enable_slep006(): LassoLarsCV(), MultiTaskElasticNetCV(), MultiTaskLassoCV(), - OneVsOneClassifier(ConsumingClassifier()), - OneVsRestClassifier(ConsumingClassifier()), OrthogonalMatchingPursuitCV(), - OutputCodeClassifier(ConsumingClassifier()), RANSACRegressor(), RFE(ConsumingClassifier()), RFECV(ConsumingClassifier()), @@ -366,7 +396,7 @@ def test_error_on_missing_requests_for_sub_estimator(metaestimator): # requests are not set if "estimator" not in metaestimator: # This test only makes sense for metaestimators which have a - # sub-estimator + # sub-estimator, e.g. MyMetaEstimator(estimator=MySubEstimator()) return cls = metaestimator["metaestimator"] @@ -398,7 +428,7 @@ def test_setting_request_on_sub_estimator_removes_error(metaestimator): # should be no errors. if "estimator" not in metaestimator: # This test only makes sense for metaestimators which have a - # sub-estimator + # sub-estimator, e.g. MyMetaEstimator(estimator=MySubEstimator()) return def set_request(estimator, method_name): @@ -427,8 +457,10 @@ def set_request(estimator, method_name): set_request(estimator, method_name) instance = cls(**kwargs) method = getattr(instance, method_name) - method(X, y, **method_kwargs) - + extra_method_args = metaestimator.get("method_args", {}).get( + method_name, {} + ) + method(X, y, **method_kwargs, **extra_method_args) # sanity check that registry is not empty, or else the test passes # trivially assert registry

diff --git a/doc/metadata_routing.rst b/doc/metadata_routing.rst index 61fc7a8f72b65..12d64eab8217c 100644 --- a/doc/metadata_routing.rst +++ b/doc/metadata_routing.rst @@ -260,6 +260,9 @@ Meta-estimators and functions supporting metadata routing: - :func:`sklearn.model_selection.cross_validate` - :func:`sklearn.model_selection.cross_val_score` - :func:`sklearn.model_selection.cross_val_predict` +- :class:`sklearn.multiclass.OneVsOneClassifier` +- :class:`sklearn.multiclass.OneVsRestClassifier` +- :class:`sklearn.multiclass.OutputCodeClassifier` - :class:`sklearn.multioutput.ClassifierChain` - :class:`sklearn.multioutput.MultiOutputClassifier` - :class:`sklearn.multioutput.MultiOutputRegressor` @@ -296,8 +299,5 @@ Meta-estimators and tools not supporting metadata routing yet: - :class:`sklearn.model_selection.learning_curve` - :class:`sklearn.model_selection.permutation_test_score` - :class:`sklearn.model_selection.validation_curve` -- :class:`sklearn.multiclass.OneVsOneClassifier` -- :class:`sklearn.multiclass.OneVsRestClassifier` -- :class:`sklearn.multiclass.OutputCodeClassifier` - :class:`sklearn.pipeline.FeatureUnion` - :class:`sklearn.semi_supervised.SelfTrainingClassifier` diff --git a/doc/whats_new/v1.4.rst b/doc/whats_new/v1.4.rst index 6afc5011ded30..250496182752f 100644 --- a/doc/whats_new/v1.4.rst +++ b/doc/whats_new/v1.4.rst @@ -40,6 +40,13 @@ The following models now support metadata routing in one or more or their methods. Refer to the :ref:`Metadata Routing User Guide <metadata_routing>` for more details. +- |Feature| :class:`multiclass.OneVsRestClassifier`, + :class:`multiclass.OneVsOneClassifier` and + :class:`multiclass.OutputCodeClassifier` now support metadata routing in + their ``fit`` and ``partial_fit``, and route metadata to the underlying + estimator's ``fit`` and ``partial_fit``. :pr:`27308` by :user:`Stefanie + Senger <StefanieSenger>`. + - |Feature| :class:`pipeline.Pipeline` now supports metadata routing according to :ref:`metadata routing user guide <metadata_routing>`. :pr:`26789` by `Adrin Jalali`_.

[ { "components": [ { "doc": "Get metadata routing of this object.\n\nPlease check :ref:`User Guide <metadata_routing>` on how the routing\nmechanism works.\n\n.. versionadded:: 1.4\n\nReturns\n-------\nrouting : MetadataRouter\n A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsula...

[ "sklearn/tests/test_metaestimators_metadata_routing.py::test_default_request[OneVsRestClassifier]", "sklearn/tests/test_metaestimators_metadata_routing.py::test_default_request[OneVsOneClassifier]", "sklearn/tests/test_metaestimators_metadata_routing.py::test_default_request[OutputCodeClassifier]", "sklearn/t...

[ "sklearn/tests/test_metaestimators_metadata_routing.py::test_unsupported_estimators_get_metadata_routing[estimator0]", "sklearn/tests/test_metaestimators_metadata_routing.py::test_unsupported_estimators_get_metadata_routing[estimator1]", "sklearn/tests/test_metaestimators_metadata_routing.py::test_unsupported_e...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> ENH Add metadata routing to OneVsRestClassifier, OneVsOneClassifier and OutputCodeClassifier #### Reference Issues/PRs Towards #22893 #### What does this implement/fix? Explain your changes. - Adds metadata routing to OneVsRestClassifier, OneVsOneClassifier and OutputCodeClassifier - The routing is added in the `fit` and `partial_fit` methods if they exist - A test is added for checking that the coefficients are different when different sample weights are passed. Another test asserts if the correct error message is shown if `enable_metadata_routing` is `False`, but metadata is passed. #### Comments I had do put those three together, because they share common functions. Thanks @glemaitre for your help! ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/multiclass.py] (definition of OneVsRestClassifier.get_metadata_routing:) def get_metadata_routing(self): """Get metadata routing of this object. Please check :ref:`User Guide <metadata_routing>` on how the routing mechanism works. .. versionadded:: 1.4 Returns ------- routing : MetadataRouter A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating routing information.""" (definition of OneVsOneClassifier.get_metadata_routing:) def get_metadata_routing(self): """Get metadata routing of this object. Please check :ref:`User Guide <metadata_routing>` on how the routing mechanism works. .. versionadded:: 1.4 Returns ------- routing : MetadataRouter A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating routing information.""" (definition of OutputCodeClassifier.get_metadata_routing:) def get_metadata_routing(self): """Get metadata routing of this object. Please check :ref:`User Guide <metadata_routing>` on how the routing mechanism works. .. versionadded:: 1.4 Returns ------- routing : MetadataRouter A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating routing information.""" [end of new definitions in sklearn/multiclass.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

ae2c80a21007d8295fb3ec3a927fce17b3d60ab8

Textualize__textual-3236

3,236

Textualize/textual

null

06b6426750a583ef9f7bc2fc458ccc72cbec9fd0

2023-09-05T12:28:31Z

diff --git a/src/textual/_slug.py b/src/textual/_slug.py new file mode 100644 index 0000000000..8d23ca4dab --- /dev/null +++ b/src/textual/_slug.py @@ -0,0 +1,116 @@ +"""Provides a utility function and class for creating Markdown-friendly slugs. + +The approach to creating slugs is designed to be as close to +GitHub-flavoured Markdown as possible. However, because there doesn't appear +to be any actual documentation for this 'standard', the code here involves +some guesswork and also some pragmatic shortcuts. + +Expect this to grow over time. + +The main rules used in here at the moment are: + +1. Strip all leading and trailing whitespace. +2. Remove all non-lingual characters (emoji, etc). +3. Remove all punctuation and whitespace apart from dash and underscore. +""" + +from __future__ import annotations + +from collections import defaultdict +from re import compile +from string import punctuation +from typing import Pattern +from urllib.parse import quote + +from typing_extensions import Final + +WHITESPACE_REPLACEMENT: Final[str] = "-" +"""The character to replace undesirable characters with.""" + +REMOVABLE: Final[str] = punctuation.replace(WHITESPACE_REPLACEMENT, "").replace("_", "") +"""The collection of characters that should be removed altogether.""" + +NONLINGUAL: Final[str] = ( + r"\U000024C2-\U0001F251" + r"\U00002702-\U000027B0" + r"\U0001F1E0-\U0001F1FF" + r"\U0001F300-\U0001F5FF" + r"\U0001F600-\U0001F64F" + r"\U0001F680-\U0001F6FF" + r"\U0001f926-\U0001f937" + r"\u200D" + r"\u2640-\u2642" +) +"""A string that can be used in a regular expression to remove most non-lingual characters.""" + +STRIP_RE: Final[Pattern] = compile(f"[{REMOVABLE}{NONLINGUAL}]+") +"""A regular expression for finding all the characters that should be removed.""" + +WHITESPACE_RE: Final[Pattern] = compile(r"\s") +"""A regular expression for finding all the whitespace and turning it into `REPLACEMENT`.""" + + +def slug(text: str) -> str: + """Create a Markdown-friendly slug from the given text. + + Args: + text: The text to generate a slug from. + + Returns: + A slug for the given text. + + The rules used in generating the slug are based on observations of how + GitHub-flavoured Markdown works. + """ + result = text.strip().lower() + for rule, replacement in ( + (STRIP_RE, ""), + (WHITESPACE_RE, WHITESPACE_REPLACEMENT), + ): + result = rule.sub(replacement, result) + return quote(result) + + +class TrackedSlugs: + """Provides a class for generating tracked slugs. + + While [`slug`][textual._slug.slug] will generate a slug for a given + string, it does not guarantee that it is unique for a given context. If + you want to ensure that the same string generates unique slugs (perhaps + heading slugs within a Markdown document, as an example), use an + instance of this class to generate them. + + Example: + ```python + >>> slug("hello world") + 'hello-world' + >>> slug("hello world") + 'hello-world' + >>> unique = TrackedSlugs() + >>> unique.slug("hello world") + 'hello-world' + >>> unique.slug("hello world") + 'hello-world-1' + ``` + """ + + def __init__(self) -> None: + """Initialise the tracked slug object.""" + self._used: defaultdict[str, int] = defaultdict(int) + """Keeps track of how many times a particular slug has been used.""" + + def slug(self, text: str) -> str: + """Create a Markdown-friendly unique slug from the given text. + + Args: + text: The text to generate a slug from. + + Returns: + A slug for the given text. + """ + slugged = slug(text) + used = self._used[slugged] + self._used[slugged] += 1 + if used: + slugged = f"{slugged}-{used}" + return slugged

diff --git a/tests/test_slug.py b/tests/test_slug.py new file mode 100644 index 0000000000..0486966e83 --- /dev/null +++ b/tests/test_slug.py @@ -0,0 +1,62 @@ +import pytest + +from textual._slug import TrackedSlugs, slug + + +@pytest.mark.parametrize( + "text, expected", + [ + ("test", "test"), + ("Test", "test"), + (" Test ", "test"), + ("-test-", "-test-"), + ("!test!", "test"), + ("test!!test", "testtest"), + ("test! !test", "test-test"), + ("test test", "test-test"), + ("test test", "test--test"), + ("test test", "test----------test"), + ("--test", "--test"), + ("test--", "test--"), + ("--test--test--", "--test--test--"), + ("test!\"#$%&'()*+,-./:;<=>?@[]^_`{|}~test", "test-_test"), + ("tëst", "t%C3%ABst"), + ("test🙂test", "testtest"), + ("test🤷test", "testtest"), + ("test🤷🏻‍♀️test", "testtest"), + ], +) +def test_simple_slug(text: str, expected: str) -> None: + """The simple slug function should produce the expected slug.""" + assert slug(text) == expected + + +@pytest.fixture(scope="module") +def tracker() -> TrackedSlugs: + return TrackedSlugs() + + +@pytest.mark.parametrize( + "text, expected", + [ + ("test", "test"), + ("test", "test-1"), + ("test", "test-2"), + ("-test-", "-test-"), + ("-test-", "-test--1"), + ("test!\"#$%&'()*+,-./:;<=>?@[]^_`{|}~test", "test-_test"), + ("test!\"#$%&'()*+,-./:;<=>?@[]^_`{|}~test", "test-_test-1"), + ("tëst", "t%C3%ABst"), + ("tëst", "t%C3%ABst-1"), + ("tëst", "t%C3%ABst-2"), + ("test🙂test", "testtest"), + ("test🤷test", "testtest-1"), + ("test🤷🏻‍♀️test", "testtest-2"), + ("test", "test-3"), + ("test", "test-4"), + (" test ", "test-5"), + ], +) +def test_tracked_slugs(tracker: TrackedSlugs, text: str, expected: str) -> None: + """The tracked slugging class should produce the expected slugs.""" + assert tracker.slug(text) == expected

[ { "components": [ { "doc": "Create a Markdown-friendly slug from the given text.\n\nArgs:\n text: The text to generate a slug from.\n\nReturns:\n A slug for the given text.\n\nThe rules used in generating the slug are based on observations of how\nGitHub-flavoured Markdown works.", "...

[ "tests/test_slug.py::test_simple_slug[test-test]", "tests/test_slug.py::test_simple_slug[Test-test]", "tests/test_slug.py::test_simple_slug[", "tests/test_slug.py::test_simple_slug[-test---test-]", "tests/test_slug.py::test_simple_slug[!test!-test]", "tests/test_slug.py::test_simple_slug[test!!test-testte...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add utility code for generating Markdown-oriented slugs With #3094 in mind, and with the feedback on #2941 in mind, this PR seeks to implement some utility code for generating slugs that can be used as anchor links with Markdown documents. As per [Will's request that it be made to work like GitHub's approach](https://github.com/Textualize/textual/pull/2941#discussion_r1308516663), this code is a first pass at attempting to deliver that. Sadly, as best as I can tell, there's no specification for what GitHub does when it comes to slugging headers, so the rules have been worked out using some "common sense" and trial and error while editing and viewing a Markdown document on GitHub. The code in here, and the tests to go with it, aim to cover the vast majority of cases. There are some weird edge cases where it doesn't seem worth trying to handle them as they appear to be bugs. For example, in GutHub, this: ``` test🤷test ``` will slug to `testtest`. On the other hand this: ``` test🤷🏻‍♀️test ``` slugs to `test%EF%B8%8Ftest` That is, it seems like there are occasions where the last codepoint "leaks" into the slug (with the emoji itself being removed first). Without a specification or reference code to work from it's difficult to say if this intended or not, but I've taken the view that it's unintended and remote and unhelpful to try and replicate it -- the vast majority of headers are going to be pretty simple to slug. This code can be extended to be "bug compatible" if we find it's an issue. With this code merged into `main` I believe we'll be in a better position to rework #2941. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/textual/_slug.py] (definition of slug:) def slug(text: str) -> str: """Create a Markdown-friendly slug from the given text. Args: text: The text to generate a slug from. Returns: A slug for the given text. The rules used in generating the slug are based on observations of how GitHub-flavoured Markdown works.""" (definition of TrackedSlugs:) class TrackedSlugs: """Provides a class for generating tracked slugs. While [`slug`][textual._slug.slug] will generate a slug for a given string, it does not guarantee that it is unique for a given context. If you want to ensure that the same string generates unique slugs (perhaps heading slugs within a Markdown document, as an example), use an instance of this class to generate them. Example: ```python >>> slug("hello world") 'hello-world' >>> slug("hello world") 'hello-world' >>> unique = TrackedSlugs() >>> unique.slug("hello world") 'hello-world' >>> unique.slug("hello world") 'hello-world-1' ```""" (definition of TrackedSlugs.__init__:) def __init__(self) -> None: """Initialise the tracked slug object.""" (definition of TrackedSlugs.slug:) def slug(self, text: str) -> str: """Create a Markdown-friendly unique slug from the given text. Args: text: The text to generate a slug from. Returns: A slug for the given text.""" [end of new definitions in src/textual/_slug.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

86e93536b991014e0ea4bf993068202b446bb698

tobymao__sqlglot-2156

2,156

tobymao/sqlglot

null

585d0bfcbd40125492640480c890af328d8bc51f

2023-09-05T09:43:42Z

diff --git a/sqlglot/dialects/snowflake.py b/sqlglot/dialects/snowflake.py index 934e320adf..8d8183c3df 100644 --- a/sqlglot/dialects/snowflake.py +++ b/sqlglot/dialects/snowflake.py @@ -190,6 +190,13 @@ def _parse_regexp_replace(args: t.List) -> exp.RegexpReplace: return regexp_replace +def _show_parser(*args: t.Any, **kwargs: t.Any) -> t.Callable[[Snowflake.Parser], exp.Show]: + def _parse(self: Snowflake.Parser) -> exp.Show: + return self._parse_show_snowflake(*args, **kwargs) + + return _parse + + class Snowflake(Dialect): # https://docs.snowflake.com/en/sql-reference/identifiers-syntax RESOLVES_IDENTIFIERS_AS_UPPERCASE = True @@ -289,6 +296,16 @@ class Parser(parser.Parser): ), } + STATEMENT_PARSERS = { + **parser.Parser.STATEMENT_PARSERS, + TokenType.SHOW: lambda self: self._parse_show(), + } + + SHOW_PARSERS = { + "PRIMARY KEYS": _show_parser("PRIMARY KEYS"), + "TERSE PRIMARY KEYS": _show_parser("PRIMARY KEYS"), + } + def _parse_id_var( self, any_token: bool = True, @@ -304,6 +321,23 @@ def _parse_id_var( return super()._parse_id_var(any_token=any_token, tokens=tokens) + def _parse_show_snowflake(self, this: str) -> exp.Show: + scope = None + scope_kind = None + + if self._match(TokenType.IN): + if self._match_text_seq("ACCOUNT"): + scope_kind = "ACCOUNT" + elif self._match_set(self.DB_CREATABLES): + scope_kind = self._prev.text + if self._curr: + scope = self._parse_table() + elif self._curr: + scope_kind = "TABLE" + scope = self._parse_table() + + return self.expression(exp.Show, this=this, scope=scope, scope_kind=scope_kind) + class Tokenizer(tokens.Tokenizer): STRING_ESCAPES = ["\\", "'"] HEX_STRINGS = [("x'", "'"), ("X'", "'")] @@ -338,6 +372,8 @@ class Tokenizer(tokens.Tokenizer): VAR_SINGLE_TOKENS = {"$"} + COMMANDS = tokens.Tokenizer.COMMANDS - {TokenType.SHOW} + class Generator(generator.Generator): PARAMETER_TOKEN = "$" MATCHED_BY_SOURCE = False @@ -413,6 +449,16 @@ class Generator(generator.Generator): exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED, } + def show_sql(self, expression: exp.Show) -> str: + scope = self.sql(expression, "scope") + scope = f" {scope}" if scope else "" + + scope_kind = self.sql(expression, "scope_kind") + if scope_kind: + scope_kind = f" IN {scope_kind}" + + return f"SHOW {expression.name}{scope_kind}{scope}" + def regexpextract_sql(self, expression: exp.RegexpExtract) -> str: # Other dialects don't support all of the following parameters, so we need to # generate default values as necessary to ensure the transpilation is correct diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index 7103b9c800..0479da09cb 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -1071,6 +1071,8 @@ class Show(Expression): "like": False, "where": False, "db": False, + "scope": False, + "scope_kind": False, "full": False, "mutex": False, "query": False, diff --git a/sqlglot/parser.py b/sqlglot/parser.py index 214998c74b..709122e04d 100644 --- a/sqlglot/parser.py +++ b/sqlglot/parser.py @@ -4852,8 +4852,7 @@ def _parse_show(self) -> t.Optional[exp.Expression]: parser = self._find_parser(self.SHOW_PARSERS, self.SHOW_TRIE) if parser: return parser(self) - self._advance() - return self.expression(exp.Show, this=self._prev.text.upper()) + return self._parse_as_command(self._prev) def _parse_set_item_assignment( self, kind: t.Optional[str] = None

diff --git a/tests/dialects/test_snowflake.py b/tests/dialects/test_snowflake.py index 05da654d8c..30a1f037bf 100644 --- a/tests/dialects/test_snowflake.py +++ b/tests/dialects/test_snowflake.py @@ -1034,3 +1034,33 @@ def test_match_recognize(self): )""", pretty=True, ) + + def test_show(self): + # Parsed as Command + self.validate_identity("SHOW COLUMNS IN TABLE dt_test") + self.validate_identity("SHOW TABLES LIKE 'line%' IN tpch.public") + + ast = parse_one("SHOW TABLES HISTORY IN tpch.public") + self.assertIsInstance(ast, exp.Command) + + # Parsed as Show + self.validate_identity("SHOW PRIMARY KEYS") + self.validate_identity("SHOW PRIMARY KEYS IN ACCOUNT") + self.validate_identity("SHOW PRIMARY KEYS IN DATABASE") + self.validate_identity("SHOW PRIMARY KEYS IN DATABASE foo") + self.validate_identity("SHOW PRIMARY KEYS IN TABLE") + self.validate_identity("SHOW PRIMARY KEYS IN TABLE foo") + self.validate_identity( + 'SHOW PRIMARY KEYS IN "TEST"."PUBLIC"."customers"', + 'SHOW PRIMARY KEYS IN TABLE "TEST"."PUBLIC"."customers"', + ) + self.validate_identity( + 'SHOW TERSE PRIMARY KEYS IN "TEST"."PUBLIC"."customers"', + 'SHOW PRIMARY KEYS IN TABLE "TEST"."PUBLIC"."customers"', + ) + + ast = parse_one('SHOW PRIMARY KEYS IN "TEST"."PUBLIC"."customers"', read="snowflake") + table = ast.find(exp.Table) + + self.assertIsNotNone(table) + self.assertEqual(table.sql(dialect="snowflake"), '"TEST"."PUBLIC"."customers"')

[]

[ "tests/dialects/test_snowflake.py::TestSnowflake::test_show" ]

[ "tests/dialects/test_snowflake.py::TestSnowflake::test_ddl", "tests/dialects/test_snowflake.py::TestSnowflake::test_describe_table", "tests/dialects/test_snowflake.py::TestSnowflake::test_flatten", "tests/dialects/test_snowflake.py::TestSnowflake::test_match_recognize", "tests/dialects/test_snowflake.py::Te...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat!(snowflake): improve parsing for SHOW statement Fixes #2148 cc @tobymao had already started working on this; it doesn't parse all `SHOW` variants, but it solves the original issue and falls back to parsing `SHOW ...` as a `Command` in all other cases. It also serves as a foundation for completing the parsing of `SHOW` statements if we ever need to extend it. Reference: https://docs.snowflake.com/en/sql-reference/sql/show-primary-keys ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Show doesn't yield any metadata ``` from sqlglot import parse_one, exp tables = parse_one('SHOW PRIMARY KEYS IN "TEST"."PUBLIC"."customers"', read="snowflake", dialect="snowflake").find_all(exp.Table) ``` Expected output: List of tables, in this case it should be `customers` Instead receiving an empty result Official documentation: https://docs.snowflake.com/en/sql-reference/sql/show-primary-keys ---------- Hey, thanks for the report, we'll look into this soon. closed by 585d0bfcbd40125492640480c890af328d8bc51f parsed as a command, explicit parsing is out of scope, but happy to accept a PR -------------------- </issues>

ceb42fabad60312699e4b15936aeebac00e22e4d

joke2k__faker-1904

1,904

joke2k/faker

null

33e36b1b6cc9c6f039fe387988853771bab60624

2023-09-04T14:06:36Z

diff --git a/faker/providers/color/__init__.py b/faker/providers/color/__init__.py index e2aa0dec16..358512b73f 100644 --- a/faker/providers/color/__init__.py +++ b/faker/providers/color/__init__.py @@ -1,5 +1,6 @@ from collections import OrderedDict -from typing import Dict, Optional +from functools import cached_property +from typing import Dict, Optional, Tuple from ...typing import HueType from .. import BaseProvider, ElementsType @@ -198,6 +199,10 @@ def rgb_css_color(self) -> str: """Generate a color formatted as a CSS rgb() function.""" return f"rgb({self.random_int(0, 255)},{self.random_int(0, 255)},{self.random_int(0, 255)})" + @cached_property + def _random_color(self): + return RandomColor(self.generator) + def color( self, hue: Optional[HueType] = None, @@ -238,8 +243,40 @@ def color( :sample: hue=135, luminosity='dark', color_format='hsv' :sample: hue=(300, 20), luminosity='random', color_format='hsl' """ - return RandomColor(self.generator).generate( + return self._random_color.generate( hue=hue, luminosity=luminosity, color_format=color_format, ) + + def color_rgb( + self, + hue: Optional[HueType] = None, + luminosity: Optional[str] = None, + ) -> Tuple[int, int, int]: + """Generate a RGB color tuple of integers in a human-friendly way.""" + return self._random_color.generate_rgb(hue=hue, luminosity=luminosity) + + def color_rgb_float( + self, + hue: Optional[HueType] = None, + luminosity: Optional[str] = None, + ) -> Tuple[float, float, float]: + """Generate a RGB color tuple of floats in a human-friendly way.""" + return self._random_color.generate_rgb_float(hue=hue, luminosity=luminosity) + + def color_hsl( + self, + hue: Optional[HueType] = None, + luminosity: Optional[str] = None, + ) -> Tuple[int, int, int]: + """Generate a HSL color tuple in a human-friendly way.""" + return self._random_color.generate_hsl(hue=hue, luminosity=luminosity) + + def color_hsv( + self, + hue: Optional[HueType] = None, + luminosity: Optional[str] = None, + ) -> Tuple[int, int, int]: + """Generate a HSV color tuple in a human-friendly way.""" + return self._random_color.generate_hsv(hue=hue, luminosity=luminosity) diff --git a/faker/providers/color/color.py b/faker/providers/color/color.py index 91132f5c60..379024f1fc 100644 --- a/faker/providers/color/color.py +++ b/faker/providers/color/color.py @@ -16,13 +16,16 @@ import random import sys -from typing import TYPE_CHECKING, Dict, Hashable, Optional, Sequence, Tuple +from typing import TYPE_CHECKING, Dict, Hashable, Literal, Optional, Sequence, Tuple if TYPE_CHECKING: from ...factory import Generator from ...typing import HueType +ColorFormat = Literal["hex", "hsl", "hsv", "rgb"] + + COLOR_MAP: Dict[str, Dict[str, Sequence[Tuple[int, int]]]] = { "monochrome": { "hue_range": [(0, 0)], @@ -144,37 +147,64 @@ def __init__(self, generator: Optional["Generator"] = None, seed: Optional[Hasha self.seed = seed if seed else random.randint(0, sys.maxsize) self.random = random.Random(self.seed) - for color_name, color_attrs in self.colormap.items(): - lower_bounds: Sequence[Tuple[int, int]] = color_attrs["lower_bounds"] - s_min, b_max = lower_bounds[0] - s_max, b_min = lower_bounds[-1] - - self.colormap[color_name]["saturation_range"] = [(s_min, s_max)] - self.colormap[color_name]["brightness_range"] = [(b_min, b_max)] - def generate( self, hue: Optional[HueType] = None, luminosity: Optional[str] = None, - color_format: str = "hex", + color_format: ColorFormat = "hex", ) -> str: - """Generate a color. + """Generate and format a color. Whenever :meth:`color() <faker.providers.color.Provider.color>` is called, the arguments used are simply passed into this method, and this method handles the rest. """ + # Generate HSV color tuple from picked hue and luminosity + hsv = self.generate_hsv(hue=hue, luminosity=luminosity) + + # Return the HSB/V color in the desired string format + return self.set_format(hsv, color_format) + + def generate_hsv( + self, + hue: Optional[HueType] = None, + luminosity: Optional[str] = None, + ) -> Tuple[int, int, int]: + """Generate a HSV color tuple.""" # First we pick a hue (H) h = self.pick_hue(hue) # Then use H to determine saturation (S) s = self.pick_saturation(h, hue, luminosity) - # Then use S and H to determine brightness (B). - b = self.pick_brightness(h, s, luminosity) + # Then use S and H to determine brightness/value (B/V). + v = self.pick_brightness(h, s, luminosity) - # Then we return the HSB color in the desired format - return self.set_format((h, s, b), color_format) + return h, s, v + + def generate_rgb( + self, + hue: Optional[HueType] = None, + luminosity: Optional[str] = None, + ) -> Tuple[int, int, int]: + """Generate a RGB color tuple of integers.""" + return self.hsv_to_rgb(self.generate_hsv(hue=hue, luminosity=luminosity)) + + def generate_rgb_float( + self, + hue: Optional[HueType] = None, + luminosity: Optional[str] = None, + ) -> Tuple[float, float, float]: + """Generate a RGB color tuple of floats.""" + return self.hsv_to_rgb_float(self.generate_hsv(hue=hue, luminosity=luminosity)) + + def generate_hsl( + self, + hue: Optional[HueType] = None, + luminosity: Optional[str] = None, + ) -> Tuple[int, int, int]: + """Generate a HSL color tuple.""" + return self.hsv_to_hsl(self.generate_hsv(hue=hue, luminosity=luminosity)) def pick_hue(self, hue: Optional[HueType]) -> int: """Return a numerical hue value.""" @@ -226,7 +256,7 @@ def pick_brightness(self, h: int, s: int, luminosity: Optional[str]) -> int: return self.random_within((b_min, b_max)) - def set_format(self, hsv: Tuple[int, int, int], color_format: str) -> str: + def set_format(self, hsv: Tuple[int, int, int], color_format: ColorFormat) -> str: """Handle conversion of HSV values into desired format.""" if color_format == "hsv": color = f"hsv({hsv[0]}, {hsv[1]}, {hsv[2]})" @@ -265,11 +295,11 @@ def get_hue_range(self, color_input: Optional[HueType]) -> Tuple[int, int]: """Return the hue range for a given ``color_input``.""" if isinstance(color_input, (int, float)) and 0 <= color_input <= 360: color_input = int(color_input) - return (color_input, color_input) + return color_input, color_input elif isinstance(color_input, str) and color_input in self.colormap: return self.colormap[color_input]["hue_range"][0] elif color_input is None: - return (0, 360) + return 0, 360 if isinstance(color_input, list): color_input = tuple(color_input) @@ -285,12 +315,13 @@ def get_hue_range(self, color_input: Optional[HueType]) -> Tuple[int, int]: v1, v2 = v2, v1 v1 = max(v1, 0) v2 = min(v2, 360) - return (v1, v2) + return v1, v2 raise TypeError("Hue must be a valid string, numeric type, or a tuple/list of 2 numeric types.") def get_saturation_range(self, hue: int) -> Tuple[int, int]: """Return the saturation range for a given numerical ``hue`` value.""" - return self.get_color_info(hue)["saturation_range"][0] + saturation_bounds = [s for s, v in self.get_color_info(hue)["lower_bounds"]] + return min(saturation_bounds), max(saturation_bounds) def get_color_info(self, hue: int) -> Dict[str, Sequence[Tuple[int, int]]]: """Return the color info for a given numerical ``hue`` value.""" @@ -310,18 +341,27 @@ def random_within(self, r: Sequence[int]) -> int: return self.random.randint(int(r[0]), int(r[1])) @classmethod - def hsv_to_rgb(cls, hsv: Tuple[int, int, int]) -> Tuple[int, int, int]: + def hsv_to_rgb_float(cls, hsv: Tuple[int, int, int]) -> Tuple[float, float, float]: """Convert HSV to RGB. This method expects ``hsv`` to be a 3-tuple of H, S, and V values, and - it will return a 3-tuple of the equivalent R, G, and B values. + it will return a 3-tuple of the equivalent R, G, and B float values. """ h, s, v = hsv h = max(h, 1) h = min(h, 359) - r, g, b = colorsys.hsv_to_rgb(h / 360, s / 100, v / 100) - return (int(r * 255), int(g * 255), int(b * 255)) + return colorsys.hsv_to_rgb(h / 360, s / 100, v / 100) + + @classmethod + def hsv_to_rgb(cls, hsv: Tuple[int, int, int]) -> Tuple[int, int, int]: + """Convert HSV to RGB. + + This method expects ``hsv`` to be a 3-tuple of H, S, and V values, and + it will return a 3-tuple of the equivalent R, G, and B integer values. + """ + r, g, b = cls.hsv_to_rgb_float(hsv) + return int(r * 255), int(g * 255), int(b * 255) @classmethod def hsv_to_hsl(cls, hsv: Tuple[int, int, int]) -> Tuple[int, int, int]: @@ -334,7 +374,7 @@ def hsv_to_hsl(cls, hsv: Tuple[int, int, int]) -> Tuple[int, int, int]: s_: float = s / 100.0 v_: float = v / 100.0 - l = 0.5 * (v_) * (2 - s_) # noqa: E741 + l = 0.5 * v_ * (2 - s_) # noqa: E741 s_ = 0.0 if l in [0, 1] else v_ * s_ / (1 - math.fabs(2 * l - 1)) - return (int(h), int(s_ * 100), int(l * 100)) + return int(h), int(s_ * 100), int(l * 100)

diff --git a/tests/providers/test_color.py b/tests/providers/test_color.py index 0770621463..608277eb8e 100644 --- a/tests/providers/test_color.py +++ b/tests/providers/test_color.py @@ -47,15 +47,42 @@ def test_rgb_css_color(self, faker, num_samples): assert 0 <= b <= 255 def test_color(self, faker, num_samples): - baseline_random_color = RandomColor(seed=4761) - expected = [baseline_random_color.generate() for _ in range(num_samples)] + random_color = self._seed_instances(faker, 4761) + expected = [random_color.generate() for _ in range(num_samples)] # The `color` provider method should behave like the `generate` # method of a standalone RandomColor instance for a given seed - faker.seed_instance(4761) colors = [faker.color() for _ in range(num_samples)] assert colors == expected + def _seed_instances(self, faker, seed): + faker.seed_instance(seed) + return RandomColor(seed=seed) + + def test_color_rgb(self, faker, num_samples): + random_color = self._seed_instances(faker, 4761) + expected = [random_color.generate_rgb() for _ in range(num_samples)] + colors = [faker.color_rgb() for _ in range(num_samples)] + assert colors == expected + + def test_color_rgb_float(self, faker, num_samples): + random_color = self._seed_instances(faker, 4761) + expected = [random_color.generate_rgb_float() for _ in range(num_samples)] + colors = [faker.color_rgb_float() for _ in range(num_samples)] + assert colors == expected + + def test_color_hsl(self, faker, num_samples): + random_color = self._seed_instances(faker, 4761) + expected = [random_color.generate_hsl() for _ in range(num_samples)] + colors = [faker.color_hsl() for _ in range(num_samples)] + assert colors == expected + + def test_color_hsv(self, faker, num_samples): + random_color = self._seed_instances(faker, 4761) + expected = [random_color.generate_hsv() for _ in range(num_samples)] + colors = [faker.color_hsv() for _ in range(num_samples)] + assert colors == expected + class TestRandomColor: """Test RandomColor class""" @@ -116,6 +143,42 @@ def test_color_format_unspecified(self, num_samples): color = self.random_color.generate() assert self.hex_color_pattern.fullmatch(color) + def test_rgb(self, num_samples): + for _ in range(num_samples): + value = self.random_color.generate_rgb() + assert len(value) == 3 + for i in range(3): + assert isinstance(value[i], int) + assert 0 <= value[i] <= 255 + + def test_rgb_float(self, num_samples): + for _ in range(num_samples): + value = self.random_color.generate_rgb_float() + assert len(value) == 3 + for i in range(3): + assert isinstance(value[i], float) + assert 0 <= value[i] <= 1 + + def test_hsl(self, num_samples): + for _ in range(num_samples): + value = self.random_color.generate_hsl() + assert len(value) == 3 + for i in range(3): + assert isinstance(value[i], int) + assert 0 <= value[0] <= 360 + assert 0 <= value[1] <= 100 + assert 0 <= value[2] <= 100 + + def test_hsv(self, num_samples): + for _ in range(num_samples): + value = self.random_color.generate_hsl() + assert len(value) == 3 + for i in range(3): + assert isinstance(value[i], int) + assert 0 <= value[0] <= 360 + assert 0 <= value[1] <= 100 + assert 0 <= value[2] <= 100 + def test_hue_integer(self): # HSV format is used, because whatever hue value supplied must be present in the output for hue in range(360):

[ { "components": [ { "doc": "", "lines": [ 203, 204 ], "name": "Provider._random_color", "signature": "def _random_color(self):", "type": "function" }, { "doc": "Generate a RGB color tuple of integers in a human-friendl...

[ "tests/providers/test_color.py::TestColorProvider::test_color_rgb", "tests/providers/test_color.py::TestColorProvider::test_color_rgb_float", "tests/providers/test_color.py::TestColorProvider::test_color_hsl", "tests/providers/test_color.py::TestColorProvider::test_color_hsv", "tests/providers/test_color.py...

[ "tests/providers/test_color.py::TestColorProvider::test_safe_hex_color", "tests/providers/test_color.py::TestColorProvider::test_hex_color", "tests/providers/test_color.py::TestColorProvider::test_rgb_color", "tests/providers/test_color.py::TestColorProvider::test_rgb_css_color", "tests/providers/test_color...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Additional pseudo-random color fakes ### What does this change Add `color_rgb`, `color_rgb_float`, `color_hsv` and `color_hsl` fakes ### What was wrong Pseudo-random colors were only available as strings. ### How this fixes it Additional fakes provide tuples of int/float. Fixes #1903 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in faker/providers/color/__init__.py] (definition of Provider._random_color:) def _random_color(self): (definition of Provider.color_rgb:) def color_rgb( self, hue: Optional[HueType] = None, luminosity: Optional[str] = None, ) -> Tuple[int, int, int]: """Generate a RGB color tuple of integers in a human-friendly way.""" (definition of Provider.color_rgb_float:) def color_rgb_float( self, hue: Optional[HueType] = None, luminosity: Optional[str] = None, ) -> Tuple[float, float, float]: """Generate a RGB color tuple of floats in a human-friendly way.""" (definition of Provider.color_hsl:) def color_hsl( self, hue: Optional[HueType] = None, luminosity: Optional[str] = None, ) -> Tuple[int, int, int]: """Generate a HSL color tuple in a human-friendly way.""" (definition of Provider.color_hsv:) def color_hsv( self, hue: Optional[HueType] = None, luminosity: Optional[str] = None, ) -> Tuple[int, int, int]: """Generate a HSV color tuple in a human-friendly way.""" [end of new definitions in faker/providers/color/__init__.py] [start of new definitions in faker/providers/color/color.py] (definition of RandomColor.generate_hsv:) def generate_hsv( self, hue: Optional[HueType] = None, luminosity: Optional[str] = None, ) -> Tuple[int, int, int]: """Generate a HSV color tuple.""" (definition of RandomColor.generate_rgb:) def generate_rgb( self, hue: Optional[HueType] = None, luminosity: Optional[str] = None, ) -> Tuple[int, int, int]: """Generate a RGB color tuple of integers.""" (definition of RandomColor.generate_rgb_float:) def generate_rgb_float( self, hue: Optional[HueType] = None, luminosity: Optional[str] = None, ) -> Tuple[float, float, float]: """Generate a RGB color tuple of floats.""" (definition of RandomColor.generate_hsl:) def generate_hsl( self, hue: Optional[HueType] = None, luminosity: Optional[str] = None, ) -> Tuple[int, int, int]: """Generate a HSL color tuple.""" (definition of RandomColor.hsv_to_rgb_float:) def hsv_to_rgb_float(cls, hsv: Tuple[int, int, int]) -> Tuple[float, float, float]: """Convert HSV to RGB. This method expects ``hsv`` to be a 3-tuple of H, S, and V values, and it will return a 3-tuple of the equivalent R, G, and B float values.""" [end of new definitions in faker/providers/color/color.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> RGB/HSV/HSL color tuples from `color` provider * Faker version: 19.3.1 * OS: any With #104/#1055 the `color` provider learned how to generate colors with certain characteristics like "dark" or from a given hue. As noted by @malefice in the previous PR, the faked values are only available as strings. Often a numeric format is more suitable as input for other data-generation or computation. I am personally looking for this functionality to generate placeholder-images with similar colors and [pycairo](https://pycairo.readthedocs.io/en/latest/reference/patterns.html#class-solidpattern-pattern) works with RGB as float. With a little refactoring it should be easy to reuse the logic already implemented in `RandomColor` to provide int/float tuples for pseudo-random colors. ### Expected behavior Instead of adding another `color_format` argument and `color()` having non-string return values, additional fakes could provide the color tuples using the same `hue` and `luminosity` kwargs as `color()`. ``` >>> from faker import Faker >>> fake = Faker() >>> fake.color(hue='red') '#931929' >>> fake.color_rgb(hue='red') (247, 127, 118) >>> fake.color_rgb_float(hue='red') (0.98, 0.68355, 0.6566) >>> fake.color_hsv(hue='red') (334, 91, 78) >>> fake.color_hsl(hue='red') (340, 57, 60) ``` ### Feature overlap and further changes... The current color provider only generates strings. There is however some overlap with `color()` and `rgb_css_color()`, that probably should be refactored/deprecated in a separate step, i.e.: ``` >>> fake.color(hue='blue', color_format='rgb') 'rgb(25, 211, 232)' >>> fake.rgb_css_color() 'rgb(117,96,199)' ``` ---------- -------------------- </issues>

6edfdbf6ae90b0153309e3bf066aa3b2d16494a7

tobymao__sqlglot-2149

2,149

tobymao/sqlglot

null

7b589ae2ce4071f004b0cd3eedab5fca4deb79bb

2023-09-04T13:29:22Z

diff --git a/sqlglot/dialects/bigquery.py b/sqlglot/dialects/bigquery.py index 7c4e051ec2..c0b3daf8b5 100644 --- a/sqlglot/dialects/bigquery.py +++ b/sqlglot/dialects/bigquery.py @@ -397,6 +397,27 @@ def _parse_table_parts(self, schema: bool = False) -> exp.Table: return table + def _parse_json_object(self) -> exp.JSONObject: + json_object = super()._parse_json_object() + array_kv_pair = seq_get(json_object.expressions, 0) + + # Converts BQ's "signature 2" of JSON_OBJECT into SQLGlot's canonical representation + # https://cloud.google.com/bigquery/docs/reference/standard-sql/json_functions#json_object_signature2 + if ( + array_kv_pair + and isinstance(array_kv_pair.this, exp.Array) + and isinstance(array_kv_pair.expression, exp.Array) + ): + keys = array_kv_pair.this.expressions + values = array_kv_pair.expression.expressions + + json_object.set( + "expressions", + [exp.JSONKeyValue(this=k, expression=v) for k, v in zip(keys, values)], + ) + + return json_object + class Generator(generator.Generator): EXPLICIT_UNION = True INTERVAL_ALLOWS_PLURAL_FORM = False @@ -619,6 +640,13 @@ def attimezone_sql(self, expression: exp.AtTimeZone) -> str: return super().attimezone_sql(expression) + def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str: + # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#json_literals + if expression.is_type("json"): + return f"JSON {self.sql(expression, 'this')}" + + return super().cast_sql(expression, safe_prefix=safe_prefix) + def trycast_sql(self, expression: exp.TryCast) -> str: return self.cast_sql(expression, safe_prefix="SAFE_") diff --git a/sqlglot/parser.py b/sqlglot/parser.py index 210a7b3e6c..8b3d0f7efa 100644 --- a/sqlglot/parser.py +++ b/sqlglot/parser.py @@ -4144,7 +4144,7 @@ def _parse_decode(self) -> t.Optional[exp.Decode | exp.Case]: def _parse_json_key_value(self) -> t.Optional[exp.JSONKeyValue]: self._match_text_seq("KEY") - key = self._parse_field() + key = self._parse_column() self._match_set((TokenType.COLON, TokenType.COMMA)) self._match_text_seq("VALUE") value = self._parse_column()

diff --git a/tests/dialects/test_bigquery.py b/tests/dialects/test_bigquery.py index 8f6dc3f645..b776bdd3ce 100644 --- a/tests/dialects/test_bigquery.py +++ b/tests/dialects/test_bigquery.py @@ -9,6 +9,7 @@ class TestBigQuery(Validator): maxDiff = None def test_bigquery(self): + self.validate_identity("""SELECT JSON '"foo"' AS json_data""") self.validate_identity("SELECT * FROM tbl FOR SYSTEM_TIME AS OF z") self.validate_all( @@ -789,5 +790,22 @@ def test_json_object(self): self.validate_identity("SELECT JSON_OBJECT('foo', 10, 'bar', TRUE) AS json_data") self.validate_identity("SELECT JSON_OBJECT('foo', 10, 'bar', ['a', 'b']) AS json_data") self.validate_identity("SELECT JSON_OBJECT('a', 10, 'a', 'foo') AS json_data") + self.validate_identity( + "SELECT JSON_OBJECT(['a', 'b'], [10, NULL]) AS json_data", + "SELECT JSON_OBJECT('a', 10, 'b', NULL) AS json_data", + ) + self.validate_identity( + """SELECT JSON_OBJECT(['a', 'b'], [JSON '10', JSON '"foo"']) AS json_data""", + """SELECT JSON_OBJECT('a', JSON '10', 'b', JSON '"foo"') AS json_data""", + ) + self.validate_identity( + "SELECT JSON_OBJECT(['a', 'b'], [STRUCT(10 AS id, 'Red' AS color), STRUCT(20 AS id, 'Blue' AS color)]) AS json_data", + "SELECT JSON_OBJECT('a', STRUCT(10 AS id, 'Red' AS color), 'b', STRUCT(20 AS id, 'Blue' AS color)) AS json_data", + ) + self.validate_identity( + "SELECT JSON_OBJECT(['a', 'b'], [TO_JSON(10), TO_JSON(['foo', 'bar'])]) AS json_data", + "SELECT JSON_OBJECT('a', TO_JSON(10), 'b', TO_JSON(['foo', 'bar'])) AS json_data", + ) + with self.assertRaises(ParseError): transpile("SELECT JSON_OBJECT('a', 1, 'b') AS json_data", read="bigquery") diff --git a/tests/dialects/test_presto.py b/tests/dialects/test_presto.py index 0043ad0808..dbca5b3f26 100644 --- a/tests/dialects/test_presto.py +++ b/tests/dialects/test_presto.py @@ -824,7 +824,7 @@ def test_presto(self, logger): self.validate_all( """JSON_FORMAT(JSON '"x"')""", write={ - "bigquery": """TO_JSON_STRING(CAST('"x"' AS JSON))""", + "bigquery": """TO_JSON_STRING(JSON '"x"')""", "duckdb": """CAST(TO_JSON(CAST('"x"' AS JSON)) AS TEXT)""", "presto": """JSON_FORMAT(CAST('"x"' AS JSON))""", "spark": """REGEXP_EXTRACT(TO_JSON(FROM_JSON('["x"]', SCHEMA_OF_JSON('["x"]'))), '^.(.*).$', 1)""",

[]

[ "tests/dialects/test_bigquery.py::TestBigQuery::test_bigquery", "tests/dialects/test_bigquery.py::TestBigQuery::test_json_object", "tests/dialects/test_presto.py::TestPresto::test_presto" ]

[ "tests/dialects/test_bigquery.py::TestBigQuery::test_group_concat", "tests/dialects/test_bigquery.py::TestBigQuery::test_merge", "tests/dialects/test_bigquery.py::TestBigQuery::test_pushdown_cte_column_names", "tests/dialects/test_bigquery.py::TestBigQuery::test_remove_precision_parameterized_types", "tests...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat!(bigquery): improve handling of array JSON_OBJECT syntax This PR was motivated by https://github.com/tobymao/sqlglot/pull/2136. It seems like `CAST(... AS JSON)` is not valid in BQ, at least for the examples I tried: ```sql SELECT CAST(1 AS JSON) AS foo -- Invalid cast from INT64 to JSON at [1:13] SELECT CAST('"foo"' AS JSON) AS foo -- Invalid cast from STRING to JSON at [1:13] SELECT CAST('foo' AS JSON) AS foo -- Invalid cast from STRING to JSON at [1:13] ``` Reference: https://cloud.google.com/bigquery/docs/reference/standard-sql/json_functions#json_object cc: @middagj ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

ceb42fabad60312699e4b15936aeebac00e22e4d

astropy__astropy-15264

15,264

astropy/astropy

5.2

d64fc339429487631173fc5f81dd0130cc54fa3d

2023-09-01T12:20:49Z

diff --git a/astropy/time/core.py b/astropy/time/core.py index 32c0af62dc84..acfd4dcf25bc 100644 --- a/astropy/time/core.py +++ b/astropy/time/core.py @@ -11,7 +11,7 @@ import operator import os import threading -from datetime import date, datetime, timedelta, timezone +from datetime import date, datetime, timezone from time import strftime from warnings import warn @@ -33,6 +33,7 @@ TIME_FORMATS, TimeAstropyTime, TimeDatetime, + TimeDeltaNumeric, TimeFromEpoch, # noqa: F401 TimeJD, TimeUnique, @@ -499,8 +500,6 @@ def _init_from_vals( inputs. This handles coercion into the correct shapes and some basic input validation. """ - if precision is None: - precision = 3 if in_subfmt is None: in_subfmt = "*" if out_subfmt is None: @@ -561,12 +560,14 @@ def _get_time_fmt(self, val, val2, format, scale, precision, in_subfmt, out_subf If format is `None` and the input is a string-type or object array then guess available formats and stop when one matches. """ - if format is None and ( - val.dtype.kind in ("S", "U", "O", "M") or val.dtype.names - ): - # Input is a string, object, datetime, or a table-like ndarray - # (structured array, recarray). These input types can be - # uniquely identified by the format classes. + if format is None: + # If val and val2 broadcasted shape is (0,) (i.e. empty array input) then we + # cannot guess format from the input values. Instead use the default + # format. + if val.size == 0 and (val2 is None or val2.size == 0): + raise ValueError( + "cannot guess format from input values with zero-size array" + ) formats = [ (name, cls) for name, cls in self.FORMATS.items() @@ -575,22 +576,20 @@ def _get_time_fmt(self, val, val2, format, scale, precision, in_subfmt, out_subf # AstropyTime is a pseudo-format that isn't in the TIME_FORMATS registry, # but try to guess it at the end. - formats.append(("astropy_time", TimeAstropyTime)) + if isinstance(self, Time): + formats.append(("astropy_time", TimeAstropyTime)) - elif not (isinstance(format, str) and format.lower() in self.FORMATS): - if format is None: - raise ValueError( - "No time format was given, and the input is not unique" - ) - else: - raise ValueError( - f"Format {format!r} is not one of the allowed formats " - f"{sorted(self.FORMATS)}" - ) + elif not isinstance(format, str): + raise TypeError("format must be a string") + + elif format.lower() not in self.FORMATS: + raise ValueError( + f"Format {format!r} is not one of the allowed formats " + f"{sorted(self.FORMATS)}" + ) else: formats = [(format, self.FORMATS[format])] - assert formats problems = {} for name, cls in formats: try: @@ -609,10 +608,12 @@ def _get_time_fmt(self, val, val2, format, scale, precision, in_subfmt, out_subf ) from err else: problems[name] = err - raise ValueError( + + message = ( "Input values did not match any of the formats where the format " - f"keyword is optional: {problems}" - ) from problems[formats[0][0]] + "keyword is optional:\n" + ) + "\n".join(f"- '{name}': {err}" for name, err in problems.items()) + raise ValueError(message) @property def writeable(self): @@ -1278,7 +1279,7 @@ def _apply(self, method, *args, format=None, cls=None, **kwargs): jd1, jd2, self.scale, - precision=0, + precision=None, in_subfmt="*", out_subfmt="*", from_jd=True, @@ -2724,7 +2725,7 @@ class TimeDelta(TimeBase): The allowed values for ``format`` can be listed with:: >>> list(TimeDelta.FORMATS) - ['sec', 'jd', 'datetime'] + ['sec', 'jd', 'datetime', 'quantity_str'] Note that for time differences, the scale can be among three groups: geocentric ('tai', 'tt', 'tcg'), barycentric ('tcb', 'tdb'), and rotational @@ -2758,6 +2759,12 @@ class TimeDelta(TimeBase): ('tdb', 'tt', 'ut1', 'tcg', 'tcb', 'tai'). If not given (or ``None``), the scale is arbitrary; when added or subtracted from a ``Time`` instance, it will be used without conversion. + precision : int, optional + Digits of precision in string representation of time + in_subfmt : str, optional + Unix glob to select subformats for parsing input times + out_subfmt : str, optional + Unix glob to select subformat for outputting times copy : bool, optional Make a copy of the input values """ @@ -2789,31 +2796,49 @@ def __new__( return self - def __init__(self, val, val2=None, format=None, scale=None, copy=False): + def __init__( + self, + val, + val2=None, + format=None, + scale=None, + *, + precision=None, + in_subfmt=None, + out_subfmt=None, + copy=False, + ): if isinstance(val, TimeDelta): if scale is not None: self._set_scale(scale) else: - format = format or self._get_format(val) - self._init_from_vals(val, val2, format, scale, copy) + self._init_from_vals( + val, + val2, + format, + scale, + copy, + precision=precision, + in_subfmt=in_subfmt, + out_subfmt=out_subfmt, + ) + self._check_numeric_no_unit(val, format) if scale is not None: self.SCALES = TIME_DELTA_TYPES[scale] - @staticmethod - def _get_format(val): - if isinstance(val, timedelta): - return "datetime" - - if getattr(val, "unit", None) is None: + def _check_numeric_no_unit(self, val, format): + if ( + isinstance(self._time, TimeDeltaNumeric) + and getattr(val, "unit", None) is None + and format is None + ): warn( "Numerical value without unit or explicit format passed to" " TimeDelta, assuming days", TimeDeltaMissingUnitWarning, ) - return "jd" - def replicate(self, *args, **kwargs): out = super().replicate(*args, **kwargs) out.SCALES = self.SCALES @@ -3049,12 +3074,13 @@ def to_value(self, *args, **kwargs): To convert to a unit with optional equivalencies, the options are:: tm.to_value('hr') # convert to u.hr (hours) - tm.to_value('hr', []) # specify equivalencies as a positional arg tm.to_value('hr', equivalencies=[]) tm.to_value(unit='hr', equivalencies=[]) - The built-in `~astropy.time.TimeDelta` options for ``format`` are: - {'jd', 'sec', 'datetime'}. + The built-in `~astropy.time.TimeDelta` options for ``format`` are shown below:: + + >>> list(TimeDelta.FORMATS) + ['sec', 'jd', 'datetime', 'quantity_str'] For the two numerical formats 'jd' and 'sec', the available ``subfmt`` options are: {'float', 'long', 'decimal', 'str', 'bytes'}. Here, 'long' @@ -3096,17 +3122,37 @@ def to_value(self, *args, **kwargs): if not (args or kwargs): raise TypeError("to_value() missing required format or unit argument") - # TODO: maybe allow 'subfmt' also for units, keeping full precision - # (effectively, by doing the reverse of quantity_day_frac)? - # This way, only equivalencies could lead to possible precision loss. + # Validate keyword arguments. + if kwargs: + allowed_kwargs = {"format", "subfmt", "unit", "equivalencies"} + if not set(kwargs).issubset(allowed_kwargs): + bad = (set(kwargs) - allowed_kwargs).pop() + raise TypeError( + f"{self.to_value.__qualname__}() got an unexpected keyword argument" + f" '{bad}'" + ) + + # Handle a valid format as first positional argument or keyword. This will also + # accept a subfmt keyword if supplied. if "format" in kwargs or ( args != () and (args[0] is None or args[0] in self.FORMATS) ): # Super-class will error with duplicate arguments, etc. return super().to_value(*args, **kwargs) - # With positional arguments, we try parsing the first one as a unit, - # so that on failure we can give a more informative exception. + # Handle subfmt keyword with no format and no args. + if "subfmt" in kwargs: + if args: + raise ValueError( + "cannot specify 'subfmt' and positional argument that is not a " + "valid format" + ) + return super().to_value(self.format, **kwargs) + + # At this point any positional argument must be a unit so try parsing as such. + # If it fails then give an informative exception. + # TODO: deprecate providing equivalencies as a positional argument. This is + # quite non-obvious in this context. if args: try: unit = u.Unit(args[0]) diff --git a/astropy/time/formats.py b/astropy/time/formats.py index 1d0187118b0c..a548351b2a05 100644 --- a/astropy/time/formats.py +++ b/astropy/time/formats.py @@ -42,6 +42,7 @@ "TimeDeltaFormat", "TimeDeltaSec", "TimeDeltaJD", + "TimeDeltaQuantityString", "TimeEpochDateString", "TimeBesselianEpochString", "TimeJulianEpochString", @@ -139,6 +140,10 @@ class TimeFormat: """ _default_scale = "utc" # As of astropy 0.4 + _default_precision = 3 + _min_precision = 0 + _max_precision = 9 + subfmts = () _registry = TIME_FORMATS @@ -276,9 +281,16 @@ def precision(self): @precision.setter def precision(self, val): + if val is None: + val = self._default_precision # Verify precision is 0-9 (inclusive) - if not isinstance(val, int) or val < 0 or val > 9: - raise ValueError("precision attribute must be an int between 0 and 9") + if not ( + isinstance(val, int) and self._min_precision <= val <= self._max_precision + ): + raise ValueError( + "precision attribute must be an int between " + f"{self._min_precision} and {self._max_precision}" + ) self._precision = val @lazyproperty @@ -2086,6 +2098,10 @@ class TimeDeltaFormat(TimeFormat): """Base class for time delta representations.""" _registry = TIME_DELTA_FORMATS + _default_precision = 3 + # Somewhat arbitrary values that are effectively no limit for precision. + _min_precision = -99 + _max_precision = 99 def _check_scale(self, scale): """ @@ -2122,7 +2138,7 @@ class TimeDeltaSec(TimeDeltaNumeric): unit = 1.0 / erfa.DAYSEC # for quantity input -class TimeDeltaJD(TimeDeltaNumeric): +class TimeDeltaJD(TimeDeltaNumeric, TimeUnique): """Time delta in Julian days (86400 SI seconds).""" name = "jd" @@ -2175,6 +2191,227 @@ def value(self): return self.mask_if_needed(iterator.operands[-1]) +class TimeDeltaQuantityString(TimeDeltaFormat, TimeUnique): + """Time delta as a string with one or more Quantity components. + + This format provides a human-readable multi-scale string representation of a time + delta. It is convenient for applications like a configuration file or a command line + option. + + The format is specified as follows: + + - The string is a sequence of one or more components. + - Each component is a number followed by an astropy unit of time. + - For input, whitespace within the string is allowed but optional. + - For output, there is a single space between components. + - The allowed components are listed below. + - The order (yr, d, hr, min, s) is fixed but individual components are optional. + + The allowed input component units are shown below: + + - "yr": years (365.25 days) + - "d": days (24 hours) + - "hr": hours (60 minutes) + - "min": minutes (60 seconds) + - "s": seconds + + .. Note:: These definitions correspond to physical units of time and are NOT + calendar date intervals. Thus adding "1yr" to "2000-01-01 00:00:00" will give + "2000-12-31 06:00:00" instead of "2001-01-01 00:00:00". + + The ``out_subfmt`` attribute specifies the components to be included in the string + output. The default is ``"multi"`` which represents the time delta as + ``"<days>d <hours>hr <minutes>min <seconds>s"``, where only non-zero components are + included. + + - "multi": multiple components, e.g. "2d 3hr 15min 5.6s" + - "yr": years + - "d": days + - "hr": hours + - "min": minutes + - "s": seconds + + Examples + -------- + >>> from astropy.time import Time, TimeDelta + >>> import astropy.units as u + + >>> print(TimeDelta("1yr")) + 365d 6hr + + >>> print(Time("2000-01-01") + TimeDelta("1yr")) + 2000-12-31 06:00:00.000 + >>> print(TimeDelta("+3.6d")) + 3d 14hr 24min + >>> print(TimeDelta("-3.6d")) + -3d 14hr 24min + >>> print(TimeDelta("1yr 3.6d", out_subfmt="d")) + 368.85d + + >>> td = TimeDelta(40 * u.hr) + >>> print(td.to_value(format="quantity_str")) + 1d 16hr + >>> print(td.to_value(format="quantity_str", subfmt="d")) + 1.667d + >>> td.precision = 9 + >>> print(td.to_value(format="quantity_str", subfmt="d")) + 1.666666667d + """ + + name = "quantity_str" + + subfmts = ( + ("multi", None, None), + ("yr", None, None), + ("d", None, None), + ("hr", None, None), + ("min", None, None), + ("s", None, None), + ) + + # Regex to parse "1.02yr 2.2d 3.12hr 4.322min 5.6s" where each element is optional + # but the order is fixed. Each element is a float with optional exponent. Each + # element is named. + re_float = r"(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?" + re_ydhms = re.compile( + rf"""^ \s* + (?P<sign>[-+])? \s* # Optional sign + (?=[^-+\s]) # At least one character which is not a sign or whitespace + ((?P<yr>{re_float}) \s* yr \s*)? + ((?P<d>{re_float}) \s* d \s*)? + ((?P<hr>{re_float}) \s* hr \s*)? + ((?P<min>{re_float}) \s* min \s*)? + ((?P<s>{re_float}) \s* s)? + \s* $ + """, + re.VERBOSE, + ) + + def _check_val_type(self, val1, val2): + if val1.dtype.kind not in ("S", "U") and val1.size: + raise TypeError(f"Input values for {self.name} class must be strings") + if val2 is not None: + raise ValueError( + f"{self.name} objects do not accept a val2 but you provided {val2}" + ) + return val1, None + + def parse_string(self, timestr): + """Read time from a single string""" + components = ("yr", "d", "hr", "min", "s") + + if (match := self.re_ydhms.match(timestr)) is None: + raise ValueError( + f"Time delta '{timestr}' does not match {self.name} format" + ) + + tm = match.groupdict() + vals = [float(tm[component] or 0.0) for component in components] + if tm["sign"] == "-": + vals = [-val for val in vals] + + return vals + + def set_jds(self, val1, val2): + """Parse the time strings contained in val1 and get jd1, jd2.""" + # Be liberal in what we accept: convert bytes to ascii. + # Here .item() is needed for arrays with entries of unequal length, + # to strip trailing 0 bytes. + to_string = ( + str if val1.dtype.kind == "U" else lambda x: str(x.item(), encoding="ascii") + ) + iterator = np.nditer( + [val1, None, None, None, None, None], + flags=["zerosize_ok"], + op_dtypes=[None] + 5 * [np.double], + ) + for val, yr, day, hr, min, sec in iterator: + val = to_string(val) + ( + yr[...], + day[...], + hr[...], + min[...], + sec[...], + ) = self.parse_string(val) + + yrs, days, hrs, mins, secs = iterator.operands[1:] + + jd1 = yrs * 365.25 + days # Exact in the case that yrs and days are integer + jd2 = hrs / 24.0 + mins / 1440.0 + secs / 86400.0 # Inexact + self.jd1, self.jd2 = day_frac(jd1, jd2) + + def to_value(self, parent=None, out_subfmt=None): + out_subfmt = out_subfmt or self.out_subfmt + subfmt = self._get_allowed_subfmt(out_subfmt) + + iterator = np.nditer( + [self.jd1, self.jd2, None], + flags=["refs_ok", "zerosize_ok"], + op_dtypes=[None, None, object], + ) + + for jd1, jd2, out in iterator: + jd = jd1 + jd2 + if jd < 0: + jd1, jd2, jd = -jd1, -jd2, -jd # Flip all signs + sign = "-" + else: + sign = "" + + if subfmt in ["*", "multi"]: + comps = self.get_multi_comps(jd1, jd2) + + else: + value = (jd * u.day).to_value(subfmt) + value = np.round(value, self.precision) + comps = [f"{value}{subfmt}"] + + out[...] = sign + " ".join(comps) + + return self.mask_if_needed(np.array(iterator.operands[-1], dtype="U")) + + def get_multi_comps(self, jd1, jd2): + jd, remainder = two_sum(jd1, jd2) + days = int(np.floor(jd)) + jd -= days + jd += remainder + + hours = int(np.floor(jd * 24.0)) + jd -= hours / 24.0 + mins = int(np.floor(jd * 1440.0)) + jd -= mins / 1440.0 + secs = np.round(jd * 86400.0, self.precision) + + comp_vals = [days, hours, mins, secs] + if secs >= 60.0: + self.fix_comp_vals_overflow(comp_vals) + + comps = [ + f"{comp_val}{name}" + for comp_val, name in zip(comp_vals, ("d", "hr", "min", "s")) + if comp_val != 0 + ] + if not comps: + comps = ["0.0s"] + + return comps + + @staticmethod + def fix_comp_vals_overflow(comp_vals): + comp_maxes = (None, 24, 60, 60.0) + for ii in [3, 2, 1]: + comp_val = comp_vals[ii] + comp_max = comp_maxes[ii] + if comp_val >= comp_max: + comp_vals[ii] -= comp_max + comp_vals[ii - 1] += 1 + + @property + def value(self): + return self.to_value() + + def _validate_jd_for_storage(jd): if isinstance(jd, (float, int)): return np.array(jd, dtype=float) diff --git a/docs/changes/time/15264.api.rst b/docs/changes/time/15264.api.rst new file mode 100644 index 000000000000..657ec69d2956 --- /dev/null +++ b/docs/changes/time/15264.api.rst @@ -0,0 +1,4 @@ +Changed the ``TimeDelta`` init signature to be consistent with that of ``Time``. +Previously the argument order was ``val, val2, format, scale, copy``. Now the order is +``val, val2, format, scale, *, precision, in_subfmt, out_subfmt, copy``, where the +arguments after the ``*`` must be specified by keyword. diff --git a/docs/changes/time/15264.feature.rst b/docs/changes/time/15264.feature.rst new file mode 100644 index 000000000000..4f8b56fee977 --- /dev/null +++ b/docs/changes/time/15264.feature.rst @@ -0,0 +1,5 @@ +Added a ``TimeDelta`` format ``quantity_str`` that represents the time delta as a string +with one or more ``Quantity`` components. This format provides a human-readable +multi-scale string representation of a time delta. The default output sub-format is not +considered stable in this release, please see https://github.com/astropy/astropy/issues/15485 +for more information. diff --git a/docs/time/index.rst b/docs/time/index.rst index b2ba8cdb49ee..229592e8b8be 100644 --- a/docs/time/index.rst +++ b/docs/time/index.rst @@ -330,6 +330,7 @@ Format Subformats ================ ======================================== ``jd`` float, long, decimal, str, bytes ``sec`` float, long, decimal, str, bytes +``quantity_str`` multi, yr, d, hr, min, s ================ ======================================== Time from Epoch Formats @@ -1189,6 +1190,8 @@ To calculate sidereal time:: .. EXAMPLE END +.. _time-delta: + Time Deltas ----------- @@ -1212,13 +1215,14 @@ day is exactly 86400 seconds. Hence, the scale cannot be UTC. The available time formats are: -========= =================================================== -Format Class -========= =================================================== -sec :class:`~astropy.time.TimeDeltaSec` -jd :class:`~astropy.time.TimeDeltaJD` -datetime :class:`~astropy.time.TimeDeltaDatetime` -========= =================================================== +============ =================================================== +Format Class +============ =================================================== +sec :class:`~astropy.time.TimeDeltaSec` +jd :class:`~astropy.time.TimeDeltaJD` +datetime :class:`~astropy.time.TimeDeltaDatetime` +quantity_str :class:`~astropy.time.TimeDeltaQuantityString` +============ =================================================== Examples ^^^^^^^^ @@ -1257,11 +1261,25 @@ Use of the |TimeDelta| object is illustrated in the few examples below:: >>> t1 + 1 * u.hour <Time object: scale='utc' format='iso' value=2010-01-01 01:00:00.000> - # The now deprecated default assumes days for numeric inputs +A human-readable multi-scale format for string representation of a time delta is +available via the ``quantity_str`` format. See the +:class:`~astropy.time.TimeDeltaQuantityString` class docstring for more details:: + + >>> TimeDelta(40.1 * u.hr).quantity_str + '1d 16hr 6min' + >>> t4 = TimeDelta("-1yr 2d 23hr 10min 5.6s") + >>> print(t4) + -368d 5hr 10min 5.6s + >>> t4.to_value(subfmt="d") + '-368.215d' + +The now deprecated default assumes days for numeric inputs:: + >>> t1 + 5.0 # doctest: +SHOW_WARNINGS +ELLIPSIS <Time object: scale='utc' format='iso' value=2010-01-06 00:00:00.000> TimeDeltaMissingUnitWarning: Numerical value without unit or explicit format passed to TimeDelta, assuming days + The |TimeDelta| has a `~astropy.time.TimeDelta.to_value` method which supports controlling the type of the output representation by providing either a format name and optional `subformat`_ or a valid ``astropy`` unit:: diff --git a/docs/whatsnew/6.0.rst b/docs/whatsnew/6.0.rst index a0ef90e8e46d..10b5fec7537b 100644 --- a/docs/whatsnew/6.0.rst +++ b/docs/whatsnew/6.0.rst @@ -18,6 +18,7 @@ In particular, this release includes: * :ref:`whatsnew-6.0-cosmology-latex-export` * :ref:`whatsnew-6.0-iers-data` * :ref:`whatsnew-6.0-model-annotation-in-votable` +* :ref:`whatsnew-6.0-time-delta-quantity-str` * :ref:`whatsnew-6.0-votable-parquet-serialization` In addition to these major changes, Astropy v6.0 includes a large number of @@ -254,6 +255,43 @@ There is no function processing data models, they will be delegated to affiliate See :ref:`votable_mivot` for more details. +.. _whatsnew-6.0-time-delta-quantity-str: + +TimeDelta string format "quantity_str" +====================================== + +A new :ref:`TimeDelta<time-delta>` format ``"quantity_str"`` is now available that +represents the time delta as a string with one or more Quantity components. This format +provides a human-readable multi-scale string representation of a time delta. It is +convenient for applications like a configuration file or a command line option. + +.. Warning:: The default output format is not yet finalized and may change in version + 6.1 of astropy. The input format is stable. Please see + `issue 15485 <https://github.com/astropy/astropy/issues/15485>`_ for more details. + +The format is a string with one or more time Quantity components separated by optional +whitespace, for example ``"1yr 2d 3hr 4min 5.6s"``. In more detail: + +- The string is a sequence of one or more components. +- Each component is a number followed by an astropy unit of time. +- For input, whitespace within the string is allowed but optional. +- For output, there is a single space between components. +- The order (yr, d, hr, min, s) is fixed but individual components are optional. + +The allowed component units are shown below and correspond to scaling relations +defined by the astropy units: + +- "yr": years (365.25 days) +- "d": days (24 hours) +- "hr": hours (60 minutes) +- "min": minutes (60 seconds) +- "s": seconds + +.. Note:: These definitions correspond to physical units of time and are NOT + calendar date intervals. Thus adding "1yr" to "2000-01-01 00:00:00" will give + "2000-12-31 06:00:00" instead of "2001-01-01 00:00:00". + +See :class:`~astropy.time.formats.TimeDeltaQuantityString` for more details. .. _whatsnew-6.0-votable-parquet-serialization:

diff --git a/astropy/time/tests/test_basic.py b/astropy/time/tests/test_basic.py index 39edda889eda..b526aa3ed576 100644 --- a/astropy/time/tests/test_basic.py +++ b/astropy/time/tests/test_basic.py @@ -2361,9 +2361,10 @@ def test_hash_time_delta(): def test_get_time_fmt_exception_messages(): - with pytest.raises(ValueError) as err: + with pytest.raises( + ValueError, match=r"Input values did not match any of the formats" + ): Time(10) - assert "No time format was given, and the input is" in str(err.value) with pytest.raises(ValueError) as err: Time("2000:001", format="not-a-format") @@ -2788,3 +2789,8 @@ def test_to_string(): exp_repr = f"<Time object: scale='utc' format='iso' value={exp_str}>" assert out_repr == exp_repr + + +def test_format_typeerror(): + with pytest.raises(TypeError, match="format must be a string"): + Time("2020-01-01", format=1) diff --git a/astropy/time/tests/test_delta.py b/astropy/time/tests/test_delta.py index e4e85b47c448..2b9332426b18 100644 --- a/astropy/time/tests/test_delta.py +++ b/astropy/time/tests/test_delta.py @@ -685,3 +685,161 @@ def test_no_units_warning(): # table column with units table = Table({"t": [1, 2, 3] * u.s}) assert np.all(TimeDelta(table["t"]).to_value(u.s) == [1, 2, 3]) + + +quantity_str_basic_cases = [ + # Simple seconds (seconds always have a decimal point) + ("1s", "1.0s", 1.0), + # Simple minutes + ("1min", "1min", 60.0), + # Float hours + ("2.5hr", "2hr 30min", 2.5 * 3600), + # Variations on single input component with exponent to multiple output components + ("3.000001e7s", "347d 5hr 20min 10.0s", 30000010.0), + ("3.e7s", "347d 5hr 20min", 30000000.0), + ("3e7s", "347d 5hr 20min", 30000000.0), + # High precision seconds + ("1.0123456789012345s", "1.012s", 1.0123456789012345), + # High precision seconds, random/missing white space and a longer time interval + (" 100.0 d1.0123456789012345 s ", "100d 1.012s", 100 * 86400 + 1.0123456789012345), + # All possible components + ( + "2yr 3d 4hr 5min 6.789s", + "733d 16hr 5min 6.789s", + 2 * 365.25 * 86400 + 3 * 86400 + 4 * 3600 + 5 * 60 + 6.789, + ), + # Float values in components get normalized + ( + "2.5yr 3.5d 4.5hr 5.5min 6.789s", + "916d 19hr 35min 36.789s", + 2.5 * 365.25 * 86400 + 3.5 * 86400 + 4.5 * 3600 + 5.5 * 60 + 6.789, + ), +] + + +@pytest.mark.parametrize("sign", ["", "+", "-"]) +@pytest.mark.parametrize("in_str, out_val, dt_sec", quantity_str_basic_cases) +def test_quantity_str_basic(sign, in_str, out_val, dt_sec): + dt = TimeDelta(sign + in_str) + minus = sign == "-" + out_sign = "-" if minus else "" + out_mult = -1 if minus else 1 + assert dt.value == out_sign + out_val + assert allclose_sec(dt.sec, out_mult * dt_sec) + + +def test_quantity_str_precision(): + dt = TimeDelta("100.0d 1.0123456789012345s", precision=9) + assert dt.value == "100d 1.012345679s" + + dt = TimeDelta("21.123456789012345s") + assert dt.value == "21.123s" + + dt.precision = -1 + assert dt.value == "20.0s" + + dt.precision = 12 + assert dt.value == "21.123456789012s" + + with pytest.raises( + ValueError, match="precision attribute must be an int between -99 and 99" + ): + dt.precision = 100 + + +quantity_str_invalid_cases = [ + "", + " ", + "+", + " - ", + "1.0", + "1.0s 2.0s", + "1.0s 2.0", + "1.0s 2min", + "++1.0s", + "2min +1s", + "2d -1s", + "1sec", +] + + +@pytest.mark.parametrize("in_str", quantity_str_invalid_cases) +def test_quantity_str_invalid(in_str): + match = "Input values did not match the format class quantity_str" + with pytest.raises(ValueError, match=match): + TimeDelta(in_str, format="quantity_str") + + +quantity_str_subfmt_exps = { + "multi": "347d 5hr 20min 10.0s", + "yr": "0.951yr", + "d": "347.222d", + "hr": "8333.336hr", + "min": "500000.167min", + "s": "30000010.0s", +} + + +def test_quantity_str_out_subfmt(): + for subfmt, exp in quantity_str_subfmt_exps.items(): + dt = TimeDelta("30000010s", out_subfmt=subfmt) + assert dt.value == exp + + +def test_quantity_str_out_subfmt_precision(): + dt = TimeDelta("100.0d 1.0123456789012345s", precision=9, out_subfmt="d") + assert dt.value == "100.000011717d" + + +def test_quantity_str_out_subfmt_to_value_subfmt(): + dt = TimeDelta("30000010s") + for subfmt, exp in quantity_str_subfmt_exps.items(): + assert dt.to_value(subfmt=subfmt) == exp + + +def test_quantity_str_out_subfmt_from_non_quantity_str(): + dt = TimeDelta(30000010.0 * u.s) + for subfmt, exp in quantity_str_subfmt_exps.items(): + assert dt.to_value(format="quantity_str", subfmt=subfmt) == exp + + +def test_quantity_str_internal_precision(): + dt = TimeDelta("100000000d 1.0123456789012345s") + assert dt.jd1 == 100000000 + assert allclose_sec(dt.jd2 * 86400, 1.0123456789012345) + + +def test_time_delta_to_value_validation_error(): + with pytest.raises( + TypeError, + match=r"TimeDelta.to_value got an unexpected keyword argument 'junk'", + ): + TimeDelta(1, format="sec").to_value(junk=1) + + +def test_quantity_str_val_type_error(): + with pytest.raises(ValueError, match="quantity_str objects do not accept"): + TimeDelta("1s", "2s") + + +def test_quantity_str_zero_value(): + dt = TimeDelta("0d") + assert dt.value == "0.0s" + assert dt._time.value == "0.0s" # get coverage of _time.value property + + +def test_quantity_str_multi_comps_overflow(): + # Default precision=3 rounds seconds to 60.0s which triggers the overflow + dt = TimeDelta("1d 23hr 59min 59.9999s") + assert dt.value == "2d" + dt.precision = 9 + assert dt.value == "1d 23hr 59min 59.9999s" + + dt = TimeDelta("1d 23hr 58min 59.9999s") + assert dt.value == "1d 23hr 59min" + + # Not actually an overflow case, but good to check + dt = TimeDelta("1d 23hr 59min 60.0001s") + assert dt.value == "2d" + dt.precision = 9 + assert dt.value == "2d 0.0001s" diff --git a/astropy/time/tests/test_quantity_interaction.py b/astropy/time/tests/test_quantity_interaction.py index 52dda8cfa760..4e84898bf005 100644 --- a/astropy/time/tests/test_quantity_interaction.py +++ b/astropy/time/tests/test_quantity_interaction.py @@ -151,8 +151,10 @@ def test_quantity_output_errors(self): dt.to_value("parrot") with pytest.raises(TypeError): dt.to_value("sec", unit=u.s) - with pytest.raises(TypeError): - # TODO: would be nice to make this work! + with pytest.raises( + ValueError, + match=r"cannot specify 'subfmt' and positional arg.*not a valid format", + ): dt.to_value(u.s, subfmt="str") def test_valid_quantity_operations1(self):

diff --git a/docs/changes/time/15264.api.rst b/docs/changes/time/15264.api.rst new file mode 100644 index 000000000000..657ec69d2956 --- /dev/null +++ b/docs/changes/time/15264.api.rst @@ -0,0 +1,4 @@ +Changed the ``TimeDelta`` init signature to be consistent with that of ``Time``. +Previously the argument order was ``val, val2, format, scale, copy``. Now the order is +``val, val2, format, scale, *, precision, in_subfmt, out_subfmt, copy``, where the +arguments after the ``*`` must be specified by keyword. diff --git a/docs/changes/time/15264.feature.rst b/docs/changes/time/15264.feature.rst new file mode 100644 index 000000000000..4f8b56fee977 --- /dev/null +++ b/docs/changes/time/15264.feature.rst @@ -0,0 +1,5 @@ +Added a ``TimeDelta`` format ``quantity_str`` that represents the time delta as a string +with one or more ``Quantity`` components. This format provides a human-readable +multi-scale string representation of a time delta. The default output sub-format is not +considered stable in this release, please see https://github.com/astropy/astropy/issues/15485 +for more information. diff --git a/docs/time/index.rst b/docs/time/index.rst index b2ba8cdb49ee..229592e8b8be 100644 --- a/docs/time/index.rst +++ b/docs/time/index.rst @@ -330,6 +330,7 @@ Format Subformats ================ ======================================== ``jd`` float, long, decimal, str, bytes ``sec`` float, long, decimal, str, bytes +``quantity_str`` multi, yr, d, hr, min, s ================ ======================================== Time from Epoch Formats @@ -1189,6 +1190,8 @@ To calculate sidereal time:: .. EXAMPLE END +.. _time-delta: + Time Deltas ----------- @@ -1212,13 +1215,14 @@ day is exactly 86400 seconds. Hence, the scale cannot be UTC. The available time formats are: -========= =================================================== -Format Class -========= =================================================== -sec :class:`~astropy.time.TimeDeltaSec` -jd :class:`~astropy.time.TimeDeltaJD` -datetime :class:`~astropy.time.TimeDeltaDatetime` -========= =================================================== +============ =================================================== +Format Class +============ =================================================== +sec :class:`~astropy.time.TimeDeltaSec` +jd :class:`~astropy.time.TimeDeltaJD` +datetime :class:`~astropy.time.TimeDeltaDatetime` +quantity_str :class:`~astropy.time.TimeDeltaQuantityString` +============ =================================================== Examples ^^^^^^^^ @@ -1257,11 +1261,25 @@ Use of the |TimeDelta| object is illustrated in the few examples below:: >>> t1 + 1 * u.hour <Time object: scale='utc' format='iso' value=2010-01-01 01:00:00.000> - # The now deprecated default assumes days for numeric inputs +A human-readable multi-scale format for string representation of a time delta is +available via the ``quantity_str`` format. See the +:class:`~astropy.time.TimeDeltaQuantityString` class docstring for more details:: + + >>> TimeDelta(40.1 * u.hr).quantity_str + '1d 16hr 6min' + >>> t4 = TimeDelta("-1yr 2d 23hr 10min 5.6s") + >>> print(t4) + -368d 5hr 10min 5.6s + >>> t4.to_value(subfmt="d") + '-368.215d' + +The now deprecated default assumes days for numeric inputs:: + >>> t1 + 5.0 # doctest: +SHOW_WARNINGS +ELLIPSIS <Time object: scale='utc' format='iso' value=2010-01-06 00:00:00.000> TimeDeltaMissingUnitWarning: Numerical value without unit or explicit format passed to TimeDelta, assuming days + The |TimeDelta| has a `~astropy.time.TimeDelta.to_value` method which supports controlling the type of the output representation by providing either a format name and optional `subformat`_ or a valid ``astropy`` unit:: diff --git a/docs/whatsnew/6.0.rst b/docs/whatsnew/6.0.rst index a0ef90e8e46d..10b5fec7537b 100644 --- a/docs/whatsnew/6.0.rst +++ b/docs/whatsnew/6.0.rst @@ -18,6 +18,7 @@ In particular, this release includes: * :ref:`whatsnew-6.0-cosmology-latex-export` * :ref:`whatsnew-6.0-iers-data` * :ref:`whatsnew-6.0-model-annotation-in-votable` +* :ref:`whatsnew-6.0-time-delta-quantity-str` * :ref:`whatsnew-6.0-votable-parquet-serialization` In addition to these major changes, Astropy v6.0 includes a large number of @@ -254,6 +255,43 @@ There is no function processing data models, they will be delegated to affiliate See :ref:`votable_mivot` for more details. +.. _whatsnew-6.0-time-delta-quantity-str: + +TimeDelta string format "quantity_str" +====================================== + +A new :ref:`TimeDelta<time-delta>` format ``"quantity_str"`` is now available that +represents the time delta as a string with one or more Quantity components. This format +provides a human-readable multi-scale string representation of a time delta. It is +convenient for applications like a configuration file or a command line option. + +.. Warning:: The default output format is not yet finalized and may change in version + 6.1 of astropy. The input format is stable. Please see + `issue 15485 <https://github.com/astropy/astropy/issues/15485>`_ for more details. + +The format is a string with one or more time Quantity components separated by optional +whitespace, for example ``"1yr 2d 3hr 4min 5.6s"``. In more detail: + +- The string is a sequence of one or more components. +- Each component is a number followed by an astropy unit of time. +- For input, whitespace within the string is allowed but optional. +- For output, there is a single space between components. +- The order (yr, d, hr, min, s) is fixed but individual components are optional. + +The allowed component units are shown below and correspond to scaling relations +defined by the astropy units: + +- "yr": years (365.25 days) +- "d": days (24 hours) +- "hr": hours (60 minutes) +- "min": minutes (60 seconds) +- "s": seconds + +.. Note:: These definitions correspond to physical units of time and are NOT + calendar date intervals. Thus adding "1yr" to "2000-01-01 00:00:00" will give + "2000-12-31 06:00:00" instead of "2001-01-01 00:00:00". + +See :class:`~astropy.time.formats.TimeDeltaQuantityString` for more details. .. _whatsnew-6.0-votable-parquet-serialization:

[ { "components": [ { "doc": "", "lines": [ 2830, 2839 ], "name": "TimeDelta._check_numeric_no_unit", "signature": "def _check_numeric_no_unit(self, val, format):", "type": "function" } ], "file": "astropy/time/core.py" }, ...

[ "astropy/time/tests/test_basic.py::test_get_time_fmt_exception_messages", "astropy/time/tests/test_basic.py::test_format_typeerror", "astropy/time/tests/test_delta.py::test_quantity_str_basic[1s-1.0s-1.0-]", "astropy/time/tests/test_delta.py::test_quantity_str_basic[1s-1.0s-1.0-+]", "astropy/time/tests/test...

[ "astropy/time/tests/test_basic.py::TestBasic::test_simple", "astropy/time/tests/test_basic.py::TestBasic::test_different_dimensions", "astropy/time/tests/test_basic.py::TestBasic::test_empty_value[jd]", "astropy/time/tests/test_basic.py::TestBasic::test_empty_value[mjd]", "astropy/time/tests/test_basic.py::...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add TimeDelta format `quantity_str` for Year Day Hour Minute Sec string      ### Description    This pull request adds a new string `TimeDelta` format `"quantity_str"` that represents the time delta as a string with one or more Quantity components. This format provides a human-readable multi-scale string representation of a time delta. It is convenient for applications like a configuration file or a command line option. It is NOT intended for high-precision applications since the internal calculations are done using 64-bit floating point numbers. The driver for this is that it can be convenient to have a human-readable string representing a time delta which has natural scales so that delta from seconds to years are manageable. A string representation is useful in configuration files and application command line inputs. This PR defines a new format which is like `"[-+]? 1yr 2d 3hr 4min 5.6s"`. The format is specified as follows: - The string is a sequence of one or more components. - Each component is a number (float or int) followed by an astropy unit of time. - For input, whitespace within the string is allowed but optional. - For output, there is a single space between components. - The allowed components are listed below. - The order (yr, d, hr, min, s) is fixed but individual components are optional. The allowed component units are shown below: - "yr": years (365.25 days) - "d": days (24 hours) - "hr": hours (60 minutes) - "min": minutes (60 seconds) - "s": seconds These definitions correspond to physical units of time and are NOT calendar date intervals. Thus adding "1yr" to "2000-01-01 00:00:00" will give "2000-12-31 06:00:00" instead of "2001-01-01 00:00:00". The format is defined internally as a single regular expression that could be used in other non-Python implementations for parsing. #### Output subformats The `quantity_str` format supports output sub-formats `"multi", "yr", "d", "hr", "min", "s"` to allow specifying the string output as a single unit or in the default multi-unit format. The `precision` attribute (default=3) applies to the specified subformat. For example `TimeDelta("100.0d 1.0123456789012345s", precision=9, out_subfmt="d").value` is `"100.000011717d"`. #### Why not re-use an existing standard? The only other existing standard that I am aware of for time intervals is defined in [ISO 8601 durations](https://en.wikipedia.org/wiki/ISO_8601#Durations) that represent the duration between two dates. The ISO 8601 duration format is: P(n)Y(n)M(n)DT(n)H(n)M(n)S. The fundamental problem with this format is that it explicitly depends on the reference start date as a calendar date in Year Month day hour min sec. So this is not suitable for physical time deltas that are independent of the reference date.   - [ ] By checking this box, the PR author has requested that maintainers do **NOT** use the "Squash and Merge" button. Maintainers should respect this when possible; however, the final decision is at the discretion of the maintainer that merges the PR. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in astropy/time/core.py] (definition of TimeDelta._check_numeric_no_unit:) def _check_numeric_no_unit(self, val, format): [end of new definitions in astropy/time/core.py] [start of new definitions in astropy/time/formats.py] (definition of TimeDeltaQuantityString:) class TimeDeltaQuantityString(TimeDeltaFormat, TimeUnique): """Time delta as a string with one or more Quantity components. This format provides a human-readable multi-scale string representation of a time delta. It is convenient for applications like a configuration file or a command line option. The format is specified as follows: - The string is a sequence of one or more components. - Each component is a number followed by an astropy unit of time. - For input, whitespace within the string is allowed but optional. - For output, there is a single space between components. - The allowed components are listed below. - The order (yr, d, hr, min, s) is fixed but individual components are optional. The allowed input component units are shown below: - "yr": years (365.25 days) - "d": days (24 hours) - "hr": hours (60 minutes) - "min": minutes (60 seconds) - "s": seconds .. Note:: These definitions correspond to physical units of time and are NOT calendar date intervals. Thus adding "1yr" to "2000-01-01 00:00:00" will give "2000-12-31 06:00:00" instead of "2001-01-01 00:00:00". The ``out_subfmt`` attribute specifies the components to be included in the string output. The default is ``"multi"`` which represents the time delta as ``"<days>d <hours>hr <minutes>min <seconds>s"``, where only non-zero components are included. - "multi": multiple components, e.g. "2d 3hr 15min 5.6s" - "yr": years - "d": days - "hr": hours - "min": minutes - "s": seconds Examples -------- >>> from astropy.time import Time, TimeDelta >>> import astropy.units as u >>> print(TimeDelta("1yr")) 365d 6hr >>> print(Time("2000-01-01") + TimeDelta("1yr")) 2000-12-31 06:00:00.000 >>> print(TimeDelta("+3.6d")) 3d 14hr 24min >>> print(TimeDelta("-3.6d")) -3d 14hr 24min >>> print(TimeDelta("1yr 3.6d", out_subfmt="d")) 368.85d >>> td = TimeDelta(40 * u.hr) >>> print(td.to_value(format="quantity_str")) 1d 16hr >>> print(td.to_value(format="quantity_str", subfmt="d")) 1.667d >>> td.precision = 9 >>> print(td.to_value(format="quantity_str", subfmt="d")) 1.666666667d""" (definition of TimeDeltaQuantityString._check_val_type:) def _check_val_type(self, val1, val2): (definition of TimeDeltaQuantityString.parse_string:) def parse_string(self, timestr): """Read time from a single string""" (definition of TimeDeltaQuantityString.set_jds:) def set_jds(self, val1, val2): """Parse the time strings contained in val1 and get jd1, jd2.""" (definition of TimeDeltaQuantityString.to_value:) def to_value(self, parent=None, out_subfmt=None): (definition of TimeDeltaQuantityString.get_multi_comps:) def get_multi_comps(self, jd1, jd2): (definition of TimeDeltaQuantityString.fix_comp_vals_overflow:) def fix_comp_vals_overflow(comp_vals): (definition of TimeDeltaQuantityString.value:) def value(self): [end of new definitions in astropy/time/formats.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

32bd0ffb6898c6a57b9ec1a55c13c7a0efe8d273

tobymao__sqlglot-2105

2,105

tobymao/sqlglot

null

bda94dfebc169c1a8bb07330d3d0c8997fabcf17

2023-08-23T00:38:05Z

diff --git a/sqlglot/dataframe/README.md b/sqlglot/dataframe/README.md index 86fdc4b045..adde9a1dfe 100644 --- a/sqlglot/dataframe/README.md +++ b/sqlglot/dataframe/README.md @@ -21,10 +21,12 @@ Currently many of the common operations are covered and more functionality will * Ex: `['cola', 'colb']` * The lack of types may limit functionality in future releases. * See [Registering Custom Schema](#registering-custom-schema-class) for information on how to skip this step if the information is stored externally. +* If your output SQL dialect is not Spark, then configure the SparkSession to use that dialect + * Ex: `SparkSession().builder.config("sqlframe.dialect", "bigquery").getOrCreate()` + * See [dialects](https://github.com/tobymao/sqlglot/tree/main/sqlglot/dialects) for a full list of dialects. * Add `.sql(pretty=True)` to your final DataFrame command to return a list of sql statements to run that command. - * In most cases a single SQL statement is returned. Currently the only exception is when caching DataFrames which isn't supported in other dialects. - * Spark is the default output dialect. See [dialects](https://github.com/tobymao/sqlglot/tree/main/sqlglot/dialects) for a full list of dialects. - * Ex: `.sql(pretty=True, dialect='bigquery')` + * In most cases a single SQL statement is returned. Currently the only exception is when caching DataFrames which isn't supported in other dialects. + * Ex: `.sql(pretty=True)` ## Examples @@ -33,6 +35,8 @@ import sqlglot from sqlglot.dataframe.sql.session import SparkSession from sqlglot.dataframe.sql import functions as F +dialect = "spark" + sqlglot.schema.add_table( 'employee', { @@ -41,10 +45,10 @@ sqlglot.schema.add_table( 'lname': 'STRING', 'age': 'INT', }, - dialect="spark", + dialect=dialect, ) # Register the table structure prior to reading from the table -spark = SparkSession() +spark = SparkSession.builder.config("sqlframe.dialect", dialect).getOrCreate() df = ( spark @@ -53,7 +57,7 @@ df = ( .agg(F.countDistinct(F.col("employee_id")).alias("num_employees")) ) -print(df.sql(pretty=True)) # Spark will be the dialect used by default +print(df.sql(pretty=True)) ``` ```sparksql @@ -81,7 +85,7 @@ class ExternalSchema(Schema): sqlglot.schema = ExternalSchema() -spark = SparkSession() +spark = SparkSession() # Spark will be used by default is not specific in SparkSession config df = ( spark @@ -119,11 +123,14 @@ schema = types.StructType([ ]) sql_statements = ( - SparkSession() + SparkSession + .builder + .config("sqlframe.dialect", "bigquery") + .getOrCreate() .createDataFrame(data, schema) .groupBy(F.col("age")) .agg(F.countDistinct(F.col("employee_id")).alias("num_employees")) - .sql(dialect="bigquery") + .sql() ) result = None @@ -166,11 +173,14 @@ schema = types.StructType([ ]) sql_statements = ( - SparkSession() + SparkSession + .builder + .config("sqlframe.dialect", "snowflake") + .getOrCreate() .createDataFrame(data, schema) .groupBy(F.col("age")) .agg(F.countDistinct(F.col("lname")).alias("num_employees")) - .sql(dialect="snowflake") + .sql() ) try: @@ -210,7 +220,7 @@ sql_statements = ( .createDataFrame(data, schema) .groupBy(F.col("age")) .agg(F.countDistinct(F.col("employee_id")).alias("num_employees")) - .sql(dialect="spark") + .sql() ) pyspark = PySparkSession.builder.master("local[*]").getOrCreate() diff --git a/sqlglot/dataframe/sql/column.py b/sqlglot/dataframe/sql/column.py index fcfd71e9a0..3acf494c2a 100644 --- a/sqlglot/dataframe/sql/column.py +++ b/sqlglot/dataframe/sql/column.py @@ -5,7 +5,6 @@ import sqlglot from sqlglot import expressions as exp from sqlglot.dataframe.sql.types import DataType -from sqlglot.dialects import Spark from sqlglot.helper import flatten, is_iterable if t.TYPE_CHECKING: @@ -15,19 +14,20 @@ class Column: def __init__(self, expression: t.Optional[t.Union[ColumnOrLiteral, exp.Expression]]): + from sqlglot.dataframe.sql.session import SparkSession + if isinstance(expression, Column): expression = expression.expression # type: ignore elif expression is None or not isinstance(expression, (str, exp.Expression)): expression = self._lit(expression).expression # type: ignore - - expression = sqlglot.maybe_parse(expression, dialect="spark") + elif not isinstance(expression, exp.Column): + expression = sqlglot.maybe_parse(expression, dialect=SparkSession().dialect).transform( + SparkSession().dialect.normalize_identifier, copy=False + ) if expression is None: raise ValueError(f"Could not parse {expression}") - if isinstance(expression, exp.Column): - expression.transform(Spark.normalize_identifier, copy=False) - - self.expression: exp.Expression = expression + self.expression: exp.Expression = expression # type: ignore def __repr__(self): return repr(self.expression) @@ -207,7 +207,9 @@ def set_table_name(self, table_name: str, copy=False) -> Column: return Column(expression) def sql(self, **kwargs) -> str: - return self.expression.sql(**{"dialect": "spark", **kwargs}) + from sqlglot.dataframe.sql.session import SparkSession + + return self.expression.sql(**{"dialect": SparkSession().dialect, **kwargs}) def alias(self, name: str) -> Column: new_expression = exp.alias_(self.column_expression, name) @@ -264,9 +266,11 @@ def cast(self, dataType: t.Union[str, DataType]) -> Column: Functionality Difference: PySpark cast accepts a datatype instance of the datatype class Sqlglot doesn't currently replicate this class so it only accepts a string """ + from sqlglot.dataframe.sql.session import SparkSession + if isinstance(dataType, DataType): dataType = dataType.simpleString() - return Column(exp.cast(self.column_expression, dataType, dialect="spark")) + return Column(exp.cast(self.column_expression, dataType, dialect=SparkSession().dialect)) def startswith(self, value: t.Union[str, Column]) -> Column: value = self._lit(value) if not isinstance(value, Column) else value diff --git a/sqlglot/dataframe/sql/dataframe.py b/sqlglot/dataframe/sql/dataframe.py index 64cceeac02..f51560820a 100644 --- a/sqlglot/dataframe/sql/dataframe.py +++ b/sqlglot/dataframe/sql/dataframe.py @@ -1,12 +1,13 @@ from __future__ import annotations import functools +import logging import typing as t import zlib from copy import copy import sqlglot -from sqlglot import expressions as exp +from sqlglot import Dialect, expressions as exp from sqlglot.dataframe.sql import functions as F from sqlglot.dataframe.sql.column import Column from sqlglot.dataframe.sql.group import GroupedData @@ -18,6 +19,7 @@ from sqlglot.dataframe.sql.window import Window from sqlglot.helper import ensure_list, object_to_dict, seq_get from sqlglot.optimizer import optimize as optimize_func +from sqlglot.optimizer.qualify_columns import quote_identifiers if t.TYPE_CHECKING: from sqlglot.dataframe.sql._typing import ( @@ -27,7 +29,9 @@ OutputExpressionContainer, ) from sqlglot.dataframe.sql.session import SparkSession + from sqlglot.dialects.dialect import DialectType +logger = logging.getLogger("sqlglot") JOIN_HINTS = { "BROADCAST", @@ -264,7 +268,9 @@ def _get_outer_select_columns(cls, item: t.Union[exp.Expression, DataFrame]) -> @classmethod def _create_hash_from_expression(cls, expression: exp.Expression) -> str: - value = expression.sql(dialect="spark").encode("utf-8") + from sqlglot.dataframe.sql.session import SparkSession + + value = expression.sql(dialect=SparkSession().dialect).encode("utf-8") return f"t{zlib.crc32(value)}"[:6] def _get_select_expressions( @@ -291,7 +297,15 @@ def _get_select_expressions( select_expressions.append(expression_select_pair) # type: ignore return select_expressions - def sql(self, dialect="spark", optimize=True, **kwargs) -> t.List[str]: + def sql( + self, dialect: t.Optional[DialectType] = None, optimize: bool = True, **kwargs + ) -> t.List[str]: + from sqlglot.dataframe.sql.session import SparkSession + + if dialect and Dialect.get_or_raise(dialect)() != SparkSession().dialect: + logger.warning( + f"The recommended way of defining a dialect is by doing `SparkSession.builder.config('sqlframe.dialect', '{dialect}').getOrCreate()`. It is no longer needed then when calling `sql`. If you run into issues try updating your query to use this pattern." + ) df = self._resolve_pending_hints() select_expressions = df._get_select_expressions() output_expressions: t.List[t.Union[exp.Select, exp.Cache, exp.Drop]] = [] @@ -299,7 +313,10 @@ def sql(self, dialect="spark", optimize=True, **kwargs) -> t.List[str]: for expression_type, select_expression in select_expressions: select_expression = select_expression.transform(replace_id_value, replacement_mapping) if optimize: - select_expression = t.cast(exp.Select, optimize_func(select_expression)) + quote_identifiers(select_expression) + select_expression = t.cast( + exp.Select, optimize_func(select_expression, dialect=SparkSession().dialect) + ) select_expression = df._replace_cte_names_with_hashes(select_expression) expression: t.Union[exp.Select, exp.Cache, exp.Drop] if expression_type == exp.Cache: @@ -313,10 +330,12 @@ def sql(self, dialect="spark", optimize=True, **kwargs) -> t.List[str]: sqlglot.schema.add_table( cache_table_name, { - expression.alias_or_name: expression.type.sql("spark") + expression.alias_or_name: expression.type.sql( + dialect=SparkSession().dialect + ) for expression in select_expression.expressions }, - dialect="spark", + dialect=SparkSession().dialect, ) cache_storage_level = select_expression.args["cache_storage_level"] options = [ @@ -345,7 +364,8 @@ def sql(self, dialect="spark", optimize=True, **kwargs) -> t.List[str]: output_expressions.append(expression) return [ - expression.sql(**{"dialect": dialect, **kwargs}) for expression in output_expressions + expression.sql(**{"dialect": SparkSession().dialect, **kwargs}) + for expression in output_expressions ] def copy(self, **kwargs) -> DataFrame: diff --git a/sqlglot/dataframe/sql/normalize.py b/sqlglot/dataframe/sql/normalize.py index 4eec782429..f68bacb2f6 100644 --- a/sqlglot/dataframe/sql/normalize.py +++ b/sqlglot/dataframe/sql/normalize.py @@ -5,7 +5,6 @@ from sqlglot import expressions as exp from sqlglot.dataframe.sql.column import Column from sqlglot.dataframe.sql.util import get_tables_from_expression_with_join -from sqlglot.dialects import Spark from sqlglot.helper import ensure_list NORMALIZE_INPUT = t.TypeVar("NORMALIZE_INPUT", bound=t.Union[str, exp.Expression, Column]) @@ -20,7 +19,7 @@ def normalize(spark: SparkSession, expression_context: exp.Select, expr: t.List[ for expression in expressions: identifiers = expression.find_all(exp.Identifier) for identifier in identifiers: - Spark.normalize_identifier(identifier) + identifier.transform(spark.dialect.normalize_identifier) replace_alias_name_with_cte_name(spark, expression_context, identifier) replace_branch_and_sequence_ids_with_cte_name(spark, expression_context, identifier) diff --git a/sqlglot/dataframe/sql/readwriter.py b/sqlglot/dataframe/sql/readwriter.py index 9d87d4a785..080448622b 100644 --- a/sqlglot/dataframe/sql/readwriter.py +++ b/sqlglot/dataframe/sql/readwriter.py @@ -4,7 +4,6 @@ import sqlglot from sqlglot import expressions as exp -from sqlglot.dialects import Spark from sqlglot.helper import object_to_dict if t.TYPE_CHECKING: @@ -18,15 +17,25 @@ def __init__(self, spark: SparkSession): def table(self, tableName: str) -> DataFrame: from sqlglot.dataframe.sql.dataframe import DataFrame + from sqlglot.dataframe.sql.session import SparkSession - sqlglot.schema.add_table(tableName, dialect="spark") + sqlglot.schema.add_table(tableName, dialect=SparkSession().dialect) return DataFrame( self.spark, exp.Select() - .from_(exp.to_table(tableName, dialect="spark").transform(Spark.normalize_identifier)) + .from_( + exp.to_table(tableName, dialect=SparkSession().dialect).transform( + SparkSession().dialect.normalize_identifier + ) + ) .select( - *(column for column in sqlglot.schema.column_names(tableName, dialect="spark")) + *( + column + for column in sqlglot.schema.column_names( + tableName, dialect=SparkSession().dialect + ) + ) ), ) @@ -63,6 +72,8 @@ def byName(self): return self.copy(by_name=True) def insertInto(self, tableName: str, overwrite: t.Optional[bool] = None) -> DataFrameWriter: + from sqlglot.dataframe.sql.session import SparkSession + output_expression_container = exp.Insert( **{ "this": exp.to_table(tableName), @@ -71,7 +82,9 @@ def insertInto(self, tableName: str, overwrite: t.Optional[bool] = None) -> Data ) df = self._df.copy(output_expression_container=output_expression_container) if self._by_name: - columns = sqlglot.schema.column_names(tableName, only_visible=True, dialect="spark") + columns = sqlglot.schema.column_names( + tableName, only_visible=True, dialect=SparkSession().dialect + ) df = df._convert_leaf_to_cte().select(*columns) return self.copy(_df=df) diff --git a/sqlglot/dataframe/sql/session.py b/sqlglot/dataframe/sql/session.py index b883359e49..531ee1728b 100644 --- a/sqlglot/dataframe/sql/session.py +++ b/sqlglot/dataframe/sql/session.py @@ -5,31 +5,35 @@ from collections import defaultdict import sqlglot -from sqlglot import expressions as exp +from sqlglot import Dialect, expressions as exp from sqlglot.dataframe.sql import functions as F from sqlglot.dataframe.sql.dataframe import DataFrame from sqlglot.dataframe.sql.readwriter import DataFrameReader from sqlglot.dataframe.sql.types import StructType from sqlglot.dataframe.sql.util import get_column_mapping_from_schema_input +from sqlglot.helper import classproperty if t.TYPE_CHECKING: from sqlglot.dataframe.sql._typing import ColumnLiterals, SchemaInput class SparkSession: - known_ids: t.ClassVar[t.Set[str]] = set() - known_branch_ids: t.ClassVar[t.Set[str]] = set() - known_sequence_ids: t.ClassVar[t.Set[str]] = set() - name_to_sequence_id_mapping: t.ClassVar[t.Dict[str, t.List[str]]] = defaultdict(list) + DEFAULT_DIALECT = "spark" + _instance = None def __init__(self): - self.incrementing_id = 1 - - def __getattr__(self, name: str) -> SparkSession: - return self - - def __call__(self, *args, **kwargs) -> SparkSession: - return self + if not hasattr(self, "known_ids"): + self.known_ids = set() + self.known_branch_ids = set() + self.known_sequence_ids = set() + self.name_to_sequence_id_mapping = defaultdict(list) + self.incrementing_id = 1 + self.dialect = Dialect.get_or_raise(self.DEFAULT_DIALECT)() + + def __new__(cls, *args, **kwargs) -> SparkSession: + if cls._instance is None: + cls._instance = super().__new__(cls) + return cls._instance @property def read(self) -> DataFrameReader: @@ -101,7 +105,7 @@ def createDataFrame( return DataFrame(self, sel_expression) def sql(self, sqlQuery: str) -> DataFrame: - expression = sqlglot.parse_one(sqlQuery, read="spark") + expression = sqlglot.parse_one(sqlQuery, read=self.dialect) if isinstance(expression, exp.Select): df = DataFrame(self, expression) df = df._convert_leaf_to_cte() @@ -149,3 +153,38 @@ def _join_hint_names(self) -> t.Set[str]: def _add_alias_to_mapping(self, name: str, sequence_id: str): self.name_to_sequence_id_mapping[name].append(sequence_id) + + class Builder: + SQLFRAME_DIALECT_KEY = "sqlframe.dialect" + + def __init__(self): + self.dialect = "spark" + + def __getattr__(self, item) -> SparkSession.Builder: + return self + + def __call__(self, *args, **kwargs): + return self + + def config( + self, + key: t.Optional[str] = None, + value: t.Optional[t.Any] = None, + *, + map: t.Optional[t.Dict[str, t.Any]] = None, + **kwargs: t.Any, + ) -> SparkSession.Builder: + if key == self.SQLFRAME_DIALECT_KEY: + self.dialect = value + elif map and self.SQLFRAME_DIALECT_KEY in map: + self.dialect = map[self.SQLFRAME_DIALECT_KEY] + return self + + def getOrCreate(self) -> SparkSession: + spark = SparkSession() + spark.dialect = Dialect.get_or_raise(self.dialect)() + return spark + + @classproperty + def builder(cls) -> Builder: + return cls.Builder() diff --git a/sqlglot/dataframe/sql/window.py b/sqlglot/dataframe/sql/window.py index c54c07e21c..c1d913fe01 100644 --- a/sqlglot/dataframe/sql/window.py +++ b/sqlglot/dataframe/sql/window.py @@ -48,7 +48,9 @@ def copy(self): return WindowSpec(self.expression.copy()) def sql(self, **kwargs) -> str: - return self.expression.sql(dialect="spark", **kwargs) + from sqlglot.dataframe.sql.session import SparkSession + + return self.expression.sql(dialect=SparkSession().dialect, **kwargs) def partitionBy(self, *cols: t.Union[ColumnOrName, t.List[ColumnOrName]]) -> WindowSpec: from sqlglot.dataframe.sql.column import Column diff --git a/sqlglot/helper.py b/sqlglot/helper.py index 582fbf4dcd..7335d1e309 100644 --- a/sqlglot/helper.py +++ b/sqlglot/helper.py @@ -33,6 +33,15 @@ def _generate_next_value_(name, _start, _count, _last_values): return name +class classproperty(property): + """ + Similar to a normal property but works for class methods + """ + + def __get__(self, obj: t.Any, owner: t.Any = None) -> t.Any: + return classmethod(self.fget).__get__(None, owner)() # type: ignore + + def seq_get(seq: t.Sequence[T], index: int) -> t.Optional[T]: """Returns the value in `seq` at position `index`, or `None` if `index` is out of bounds.""" try:

diff --git a/tests/dataframe/unit/dataframe_sql_validator.py b/tests/dataframe/unit/dataframe_sql_validator.py index 2dcdb39f23..4363b0dfa1 100644 --- a/tests/dataframe/unit/dataframe_sql_validator.py +++ b/tests/dataframe/unit/dataframe_sql_validator.py @@ -1,14 +1,11 @@ -import typing as t -import unittest - from sqlglot.dataframe.sql import types -from sqlglot.dataframe.sql.dataframe import DataFrame from sqlglot.dataframe.sql.session import SparkSession -from sqlglot.helper import ensure_list +from tests.dataframe.unit.dataframe_test_base import DataFrameTestBase -class DataFrameSQLValidator(unittest.TestCase): +class DataFrameSQLValidator(DataFrameTestBase): def setUp(self) -> None: + super().setUp() self.spark = SparkSession() self.employee_schema = types.StructType( [ @@ -29,12 +26,3 @@ def setUp(self) -> None: self.df_employee = self.spark.createDataFrame( data=employee_data, schema=self.employee_schema ) - - def compare_sql( - self, df: DataFrame, expected_statements: t.Union[str, t.List[str]], pretty=False - ): - actual_sqls = df.sql(pretty=pretty) - expected_statements = ensure_list(expected_statements) - self.assertEqual(len(expected_statements), len(actual_sqls)) - for expected, actual in zip(expected_statements, actual_sqls): - self.assertEqual(expected, actual) diff --git a/tests/dataframe/unit/dataframe_test_base.py b/tests/dataframe/unit/dataframe_test_base.py new file mode 100644 index 0000000000..6b07df98bd --- /dev/null +++ b/tests/dataframe/unit/dataframe_test_base.py @@ -0,0 +1,23 @@ +import typing as t +import unittest + +import sqlglot +from sqlglot import MappingSchema +from sqlglot.dataframe.sql import SparkSession +from sqlglot.dataframe.sql.dataframe import DataFrame +from sqlglot.helper import ensure_list + + +class DataFrameTestBase(unittest.TestCase): + def setUp(self) -> None: + sqlglot.schema = MappingSchema() + SparkSession._instance = None + + def compare_sql( + self, df: DataFrame, expected_statements: t.Union[str, t.List[str]], pretty=False + ): + actual_sqls = df.sql(pretty=pretty) + expected_statements = ensure_list(expected_statements) + self.assertEqual(len(expected_statements), len(actual_sqls)) + for expected, actual in zip(expected_statements, actual_sqls): + self.assertEqual(expected, actual) diff --git a/tests/dataframe/unit/test_session.py b/tests/dataframe/unit/test_session.py index 4c275e9c0d..9758033fa6 100644 --- a/tests/dataframe/unit/test_session.py +++ b/tests/dataframe/unit/test_session.py @@ -1,9 +1,6 @@ -from unittest import mock - import sqlglot from sqlglot.dataframe.sql import functions as F, types from sqlglot.dataframe.sql.session import SparkSession -from sqlglot.schema import MappingSchema from tests.dataframe.unit.dataframe_sql_validator import DataFrameSQLValidator @@ -68,7 +65,6 @@ def test_typed_schema_nested(self): self.compare_sql(df, expected) - @mock.patch("sqlglot.schema", MappingSchema()) def test_sql_select_only(self): query = "SELECT cola, colb FROM table" sqlglot.schema.add_table("table", {"cola": "string", "colb": "string"}, dialect="spark") @@ -78,16 +74,6 @@ def test_sql_select_only(self): df.sql(pretty=False)[0], ) - @mock.patch("sqlglot.schema", MappingSchema()) - def test_select_quoted(self): - sqlglot.schema.add_table("`TEST`", {"name": "string"}, dialect="spark") - - self.assertEqual( - SparkSession().table("`TEST`").select(F.col("name")).sql(dialect="snowflake")[0], - '''SELECT "test"."name" AS "name" FROM "test" AS "test"''', - ) - - @mock.patch("sqlglot.schema", MappingSchema()) def test_sql_with_aggs(self): query = "SELECT cola, colb FROM table" sqlglot.schema.add_table("table", {"cola": "string", "colb": "string"}, dialect="spark") @@ -97,7 +83,6 @@ def test_sql_with_aggs(self): df.sql(pretty=False, optimize=False)[0], ) - @mock.patch("sqlglot.schema", MappingSchema()) def test_sql_create(self): query = "CREATE TABLE new_table AS WITH t1 AS (SELECT cola, colb FROM table) SELECT cola, colb, FROM t1" sqlglot.schema.add_table("table", {"cola": "string", "colb": "string"}, dialect="spark") @@ -105,7 +90,6 @@ def test_sql_create(self): expected = "CREATE TABLE new_table AS SELECT `table`.`cola` AS `cola`, `table`.`colb` AS `colb` FROM `table` AS `table`" self.compare_sql(df, expected) - @mock.patch("sqlglot.schema", MappingSchema()) def test_sql_insert(self): query = "WITH t1 AS (SELECT cola, colb FROM table) INSERT INTO new_table SELECT cola, colb FROM t1" sqlglot.schema.add_table("table", {"cola": "string", "colb": "string"}, dialect="spark") @@ -114,5 +98,4 @@ def test_sql_insert(self): self.compare_sql(df, expected) def test_session_create_builder_patterns(self): - spark = SparkSession() - self.assertEqual(spark.builder.appName("abc").getOrCreate(), spark) + self.assertEqual(SparkSession.builder.appName("abc").getOrCreate(), SparkSession()) diff --git a/tests/dataframe/unit/test_session_case_sensitivity.py b/tests/dataframe/unit/test_session_case_sensitivity.py new file mode 100644 index 0000000000..7e352895c1 --- /dev/null +++ b/tests/dataframe/unit/test_session_case_sensitivity.py @@ -0,0 +1,81 @@ +import sqlglot +from sqlglot.dataframe.sql import functions as F +from sqlglot.dataframe.sql.session import SparkSession +from sqlglot.errors import OptimizeError +from tests.dataframe.unit.dataframe_test_base import DataFrameTestBase + + +class TestSessionCaseSensitivity(DataFrameTestBase): + def setUp(self) -> None: + super().setUp() + self.spark = SparkSession.builder.config("sqlframe.dialect", "snowflake").getOrCreate() + + tests = [ + ( + "All lower no intention of CS", + "test", + "test", + {"name": "VARCHAR"}, + "name", + '''SELECT "TEST"."NAME" AS "NAME" FROM "TEST" AS "TEST"''', + ), + ( + "Table has CS while column does not", + '"Test"', + '"Test"', + {"name": "VARCHAR"}, + "name", + '''SELECT "TEST"."NAME" AS "NAME" FROM "Test" AS "TEST"''', + ), + ( + "Column has CS while table does not", + "test", + "test", + {'"Name"': "VARCHAR"}, + '"Name"', + '''SELECT "TEST"."Name" AS "Name" FROM "TEST" AS "TEST"''', + ), + ( + "Both Table and column have CS", + '"Test"', + '"Test"', + {'"Name"': "VARCHAR"}, + '"Name"', + '''SELECT "TEST"."Name" AS "Name" FROM "Test" AS "TEST"''', + ), + ( + "Lowercase CS table and column", + '"test"', + '"test"', + {'"name"': "VARCHAR"}, + '"name"', + '''SELECT "TEST"."name" AS "name" FROM "test" AS "TEST"''', + ), + ( + "CS table and column and query table but no CS in query column", + '"test"', + '"test"', + {'"name"': "VARCHAR"}, + "name", + OptimizeError(), + ), + ( + "CS table and column and query column but no CS in query table", + '"test"', + "test", + {'"name"': "VARCHAR"}, + '"name"', + OptimizeError(), + ), + ] + + def test_basic_case_sensitivity(self): + for test_name, table_name, spark_table, schema, spark_column, expected in self.tests: + with self.subTest(test_name): + sqlglot.schema.add_table(table_name, schema, dialect=self.spark.dialect) + df = self.spark.table(spark_table).select(F.col(spark_column)) + if isinstance(expected, OptimizeError): + with self.assertRaises(OptimizeError): + df.sql() + else: + self.compare_sql(df, expected) diff --git a/tests/dataframe/unit/test_window.py b/tests/dataframe/unit/test_window.py index 45d736f115..9c4c897586 100644 --- a/tests/dataframe/unit/test_window.py +++ b/tests/dataframe/unit/test_window.py @@ -1,10 +1,9 @@ -import unittest - from sqlglot.dataframe.sql import functions as F from sqlglot.dataframe.sql.window import Window, WindowSpec +from tests.dataframe.unit.dataframe_test_base import DataFrameTestBase -class TestDataframeWindow(unittest.TestCase): +class TestDataframeWindow(DataFrameTestBase): def test_window_spec_partition_by(self): partition_by = WindowSpec().partitionBy(F.col("cola"), F.col("colb")) self.assertEqual("OVER (PARTITION BY cola, colb)", partition_by.sql())

diff --git a/sqlglot/dataframe/README.md b/sqlglot/dataframe/README.md index 86fdc4b045..adde9a1dfe 100644 --- a/sqlglot/dataframe/README.md +++ b/sqlglot/dataframe/README.md @@ -21,10 +21,12 @@ Currently many of the common operations are covered and more functionality will * Ex: `['cola', 'colb']` * The lack of types may limit functionality in future releases. * See [Registering Custom Schema](#registering-custom-schema-class) for information on how to skip this step if the information is stored externally. +* If your output SQL dialect is not Spark, then configure the SparkSession to use that dialect + * Ex: `SparkSession().builder.config("sqlframe.dialect", "bigquery").getOrCreate()` + * See [dialects](https://github.com/tobymao/sqlglot/tree/main/sqlglot/dialects) for a full list of dialects. * Add `.sql(pretty=True)` to your final DataFrame command to return a list of sql statements to run that command. - * In most cases a single SQL statement is returned. Currently the only exception is when caching DataFrames which isn't supported in other dialects. - * Spark is the default output dialect. See [dialects](https://github.com/tobymao/sqlglot/tree/main/sqlglot/dialects) for a full list of dialects. - * Ex: `.sql(pretty=True, dialect='bigquery')` + * In most cases a single SQL statement is returned. Currently the only exception is when caching DataFrames which isn't supported in other dialects. + * Ex: `.sql(pretty=True)` ## Examples @@ -33,6 +35,8 @@ import sqlglot from sqlglot.dataframe.sql.session import SparkSession from sqlglot.dataframe.sql import functions as F +dialect = "spark" + sqlglot.schema.add_table( 'employee', { @@ -41,10 +45,10 @@ sqlglot.schema.add_table( 'lname': 'STRING', 'age': 'INT', }, - dialect="spark", + dialect=dialect, ) # Register the table structure prior to reading from the table -spark = SparkSession() +spark = SparkSession.builder.config("sqlframe.dialect", dialect).getOrCreate() df = ( spark @@ -53,7 +57,7 @@ df = ( .agg(F.countDistinct(F.col("employee_id")).alias("num_employees")) ) -print(df.sql(pretty=True)) # Spark will be the dialect used by default +print(df.sql(pretty=True)) ``` ```sparksql @@ -81,7 +85,7 @@ class ExternalSchema(Schema): sqlglot.schema = ExternalSchema() -spark = SparkSession() +spark = SparkSession() # Spark will be used by default is not specific in SparkSession config df = ( spark @@ -119,11 +123,14 @@ schema = types.StructType([ ]) sql_statements = ( - SparkSession() + SparkSession + .builder + .config("sqlframe.dialect", "bigquery") + .getOrCreate() .createDataFrame(data, schema) .groupBy(F.col("age")) .agg(F.countDistinct(F.col("employee_id")).alias("num_employees")) - .sql(dialect="bigquery") + .sql() ) result = None @@ -166,11 +173,14 @@ schema = types.StructType([ ]) sql_statements = ( - SparkSession() + SparkSession + .builder + .config("sqlframe.dialect", "snowflake") + .getOrCreate() .createDataFrame(data, schema) .groupBy(F.col("age")) .agg(F.countDistinct(F.col("lname")).alias("num_employees")) - .sql(dialect="snowflake") + .sql() ) try: @@ -210,7 +220,7 @@ sql_statements = ( .createDataFrame(data, schema) .groupBy(F.col("age")) .agg(F.countDistinct(F.col("employee_id")).alias("num_employees")) - .sql(dialect="spark") + .sql() ) pyspark = PySparkSession.builder.master("local[*]").getOrCreate()

[]

[ "tests/dataframe/unit/test_session.py::TestDataframeSession::test_session_create_builder_patterns", "tests/dataframe/unit/test_session_case_sensitivity.py::TestSessionCaseSensitivity::test_basic_case_sensitivity" ]

[ "tests/dataframe/unit/test_session.py::TestDataframeSession::test_cdf_dict_rows", "tests/dataframe/unit/test_session.py::TestDataframeSession::test_cdf_multiple_rows", "tests/dataframe/unit/test_session.py::TestDataframeSession::test_cdf_no_schema", "tests/dataframe/unit/test_session.py::TestDataframeSession:...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat: Support dialect across all Dataframe Operations Slack thread that prompted this change: https://tobiko-data.slack.com/archives/C0448SFS3PF/p1692679901587439?thread_ts=1692679773.389409&cid=C0448SFS3PF Prior to this change all input was assumed to be Spark and then you could transpile that final query to whatever dialect you wanted. One challenge with this approach is when the user wants to do something that isn't natively supported by Spark. This example was that the user wanted case-sensitive columns but all column input into the Dataframe was assumed to be Spark and therefore case-insensitive. This change makes it so that the SparkSession can be configured for a specific dialect and therefore that dialect would be used for parsing all user input. As shown by the tests, this then support case-sensitive input if the target engine is case-sensitive. The old behavior of allowing a dialect to be defined with the `sql` method is still supported for backwards compatibility. A warning is shown if their dialect doesn't match the configured dialect and shows them how to fix this going forward. The plan is to eventually drop `dialect` from `sql` in a future major release. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

ceb42fabad60312699e4b15936aeebac00e22e4d

Aider-AI__aider-207

207

Aider-AI/aider

null

43047c38358d7453c5778d4415475f152e4c562e

2023-08-18T17:17:40Z

diff --git a/HISTORY.md b/HISTORY.md index b033f264ac7..8f8750dc81e 100644 --- a/HISTORY.md +++ b/HISTORY.md @@ -2,6 +2,7 @@ ### main branch +- [Only git commit dirty files that GPT tries to edit](https://aider.chat/docs/faq.html#how-does-aider-use-git) - Send chat history as prompt/context for Whisper voice transcription - Added `--voice-language` switch to constrain `/voice` to transcribe to a specific language diff --git a/aider/coders/base_coder.py b/aider/coders/base_coder.py index fe1415f0289..06c1a518ec0 100755 --- a/aider/coders/base_coder.py +++ b/aider/coders/base_coder.py @@ -57,13 +57,7 @@ def create( io, **kwargs, ): - from . import ( - EditBlockCoder, - EditBlockFunctionCoder, - SingleWholeFileFunctionCoder, - WholeFileCoder, - WholeFileFunctionCoder, - ) + from . import EditBlockCoder, WholeFileCoder if not main_model: main_model = models.GPT35_16k @@ -84,14 +78,6 @@ def create( return EditBlockCoder(main_model, io, **kwargs) elif edit_format == "whole": return WholeFileCoder(main_model, io, **kwargs) - elif edit_format == "whole-func": - return WholeFileFunctionCoder(main_model, io, **kwargs) - elif edit_format == "single-whole-func": - return SingleWholeFileFunctionCoder(main_model, io, **kwargs) - elif edit_format == "diff-func-list": - return EditBlockFunctionCoder("list", main_model, io, **kwargs) - elif edit_format in ("diff-func", "diff-func-string"): - return EditBlockFunctionCoder("string", main_model, io, **kwargs) else: raise ValueError(f"Unknown edit format {edit_format}") @@ -119,6 +105,7 @@ def __init__( self.chat_completion_call_hashes = [] self.chat_completion_response_hashes = [] + self.need_commit_before_edits = set() self.verbose = verbose self.abs_fnames = set() @@ -203,9 +190,6 @@ def __init__( for fname in self.get_inchat_relative_files(): self.io.tool_output(f"Added {fname} to the chat.") - if self.repo: - self.repo.add_new_files(fname for fname in fnames if not Path(fname).is_dir()) - self.summarizer = ChatSummary() self.summarizer_thread = None self.summarized_done_messages = None @@ -408,11 +392,6 @@ def run_loop(self): self.commands, ) - if self.should_dirty_commit(inp) and self.dirty_commit(): - if inp.strip(): - self.io.tool_output("Use up-arrow to retry previous command:", inp) - return - if not inp: return @@ -500,7 +479,7 @@ def send_new_user_message(self, inp): if edited: if self.repo and self.auto_commits and not self.dry_run: - saved_message = self.auto_commit() + saved_message = self.auto_commit(edited) elif hasattr(self.gpt_prompts, "files_content_gpt_edits_no_repo"): saved_message = self.gpt_prompts.files_content_gpt_edits_no_repo else: @@ -728,42 +707,93 @@ def get_last_modified(self): def get_addable_relative_files(self): return set(self.get_all_relative_files()) - set(self.get_inchat_relative_files()) - def allowed_to_edit(self, path, write_content=None): + def check_for_dirty_commit(self, path): + if not self.repo: + return + if not self.dirty_commits: + return + if not self.repo.is_dirty(path): + return + + fullp = Path(self.abs_root_path(path)) + if not fullp.stat().st_size: + return + + self.io.tool_output(f"Committing {path} before applying edits.") + self.need_commit_before_edits.add(path) + return + + def allowed_to_edit(self, path): full_path = self.abs_root_path(path) + if self.repo: + need_to_add = not self.repo.path_in_repo(path) + else: + need_to_add = False if full_path in self.abs_fnames: - if write_content: - self.io.write_text(full_path, write_content) - return full_path + self.check_for_dirty_commit(path) + return True if not Path(full_path).exists(): - question = f"Allow creation of new file {path}?" # noqa: E501 - else: - question = f"Allow edits to {path} which was not previously provided?" # noqa: E501 - if not self.io.confirm_ask(question): - self.io.tool_error(f"Skipping edit to {path}") + if not self.io.confirm_ask(f"Allow creation of new file {path}?"): + self.io.tool_error(f"Skipping edits to {path}") + return + + if not self.dry_run: + Path(full_path).parent.mkdir(parents=True, exist_ok=True) + Path(full_path).touch() + + # Seems unlikely that we needed to create the file, but it was + # actually already part of the repo. + # But let's only add if we need to, just to be safe. + if need_to_add: + self.repo.repo.git.add(full_path) + + self.abs_fnames.add(full_path) + return True + + if not self.io.confirm_ask( + f"Allow edits to {path} which was not previously added to chat?" + ): + self.io.tool_error(f"Skipping edits to {path}") return - if not Path(full_path).exists() and not self.dry_run: - Path(full_path).parent.mkdir(parents=True, exist_ok=True) - Path(full_path).touch() + if need_to_add: + self.repo.repo.git.add(full_path) self.abs_fnames.add(full_path) + self.check_for_dirty_commit(path) + return True - # Check if the file is already in the repo - if self.repo: - tracked_files = set(self.repo.get_tracked_files()) - relative_fname = self.get_rel_fname(full_path) - if relative_fname not in tracked_files and self.io.confirm_ask(f"Add {path} to git?"): - if not self.dry_run: - self.repo.repo.git.add(full_path) + apply_update_errors = 0 - if write_content: - self.io.write_text(full_path, write_content) + def prepare_to_edit(self, edits): + res = [] + seen = dict() - return full_path + self.need_commit_before_edits = set() - apply_update_errors = 0 + for edit in edits: + path = edit[0] + if path in seen: + allowed = seen[path] + else: + allowed = self.allowed_to_edit(path) + seen[path] = allowed + + if allowed: + res.append(edit) + + self.dirty_commit() + self.need_commit_before_edits = set() + + return res + + def update_files(self): + edits = self.get_edits() + edits = self.prepare_to_edit(edits) + self.apply_edits(edits) + return set(edit[0] for edit in edits) def apply_updates(self): max_apply_update_errors = 3 @@ -795,12 +825,11 @@ def apply_updates(self): self.apply_update_errors = 0 - if edited: - for path in sorted(edited): - if self.dry_run: - self.io.tool_output(f"Did not apply edit to {path} (--dry-run)") - else: - self.io.tool_output(f"Applied edit to {path}") + for path in edited: + if self.dry_run: + self.io.tool_output(f"Did not apply edit to {path} (--dry-run)") + else: + self.io.tool_output(f"Applied edit to {path}") return edited, None @@ -840,9 +869,9 @@ def get_context_from_history(self, history): context += "\n" + msg["role"].upper() + ": " + msg["content"] + "\n" return context - def auto_commit(self): + def auto_commit(self, edited): context = self.get_context_from_history(self.cur_messages) - res = self.repo.commit(context=context, prefix="aider: ") + res = self.repo.commit(fnames=edited, context=context, prefix="aider: ") if res: commit_hash, commit_message = res self.last_aider_commit_hash = commit_hash @@ -855,43 +884,14 @@ def auto_commit(self): self.io.tool_output("No changes made to git tracked files.") return self.gpt_prompts.files_content_gpt_no_edits - def should_dirty_commit(self, inp): - cmds = self.commands.matching_commands(inp) - if cmds: - matching_commands, _, _ = cmds - if len(matching_commands) == 1: - cmd = matching_commands[0][1:] - if cmd in "add clear commit diff drop exit help ls tokens".split(): - return - - if self.last_asked_for_commit_time >= self.get_last_modified(): - return - return True - def dirty_commit(self): + if not self.need_commit_before_edits: + return if not self.dirty_commits: return if not self.repo: return - if not self.repo.is_dirty(): - return - - self.io.tool_output("Git repo has uncommitted changes.") - self.repo.show_diffs(self.pretty) - self.last_asked_for_commit_time = self.get_last_modified() - res = self.io.prompt_ask( - "Commit before the chat proceeds [y/n/commit message]?", - default="y", - ).strip() - if res.lower() in ["n", "no"]: - self.io.tool_error("Skipped commmit.") - return - if res.lower() in ["y", "yes"]: - message = None - else: - message = res.strip() - - self.repo.commit(message=message) + self.repo.commit(fnames=self.need_commit_before_edits) # files changed, move cur messages back behind the files messages self.move_back_cur_messages(self.gpt_prompts.files_content_local_edits) diff --git a/aider/coders/editblock_coder.py b/aider/coders/editblock_coder.py index 5388bbac70c..bcc36762721 100644 --- a/aider/coders/editblock_coder.py +++ b/aider/coders/editblock_coder.py @@ -13,22 +13,21 @@ def __init__(self, *args, **kwargs): self.gpt_prompts = EditBlockPrompts() super().__init__(*args, **kwargs) - def update_files(self): + def get_edits(self): content = self.partial_response_content # might raise ValueError for malformed ORIG/UPD blocks edits = list(find_original_update_blocks(content)) - edited = set() + return edits + + def apply_edits(self, edits): for path, original, updated in edits: - full_path = self.allowed_to_edit(path) - if not full_path: - continue + full_path = self.abs_root_path(path) content = self.io.read_text(full_path) content = do_replace(full_path, content, original, updated) if content: self.io.write_text(full_path, content) - edited.add(path) continue raise ValueError(f"""InvalidEditBlock: edit failed! @@ -42,8 +41,6 @@ def update_files(self): {original}``` """) - return edited - def prep(content): if content and not content.endswith("\n"): diff --git a/aider/coders/editblock_func_coder.py b/aider/coders/editblock_func_coder.py index 3f7acbaf52d..42bbb20f359 100644 --- a/aider/coders/editblock_func_coder.py +++ b/aider/coders/editblock_func_coder.py @@ -58,6 +58,7 @@ class EditBlockFunctionCoder(Coder): ] def __init__(self, code_format, *args, **kwargs): + raise RuntimeError("Deprecated, needs to be refactored to support get_edits/apply_edits") self.code_format = code_format if code_format == "string": @@ -91,7 +92,7 @@ def render_incremental_response(self, final=False): res = json.dumps(args, indent=4) return res - def update_files(self): + def _update_files(self): name = self.partial_response_function_call.get("name") if name and name != "replace_lines": diff --git a/aider/coders/single_wholefile_func_coder.py b/aider/coders/single_wholefile_func_coder.py index 2d99c364580..ef1680e97eb 100644 --- a/aider/coders/single_wholefile_func_coder.py +++ b/aider/coders/single_wholefile_func_coder.py @@ -31,6 +31,7 @@ class SingleWholeFileFunctionCoder(Coder): ] def __init__(self, *args, **kwargs): + raise RuntimeError("Deprecated, needs to be refactored to support get_edits/apply_edits") self.gpt_prompts = SingleWholeFileFunctionPrompts() super().__init__(*args, **kwargs) @@ -94,7 +95,7 @@ def live_diffs(self, fname, content, final): return "\n".join(show_diff) - def update_files(self): + def _update_files(self): name = self.partial_response_function_call.get("name") if name and name != "write_file": raise ValueError(f'Unknown function_call name="{name}", use name="write_file"') diff --git a/aider/coders/wholefile_coder.py b/aider/coders/wholefile_coder.py index c70576daebb..6bd7d46349c 100644 --- a/aider/coders/wholefile_coder.py +++ b/aider/coders/wholefile_coder.py @@ -22,11 +22,11 @@ def update_cur_messages(self, edited): def render_incremental_response(self, final): try: - return self.update_files(mode="diff") + return self.get_edits(mode="diff") except ValueError: return self.partial_response_content - def update_files(self, mode="update"): + def get_edits(self, mode="update"): content = self.partial_response_content chat_files = self.get_inchat_relative_files() @@ -46,7 +46,7 @@ def update_files(self, mode="update"): # ending an existing block saw_fname = None - full_path = (Path(self.root) / fname).absolute() + full_path = self.abs_root_path(fname) if mode == "diff": output += self.do_live_diff(full_path, new_lines, True) @@ -104,25 +104,30 @@ def update_files(self, mode="update"): if fname: edits.append((fname, fname_source, new_lines)) - edited = set() + seen = set() + refined_edits = [] # process from most reliable filename, to least reliable for source in ("block", "saw", "chat"): for fname, fname_source, new_lines in edits: if fname_source != source: continue # if a higher priority source already edited the file, skip - if fname in edited: + if fname in seen: continue - # we have a winner - new_lines = "".join(new_lines) - if self.allowed_to_edit(fname, new_lines): - edited.add(fname) + seen.add(fname) + refined_edits.append((fname, fname_source, new_lines)) - return edited + return refined_edits + + def apply_edits(self, edits): + for path, fname_source, new_lines in edits: + full_path = self.abs_root_path(path) + new_lines = "".join(new_lines) + self.io.write_text(full_path, new_lines) def do_live_diff(self, full_path, new_lines, final): - if full_path.exists(): + if Path(full_path).exists(): orig_lines = self.io.read_text(full_path).splitlines(keepends=True) show_diff = diffs.diff_partial_update( diff --git a/aider/coders/wholefile_func_coder.py b/aider/coders/wholefile_func_coder.py index ebf10764d69..987010ea7b6 100644 --- a/aider/coders/wholefile_func_coder.py +++ b/aider/coders/wholefile_func_coder.py @@ -44,6 +44,8 @@ class WholeFileFunctionCoder(Coder): ] def __init__(self, *args, **kwargs): + raise RuntimeError("Deprecated, needs to be refactored to support get_edits/apply_edits") + self.gpt_prompts = WholeFileFunctionPrompts() super().__init__(*args, **kwargs) @@ -105,7 +107,7 @@ def live_diffs(self, fname, content, final): return "\n".join(show_diff) - def update_files(self): + def _update_files(self): name = self.partial_response_function_call.get("name") if name and name != "write_file": raise ValueError(f'Unknown function_call name="{name}", use name="write_file"') diff --git a/aider/commands.py b/aider/commands.py index af0fa332ece..6047e9438f9 100644 --- a/aider/commands.py +++ b/aider/commands.py @@ -230,7 +230,7 @@ def cmd_diff(self, args): return commits = f"{self.coder.last_aider_commit_hash}~1" - diff = self.coder.repo.get_diffs( + diff = self.coder.repo.diff_commits( self.coder.pretty, commits, self.coder.last_aider_commit_hash, diff --git a/aider/main.py b/aider/main.py index 9ab8eb9b1fe..540c19bfe2b 100644 --- a/aider/main.py +++ b/aider/main.py @@ -522,8 +522,6 @@ def scrub_sensitive_info(text): io.tool_output("Use /help to see in-chat commands, run with --help to see cmd line args") - coder.dirty_commit() - if args.message: io.tool_output() coder.run(with_message=args.message) diff --git a/aider/repo.py b/aider/repo.py index 07a47592c01..92cfb1cb2be 100644 --- a/aider/repo.py +++ b/aider/repo.py @@ -49,24 +49,14 @@ def __init__(self, io, fnames, git_dname): self.repo = git.Repo(repo_paths.pop(), odbt=git.GitDB) self.root = utils.safe_abs_path(self.repo.working_tree_dir) - def add_new_files(self, fnames): - cur_files = [str(Path(fn).resolve()) for fn in self.get_tracked_files()] - for fname in fnames: - if str(Path(fname).resolve()) in cur_files: - continue - if not Path(fname).exists(): - continue - self.io.tool_output(f"Adding {fname} to git") - self.repo.git.add(fname) - - def commit(self, context=None, prefix=None, message=None): - if not self.repo.is_dirty(): + def commit(self, fnames=None, context=None, prefix=None, message=None): + if not fnames and not self.repo.is_dirty(): return if message: commit_message = message else: - diffs = self.get_diffs(False) + diffs = self.get_diffs(fnames) commit_message = self.get_commit_message(diffs, context) if not commit_message: @@ -79,7 +69,16 @@ def commit(self, context=None, prefix=None, message=None): if context: full_commit_message += "\n\n# Aider chat conversation:\n\n" + context - self.repo.git.commit("-a", "-m", full_commit_message, "--no-verify") + cmd = ["-m", full_commit_message, "--no-verify"] + if fnames: + fnames = [str(self.abs_root_path(fn)) for fn in fnames] + for fname in fnames: + self.repo.git.add(fname) + cmd += ["--"] + fnames + else: + cmd += ["-a"] + + self.repo.git.commit(cmd) commit_hash = self.repo.head.commit.hexsha[:7] self.io.tool_output(f"Commit {commit_hash} {commit_message}") @@ -125,41 +124,38 @@ def get_commit_message(self, diffs, context): return commit_message - def get_diffs(self, pretty, *args): - args = list(args) - - # if args are specified, just add --pretty if needed - if args: - if pretty: - args = ["--color"] + args - return self.repo.git.diff(*args) - - # otherwise, we always want diffs of index and working dir - + def get_diffs(self, fnames=None): + # We always want diffs of index and working dir try: commits = self.repo.iter_commits(self.repo.active_branch) current_branch_has_commits = any(commits) except git.exc.GitCommandError: current_branch_has_commits = False - if pretty: - args = ["--color"] + if not fnames: + fnames = [] if current_branch_has_commits: - # if there is a HEAD, just diff against it to pick up index + working - args += ["HEAD"] + args = ["HEAD", "--"] + list(fnames) return self.repo.git.diff(*args) - # diffs in the index - diffs = self.repo.git.diff(*(args + ["--cached"])) - # plus, diffs in the working dir - diffs += self.repo.git.diff(*args) + wd_args = ["--"] + list(fnames) + index_args = ["--cached"] + wd_args + + diffs = self.repo.git.diff(*index_args) + diffs += self.repo.git.diff(*wd_args) return diffs - def show_diffs(self, pretty): - diffs = self.get_diffs(pretty) - print(diffs) + def diff_commits(self, pretty, from_commit, to_commit): + args = [] + if pretty: + args += ["--color"] + + args += [from_commit, to_commit] + diffs = self.repo.git.diff(*args) + + return diffs def get_tracked_files(self): if not self.repo: @@ -190,5 +186,19 @@ def get_tracked_files(self): return res - def is_dirty(self): - return self.repo.is_dirty() + def path_in_repo(self, path): + if not self.repo: + return + + tracked_files = set(self.get_tracked_files()) + return path in tracked_files + + def abs_root_path(self, path): + res = Path(self.root) / path + return utils.safe_abs_path(res) + + def is_dirty(self, path=None): + if path and not self.path_in_repo(path): + return True + + return self.repo.is_dirty(path=path) diff --git a/docs/faq.md b/docs/faq.md index 789adecb512..806ff0c5508 100644 --- a/docs/faq.md +++ b/docs/faq.md @@ -13,29 +13,29 @@ It is recommended that you use aider with code that is part of a git repo. This allows aider to maintain the safety of your code. Using git makes it easy to: - - Review the changes GPT made to your code - - Undo changes that weren't appropriate + - Undo any changes that weren't appropriate + - Go back later to review the changes GPT made to your code - Manage a series of GPT's changes on a git branch - - etc -Working without git means that GPT might drastically change your code without an easy way to undo the changes. +Working without git means that GPT might drastically change your code +without an easy way to undo the changes. Aider tries to provide safety using git in a few ways: - It asks to create a git repo if you launch it in a directory without one. - - When you add a file to the chat, aider asks permission to add it to the git repo if needed. - - At launch and before sending requests to GPT, aider checks if the repo is dirty and offers to commit those changes for you. This way, the GPT changes will be applied to a clean repo and won't be intermingled with your own changes. - - After GPT changes your code, aider commits those changes with a descriptive commit message. - + - Whenever GPT edits a file, those changes are committed with a descriptive commit message. This makes it easy to revert or review GPT's changes. + - If GPT tries to edit files that already have uncommitted changes (dirty files), aider will first commit those existing changes with a descriptive commit message. This makes sure you never lose your work if GPT makes an inappropriate change to uncommitted code. + Aider also allows you to use in-chat commands to `/diff` or `/undo` the last change made by GPT. -To do more complex management of your git history, you should use `git` on the command line outside of aider. +To do more complex management of your git history, you cat use raw `git` commands, +either by using `/git` or with git tools outside of aider. You can start a branch before using aider to make a sequence of changes. Or you can `git reset` a longer series of aider changes that didn't pan out. Etc. While it is not recommended, you can disable aider's use of git in a few ways: - `--no-auto-commits` will stop aider from git committing each of GPT's changes. - - `--no-dirty-commits` will stop aider from ensuring your repo is clean before sending requests to GPT. + - `--no-dirty-commits` will stop aider from committing dirty files before applying GPT's edits. - `--no-git` will completely stop aider from using git on your files. You should ensure you are keeping sensible backups of the files you are working with.

diff --git a/tests/test_coder.py b/tests/test_coder.py index 1c2eaa8b290..3faf42bc7a8 100644 --- a/tests/test_coder.py +++ b/tests/test_coder.py @@ -22,79 +22,84 @@ def setUp(self): def tearDown(self): self.patcher.stop() - def test_new_file_commit_message(self): + def test_allowed_to_edit(self): with GitTemporaryDirectory(): repo = git.Repo() - fname = Path("foo.txt") - - io = InputOutput(yes=True) - # Initialize the Coder object with the mocked IO and mocked repo - Coder.create(models.GPT4, None, io, fnames=[str(fname)]) - self.assertTrue(fname.exists()) - - # Mock the get_commit_message method to return "I added str(fname)" - repo.get_commit_message = MagicMock(return_value=f"I added {str(fname)}") - # Get the latest commit message - commit_message = repo.get_commit_message() - # Check that the latest commit message is "I added str(fname)" - self.assertEqual(commit_message, f"I added {str(fname)}") + fname = Path("added.txt") + fname.touch() + repo.git.add(str(fname)) - def test_allowed_to_edit(self): - with GitTemporaryDirectory(): - repo = git.Repo(Path.cwd()) - fname = Path("foo.txt") + fname = Path("repo.txt") fname.touch() repo.git.add(str(fname)) + repo.git.commit("-m", "init") + # YES! io = InputOutput(yes=True) - # Initialize the Coder object with the mocked IO and mocked repo - coder = Coder.create(models.GPT4, None, io, fnames=["foo.txt"]) + coder = Coder.create(models.GPT4, None, io, fnames=["added.txt"]) - self.assertTrue(coder.allowed_to_edit("foo.txt")) + self.assertTrue(coder.allowed_to_edit("added.txt")) + self.assertTrue(coder.allowed_to_edit("repo.txt")) self.assertTrue(coder.allowed_to_edit("new.txt")) + self.assertIn("repo.txt", str(coder.abs_fnames)) + self.assertIn("new.txt", str(coder.abs_fnames)) + + self.assertFalse(coder.need_commit_before_edits) + def test_allowed_to_edit_no(self): with GitTemporaryDirectory(): - repo = git.Repo(Path.cwd()) - fname = Path("foo.txt") + repo = git.Repo() + + fname = Path("added.txt") + fname.touch() + repo.git.add(str(fname)) + + fname = Path("repo.txt") fname.touch() repo.git.add(str(fname)) + repo.git.commit("-m", "init") # say NO io = InputOutput(yes=False) - coder = Coder.create(models.GPT4, None, io, fnames=["foo.txt"]) + coder = Coder.create(models.GPT4, None, io, fnames=["added.txt"]) - self.assertTrue(coder.allowed_to_edit("foo.txt")) + self.assertTrue(coder.allowed_to_edit("added.txt")) + self.assertFalse(coder.allowed_to_edit("repo.txt")) self.assertFalse(coder.allowed_to_edit("new.txt")) - def test_get_last_modified(self): - # Mock the IO object - mock_io = MagicMock() + self.assertNotIn("repo.txt", str(coder.abs_fnames)) + self.assertNotIn("new.txt", str(coder.abs_fnames)) + + self.assertFalse(coder.need_commit_before_edits) + def test_allowed_to_edit_dirty(self): with GitTemporaryDirectory(): - repo = git.Repo(Path.cwd()) - fname = Path("new.txt") + repo = git.Repo() + + fname = Path("added.txt") fname.touch() repo.git.add(str(fname)) - repo.git.commit("-m", "new") - # Initialize the Coder object with the mocked IO and mocked repo - coder = Coder.create(models.GPT4, None, mock_io) + repo.git.commit("-m", "init") - mod = coder.get_last_modified() + # say NO + io = InputOutput(yes=False) - fname.write_text("hi") - mod_newer = coder.get_last_modified() - self.assertLess(mod, mod_newer) + coder = Coder.create(models.GPT4, None, io, fnames=["added.txt"]) - fname.unlink() - self.assertEqual(coder.get_last_modified(), 0) + self.assertTrue(coder.allowed_to_edit("added.txt")) + self.assertFalse(coder.need_commit_before_edits) + + fname.write_text("dirty!") + self.assertTrue(coder.allowed_to_edit("added.txt")) + self.assertTrue(coder.need_commit_before_edits) - def test_should_dirty_commit(self): + def test_get_last_modified(self): # Mock the IO object mock_io = MagicMock() @@ -108,11 +113,14 @@ def test_should_dirty_commit(self): # Initialize the Coder object with the mocked IO and mocked repo coder = Coder.create(models.GPT4, None, mock_io) + mod = coder.get_last_modified() + fname.write_text("hi") - self.assertTrue(coder.should_dirty_commit("hi")) + mod_newer = coder.get_last_modified() + self.assertLess(mod, mod_newer) - self.assertFalse(coder.should_dirty_commit("/exit")) - self.assertFalse(coder.should_dirty_commit("/help")) + fname.unlink() + self.assertEqual(coder.get_last_modified(), 0) def test_check_for_file_mentions(self): # Mock the IO object @@ -219,7 +227,6 @@ def test_check_for_subdir_mention(self): mock.return_value = set([str(fname)]) coder.repo.get_tracked_files = mock - dump(fname) # Call the check_for_file_mentions method coder.check_for_file_mentions(f"Please check `{fname}`") @@ -362,5 +369,185 @@ def test_run_with_invalid_request_error(self, mock_chat_completion_create): with self.assertRaises(openai.error.InvalidRequestError): coder.run(with_message="hi") - if __name__ == "__main__": - unittest.main() + def test_new_file_edit_one_commit(self): + """A new file shouldn't get pre-committed before the GPT edit commit""" + with GitTemporaryDirectory(): + repo = git.Repo() + + fname = Path("file.txt") + + io = InputOutput(yes=True) + coder = Coder.create(models.GPT4, "diff", io=io, fnames=[str(fname)]) + + self.assertTrue(fname.exists()) + + # make sure it was not committed + with self.assertRaises(git.exc.GitCommandError): + list(repo.iter_commits(repo.active_branch.name)) + + def mock_send(*args, **kwargs): + coder.partial_response_content = f""" +Do this: + +{str(fname)} +<<<<<<< HEAD +======= +new +>>>>>>> updated + +""" + coder.partial_response_function_call = dict() + + coder.send = MagicMock(side_effect=mock_send) + coder.repo.get_commit_message = MagicMock() + coder.repo.get_commit_message.return_value = "commit message" + + coder.run(with_message="hi") + + content = fname.read_text() + self.assertEqual(content, "new\n") + + num_commits = len(list(repo.iter_commits(repo.active_branch.name))) + self.assertEqual(num_commits, 1) + + def test_only_commit_gpt_edited_file(self): + """ + Only commit file that gpt edits, not other dirty files. + Also ensure commit msg only depends on diffs from the GPT edited file. + """ + + with GitTemporaryDirectory(): + repo = git.Repo() + + fname1 = Path("file1.txt") + fname2 = Path("file2.txt") + + fname1.write_text("one\n") + fname2.write_text("two\n") + + repo.git.add(str(fname1)) + repo.git.add(str(fname2)) + repo.git.commit("-m", "new") + + # DIRTY! + fname1.write_text("ONE\n") + + io = InputOutput(yes=True) + coder = Coder.create(models.GPT4, "diff", io=io, fnames=[str(fname1), str(fname2)]) + + def mock_send(*args, **kwargs): + coder.partial_response_content = f""" +Do this: + +{str(fname2)} +<<<<<<< HEAD +two +======= +TWO +>>>>>>> updated + +""" + coder.partial_response_function_call = dict() + + def mock_get_commit_message(diffs, context): + self.assertNotIn("one", diffs) + self.assertNotIn("ONE", diffs) + return "commit message" + + coder.send = MagicMock(side_effect=mock_send) + coder.repo.get_commit_message = MagicMock(side_effect=mock_get_commit_message) + + coder.run(with_message="hi") + + content = fname2.read_text() + self.assertEqual(content, "TWO\n") + + self.assertTrue(repo.is_dirty(path=str(fname1))) + + def test_gpt_edit_to_dirty_file(self): + """A dirty file should be committed before the GPT edits are committed""" + + with GitTemporaryDirectory(): + repo = git.Repo() + + fname = Path("file.txt") + fname.write_text("one\n") + repo.git.add(str(fname)) + + fname2 = Path("other.txt") + fname2.write_text("other\n") + repo.git.add(str(fname2)) + + repo.git.commit("-m", "new") + + # dirty + fname.write_text("two\n") + fname2.write_text("OTHER\n") + + io = InputOutput(yes=True) + coder = Coder.create(models.GPT4, "diff", io=io, fnames=[str(fname)]) + + def mock_send(*args, **kwargs): + coder.partial_response_content = f""" +Do this: + +{str(fname)} +<<<<<<< HEAD +two +======= +three +>>>>>>> updated + +""" + coder.partial_response_function_call = dict() + + saved_diffs = [] + + def mock_get_commit_message(diffs, context): + saved_diffs.append(diffs) + return "commit message" + + coder.repo.get_commit_message = MagicMock(side_effect=mock_get_commit_message) + coder.send = MagicMock(side_effect=mock_send) + + coder.run(with_message="hi") + + content = fname.read_text() + self.assertEqual(content, "three\n") + + num_commits = len(list(repo.iter_commits(repo.active_branch.name))) + self.assertEqual(num_commits, 3) + + diff = repo.git.diff(["HEAD~2", "HEAD~1"]) + self.assertIn("one", diff) + self.assertIn("two", diff) + self.assertNotIn("three", diff) + self.assertNotIn("other", diff) + self.assertNotIn("OTHER", diff) + + diff = saved_diffs[0] + self.assertIn("one", diff) + self.assertIn("two", diff) + self.assertNotIn("three", diff) + self.assertNotIn("other", diff) + self.assertNotIn("OTHER", diff) + + diff = repo.git.diff(["HEAD~1", "HEAD"]) + self.assertNotIn("one", diff) + self.assertIn("two", diff) + self.assertIn("three", diff) + self.assertNotIn("other", diff) + self.assertNotIn("OTHER", diff) + + diff = saved_diffs[1] + self.assertNotIn("one", diff) + self.assertIn("two", diff) + self.assertIn("three", diff) + self.assertNotIn("other", diff) + self.assertNotIn("OTHER", diff) + + self.assertEqual(len(saved_diffs), 2) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_repo.py b/tests/test_repo.py index aee78abdfbc..77092c2da4c 100644 --- a/tests/test_repo.py +++ b/tests/test_repo.py @@ -26,7 +26,7 @@ def test_diffs_empty_repo(self): fname.write_text("workingdir\n") git_repo = GitRepo(InputOutput(), None, ".") - diffs = git_repo.get_diffs(False) + diffs = git_repo.get_diffs() self.assertIn("index", diffs) self.assertIn("workingdir", diffs) @@ -49,7 +49,7 @@ def test_diffs_nonempty_repo(self): fname2.write_text("workingdir\n") git_repo = GitRepo(InputOutput(), None, ".") - diffs = git_repo.get_diffs(False) + diffs = git_repo.get_diffs() self.assertIn("index", diffs) self.assertIn("workingdir", diffs) @@ -67,7 +67,7 @@ def test_diffs_between_commits(self): repo.git.commit("-m", "second") git_repo = GitRepo(InputOutput(), None, ".") - diffs = git_repo.get_diffs(False, ["HEAD~1", "HEAD"]) + diffs = git_repo.diff_commits(False, "HEAD~1", "HEAD") dump(diffs) self.assertIn("two", diffs) diff --git a/tests/test_wholefile.py b/tests/test_wholefile.py index 8f9f89fc5bd..29cc74fa246 100644 --- a/tests/test_wholefile.py +++ b/tests/test_wholefile.py @@ -90,7 +90,7 @@ def test_update_files_live_diff(self): # Set the partial response content with the updated content coder.partial_response_content = f"{sample_file}\n```\n0\n\1\n2\n" - lines = coder.update_files(mode="diff").splitlines() + lines = coder.get_edits(mode="diff").splitlines() # the live diff should be concise, since we haven't changed anything yet self.assertLess(len(lines), 20)

diff --git a/HISTORY.md b/HISTORY.md index b033f264ac7..8f8750dc81e 100644 --- a/HISTORY.md +++ b/HISTORY.md @@ -2,6 +2,7 @@ ### main branch +- [Only git commit dirty files that GPT tries to edit](https://aider.chat/docs/faq.html#how-does-aider-use-git) - Send chat history as prompt/context for Whisper voice transcription - Added `--voice-language` switch to constrain `/voice` to transcribe to a specific language diff --git a/docs/faq.md b/docs/faq.md index 789adecb512..806ff0c5508 100644 --- a/docs/faq.md +++ b/docs/faq.md @@ -13,29 +13,29 @@ It is recommended that you use aider with code that is part of a git repo. This allows aider to maintain the safety of your code. Using git makes it easy to: - - Review the changes GPT made to your code - - Undo changes that weren't appropriate + - Undo any changes that weren't appropriate + - Go back later to review the changes GPT made to your code - Manage a series of GPT's changes on a git branch - - etc -Working without git means that GPT might drastically change your code without an easy way to undo the changes. +Working without git means that GPT might drastically change your code +without an easy way to undo the changes. Aider tries to provide safety using git in a few ways: - It asks to create a git repo if you launch it in a directory without one. - - When you add a file to the chat, aider asks permission to add it to the git repo if needed. - - At launch and before sending requests to GPT, aider checks if the repo is dirty and offers to commit those changes for you. This way, the GPT changes will be applied to a clean repo and won't be intermingled with your own changes. - - After GPT changes your code, aider commits those changes with a descriptive commit message. - + - Whenever GPT edits a file, those changes are committed with a descriptive commit message. This makes it easy to revert or review GPT's changes. + - If GPT tries to edit files that already have uncommitted changes (dirty files), aider will first commit those existing changes with a descriptive commit message. This makes sure you never lose your work if GPT makes an inappropriate change to uncommitted code. + Aider also allows you to use in-chat commands to `/diff` or `/undo` the last change made by GPT. -To do more complex management of your git history, you should use `git` on the command line outside of aider. +To do more complex management of your git history, you cat use raw `git` commands, +either by using `/git` or with git tools outside of aider. You can start a branch before using aider to make a sequence of changes. Or you can `git reset` a longer series of aider changes that didn't pan out. Etc. While it is not recommended, you can disable aider's use of git in a few ways: - `--no-auto-commits` will stop aider from git committing each of GPT's changes. - - `--no-dirty-commits` will stop aider from ensuring your repo is clean before sending requests to GPT. + - `--no-dirty-commits` will stop aider from committing dirty files before applying GPT's edits. - `--no-git` will completely stop aider from using git on your files. You should ensure you are keeping sensible backups of the files you are working with.

[ { "components": [ { "doc": "", "lines": [ 710, 724 ], "name": "Coder.check_for_dirty_commit", "signature": "def check_for_dirty_commit(self, path):", "type": "function" }, { "doc": "", "lines": [ 770,...

[ "tests/test_coder.py::TestCoder::test_allowed_to_edit", "tests/test_coder.py::TestCoder::test_allowed_to_edit_dirty", "tests/test_coder.py::TestCoder::test_allowed_to_edit_no", "tests/test_coder.py::TestCoder::test_gpt_edit_to_dirty_file", "tests/test_coder.py::TestCoder::test_only_commit_gpt_edited_file", ...

[ "tests/test_coder.py::TestCoder::test_check_for_ambiguous_filename_mentions_of_longer_paths", "tests/test_coder.py::TestCoder::test_check_for_file_mentions", "tests/test_coder.py::TestCoder::test_check_for_filename_mentions_of_longer_paths", "tests/test_coder.py::TestCoder::test_check_for_subdir_mention", "...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Only commit dirty files if GPT tries to edit them #200 Discussed in #200 If GPT tries to edit a dirty file, aider will just commit the dirty changes (with a nice message) before applying and committing GPT's edits. You now never get interrupted and asked about pending dirty changes. Aider just commits them for you to keep them distinct from GPT's edits and preserve the ability to cleanly undo GPT's changes. And dirty changes are only ever committed by aider if the file is about to get modified by GPT. As always, aider still respects the --no-dirty-commits flag. If set, it will apply GPT's edits without first committing dirty files. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in aider/coders/base_coder.py] (definition of Coder.check_for_dirty_commit:) def check_for_dirty_commit(self, path): (definition of Coder.prepare_to_edit:) def prepare_to_edit(self, edits): (definition of Coder.update_files:) def update_files(self): [end of new definitions in aider/coders/base_coder.py] [start of new definitions in aider/coders/editblock_coder.py] (definition of EditBlockCoder.get_edits:) def get_edits(self): (definition of EditBlockCoder.apply_edits:) def apply_edits(self, edits): [end of new definitions in aider/coders/editblock_coder.py] [start of new definitions in aider/coders/editblock_func_coder.py] (definition of EditBlockFunctionCoder._update_files:) def _update_files(self): [end of new definitions in aider/coders/editblock_func_coder.py] [start of new definitions in aider/coders/single_wholefile_func_coder.py] (definition of SingleWholeFileFunctionCoder._update_files:) def _update_files(self): [end of new definitions in aider/coders/single_wholefile_func_coder.py] [start of new definitions in aider/coders/wholefile_coder.py] (definition of WholeFileCoder.get_edits:) def get_edits(self, mode="update"): (definition of WholeFileCoder.apply_edits:) def apply_edits(self, edits): [end of new definitions in aider/coders/wholefile_coder.py] [start of new definitions in aider/coders/wholefile_func_coder.py] (definition of WholeFileFunctionCoder._update_files:) def _update_files(self): [end of new definitions in aider/coders/wholefile_func_coder.py] [start of new definitions in aider/repo.py] (definition of GitRepo.diff_commits:) def diff_commits(self, pretty, from_commit, to_commit): (definition of GitRepo.path_in_repo:) def path_in_repo(self, path): (definition of GitRepo.abs_root_path:) def abs_root_path(self, path): [end of new definitions in aider/repo.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

43047c38358d7453c5778d4415475f152e4c562e

sphinx-doc__sphinx-11592

11,592

sphinx-doc/sphinx

7.4

3d118ce81c368c0143e90a096cef3a872be2eece

2023-08-15T08:53:52Z

diff --git a/CHANGES.rst b/CHANGES.rst index fcdcf2df9af..1f178f5c200 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -71,6 +71,9 @@ Features added * #12523: Added configuration option, :confval:`math_numsep`, to define the separator for math numbering. Patch by Thomas Fanning +* #11592: Add :confval:`coverage_modules` to the coverage builder + to allow explicitly specifying which modules should be documented. + Patch by Stephen Finucane. Bugs fixed ---------- diff --git a/doc/usage/extensions/coverage.rst b/doc/usage/extensions/coverage.rst index b9c493b5f3b..75ffc0f59ed 100644 --- a/doc/usage/extensions/coverage.rst +++ b/doc/usage/extensions/coverage.rst @@ -6,15 +6,64 @@ This extension features one additional builder, the :class:`CoverageBuilder`. -.. class:: CoverageBuilder +.. todo:: Write this section. - To use this builder, activate the coverage extension in your configuration - file and give ``-M coverage`` on the command line. +.. note:: -.. todo:: Write this section. + The :doc:`sphinx-apidoc </man/sphinx-apidoc>` command can be used to + automatically generate API documentation for all code in a project, + avoiding the need to manually author these documents and keep them up-to-date. + +.. warning:: + + :mod:`~sphinx.ext.coverage` **imports** the modules to be documented. + If any modules have side effects on import, + these will be executed by the coverage builder when ``sphinx-build`` is run. + + If you document scripts (as opposed to library modules), + make sure their main routine is protected by a + ``if __name__ == '__main__'`` condition. + +.. note:: + + For Sphinx (actually, the Python interpreter that executes Sphinx) + to find your module, it must be importable. + That means that the module or the package must be in + one of the directories on :data:`sys.path` -- adapt your :data:`sys.path` + in the configuration file accordingly. + +To use this builder, activate the coverage extension in your configuration file +and run ``sphinx-build -M coverage`` on the command line. + + +Builder +------- + +.. py:class:: CoverageBuilder + + +Configuration +------------- + +Several configuration values can be used to specify +what the builder should check: + +.. confval:: coverage_modules + :type: ``list[str]`` + :default: ``[]`` + + List of Python packages or modules to test coverage for. + When this is provided, Sphinx will introspect each package + or module provided in this list as well + as all sub-packages and sub-modules found in each. + When this is not provided, Sphinx will only provide coverage + for Python packages and modules that it is aware of: + that is, any modules documented using the :rst:dir:`py:module` directive + provided in the :doc:`Python domain </usage/domains/python>` + or the :rst:dir:`automodule` directive provided by the + :mod:`~sphinx.ext.autodoc` extension. -Several configuration values can be used to specify what the builder -should check: + .. versionadded:: 7.4 .. confval:: coverage_ignore_modules diff --git a/sphinx/ext/coverage.py b/sphinx/ext/coverage.py index cfe093623c1..f7ce3beaa65 100644 --- a/sphinx/ext/coverage.py +++ b/sphinx/ext/coverage.py @@ -9,6 +9,7 @@ import glob import inspect import pickle +import pkgutil import re import sys from importlib import import_module @@ -23,7 +24,7 @@ from sphinx.util.inspect import safe_getattr if TYPE_CHECKING: - from collections.abc import Iterator + from collections.abc import Iterable, Iterator, Sequence, Set from sphinx.application import Sphinx from sphinx.util.typing import ExtensionMetadata @@ -66,6 +67,93 @@ def _add_row(col_widths: list[int], columns: list[str], separator: str) -> Itera yield _add_line(col_widths, separator) +def _load_modules(mod_name: str, ignored_module_exps: Iterable[re.Pattern[str]]) -> Set[str]: + """Recursively load all submodules. + + :param mod_name: The name of a module to load submodules for. + :param ignored_module_exps: A list of regexes for modules to ignore. + :returns: A set of modules names including the provided module name, + ``mod_name`` + :raises ImportError: If the module indicated by ``mod_name`` could not be + loaded. + """ + if any(exp.match(mod_name) for exp in ignored_module_exps): + return set() + + # This can raise an exception, which must be handled by the caller. + mod = import_module(mod_name) + modules = {mod_name} + if mod.__spec__ is None: + return modules + + search_locations = mod.__spec__.submodule_search_locations + for (_, sub_mod_name, sub_mod_ispkg) in pkgutil.iter_modules(search_locations): + if sub_mod_name == '__main__': + continue + + if sub_mod_ispkg: + modules |= _load_modules(f'{mod_name}.{sub_mod_name}', ignored_module_exps) + else: + if any(exp.match(sub_mod_name) for exp in ignored_module_exps): + continue + modules.add(f'{mod_name}.{sub_mod_name}') + + return modules + + +def _determine_py_coverage_modules( + coverage_modules: Sequence[str], + seen_modules: Set[str], + ignored_module_exps: Iterable[re.Pattern[str]], + py_undoc: dict[str, dict[str, Any]], +) -> list[str]: + """Return a sorted list of modules to check for coverage. + + Figure out which of the two operating modes to use: + + - If 'coverage_modules' is not specified, we check coverage for all modules + seen in the documentation tree. Any objects found in these modules that are + not documented will be noted. This will therefore only identify missing + objects, but it requires no additional configuration. + + - If 'coverage_modules' is specified, we check coverage for all modules + specified in this configuration value. Any objects found in these modules + that are not documented will be noted. In addition, any objects from other + modules that are documented will be noted. This will therefore identify both + missing modules and missing objects, but it requires manual configuration. + """ + if not coverage_modules: + return sorted(seen_modules) + + modules: set[str] = set() + for mod_name in coverage_modules: + try: + modules |= _load_modules(mod_name, ignored_module_exps) + except ImportError as err: + # TODO(stephenfin): Define a subtype for all logs in this module + logger.warning(__('module %s could not be imported: %s'), mod_name, err) + py_undoc[mod_name] = {'error': err} + continue + + # if there are additional modules then we warn but continue scanning + if additional_modules := seen_modules - modules: + logger.warning( + __('the following modules are documented but were not specified ' + 'in coverage_modules: %s'), + ', '.join(additional_modules), + ) + + # likewise, if there are missing modules we warn but continue scanning + if missing_modules := modules - seen_modules: + logger.warning( + __('the following modules are specified in coverage_modules ' + 'but were not documented'), + ', '.join(missing_modules), + ) + + return sorted(modules) + + class CoverageBuilder(Builder): """ Evaluates coverage of code in the documentation. @@ -106,12 +194,12 @@ def get_outdated_docs(self) -> str: def write(self, *ignored: Any) -> None: self.py_undoc: dict[str, dict[str, Any]] = {} - self.py_undocumented: dict[str, set[str]] = {} - self.py_documented: dict[str, set[str]] = {} + self.py_undocumented: dict[str, Set[str]] = {} + self.py_documented: dict[str, Set[str]] = {} self.build_py_coverage() self.write_py_coverage() - self.c_undoc: dict[str, set[tuple[str, str]]] = {} + self.c_undoc: dict[str, Set[tuple[str, str]]] = {} self.build_c_coverage() self.write_c_coverage() @@ -169,11 +257,14 @@ def ignore_pyobj(self, full_name: str) -> bool: ) def build_py_coverage(self) -> None: - objects = self.env.domaindata['py']['objects'] - modules = self.env.domaindata['py']['modules'] + seen_objects = frozenset(self.env.domaindata['py']['objects']) + seen_modules = frozenset(self.env.domaindata['py']['modules']) skip_undoc = self.config.coverage_skip_undoc_in_source + modules = _determine_py_coverage_modules( + self.config.coverage_modules, seen_modules, self.mod_ignorexps, self.py_undoc, + ) for mod_name in modules: ignore = False for exp in self.mod_ignorexps: @@ -213,7 +304,7 @@ def build_py_coverage(self) -> None: continue if inspect.isfunction(obj): - if full_name not in objects: + if full_name not in seen_objects: for exp in self.fun_ignorexps: if exp.match(name): break @@ -229,7 +320,7 @@ def build_py_coverage(self) -> None: if exp.match(name): break else: - if full_name not in objects: + if full_name not in seen_objects: if skip_undoc and not obj.__doc__: continue # not documented at all @@ -257,7 +348,7 @@ def build_py_coverage(self) -> None: full_attr_name = f'{full_name}.{attr_name}' if self.ignore_pyobj(full_attr_name): continue - if full_attr_name not in objects: + if full_attr_name not in seen_objects: attrs.append(attr_name) undocumented_objects.add(full_attr_name) else: @@ -273,19 +364,17 @@ def build_py_coverage(self) -> None: def _write_py_statistics(self, op: TextIO) -> None: """Outputs the table of ``op``.""" - all_modules = set(self.py_documented.keys()).union( - set(self.py_undocumented.keys())) - all_objects: set[str] = set() - all_documented_objects: set[str] = set() + all_modules = frozenset(self.py_documented.keys() | self.py_undocumented.keys()) + all_objects: Set[str] = set() + all_documented_objects: Set[str] = set() for module in all_modules: - all_module_objects = self.py_documented[module].union(self.py_undocumented[module]) - all_objects = all_objects.union(all_module_objects) - all_documented_objects = all_documented_objects.union(self.py_documented[module]) + all_objects |= self.py_documented[module] | self.py_undocumented[module] + all_documented_objects |= self.py_documented[module] # prepare tabular table = [['Module', 'Coverage', 'Undocumented']] - for module in all_modules: - module_objects = self.py_documented[module].union(self.py_undocumented[module]) + for module in sorted(all_modules): + module_objects = self.py_documented[module] | self.py_undocumented[module] if len(module_objects): value = 100.0 * len(self.py_documented[module]) / len(module_objects) else: @@ -391,6 +480,7 @@ def finish(self) -> None: def setup(app: Sphinx) -> ExtensionMetadata: app.add_builder(CoverageBuilder) + app.add_config_value('coverage_modules', (), '', types={tuple, list}) app.add_config_value('coverage_ignore_modules', [], '') app.add_config_value('coverage_ignore_functions', [], '') app.add_config_value('coverage_ignore_classes', [], '')

diff --git a/tests/roots/test-ext-coverage/conf.py b/tests/roots/test-ext-coverage/conf.py index d3ec6e87f34..70fd03e91b2 100644 --- a/tests/roots/test-ext-coverage/conf.py +++ b/tests/roots/test-ext-coverage/conf.py @@ -5,8 +5,11 @@ extensions = ['sphinx.ext.autodoc', 'sphinx.ext.coverage'] +coverage_modules = [ + 'grog', +] coverage_ignore_pyobjects = [ - r'^coverage_ignored(\..*)?$', + r'^grog\.coverage_ignored(\..*)?$', r'\.Ignored$', r'\.Documented\.ignored\d$', ] diff --git a/tests/roots/test-ext-coverage/grog/__init__.py b/tests/roots/test-ext-coverage/grog/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tests/roots/test-ext-coverage/coverage_ignored.py b/tests/roots/test-ext-coverage/grog/coverage_ignored.py similarity index 100% rename from tests/roots/test-ext-coverage/coverage_ignored.py rename to tests/roots/test-ext-coverage/grog/coverage_ignored.py diff --git a/tests/roots/test-ext-coverage/grog/coverage_missing.py b/tests/roots/test-ext-coverage/grog/coverage_missing.py new file mode 100644 index 00000000000..2fe44338caa --- /dev/null +++ b/tests/roots/test-ext-coverage/grog/coverage_missing.py @@ -0,0 +1,7 @@ +"""This module is intentionally not documented.""" + +class Missing: + """An undocumented class.""" + + def missing_a(self): + """An undocumented method.""" diff --git a/tests/roots/test-ext-coverage/coverage_not_ignored.py b/tests/roots/test-ext-coverage/grog/coverage_not_ignored.py similarity index 100% rename from tests/roots/test-ext-coverage/coverage_not_ignored.py rename to tests/roots/test-ext-coverage/grog/coverage_not_ignored.py diff --git a/tests/roots/test-ext-coverage/index.rst b/tests/roots/test-ext-coverage/index.rst index b8468987ee2..85dccf9b1eb 100644 --- a/tests/roots/test-ext-coverage/index.rst +++ b/tests/roots/test-ext-coverage/index.rst @@ -1,6 +1,6 @@ -.. automodule:: coverage_ignored +.. automodule:: grog.coverage_ignored :members: -.. automodule:: coverage_not_ignored +.. automodule:: grog.coverage_not_ignored :members: diff --git a/tests/test_extensions/test_ext_coverage.py b/tests/test_extensions/test_ext_coverage.py index c9e9ba93a6d..ed7b5adac37 100644 --- a/tests/test_extensions/test_ext_coverage.py +++ b/tests/test_extensions/test_ext_coverage.py @@ -10,8 +10,10 @@ def test_build(app, status, warning): app.build(force_all=True) py_undoc = (app.outdir / 'python.txt').read_text(encoding='utf8') - assert py_undoc.startswith('Undocumented Python objects\n' - '===========================\n') + assert py_undoc.startswith( + 'Undocumented Python objects\n' + '===========================\n', + ) assert 'autodoc_target\n--------------\n' in py_undoc assert ' * Class -- missing methods:\n' in py_undoc assert ' * raises\n' in py_undoc @@ -23,8 +25,10 @@ def test_build(app, status, warning): assert "undocumented py" not in status.getvalue() c_undoc = (app.outdir / 'c.txt').read_text(encoding='utf8') - assert c_undoc.startswith('Undocumented C API elements\n' - '===========================\n') + assert c_undoc.startswith( + 'Undocumented C API elements\n' + '===========================\n', + ) assert 'api.h' in c_undoc assert ' * Py_SphinxTest' in c_undoc @@ -54,16 +58,26 @@ def test_coverage_ignore_pyobjects(app, status, warning): Statistics ---------- -+----------------------+----------+--------------+ -| Module | Coverage | Undocumented | -+======================+==========+==============+ -| coverage_not_ignored | 0.00% | 2 | -+----------------------+----------+--------------+ -| TOTAL | 0.00% | 2 | -+----------------------+----------+--------------+ ++---------------------------+----------+--------------+ +| Module | Coverage | Undocumented | ++===========================+==========+==============+ +| grog | 100.00% | 0 | ++---------------------------+----------+--------------+ +| grog.coverage_missing | 100.00% | 0 | ++---------------------------+----------+--------------+ +| grog.coverage_not_ignored | 0.00% | 2 | ++---------------------------+----------+--------------+ +| TOTAL | 0.00% | 2 | ++---------------------------+----------+--------------+ + +grog.coverage_missing +--------------------- -coverage_not_ignored --------------------- +Classes: + * Missing + +grog.coverage_not_ignored +------------------------- Classes: * Documented -- missing methods:

diff --git a/CHANGES.rst b/CHANGES.rst index fcdcf2df9af..1f178f5c200 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -71,6 +71,9 @@ Features added * #12523: Added configuration option, :confval:`math_numsep`, to define the separator for math numbering. Patch by Thomas Fanning +* #11592: Add :confval:`coverage_modules` to the coverage builder + to allow explicitly specifying which modules should be documented. + Patch by Stephen Finucane. Bugs fixed ---------- diff --git a/doc/usage/extensions/coverage.rst b/doc/usage/extensions/coverage.rst index b9c493b5f3b..75ffc0f59ed 100644 --- a/doc/usage/extensions/coverage.rst +++ b/doc/usage/extensions/coverage.rst @@ -6,15 +6,64 @@ This extension features one additional builder, the :class:`CoverageBuilder`. -.. class:: CoverageBuilder +.. todo:: Write this section. - To use this builder, activate the coverage extension in your configuration - file and give ``-M coverage`` on the command line. +.. note:: -.. todo:: Write this section. + The :doc:`sphinx-apidoc </man/sphinx-apidoc>` command can be used to + automatically generate API documentation for all code in a project, + avoiding the need to manually author these documents and keep them up-to-date. + +.. warning:: + + :mod:`~sphinx.ext.coverage` **imports** the modules to be documented. + If any modules have side effects on import, + these will be executed by the coverage builder when ``sphinx-build`` is run. + + If you document scripts (as opposed to library modules), + make sure their main routine is protected by a + ``if __name__ == '__main__'`` condition. + +.. note:: + + For Sphinx (actually, the Python interpreter that executes Sphinx) + to find your module, it must be importable. + That means that the module or the package must be in + one of the directories on :data:`sys.path` -- adapt your :data:`sys.path` + in the configuration file accordingly. + +To use this builder, activate the coverage extension in your configuration file +and run ``sphinx-build -M coverage`` on the command line. + + +Builder +------- + +.. py:class:: CoverageBuilder + + +Configuration +------------- + +Several configuration values can be used to specify +what the builder should check: + +.. confval:: coverage_modules + :type: ``list[str]`` + :default: ``[]`` + + List of Python packages or modules to test coverage for. + When this is provided, Sphinx will introspect each package + or module provided in this list as well + as all sub-packages and sub-modules found in each. + When this is not provided, Sphinx will only provide coverage + for Python packages and modules that it is aware of: + that is, any modules documented using the :rst:dir:`py:module` directive + provided in the :doc:`Python domain </usage/domains/python>` + or the :rst:dir:`automodule` directive provided by the + :mod:`~sphinx.ext.autodoc` extension. -Several configuration values can be used to specify what the builder -should check: + .. versionadded:: 7.4 .. confval:: coverage_ignore_modules

[ { "components": [ { "doc": "Recursively load all submodules.\n\n:param mod_name: The name of a module to load submodules for.\n:param ignored_module_exps: A list of regexes for modules to ignore.\n:returns: A set of modules names including the provided module name,\n ``mod_name``\n:raises Impor...

[ "tests/test_extensions/test_ext_coverage.py::test_coverage_ignore_pyobjects" ]

[ "tests/test_extensions/test_ext_coverage.py::test_build", "tests/test_extensions/test_ext_coverage.py::test_show_missing_items", "tests/test_extensions/test_ext_coverage.py::test_show_missing_items_quiet" ]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> coverage: Specify modules to run coverage for ### Feature or Bugfix Feature ### Purpose Currently, the coverage builder lets you check for partially documented modules, but there is no mechanism to identify totally undocumented modules. Resolve this by introducing a new `coverage_modules` config option. This is a list of modules that should be documented somewhere within the documentation tree. Any modules that are specified in the configuration value but are not documented anywhere will result in a warning. Likewise, any modules that are not in the config option but are documented somewhere will result in a warning. > **Note** > I have a WIP series locally that will complete the documentation for this module and close out #1288, but I'm keeping that out of this to avoid making it any more complicated than necessary. ### Detail (none) ### Relates (none) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sphinx/ext/coverage.py] (definition of _load_modules:) def _load_modules(mod_name: str, ignored_module_exps: Iterable[re.Pattern[str]]) -> Set[str]: """Recursively load all submodules. :param mod_name: The name of a module to load submodules for. :param ignored_module_exps: A list of regexes for modules to ignore. :returns: A set of modules names including the provided module name, ``mod_name`` :raises ImportError: If the module indicated by ``mod_name`` could not be loaded.""" (definition of _determine_py_coverage_modules:) def _determine_py_coverage_modules( coverage_modules: Sequence[str], seen_modules: Set[str], ignored_module_exps: Iterable[re.Pattern[str]], py_undoc: dict[str, dict[str, Any]], ) -> list[str]: """Return a sorted list of modules to check for coverage. Figure out which of the two operating modes to use: - If 'coverage_modules' is not specified, we check coverage for all modules seen in the documentation tree. Any objects found in these modules that are not documented will be noted. This will therefore only identify missing objects, but it requires no additional configuration. - If 'coverage_modules' is specified, we check coverage for all modules specified in this configuration value. Any objects found in these modules that are not documented will be noted. In addition, any objects from other modules that are documented will be noted. This will therefore identify both missing modules and missing objects, but it requires manual configuration.""" [end of new definitions in sphinx/ext/coverage.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

35e7bfc347f845deff50787f0cd0340ea2ea0a5d

pvlib__pvlib-python-1834

1,834

pvlib/pvlib-python

0.9

2d04aeb72e4d8509839486b4e9085b0d85f58c44

2023-08-14T13:56:53Z

diff --git a/docs/sphinx/source/reference/irradiance/decomposition.rst b/docs/sphinx/source/reference/irradiance/decomposition.rst index 08724be38e..eede9df089 100644 --- a/docs/sphinx/source/reference/irradiance/decomposition.rst +++ b/docs/sphinx/source/reference/irradiance/decomposition.rst @@ -12,6 +12,7 @@ DNI estimation models irradiance.dirint irradiance.dirindex irradiance.erbs + irradiance.erbs_driesse irradiance.orgill_hollands irradiance.boland irradiance.campbell_norman diff --git a/docs/sphinx/source/whatsnew/v0.10.2.rst b/docs/sphinx/source/whatsnew/v0.10.2.rst index 42b81f5e5d..e1bf89dcd3 100644 --- a/docs/sphinx/source/whatsnew/v0.10.2.rst +++ b/docs/sphinx/source/whatsnew/v0.10.2.rst @@ -15,8 +15,10 @@ Enhancements :py:func:`pvlib.iotools.get_pvgis_hourly`, :py:func:`pvlib.iotools.get_cams`, :py:func:`pvlib.iotools.get_bsrn`, and :py:func:`pvlib.iotools.read_midc_raw_data_from_nrel`. (:pull:`1800`) -* Added option to infer threshold values for +* Added option to infer threshold values for :py:func:`pvlib.clearsky.detect_clearsky` (:issue:`1808`, :pull:`1784`) +* Added a continuous version of the Erbs diffuse-fraction/decomposition model. + :py:func:`pvlib.irradiance.erbs_driesse` (:issue:`1755`, :pull:`1834`) Bug fixes @@ -52,5 +54,6 @@ Contributors * Abigail Jones (:ghuser:`ajonesr`) * Taos Transue (:ghuser:`reepoi`) * NativeSci (:ghuser:`nativesci`) +* Anton Driesse (:ghuser:`adriesse`) * Lukas Grossar (:ghuser:`tongpu`) * Areeba Turabi (:ghuser:`aturabi`) diff --git a/pvlib/irradiance.py b/pvlib/irradiance.py index beec6dd0b2..48cc28c33a 100644 --- a/pvlib/irradiance.py +++ b/pvlib/irradiance.py @@ -2267,6 +2267,136 @@ def erbs(ghi, zenith, datetime_or_doy, min_cos_zenith=0.065, max_zenith=87): return data +def erbs_driesse(ghi, zenith, datetime_or_doy=None, dni_extra=None, + min_cos_zenith=0.065, max_zenith=87): + r""" + Estimate DNI and DHI from GHI using the continuous Erbs-Driesse model. + + The Erbs-Driesse model [1]_ is a reformulation of the original Erbs + model [2]_ that provides continuity of the function and its first + derivative at the two transition points. + + .. math:: + + DHI = DF \times GHI + + DNI is then estimated as + + .. math:: + + DNI = (GHI - DHI)/\cos(Z) + + where Z is the zenith angle. + + Parameters + ---------- + ghi: numeric + Global horizontal irradiance in W/m^2. + zenith: numeric + True (not refraction-corrected) zenith angles in decimal degrees. + datetime_or_doy : int, float, array, pd.DatetimeIndex, default None + Day of year or array of days of year e.g. + pd.DatetimeIndex.dayofyear, or pd.DatetimeIndex. + Either datetime_or_doy or dni_extra must be provided. + dni_extra : numeric, default None + Extraterrestrial normal irradiance. + dni_extra can be provided if available to avoid recalculating it + inside this function. In this case datetime_or_doy is not required. + min_cos_zenith : numeric, default 0.065 + Minimum value of cos(zenith) to allow when calculating global + clearness index `kt`. Equivalent to zenith = 86.273 degrees. + max_zenith : numeric, default 87 + Maximum value of zenith to allow in DNI calculation. DNI will be + set to 0 for times with zenith values greater than `max_zenith`. + + Returns + ------- + data : OrderedDict or DataFrame + Contains the following keys/columns: + + * ``dni``: the modeled direct normal irradiance in W/m^2. + * ``dhi``: the modeled diffuse horizontal irradiance in + W/m^2. + * ``kt``: Ratio of global to extraterrestrial irradiance + on a horizontal plane. + + Raises + ------ + ValueError + If neither datetime_or_doy nor dni_extra is provided. + + Notes + ----- + The diffuse fraction DHI/GHI of the Erbs-Driesse model deviates from the + original Erbs model by less than 0.0005. + + References + ---------- + .. [1] A. Driesse, A. Jensen, R. Perez, A Continuous Form of the Perez + Diffuse Sky Model for Forward and Reverse Transposition, forthcoming. + + .. [2] D. G. Erbs, S. A. Klein and J. A. Duffie, Estimation of the + diffuse radiation fraction for hourly, daily and monthly-average + global radiation, Solar Energy 28(4), pp 293-302, 1982. Eq. 1 + + See also + -------- + erbs + dirint + disc + orgill_hollands + boland + """ + # central polynomial coefficients with float64 precision + p = [+12.26911439571261000, + -16.47050842469730700, + +04.24692671521831700, + -00.11390583806313881, + +00.94629663357100100] + + if datetime_or_doy is None and dni_extra is None: + raise ValueError('Either datetime_or_doy or dni_extra ' + 'must be provided.') + + if dni_extra is None: + dni_extra = get_extra_radiation(datetime_or_doy) + + # negative ghi should not reach this point, but just in case + ghi = np.maximum(0, ghi) + + kt = clearness_index(ghi, zenith, dni_extra, min_cos_zenith=min_cos_zenith, + max_clearness_index=1) + + # For all Kt, set the default diffuse fraction + df = 1 - 0.09 * kt + + # For Kt > 0.216, update the diffuse fraction + df = np.where(kt > 0.216, np.polyval(p, kt), df) + + # For Kt > 0.792, update the diffuse fraction again + df = np.where(kt > 0.792, 0.165, df) + + dhi = df * ghi + + dni = (ghi - dhi) / tools.cosd(zenith) + bad_values = (zenith > max_zenith) | (ghi < 0) | (dni < 0) + dni = np.where(bad_values, 0, dni) + # ensure that closure relationship remains valid + dhi = np.where(bad_values, ghi, dhi) + + data = OrderedDict() + data['dni'] = dni + data['dhi'] = dhi + data['kt'] = kt + + if isinstance(datetime_or_doy, pd.DatetimeIndex): + data = pd.DataFrame(data, index=datetime_or_doy) + elif isinstance(ghi, pd.Series): + data = pd.DataFrame(data, index=ghi.index) + + return data + + def orgill_hollands(ghi, zenith, datetime_or_doy, dni_extra=None, min_cos_zenith=0.065, max_zenith=87): """Estimate DNI and DHI from GHI using the Orgill and Hollands model.

diff --git a/pvlib/tests/test_irradiance.py b/pvlib/tests/test_irradiance.py index ab1af612a7..2f660d5c97 100644 --- a/pvlib/tests/test_irradiance.py +++ b/pvlib/tests/test_irradiance.py @@ -805,6 +805,34 @@ def test_erbs(): assert_frame_equal(np.round(out, 0), np.round(expected, 0)) +def test_erbs_driesse(): + index = pd.DatetimeIndex(['20190101']*3 + ['20190620']) + ghi = pd.Series([0, 50, 1000, 1000], index=index) + zenith = pd.Series([120, 85, 10, 10], index=index) + # expected values are the same as for erbs original test + expected = pd.DataFrame(np.array( + [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [9.67192672e+01, 4.15703604e+01, 4.05723511e-01], + [7.94205651e+02, 2.17860117e+02, 7.18132729e-01], + [8.42001578e+02, 1.70790318e+02, 7.68214312e-01]]), + columns=['dni', 'dhi', 'kt'], index=index) + + out = irradiance.erbs_driesse(ghi, zenith, index) + + assert_frame_equal(np.round(out, 0), np.round(expected, 0)) + + # test with the new optional dni_extra argument + dni_extra = irradiance.get_extra_radiation(index) + + out = irradiance.erbs_driesse(ghi, zenith, dni_extra=dni_extra) + + assert_frame_equal(np.round(out, 0), np.round(expected, 0)) + + # test for required inputs + with pytest.raises(ValueError): + irradiance.erbs_driesse(ghi, zenith) + + def test_boland(): index = pd.DatetimeIndex(['20190101']*3 + ['20190620']) ghi = pd.Series([0, 50, 1000, 1000], index=index)

diff --git a/docs/sphinx/source/reference/irradiance/decomposition.rst b/docs/sphinx/source/reference/irradiance/decomposition.rst index 08724be38e..eede9df089 100644 --- a/docs/sphinx/source/reference/irradiance/decomposition.rst +++ b/docs/sphinx/source/reference/irradiance/decomposition.rst @@ -12,6 +12,7 @@ DNI estimation models irradiance.dirint irradiance.dirindex irradiance.erbs + irradiance.erbs_driesse irradiance.orgill_hollands irradiance.boland irradiance.campbell_norman diff --git a/docs/sphinx/source/whatsnew/v0.10.2.rst b/docs/sphinx/source/whatsnew/v0.10.2.rst index 42b81f5e5d..e1bf89dcd3 100644 --- a/docs/sphinx/source/whatsnew/v0.10.2.rst +++ b/docs/sphinx/source/whatsnew/v0.10.2.rst @@ -15,8 +15,10 @@ Enhancements :py:func:`pvlib.iotools.get_pvgis_hourly`, :py:func:`pvlib.iotools.get_cams`, :py:func:`pvlib.iotools.get_bsrn`, and :py:func:`pvlib.iotools.read_midc_raw_data_from_nrel`. (:pull:`1800`) -* Added option to infer threshold values for +* Added option to infer threshold values for :py:func:`pvlib.clearsky.detect_clearsky` (:issue:`1808`, :pull:`1784`) +* Added a continuous version of the Erbs diffuse-fraction/decomposition model. + :py:func:`pvlib.irradiance.erbs_driesse` (:issue:`1755`, :pull:`1834`) Bug fixes @@ -52,5 +54,6 @@ Contributors * Abigail Jones (:ghuser:`ajonesr`) * Taos Transue (:ghuser:`reepoi`) * NativeSci (:ghuser:`nativesci`) +* Anton Driesse (:ghuser:`adriesse`) * Lukas Grossar (:ghuser:`tongpu`) * Areeba Turabi (:ghuser:`aturabi`)

[ { "components": [ { "doc": "Estimate DNI and DHI from GHI using the continuous Erbs-Driesse model.\n\nThe Erbs-Driesse model [1]_ is a reformulation of the original Erbs\nmodel [2]_ that provides continuity of the function and its first\nderivative at the two transition points.\n\n.. math::\n\n ...

[ "pvlib/tests/test_irradiance.py::test_erbs_driesse" ]

[ "pvlib/tests/test_irradiance.py::test_get_extra_radiation[asce-300-1383.636203]", "pvlib/tests/test_irradiance.py::test_get_extra_radiation[asce-300.0-1383.636203]", "pvlib/tests/test_irradiance.py::test_get_extra_radiation[asce-testval2-1383.636203]", "pvlib/tests/test_irradiance.py::test_get_extra_radiation...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Implement C1 continuous version of the Erbs diffuse-fraction/decomposition model  - [x] Closes #1755 - [x] I am familiar with the [contributing guidelines](https://pvlib-python.readthedocs.io/en/latest/contributing.html) - [x] Tests added - [x] Updates entries in [`docs/sphinx/source/reference`](https://github.com/pvlib/pvlib-python/blob/main/docs/sphinx/source/reference) for API changes. - [x] Adds description and name entries in the appropriate "what's new" file in [`docs/sphinx/source/whatsnew`](https://github.com/pvlib/pvlib-python/tree/main/docs/sphinx/source/whatsnew) for all changes. Includes link to the GitHub Issue with `` :issue:`num` `` or this Pull Request with `` :pull:`num` ``. Includes contributor name and/or GitHub username (link with `` :ghuser:`user` ``). - [x] New code is fully documented. Includes [numpydoc](https://numpydoc.readthedocs.io/en/latest/format.html) compliant docstrings, examples, and comments where necessary. - [x] Pull request is nearly complete and ready for detailed review. - [x] Maintainer: Appropriate GitHub Labels (including `remote-data`) and Milestone are assigned to the Pull Request and linked Issue.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pvlib/irradiance.py] (definition of erbs_driesse:) def erbs_driesse(ghi, zenith, datetime_or_doy=None, dni_extra=None, min_cos_zenith=0.065, max_zenith=87): """Estimate DNI and DHI from GHI using the continuous Erbs-Driesse model. The Erbs-Driesse model [1]_ is a reformulation of the original Erbs model [2]_ that provides continuity of the function and its first derivative at the two transition points. .. math:: DHI = DF \times GHI DNI is then estimated as .. math:: DNI = (GHI - DHI)/\cos(Z) where Z is the zenith angle. Parameters ---------- ghi: numeric Global horizontal irradiance in W/m^2. zenith: numeric True (not refraction-corrected) zenith angles in decimal degrees. datetime_or_doy : int, float, array, pd.DatetimeIndex, default None Day of year or array of days of year e.g. pd.DatetimeIndex.dayofyear, or pd.DatetimeIndex. Either datetime_or_doy or dni_extra must be provided. dni_extra : numeric, default None Extraterrestrial normal irradiance. dni_extra can be provided if available to avoid recalculating it inside this function. In this case datetime_or_doy is not required. min_cos_zenith : numeric, default 0.065 Minimum value of cos(zenith) to allow when calculating global clearness index `kt`. Equivalent to zenith = 86.273 degrees. max_zenith : numeric, default 87 Maximum value of zenith to allow in DNI calculation. DNI will be set to 0 for times with zenith values greater than `max_zenith`. Returns ------- data : OrderedDict or DataFrame Contains the following keys/columns: * ``dni``: the modeled direct normal irradiance in W/m^2. * ``dhi``: the modeled diffuse horizontal irradiance in W/m^2. * ``kt``: Ratio of global to extraterrestrial irradiance on a horizontal plane. Raises ------ ValueError If neither datetime_or_doy nor dni_extra is provided. Notes ----- The diffuse fraction DHI/GHI of the Erbs-Driesse model deviates from the original Erbs model by less than 0.0005. References ---------- .. [1] A. Driesse, A. Jensen, R. Perez, A Continuous Form of the Perez Diffuse Sky Model for Forward and Reverse Transposition, forthcoming. .. [2] D. G. Erbs, S. A. Klein and J. A. Duffie, Estimation of the diffuse radiation fraction for hourly, daily and monthly-average global radiation, Solar Energy 28(4), pp 293-302, 1982. Eq. 1 See also -------- erbs dirint disc orgill_hollands boland""" [end of new definitions in pvlib/irradiance.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Erbs diffuse fraction model has discontinuities at transition points **Is your feature request related to a problem? Please describe.** If you look closely at the piecewise definition of the Erbs diffuse fraction model you will see that it is discontinuous at the two transition points. This is not usually a problem, but when the Erbs model happens to be used in some kind of numerical optimization the discontinuities could cause problems. **Describe the solution you'd like** Add a new diffuse fraction function with a piecewise definition that closely matches the original Erbs model but is continuous. And while we're at it we can make the first derivative continuous too. **Describe alternatives you've considered** Modify the existing model function. **Additional context** This has been implemented and tested off line but I don't have the bandwidth for a PR currently. I thought I should mention it since it is somewhat relevant to #1753. ---------- -------------------- </issues>

d53f97e984bfdd268aa92f8bf482ced0edda0110

astropy__astropy-15168

15,168

astropy/astropy

5.2

ebefb4f216b9f6df7da895dcc9738e2ca73bdcf0

2023-08-14T02:13:26Z

diff --git a/astropy/cosmology/_io/html.py b/astropy/cosmology/_io/html.py index 948334c2c194..0606d1722b36 100644 --- a/astropy/cosmology/_io/html.py +++ b/astropy/cosmology/_io/html.py @@ -313,15 +313,15 @@ def write_html_table( cosmo_cls = type(cosmology) for name, col in table.columns.items(): - param = getattr(cosmo_cls, name, None) + param = cosmo_cls.parameters.get(name) if not isinstance(param, Parameter) or param.unit in (None, u.one): continue # Replace column with unitless version table.replace_column(name, (col << param.unit).value, copy=False) if latex_names: - new_names = [_FORMAT_TABLE.get(k, k) for k in cosmology.__parameters__] - table.rename_columns(cosmology.__parameters__, new_names) + new_names = [_FORMAT_TABLE.get(k, k) for k in cosmology.parameters] + table.rename_columns(tuple(cosmology.parameters), new_names) # Write HTML, using table I/O table.write(file, overwrite=overwrite, format="ascii.html", **kwargs) diff --git a/astropy/cosmology/_io/latex.py b/astropy/cosmology/_io/latex.py index 593a6af2ac17..70644dd156d3 100644 --- a/astropy/cosmology/_io/latex.py +++ b/astropy/cosmology/_io/latex.py @@ -170,7 +170,7 @@ def write_latex( cosmo_cls = type(cosmology) for name in table.columns.keys(): - param = getattr(cosmo_cls, name, None) + param = cosmo_cls.parameters.get(name) if not isinstance(param, Parameter) or param.unit in (None, u.one): continue # Get column to correct unit @@ -178,8 +178,8 @@ def write_latex( # Convert parameter names to LaTeX format if latex_names: - new_names = [_FORMAT_TABLE.get(k, k) for k in cosmology.__parameters__] - table.rename_columns(cosmology.__parameters__, new_names) + new_names = [_FORMAT_TABLE.get(k, k) for k in cosmology.parameters] + table.rename_columns(tuple(cosmology.parameters), new_names) table.write(file, overwrite=overwrite, format="ascii.latex", **kwargs) diff --git a/astropy/cosmology/_io/mapping.py b/astropy/cosmology/_io/mapping.py index cbb7872b8062..9b41622469c5 100644 --- a/astropy/cosmology/_io/mapping.py +++ b/astropy/cosmology/_io/mapping.py @@ -403,13 +403,7 @@ def to_mapping( m.update(meta) # Add all the immutable inputs - m.update( - { - k: v - for k, v in cosmology._init_arguments.items() - if k not in ("meta", "name") - } - ) + m.update(cosmology.parameters) # Lastly, add the metadata, if haven't already (above) if not move_from_meta: m["meta"] = meta # TODO? should meta be type(cls) diff --git a/astropy/cosmology/_io/model.py b/astropy/cosmology/_io/model.py index 962e38dd8dfc..a44fbce0075c 100644 --- a/astropy/cosmology/_io/model.py +++ b/astropy/cosmology/_io/model.py @@ -240,17 +240,13 @@ def to_model(cosmology, *_, method): attrs["n_inputs"] = n_inputs attrs["n_outputs"] = 1 - params = {} # Parameters (also class attributes) - for n in cosmology.__parameters__: - v = getattr(cosmology, n) # parameter value - - if v is None: # skip unspecified parameters - continue - - # add as Model Parameter - params[n] = convert_parameter_to_model_parameter( - getattr(cosmo_cls, n), v, cosmology.meta.get(n) + params = { + k: convert_parameter_to_model_parameter( + cosmo_cls.parameters[k], v, meta=cosmology.meta.get(k) ) + for k, v in cosmology.parameters.items() + if v is not None + } # class name is cosmology name + Cosmology + method name + Model clsname = ( @@ -269,8 +265,9 @@ def to_model(cosmology, *_, method): ) # instantiate class using default values - ps = {n: getattr(cosmology, n) for n in params.keys()} - model = CosmoModel(**ps, name=cosmology.name, meta=copy.deepcopy(cosmology.meta)) + model = CosmoModel( + **cosmology.parameters, name=cosmology.name, meta=copy.deepcopy(cosmology.meta) + ) return model diff --git a/astropy/cosmology/_io/table.py b/astropy/cosmology/_io/table.py index bb228f598ea3..03eaf8d132e5 100644 --- a/astropy/cosmology/_io/table.py +++ b/astropy/cosmology/_io/table.py @@ -428,9 +428,9 @@ def to_table(cosmology, *args, cls=QTable, cosmology_in_meta=True, rename=None): # - list for anything else cosmo_cls = cosmology.__class__ for k, v in data.items(): - if k in cosmology.__parameters__: + if k in cosmology.parameters: col = convert_parameter_to_column( - getattr(cosmo_cls, k), v, cosmology.meta.get(k) + cosmo_cls.parameters[k], v, cosmology.meta.get(k) ) else: col = Column([v]) diff --git a/astropy/cosmology/_utils.py b/astropy/cosmology/_utils.py index 8e080b800c97..6209ace2141d 100644 --- a/astropy/cosmology/_utils.py +++ b/astropy/cosmology/_utils.py @@ -1,7 +1,13 @@ # Licensed under a 3-clause BSD style license - see LICENSE.rst +from __future__ import annotations + +__all__ = [] # nothing is publicly scoped + import functools +import operator from numbers import Number +from typing import Any import numpy as np @@ -9,8 +15,6 @@ from . import units as cu -__all__ = [] # nothing is publicly scoped - def vectorize_redshift_method(func=None, nin=1): """Vectorize a method of redshift(s). @@ -71,3 +75,9 @@ def aszarr(z): return z # not one of the preferred types: Number / array ducktype return Quantity(z, cu.redshift).value + + +def all_cls_vars(obj: object | type, /) -> dict[str, Any]: + """Return all variables in the whole class hierarchy.""" + cls = obj if isinstance(obj, type) else obj.__class__ + return functools.reduce(operator.__or__, map(vars, cls.mro()[::-1])) diff --git a/astropy/cosmology/core.py b/astropy/cosmology/core.py index 3fdc7b1d8fd1..34d644c3e74e 100644 --- a/astropy/cosmology/core.py +++ b/astropy/cosmology/core.py @@ -4,7 +4,8 @@ import abc import inspect -from typing import TYPE_CHECKING, Any, TypeVar +from types import MappingProxyType +from typing import TYPE_CHECKING, Any, ClassVar, TypeVar import numpy as np @@ -12,6 +13,7 @@ from astropy.utils.decorators import classproperty from astropy.utils.metadata import MetaData +from ._utils import all_cls_vars from .connect import ( CosmologyFromFormat, CosmologyRead, @@ -19,6 +21,7 @@ CosmologyWrite, ) from .parameter import Parameter +from .parameter._descriptors import ParametersAttribute if TYPE_CHECKING: # pragma: no cover from collections.abc import Mapping @@ -93,8 +96,25 @@ class Cosmology(metaclass=abc.ABCMeta): write = UnifiedReadWriteMethod(CosmologyWrite) # Parameters - __parameters__: tuple[str, ...] = () - __all_parameters__: tuple[str, ...] = () + parameters = ParametersAttribute() + """Immutable mapping of the Parameters. + + If accessed from the class, this returns a mapping of the Parameter + objects themselves. If accessed from an instance, this returns a + mapping of the values of the Parameters. + """ + + derived_parameters = ParametersAttribute() + """Immutable mapping of the derived Parameters. + + If accessed from the class, this returns a mapping of the Parameter + objects themselves. If accessed from an instance, this returns a + mapping of the values of the Parameters. + """ + + _parameters: ClassVar = MappingProxyType[str, Parameter]({}) + _derived_parameters: ClassVar = MappingProxyType[str, Parameter]({}) + _parameters_all: ClassVar = frozenset[str]() # --------------------------------------------------------------- @@ -104,29 +124,25 @@ def __init_subclass__(cls): # ------------------- # Parameters - # Get parameters that are still Parameters, either in this class or above. - parameters = [] - derived_parameters = [] - for n in cls.__parameters__: - p = getattr(cls, n) - if isinstance(p, Parameter): - derived_parameters.append(n) if p.derived else parameters.append(n) - - # Add new parameter definitions - for n, v in cls.__dict__.items(): - if n in parameters or n.startswith("_") or not isinstance(v, Parameter): + params = {} + derived_params = {} + for n, v in all_cls_vars(cls).items(): + if not isinstance(v, Parameter): continue - derived_parameters.append(n) if v.derived else parameters.append(n) - - # reorder to match signature - ordered = [ - parameters.pop(parameters.index(n)) + if v.derived: + derived_params[n] = v + else: + params[n] = v + + # reorder to match signature, placing "unordered" at the end + ordered = { + n: params.pop(n) for n in cls._init_signature.parameters.keys() - if n in parameters - ] - parameters = ordered + parameters # place "unordered" at the end - cls.__parameters__ = tuple(parameters) - cls.__all_parameters__ = cls.__parameters__ + tuple(derived_parameters) + if n in params + } + cls._parameters = MappingProxyType(ordered | params) + cls._derived_parameters = MappingProxyType(derived_params) + cls._parameters_all = frozenset(cls.parameters).union(cls.derived_parameters) # ------------------- # Registration @@ -222,7 +238,7 @@ def clone(self, *, meta=None, **kwargs): meta = meta if meta is not None else {} new_meta = {**self.meta, **meta} # Mix kwargs into initial arguments, preferring the former. - new_init = {**self._init_arguments, "meta": new_meta, **kwargs} + new_init = {**self.parameters, "meta": new_meta, **kwargs} # Create BoundArgument to handle args versus kwargs. # This also handles all errors from mismatched arguments ba = self._init_signature.bind_partial(**new_init) @@ -236,17 +252,6 @@ def clone(self, *, meta=None, **kwargs): return cloned - @property - def _init_arguments(self): - # parameters - kw = {n: getattr(self, n) for n in self.__parameters__} - - # other info - kw["name"] = self.name - kw["meta"] = self.meta - - return kw - # --------------------------------------------------------------- # comparison methods @@ -350,9 +355,10 @@ def __equiv__(self, other: Any, /) -> bool: # Check all parameters in 'other' match those in 'self' and 'other' has # no extra parameters (latter part should never happen b/c same class) - return set(self.__all_parameters__) == set(other.__all_parameters__) and all( - np.all(getattr(self, k) == getattr(other, k)) - for k in self.__all_parameters__ + # We do not use `self.parameters == other.parameters` because it does not work + # for aggregating the truthiness of arrays, e.g. `m_nu`. + return self._parameters_all == other._parameters_all and all( + np.all(getattr(self, k) == getattr(other, k)) for k in self._parameters_all ) def __eq__(self, other: Any, /) -> bool: @@ -378,11 +384,13 @@ def __eq__(self, other: Any, /) -> bool: self.name == other.name # check all parameters in 'other' match those in 'self' and 'other' # has no extra parameters (latter part should never happen b/c same - # class) TODO! element-wise when there are array cosmologies - and set(self.__all_parameters__) == set(other.__all_parameters__) + # class). We do not use `self.parameters == other.parameters` because + # it does not work for aggregating the truthiness of arrays, e.g. `m_nu`. + # TODO! element-wise when there are array cosmologies + and self._parameters_all == other._parameters_all and all( np.all(getattr(self, k) == getattr(other, k)) - for k in self.__all_parameters__ + for k in self._parameters_all ) ) @@ -391,18 +399,13 @@ def __eq__(self, other: Any, /) -> bool: # --------------------------------------------------------------- def __repr__(self): - namelead = f"{self.__class__.__qualname__}(" - if self.name is not None: - namelead += f"name={self.name!r}, " - # nicely formatted parameters - fmtps = (f"{k}={getattr(self, k)!r}" for k in self.__parameters__) - - return namelead + ", ".join(fmtps) + ")" + fmtps = (f"{k}={v!r}" for k, v in self.parameters.items()) + return f"{type(self).__qualname__}(name={self.name!r}, {', '.join(fmtps)})" def __str__(self): """Return a string representation of the cosmology.""" name_str = "" if self.name is None else f'name="{self.name}", ' - param_strs = (f"{k!s}={getattr(self, k)!s}" for k in self.__parameters__) + param_strs = (f"{k!s}={v!s}" for k, v in self.parameters.items()) return f"{type(self).__name__}({name_str}{', '.join(param_strs)})" def __astropy_table__(self, cls, copy, **kwargs): @@ -436,8 +439,8 @@ class FlatCosmologyMixin(metaclass=abc.ABCMeta): ``FlatLambdaCDM`` **will** be flat. """ - __all_parameters__: tuple[str, ...] - __parameters__: tuple[str, ...] + _parameters: ClassVar[MappingProxyType[str, Parameter]] + _derived_parameters: ClassVar[MappingProxyType[str, Parameter]] def __init_subclass__(cls: type[_FlatCosmoT]) -> None: super().__init_subclass__() @@ -600,11 +603,11 @@ def __equiv__(self, other): # Check if have equivalent parameters and all parameters in `other` # match those in `self`` and `other`` has no extra parameters. params_eq = ( - set(self.__all_parameters__) == set(other.__all_parameters__) # no extra + # no extra parameters + self._parameters_all == other._parameters_all # equal and all( - np.all(getattr(self, k) == getattr(other, k)) - for k in self.__parameters__ + np.all(getattr(self, k) == getattr(other, k)) for k in self.parameters ) # flatness check and other.is_flat diff --git a/astropy/cosmology/flrw/base.py b/astropy/cosmology/flrw/base.py index 61f429257cc5..dfc8ae6acd6c 100644 --- a/astropy/cosmology/flrw/base.py +++ b/astropy/cosmology/flrw/base.py @@ -95,6 +95,12 @@ def scale_factor(self, z): return 1.0 / (aszarr(z) + 1.0) +ParameterOde0 = Parameter( + doc="Omega dark energy; dark energy density/critical density at z=0.", + fvalidate="float", +) + + class FLRW(Cosmology, _ScaleFactorMixin): """An isotropic and homogeneous (Friedmann-Lemaitre-Robertson-Walker) cosmology. @@ -162,10 +168,7 @@ class FLRW(Cosmology, _ScaleFactorMixin): doc="Omega matter; matter density/critical density at z=0.", fvalidate="non-negative", ) - Ode0 = Parameter( - doc="Omega dark energy; dark energy density/critical density at z=0.", - fvalidate="float", - ) + Ode0 = ParameterOde0 Tcmb0 = Parameter( default=0.0 * u.K, doc="Temperature of the CMB as `~astropy.units.Quantity` at z=0.", @@ -1480,7 +1483,7 @@ class FlatFLRWMixin(FlatCosmologyMixin): parameter values), but ``FlatLambdaCDM`` **will** be flat. """ - Ode0 = FLRW.Ode0.clone(derived=True) # same as FLRW, but now a derived param. + Ode0 = ParameterOde0.clone(derived=True) # same as FLRW, but derived. def __init_subclass__(cls): super().__init_subclass__() @@ -1500,12 +1503,12 @@ def nonflat(self: _FlatFLRWMixinT) -> _FLRWT: # Create BoundArgument to handle args versus kwargs. # This also handles all errors from mismatched arguments ba = self.__nonflatclass__._init_signature.bind_partial( - **self._init_arguments, Ode0=self.Ode0 + **self.parameters, Ode0=self.Ode0, name=self.name ) # Make new instance, respecting args vs kwargs inst = self.__nonflatclass__(*ba.args, **ba.kwargs) # Because of machine precision, make sure parameters exactly match - for n in inst.__all_parameters__ + ("Ok0",): + for n in (*inst._parameters_all, "Ok0"): setattr(inst, "_" + n, getattr(self, n)) return inst diff --git a/astropy/cosmology/parameter/__init__.py b/astropy/cosmology/parameter/__init__.py index 5acbc2fc3e9c..9fc4e72a3467 100644 --- a/astropy/cosmology/parameter/__init__.py +++ b/astropy/cosmology/parameter/__init__.py @@ -1,5 +1,6 @@ # Licensed under a 3-clause BSD style license - see LICENSE.rst -__all__ = ["Parameter"] +from . import _core +from ._core import * -from ._core import Parameter +__all__ = _core.__all__ diff --git a/astropy/cosmology/parameter/_core.py b/astropy/cosmology/parameter/_core.py index 3d229bf60626..445b62f99be6 100644 --- a/astropy/cosmology/parameter/_core.py +++ b/astropy/cosmology/parameter/_core.py @@ -2,7 +2,7 @@ from __future__ import annotations -__all__ = [] +__all__ = ["Parameter"] import copy from dataclasses import dataclass, field, fields, replace diff --git a/astropy/cosmology/parameter/_descriptors.py b/astropy/cosmology/parameter/_descriptors.py new file mode 100644 index 000000000000..e75f9a62bdef --- /dev/null +++ b/astropy/cosmology/parameter/_descriptors.py @@ -0,0 +1,47 @@ +# Licensed under a 3-clause BSD style license - see LICENSE.rst + +from __future__ import annotations + +__all__ = [] + +from dataclasses import dataclass, field +from types import MappingProxyType +from typing import TYPE_CHECKING, Any, NoReturn + +from astropy.utils.compat.misc import PYTHON_LT_3_10 + +if TYPE_CHECKING: + from astropy.cosmology.core import Cosmology + + +_dataclass_kwargs = {} if PYTHON_LT_3_10 else {"slots": True} + + +@dataclass(frozen=True, **_dataclass_kwargs) +class ParametersAttribute: + """Immutable mapping of the Parameters. + + If accessed from the class, this returns a mapping of the Parameter + objects themselves. If accessed from an instance, this returns a + mapping of the values of the Parameters. + """ + + attr_name: str = field(init=False) + + def __set_name__(self, owner: type[Cosmology], name: str) -> None: + object.__setattr__(self, "attr_name", f"_{name}") + + def __get__( + self, instance: Cosmology | None, owner: type[Cosmology] | None + ) -> MappingProxyType[str, Any]: + # called from the class + if instance is None: + return getattr(owner, self.attr_name) + # called from the instance + return MappingProxyType( + {n: getattr(instance, n) for n in getattr(instance, self.attr_name)} + ) + + def __set__(self, instance: Any, value: Any) -> NoReturn: + msg = f"cannot set {self.attr_name.lstrip('_').rstrip('_')!r} of {instance!r}." + raise AttributeError(msg) diff --git a/docs/changes/cosmology/15168.feature.rst b/docs/changes/cosmology/15168.feature.rst new file mode 100644 index 000000000000..f99ea2b93c7a --- /dev/null +++ b/docs/changes/cosmology/15168.feature.rst @@ -0,0 +1,5 @@ +The ``Cosmology`` class now has two new properties to access the parameters of the +cosmology: ``.parameters`` and ``.derived_parameters``. These properties return a +read-only dictionary of all the (derived) parameter values on the cosmology object. +When accessed from the class (not an instance) the dictionary contains ``Parameter`` +objects, not the values. diff --git a/docs/cosmology/dev.rst b/docs/cosmology/dev.rst index 05c70d773c8a..00742b81e94e 100644 --- a/docs/cosmology/dev.rst +++ b/docs/cosmology/dev.rst @@ -116,10 +116,10 @@ the definition of |FLRW|. raise ValueError("baryonic density can not be larger than total matter density.") return value -First note that all the parameters are also arguments in ``__init__``. This is -not strictly necessary, but is good practice. If the parameter has units (and -related equivalencies) these must be specified on the Parameter, as seen in -:attr:`~astropy.cosmology.FLRW.H0` and :attr:`~astropy.cosmology.FLRW.m_nu`. +First note that all the parameters are also arguments in ``__init__()``. This is not +strictly necessary, but is good practice. If the parameter has units (and related +equivalencies) these must be specified on the |Parameter|, as seen in +The "H0" item in :attr:`~astropy.cosmology.FLRW.parameters`. The next important thing to note is how the parameter value is set, in ``__init__``. |Parameter| allows for a value to be set once (before @@ -147,7 +147,7 @@ parameter and change any constructor argument. For example, see class FlatFLRWMixin(FlatCosmologyMixin): ... - Ode0 = FLRW.Ode0.clone(derived=True) # now a derived param. + Ode0 = FLRW.parameters["Ode0"].clone(derived=True) Mixins ------ diff --git a/docs/whatsnew/6.0.rst b/docs/whatsnew/6.0.rst index fd4bf7b27ff7..707cafaff840 100644 --- a/docs/whatsnew/6.0.rst +++ b/docs/whatsnew/6.0.rst @@ -187,6 +187,32 @@ format:: Planck18 67.66 0.30966 2.7255 3.046 0.0 .. 0.06 0.04897 +New properties to access |Cosmology| parameters +----------------------------------------------- + +The :class:`~astropy.cosmology.Cosmology` class now has two new properties +to access the parameters of the cosmology: :attr:`~astropy.cosmology.Cosmology.parameters` +and :attr:`~astropy.cosmology.Cosmology.derived_parameters`. These properties +return a :class:`~types.MappingProxyType` object, which is a read-only dictionary +of all the (derived-)parameter values on the |Cosmology| instance. For example:: + + >>> from astropy.cosmology import Planck18 + >>> Planck18.parameters["H0"] + <Quantity 67.66 km / (Mpc s)> + >>> Planck18.derived_parameters["Ode0"] + 0.6888463055445441 + +When accessed from the cosmology class itself, the returned dictionary is +not the parameter values but :class:`~astropy.cosmology.Parameter` objects +with information about the parameter used when setting up the cosmology:: + + >>> from astropy.cosmology import FlatLambdaCDM + >>> FlatLambdaCDM.parameters["H0"] + Parameter(derived=False, unit=Unit("km / (Mpc s)"), equivalencies=[], ...) + >>> FlatLambdaCDM.derived_parameters["Ode0"] + Parameter(derived=True, unit=None, equivalencies=[], ...) + + :class:`~astropy.cosmology.Parameter` as a :func:`~dataclasses.dataclass` ------------------------------------------------------------------------- @@ -196,7 +222,7 @@ This means that the :mod:`dataclasses` machinery can be used to work with >>> from dataclasses import replace >>> from astropy.cosmology import FlatLambdaCDM - >>> m_nu = FlatLambdaCDM.m_nu + >>> m_nu = FlatLambdaCDM.parameters["m_nu"] >>> m_nu Parameter(default=<Quantity 0. eV>, derived=False, unit=Unit("eV"), ...) >>> replace(m_nu, derived=True)

diff --git a/astropy/cosmology/_io/tests/test_html.py b/astropy/cosmology/_io/tests/test_html.py index 8c92b091ca2e..ef4a6f59443b 100644 --- a/astropy/cosmology/_io/tests/test_html.py +++ b/astropy/cosmology/_io/tests/test_html.py @@ -4,7 +4,6 @@ import astropy.units as u from astropy.cosmology._io.html import _FORMAT_TABLE, read_html_table, write_html_table -from astropy.cosmology.parameter import Parameter from astropy.table import QTable, Table, vstack from astropy.utils.compat.optional_deps import HAS_BS4 @@ -190,10 +189,10 @@ def test_readwrite_html_mutlirow(self, cosmo, read, write, tmp_path, add_cu): assert cosmo is not None for n, col in zip(table.colnames, table.itercols()): - if n == "cosmology": + if n not in cosmo_cls.parameters: continue - param = getattr(cosmo_cls, n) - if not isinstance(param, Parameter) or param.unit in (None, u.one): + param = cosmo_cls.parameters[n] + if param.unit in (None, u.one): continue # Replace column with unitless version table.replace_column(n, (col << param.unit).value, copy=False) diff --git a/astropy/cosmology/_io/tests/test_mapping.py b/astropy/cosmology/_io/tests/test_mapping.py index be62907a510f..51f8919d89fd 100644 --- a/astropy/cosmology/_io/tests/test_mapping.py +++ b/astropy/cosmology/_io/tests/test_mapping.py @@ -34,9 +34,9 @@ def test_to_mapping_default(self, cosmo, to_format): assert m.pop("cosmology") is cosmo.__class__ assert keys[1] == "name" assert m.pop("name") == cosmo.name - for i, k in enumerate(cosmo.__parameters__, start=2): + for i, (k, v) in enumerate(cosmo.parameters.items(), start=2): assert keys[i] == k - assert np.array_equal(m.pop(k), getattr(cosmo, k)) + np.testing.assert_array_equal(m.pop(k), v) assert keys[-1] == "meta" assert m.pop("meta") == cosmo.meta diff --git a/astropy/cosmology/_io/tests/test_model.py b/astropy/cosmology/_io/tests/test_model.py index 9cabb63c6646..d9caf1544f26 100644 --- a/astropy/cosmology/_io/tests/test_model.py +++ b/astropy/cosmology/_io/tests/test_model.py @@ -80,7 +80,7 @@ def test_toformat_model(self, cosmo, to_format, method_name): assert isinstance(model, _CosmologyModel) # Parameters - expect = tuple(n for n in cosmo.__parameters__ if getattr(cosmo, n) is not None) + expect = tuple(k for k, v in cosmo.parameters.items() if v is not None) assert model.param_names == expect # scalar result diff --git a/astropy/cosmology/_io/tests/test_table.py b/astropy/cosmology/_io/tests/test_table.py index 65fe677de294..24c93b1d629c 100644 --- a/astropy/cosmology/_io/tests/test_table.py +++ b/astropy/cosmology/_io/tests/test_table.py @@ -74,8 +74,7 @@ def test_to_table(self, cosmo_cls, cosmo, to_format): assert tbl.indices # indexed # Test each Parameter column has expected information. - for n in cosmo.__parameters__: - P = getattr(cosmo_cls, n) # Parameter + for n, P in cosmo_cls.parameters.items(): col = tbl[n] # Column # Compare the two diff --git a/astropy/cosmology/flrw/tests/conftest.py b/astropy/cosmology/flrw/tests/conftest.py index f44cf0e8061f..9fd0898aa721 100644 --- a/astropy/cosmology/flrw/tests/conftest.py +++ b/astropy/cosmology/flrw/tests/conftest.py @@ -2,5 +2,35 @@ """Configure the tests for :mod:`astropy.cosmology`.""" +from __future__ import annotations + +from typing import TYPE_CHECKING, TypeVar + from astropy.cosmology.tests.helper import clean_registry # noqa: F401 from astropy.tests.helper import pickle_protocol # noqa: F401 + +if TYPE_CHECKING: + from collections.abc import Iterable, Mapping, Sequence + +K = TypeVar("K") +V = TypeVar("V") + + +def filter_keys_from_items( + m: Mapping[K, V], /, filter_out: Sequence[K] +) -> Iterable[K, V]: + """Filter ``m``, returning key-value pairs not including keys in ``filter``. + + Parameters + ---------- + m : mapping[K, V] + A mapping from which to remove keys in ``filter_out``. + filter_out : sequence[K] + Sequence of keys to filter out from ``m``. + + Returns + ------- + iterable[K, V] + Iterable of ``(key, value)`` pairs with the ``filter_out`` keys removed. + """ + return ((k, v) for k, v in m.items() if k not in filter_out) diff --git a/astropy/cosmology/flrw/tests/test_base.py b/astropy/cosmology/flrw/tests/test_base.py index 0c2703e50527..83db44c14a08 100644 --- a/astropy/cosmology/flrw/tests/test_base.py +++ b/astropy/cosmology/flrw/tests/test_base.py @@ -2,14 +2,9 @@ """Testing :mod:`astropy.cosmology.flrw.base`.""" -############################################################################## -# IMPORTS - -# STDLIB import abc import copy -# THIRD PARTY import numpy as np import pytest @@ -29,8 +24,11 @@ invalid_zs, valid_zs, ) +from astropy.tests.helper import assert_quantity_allclose from astropy.utils.compat.optional_deps import HAS_SCIPY +from .conftest import filter_keys_from_items + ############################################################################## # SETUP / TEARDOWN @@ -68,16 +66,17 @@ def test_H0(self, cosmo_cls, cosmo): unit = u.Unit("km/(s Mpc)") # on the class - assert isinstance(cosmo_cls.H0, Parameter) - assert "Hubble constant" in cosmo_cls.H0.__doc__ - assert cosmo_cls.H0.unit == unit - assert cosmo_cls.H0.default is MISSING + H0 = cosmo_cls.parameters["H0"] + assert isinstance(H0, Parameter) + assert "Hubble constant" in H0.__doc__ + assert H0.unit == unit + assert H0.default is MISSING # validation - assert cosmo_cls.H0.validate(cosmo, 1) == 1 * unit - assert cosmo_cls.H0.validate(cosmo, 10 * unit) == 10 * unit + assert H0.validate(cosmo, 1) == 1 * unit + assert H0.validate(cosmo, 10 * unit) == 10 * unit with pytest.raises(ValueError, match="H0 is a non-scalar quantity"): - cosmo_cls.H0.validate(cosmo, [1, 2]) + H0.validate(cosmo, [1, 2]) # on the instance assert cosmo.H0 is cosmo._H0 @@ -112,15 +111,16 @@ class ParameterOm0TestMixin(ParameterTestMixin): def test_Om0(self, cosmo_cls, cosmo): """Test Parameter ``Om0``.""" # on the class - assert isinstance(cosmo_cls.Om0, Parameter) - assert "Omega matter" in cosmo_cls.Om0.__doc__ - assert cosmo_cls.Om0.default is MISSING + Om0 = cosmo_cls.parameters["Om0"] + assert isinstance(Om0, Parameter) + assert "Omega matter" in Om0.__doc__ + assert Om0.default is MISSING # validation - assert cosmo_cls.Om0.validate(cosmo, 1) == 1 - assert cosmo_cls.Om0.validate(cosmo, 10 * u.one) == 10 + assert Om0.validate(cosmo, 1) == 1 + assert Om0.validate(cosmo, 10 * u.one) == 10 with pytest.raises(ValueError, match="Om0 cannot be negative"): - cosmo_cls.Om0.validate(cosmo, -1) + Om0.validate(cosmo, -1) # on the instance assert cosmo.Om0 is cosmo._Om0 @@ -155,16 +155,22 @@ class ParameterOde0TestMixin(ParameterTestMixin): def test_Parameter_Ode0(self, cosmo_cls): """Test Parameter ``Ode0`` on the class.""" - assert isinstance(cosmo_cls.Ode0, Parameter) - assert "Omega dark energy" in cosmo_cls.Ode0.__doc__ - assert cosmo_cls.Ode0.default is MISSING + Ode0 = cosmo_cls.parameters.get( + "Ode0", cosmo_cls.derived_parameters.get("Ode0") + ) + assert isinstance(Ode0, Parameter) + assert "Omega dark energy" in Ode0.__doc__ + assert Ode0.default is MISSING def test_Parameter_Ode0_validation(self, cosmo_cls, cosmo): """Test Parameter ``Ode0`` validation.""" - assert cosmo_cls.Ode0.validate(cosmo, 1.1) == 1.1 - assert cosmo_cls.Ode0.validate(cosmo, 10 * u.one) == 10.0 + Ode0 = cosmo_cls.parameters.get( + "Ode0", cosmo_cls.derived_parameters.get("Ode0") + ) + assert Ode0.validate(cosmo, 1.1) == 1.1 + assert Ode0.validate(cosmo, 10 * u.one) == 10.0 with pytest.raises(TypeError, match="only dimensionless"): - cosmo_cls.Ode0.validate(cosmo, 10 * u.km) + Ode0.validate(cosmo, 10 * u.km) def test_Ode0(self, cosmo): """Test Parameter ``Ode0`` validation.""" @@ -208,16 +214,17 @@ class ParameterTcmb0TestMixin(ParameterTestMixin): def test_Tcmb0(self, cosmo_cls, cosmo): """Test Parameter ``Tcmb0``.""" # on the class - assert isinstance(cosmo_cls.Tcmb0, Parameter) - assert "Temperature of the CMB" in cosmo_cls.Tcmb0.__doc__ - assert cosmo_cls.Tcmb0.unit == u.K - assert cosmo_cls.Tcmb0.default == 0.0 * u.K + Tcmb0 = cosmo_cls.parameters["Tcmb0"] + assert isinstance(Tcmb0, Parameter) + assert "Temperature of the CMB" in Tcmb0.__doc__ + assert Tcmb0.unit == u.K + assert Tcmb0.default == 0.0 * u.K # validation - assert cosmo_cls.Tcmb0.validate(cosmo, 1) == 1 * u.K - assert cosmo_cls.Tcmb0.validate(cosmo, 10 * u.K) == 10 * u.K + assert Tcmb0.validate(cosmo, 1) == 1 * u.K + assert Tcmb0.validate(cosmo, 10 * u.K) == 10 * u.K with pytest.raises(ValueError, match="Tcmb0 is a non-scalar quantity"): - cosmo_cls.Tcmb0.validate(cosmo, [1, 2]) + Tcmb0.validate(cosmo, [1, 2]) # on the instance assert cosmo.Tcmb0 is cosmo._Tcmb0 @@ -252,15 +259,16 @@ class ParameterNeffTestMixin(ParameterTestMixin): def test_Neff(self, cosmo_cls, cosmo): """Test Parameter ``Neff``.""" # on the class - assert isinstance(cosmo_cls.Neff, Parameter) - assert "Number of effective neutrino species" in cosmo_cls.Neff.__doc__ - assert cosmo_cls.Neff.default == 3.04 + Neff = cosmo_cls.parameters["Neff"] + assert isinstance(Neff, Parameter) + assert "Number of effective neutrino species" in Neff.__doc__ + assert Neff.default == 3.04 # validation - assert cosmo_cls.Neff.validate(cosmo, 1) == 1 - assert cosmo_cls.Neff.validate(cosmo, 10 * u.one) == 10 + assert Neff.validate(cosmo, 1) == 1 + assert Neff.validate(cosmo, 10 * u.one) == 10 with pytest.raises(ValueError, match="Neff cannot be negative"): - cosmo_cls.Neff.validate(cosmo, -1) + Neff.validate(cosmo, -1) # on the instance assert cosmo.Neff is cosmo._Neff @@ -295,11 +303,12 @@ class Parameterm_nuTestMixin(ParameterTestMixin): def test_m_nu(self, cosmo_cls, cosmo): """Test Parameter ``m_nu``.""" # on the class - assert isinstance(cosmo_cls.m_nu, Parameter) - assert "Mass of neutrino species" in cosmo_cls.m_nu.__doc__ - assert cosmo_cls.m_nu.unit == u.eV - assert cosmo_cls.m_nu.equivalencies == u.mass_energy() - assert cosmo_cls.m_nu.default == 0.0 * u.eV + m_nu = cosmo_cls.parameters["m_nu"] + assert isinstance(m_nu, Parameter) + assert "Mass of neutrino species" in m_nu.__doc__ + assert m_nu.unit == u.eV + assert m_nu.equivalencies == u.mass_energy() + assert m_nu.default == 0.0 * u.eV # on the instance # assert cosmo.m_nu is cosmo._m_nu @@ -404,18 +413,19 @@ class ParameterOb0TestMixin(ParameterTestMixin): def test_Ob0(self, cosmo_cls, cosmo): """Test Parameter ``Ob0``.""" # on the class - assert isinstance(cosmo_cls.Ob0, Parameter) - assert "Omega baryon;" in cosmo_cls.Ob0.__doc__ - assert cosmo_cls.Ob0.default is None + Ob0 = cosmo_cls.parameters["Ob0"] + assert isinstance(Ob0, Parameter) + assert "Omega baryon;" in Ob0.__doc__ + assert Ob0.default is None # validation - assert cosmo_cls.Ob0.validate(cosmo, None) is None - assert cosmo_cls.Ob0.validate(cosmo, 0.1) == 0.1 - assert cosmo_cls.Ob0.validate(cosmo, 0.1 * u.one) == 0.1 + assert Ob0.validate(cosmo, None) is None + assert Ob0.validate(cosmo, 0.1) == 0.1 + assert Ob0.validate(cosmo, 0.1 * u.one) == 0.1 with pytest.raises(ValueError, match="Ob0 cannot be negative"): - cosmo_cls.Ob0.validate(cosmo, -1) + Ob0.validate(cosmo, -1) with pytest.raises(ValueError, match="baryonic density can not be larger"): - cosmo_cls.Ob0.validate(cosmo, cosmo.Om0 + 1) + Ob0.validate(cosmo, cosmo.Om0 + 1) # on the instance assert cosmo.Ob0 is cosmo._Ob0 @@ -753,9 +763,7 @@ def test_clone_change_param(self, cosmo): super().test_clone_change_param(cosmo) # don't change any values - kwargs = cosmo._init_arguments.copy() - kwargs.pop("name", None) # make sure not setting name - kwargs.pop("meta", None) # make sure not setting name + kwargs = dict(cosmo.parameters) c = cosmo.clone(**kwargs) assert c.__class__ == cosmo.__class__ assert c == cosmo @@ -766,14 +774,12 @@ def test_clone_change_param(self, cosmo): assert c.__class__ == cosmo.__class__ assert c.name == cosmo.name + " (modified)" assert c.H0.value == 100 - for n in set(cosmo.__parameters__) - {"H0"}: - v = getattr(c, n) + for n, v in filter_keys_from_items(c.parameters, ("H0",)): + v_expect = getattr(cosmo, n) if v is None: - assert v is getattr(cosmo, n) + assert v is v_expect else: - assert u.allclose( - v, getattr(cosmo, n), atol=1e-4 * getattr(v, "unit", 1) - ) + assert_quantity_allclose(v, v_expect, atol=1e-4 * getattr(v, "unit", 1)) assert not u.allclose(c.Ogamma0, cosmo.Ogamma0) assert not u.allclose(c.Onu0, cosmo.Onu0) @@ -784,14 +790,12 @@ def test_clone_change_param(self, cosmo): assert c.H0.value == 100 assert c.Tcmb0.value == 2.8 assert c.meta == {**cosmo.meta, **dict(zz="tops")} - for n in set(cosmo.__parameters__) - {"H0", "Tcmb0"}: - v = getattr(c, n) + for n, v in filter_keys_from_items(c.parameters, ("H0", "Tcmb0")): + v_expect = getattr(cosmo, n) if v is None: - assert v is getattr(cosmo, n) + assert v is v_expect else: - assert u.allclose( - v, getattr(cosmo, n), atol=1e-4 * getattr(v, "unit", 1) - ) + assert_quantity_allclose(v, v_expect, atol=1e-4 * getattr(v, "unit", 1)) assert not u.allclose(c.Ogamma0, cosmo.Ogamma0) assert not u.allclose(c.Onu0, cosmo.Onu0) assert not u.allclose(c.Tcmb0.value, cosmo.Tcmb0.value) @@ -943,7 +947,8 @@ class ParameterFlatOde0TestMixin(ParameterOde0TestMixin): def test_Parameter_Ode0(self, cosmo_cls): """Test Parameter ``Ode0`` on the class.""" super().test_Parameter_Ode0(cosmo_cls) - assert cosmo_cls.Ode0.derived in (True, np.True_) + Ode0 = cosmo_cls.parameters.get("Ode0", cosmo_cls.derived_parameters["Ode0"]) + assert Ode0.derived in (True, np.True_) def test_Ode0(self, cosmo): """Test no-longer-Parameter ``Ode0``.""" diff --git a/astropy/cosmology/flrw/tests/test_w0cdm.py b/astropy/cosmology/flrw/tests/test_w0cdm.py index 6ab042dc8f03..ef9f1696c87e 100644 --- a/astropy/cosmology/flrw/tests/test_w0cdm.py +++ b/astropy/cosmology/flrw/tests/test_w0cdm.py @@ -14,8 +14,10 @@ from astropy.cosmology import FlatwCDM, wCDM from astropy.cosmology.parameter import Parameter from astropy.cosmology.tests.test_core import ParameterTestMixin, valid_zs +from astropy.tests.helper import assert_quantity_allclose from astropy.utils.compat.optional_deps import HAS_SCIPY +from .conftest import filter_keys_from_items from .test_base import FlatFLRWMixinTest, FLRWTest ############################################################################## @@ -34,10 +36,11 @@ class Parameterw0TestMixin(ParameterTestMixin): def test_w0(self, cosmo_cls, cosmo): """Test Parameter ``w0``.""" # on the class - assert isinstance(cosmo_cls.w0, Parameter) - assert "Dark energy equation of state" in cosmo_cls.w0.__doc__ - assert cosmo_cls.w0.unit is None - assert cosmo_cls.w0.default == -1.0 + w0 = cosmo_cls.parameters["w0"] + assert isinstance(w0, Parameter) + assert "Dark energy equation of state" in w0.__doc__ + assert w0.unit is None + assert w0.default == -1.0 # on the instance assert cosmo.w0 is cosmo._w0 @@ -81,14 +84,12 @@ def test_clone_change_param(self, cosmo): # `w` params c = cosmo.clone(w0=0.1) assert c.w0 == 0.1 - for n in set(cosmo.__parameters__) - {"w0"}: - v = getattr(c, n) + for n, v in filter_keys_from_items(c.parameters, ("w0",)): + v_expect = getattr(cosmo, n) if v is None: - assert v is getattr(cosmo, n) + assert v is v_expect else: - assert u.allclose( - v, getattr(cosmo, n), atol=1e-4 * getattr(v, "unit", 1) - ) + assert_quantity_allclose(v, v_expect, atol=1e-4 * getattr(v, "unit", 1)) @pytest.mark.parametrize("z", valid_zs) def test_w(self, cosmo, z): diff --git a/astropy/cosmology/flrw/tests/test_w0wacdm.py b/astropy/cosmology/flrw/tests/test_w0wacdm.py index 1490b371ce6d..331658b9ef30 100644 --- a/astropy/cosmology/flrw/tests/test_w0wacdm.py +++ b/astropy/cosmology/flrw/tests/test_w0wacdm.py @@ -14,8 +14,10 @@ from astropy.cosmology import Flatw0waCDM, Planck18, w0waCDM from astropy.cosmology.parameter import Parameter from astropy.cosmology.tests.test_core import ParameterTestMixin +from astropy.tests.helper import assert_quantity_allclose from astropy.utils.compat.optional_deps import HAS_SCIPY +from .conftest import filter_keys_from_items from .test_base import FlatFLRWMixinTest, FLRWTest from .test_w0cdm import Parameterw0TestMixin @@ -35,10 +37,11 @@ class ParameterwaTestMixin(ParameterTestMixin): def test_wa(self, cosmo_cls, cosmo): """Test Parameter ``wa``.""" # on the class - assert isinstance(cosmo_cls.wa, Parameter) - assert "Negative derivative" in cosmo_cls.wa.__doc__ - assert cosmo_cls.wa.unit is None - assert cosmo_cls.wa.default == 0.0 + wa = cosmo_cls.parameters["wa"] + assert isinstance(wa, Parameter) + assert "Negative derivative" in wa.__doc__ + assert wa.unit is None + assert wa.default == 0.0 # on the instance assert cosmo.wa is cosmo._wa @@ -82,14 +85,12 @@ def test_clone_change_param(self, cosmo): c = cosmo.clone(w0=0.1, wa=0.2) assert c.w0 == 0.1 assert c.wa == 0.2 - for n in set(cosmo.__parameters__) - {"w0", "wa"}: - v = getattr(c, n) + for n, v in filter_keys_from_items(c.parameters, ("w0", "wa")): + v_expect = getattr(cosmo, n) if v is None: - assert v is getattr(cosmo, n) + assert v is v_expect else: - assert u.allclose( - v, getattr(cosmo, n), atol=1e-4 * getattr(v, "unit", 1) - ) + assert_quantity_allclose(v, v_expect, atol=1e-4 * getattr(v, "unit", 1)) # @pytest.mark.parametrize("z", valid_zs) # TODO! recompute comparisons below def test_w(self, cosmo): @@ -265,7 +266,7 @@ def test_varyde_lumdist_mathematica(): def test_equality(): """Test equality and equivalence.""" # mismatched signatures, both directions. - newcosmo = w0waCDM(**Planck18._init_arguments, Ode0=0.6) + newcosmo = w0waCDM(**Planck18.parameters, Ode0=0.6) assert newcosmo != Planck18 assert Planck18 != newcosmo diff --git a/astropy/cosmology/flrw/tests/test_w0wzcdm.py b/astropy/cosmology/flrw/tests/test_w0wzcdm.py index f63853503bf5..d30247db0152 100644 --- a/astropy/cosmology/flrw/tests/test_w0wzcdm.py +++ b/astropy/cosmology/flrw/tests/test_w0wzcdm.py @@ -13,6 +13,7 @@ from astropy.cosmology.tests.test_core import ParameterTestMixin, make_valid_zs from astropy.utils.compat.optional_deps import HAS_SCIPY +from .conftest import filter_keys_from_items from .test_base import FlatFLRWMixinTest, FLRWTest from .test_w0cdm import Parameterw0TestMixin @@ -40,10 +41,11 @@ class ParameterwzTestMixin(ParameterTestMixin): def test_wz(self, cosmo_cls, cosmo): """Test Parameter ``wz``.""" # on the class - assert isinstance(cosmo_cls.wz, Parameter) - assert "Derivative of the dark energy" in cosmo_cls.wz.__doc__ - assert cosmo_cls.wz.unit is None - assert cosmo_cls.wz.default == 0.0 + wz = cosmo_cls.parameters["wz"] + assert isinstance(wz, Parameter) + assert "Derivative of the dark energy" in wz.__doc__ + assert wz.unit is None + assert wz.default == 0.0 # on the instance assert cosmo.wz is cosmo._wz @@ -87,8 +89,7 @@ def test_clone_change_param(self, cosmo): c = cosmo.clone(w0=0.1, wz=0.2) assert c.w0 == 0.1 assert c.wz == 0.2 - for n in set(cosmo.__parameters__) - {"w0", "wz"}: - v = getattr(c, n) + for n, v in filter_keys_from_items(c.parameters, ("w0", "wz")): if v is None: assert v is getattr(cosmo, n) else: diff --git a/astropy/cosmology/flrw/tests/test_wpwazpcdm.py b/astropy/cosmology/flrw/tests/test_wpwazpcdm.py index a66381d461bb..fd7d055d312c 100644 --- a/astropy/cosmology/flrw/tests/test_wpwazpcdm.py +++ b/astropy/cosmology/flrw/tests/test_wpwazpcdm.py @@ -13,8 +13,10 @@ from astropy.cosmology import FlatwpwaCDM, wpwaCDM from astropy.cosmology.parameter import Parameter from astropy.cosmology.tests.test_core import ParameterTestMixin +from astropy.tests.helper import assert_quantity_allclose from astropy.utils.compat.optional_deps import HAS_SCIPY +from .conftest import filter_keys_from_items from .test_base import FlatFLRWMixinTest, FLRWTest from .test_w0wacdm import ParameterwaTestMixin @@ -40,10 +42,11 @@ class ParameterwpTestMixin(ParameterTestMixin): def test_wp(self, cosmo_cls, cosmo): """Test Parameter ``wp``.""" # on the class - assert isinstance(cosmo_cls.wp, Parameter) - assert "at the pivot" in cosmo_cls.wp.__doc__ - assert cosmo_cls.wp.unit is None - assert cosmo_cls.wp.default == -1.0 + wp = cosmo_cls.parameters["wp"] + assert isinstance(wp, Parameter) + assert "at the pivot" in wp.__doc__ + assert wp.unit is None + assert wp.default == -1.0 # on the instance assert cosmo.wp is cosmo._wp @@ -78,10 +81,11 @@ class ParameterzpTestMixin(ParameterTestMixin): def test_zp(self, cosmo_cls, cosmo): """Test Parameter ``zp``.""" # on the class - assert isinstance(cosmo_cls.zp, Parameter) - assert "pivot redshift" in cosmo_cls.zp.__doc__ - assert cosmo_cls.zp.unit == cu.redshift - assert cosmo_cls.zp.default == 0.0 + zp = cosmo_cls.parameters["zp"] + assert isinstance(zp, Parameter) + assert "pivot redshift" in zp.__doc__ + assert zp.unit == cu.redshift + assert zp.default == 0.0 # on the instance assert cosmo.zp is cosmo._zp @@ -128,14 +132,12 @@ def test_clone_change_param(self, cosmo): assert c.wp == 0.1 assert c.wa == 0.2 assert c.zp == 14 - for n in set(cosmo.__parameters__) - {"wp", "wa", "zp"}: - v = getattr(c, n) + for n, v in filter_keys_from_items(c.parameters, ("wp", "wa", "zp")): + v_expect = getattr(cosmo, n) if v is None: - assert v is getattr(cosmo, n) + assert v is v_expect else: - assert u.allclose( - v, getattr(cosmo, n), atol=1e-4 * getattr(v, "unit", 1) - ) + assert_quantity_allclose(v, v_expect, atol=1e-4 * getattr(v, "unit", 1)) # @pytest.mark.parametrize("z", valid_zs) # TODO! recompute comparisons below def test_w(self, cosmo): diff --git a/astropy/cosmology/funcs/tests/test_comparison.py b/astropy/cosmology/funcs/tests/test_comparison.py index 167620797f15..22e7f42bc612 100644 --- a/astropy/cosmology/funcs/tests/test_comparison.py +++ b/astropy/cosmology/funcs/tests/test_comparison.py @@ -66,8 +66,7 @@ def converted(self, to_format, format): @pytest.fixture(scope="class") def pert_cosmo(self, cosmo): # change one parameter - p = cosmo.__parameters__[0] - v = getattr(cosmo, p) + p, v = next(iter(cosmo.parameters.items())) cosmo2 = cosmo.clone( **{p: v * 1.0001 if v != 0 else 0.001 * getattr(v, "unit", 1)} ) diff --git a/astropy/cosmology/parameter/tests/__init__.py b/astropy/cosmology/parameter/tests/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/astropy/cosmology/parameter/tests/conftest.py b/astropy/cosmology/parameter/tests/conftest.py new file mode 100644 index 000000000000..47de13803227 --- /dev/null +++ b/astropy/cosmology/parameter/tests/conftest.py @@ -0,0 +1,6 @@ +# Licensed under a 3-clause BSD style license - see LICENSE.rst + +"""Configure the tests for :mod:`astropy.cosmology.parameter`.""" + +from astropy.cosmology.tests.helper import clean_registry # noqa: F401 +from astropy.tests.helper import pickle_protocol # noqa: F401 diff --git a/astropy/cosmology/parameter/tests/test_descriptors.py b/astropy/cosmology/parameter/tests/test_descriptors.py new file mode 100644 index 000000000000..da35042b1422 --- /dev/null +++ b/astropy/cosmology/parameter/tests/test_descriptors.py @@ -0,0 +1,42 @@ +# Licensed under a 3-clause BSD style license - see LICENSE.rst + +"""Testing :mod:`astropy.cosmology.parameter._descriptor`.""" + +from types import MappingProxyType + +import pytest + +from astropy.cosmology.parameter import Parameter + + +class ParametersAttributeTestMixin: + """Test the descriptor for ``parameters`` on Cosmology classes.""" + + @pytest.mark.parametrize("name", ["parameters", "derived_parameters"]) + def test_parameters_from_class(self, cosmo_cls, name): + """Test descriptor ``parameters`` accessed from the class.""" + # test presence + assert hasattr(cosmo_cls, name) + # test Parameter is a MappingProxyType + parameters = getattr(cosmo_cls, name) + assert isinstance(parameters, MappingProxyType) + # Test items + assert set(parameters.keys()) == set(getattr(cosmo_cls, f"_{name}")) + assert all(isinstance(p, Parameter) for p in parameters.values()) + + @pytest.mark.parametrize("name", ["parameters", "derived_parameters"]) + def test_parameters_from_instance(self, cosmo, name): + """Test descriptor ``parameters`` accessed from the instance.""" + # test presence + assert hasattr(cosmo, name) + # test Parameter is a MappingProxyType + parameters = getattr(cosmo, name) + assert isinstance(parameters, MappingProxyType) + # Test keys + assert set(parameters) == set(getattr(cosmo, f"_{name}")) + + @pytest.mark.parametrize("name", ["parameters", "derived_parameters"]) + def test_parameters_cannot_set_on_instance(self, cosmo, name): + """Test descriptor ``parameters`` cannot be set on the instance.""" + with pytest.raises(AttributeError, match=f"cannot set {name!r} of"): + setattr(cosmo, name, {}) diff --git a/astropy/cosmology/tests/test_parameter.py b/astropy/cosmology/parameter/tests/test_parameter.py similarity index 84% rename from astropy/cosmology/tests/test_parameter.py rename to astropy/cosmology/parameter/tests/test_parameter.py index 6757a5acc2d0..e6b7153a4e8b 100644 --- a/astropy/cosmology/tests/test_parameter.py +++ b/astropy/cosmology/parameter/tests/test_parameter.py @@ -6,7 +6,6 @@ # IMPORTS # STDLIB -import inspect from typing import Callable # THIRD PARTY @@ -86,20 +85,17 @@ class ParameterTestMixin: @pytest.fixture def parameter(self, cosmo_cls): """Cosmological Parameters""" - # I wish this would work - # yield from {getattr(cosmo_cls, n) for n in cosmo_cls.__parameters__} - - # just return one parameter at random - yield getattr(cosmo_cls, set(cosmo_cls.__parameters__).pop()) + yield from cosmo_cls.parameters.values() @pytest.fixture def all_parameter(self, cosmo_cls): """Cosmological All Parameter instances""" - # I wish this would work - # yield from {getattr(cosmo_cls, n) for n in cosmo_cls.__all_parameters__} - # just return one parameter at random - yield getattr(cosmo_cls, set(cosmo_cls.__all_parameters__).pop()) + n = set(cosmo_cls._parameters_all).pop() + try: + yield cosmo_cls.parameters[n] + except KeyError: + yield cosmo_cls.derived_parameters[n] # =============================================================== # Method Tests @@ -150,9 +146,7 @@ def test_Parameter_derived(self, cosmo_cls, all_parameter): assert isinstance(all_parameter.derived, bool) # test value - assert all_parameter.derived is ( - all_parameter.name not in cosmo_cls.__parameters__ - ) + assert all_parameter.derived is (all_parameter.name not in cosmo_cls.parameters) def test_Parameter_default(self, cosmo_cls, all_parameter): """Test :attr:`astropy.cosmology.Parameter.default`.""" @@ -167,8 +161,9 @@ def test_Parameter_default(self, cosmo_cls, all_parameter): def test_Parameter_descriptor_get(self, cosmo_cls, cosmo, all_parameter): """Test :attr:`astropy.cosmology.Parameter.__get__`.""" # from class - parameter = getattr(cosmo_cls, all_parameter.name) - np.testing.assert_array_equal(parameter.default, all_parameter.default) + np.testing.assert_array_equal( + getattr(cosmo_cls, all_parameter.name).default, all_parameter.default + ) # from instance parameter = getattr(cosmo, all_parameter.name) @@ -196,16 +191,10 @@ def test_Parameter_listed(self, cosmo_cls, all_parameter): assert isinstance(all_parameter, Parameter) # the reverse: check that if it is a Parameter, it's listed. - # note have to check the more inclusive ``__all_parameters__`` - assert all_parameter.name in cosmo_cls.__all_parameters__ - if not all_parameter.derived: - assert all_parameter.name in cosmo_cls.__parameters__ - - def test_parameter_related_attributes_on_Cosmology(self, cosmo_cls): - """Test `astropy.cosmology.Parameter`-related on Cosmology.""" - # establish has expected attribute - assert hasattr(cosmo_cls, "__parameters__") - assert hasattr(cosmo_cls, "__all_parameters__") + if all_parameter.derived: + assert all_parameter.name in cosmo_cls.derived_parameters + else: + assert all_parameter.name in cosmo_cls.parameters def test_Parameter_not_unique(self, cosmo_cls, clean_registry): """Cosmology Parameter not unique to class when subclass defined.""" @@ -217,8 +206,8 @@ class ExampleBase(cosmo_cls): class Example(ExampleBase): pass - assert Example.param is ExampleBase.param - assert Example.__parameters__ == ExampleBase.__parameters__ + assert Example.parameters["param"] is ExampleBase.parameters["param"] + assert Example.parameters == ExampleBase.parameters def test_Parameters_reorder_by_signature(self, cosmo_cls, clean_registry): """Test parameters are reordered.""" @@ -230,11 +219,11 @@ def __init__(self, param, *, name=None, meta=None): pass # never actually initialized # param should be 1st, all other parameters next - assert Example.__parameters__[0] == "param" + assert next(iter(Example.parameters)) == "param" # Check the other parameters are as expected. # only run this test if "param" is not already on the cosmology - if cosmo_cls.__parameters__[0] != "param": - assert set(Example.__parameters__[1:]) == set(cosmo_cls.__parameters__) + if next(iter(cosmo_cls.parameters)) != "param": + assert set(tuple(Example.parameters)[1:]) == set(cosmo_cls.parameters) def test_make_from_Parameter(self, cosmo_cls, clean_registry): """Test the parameter creation process. Uses ``__set__``.""" @@ -265,12 +254,14 @@ class TestParameter(ParameterTestMixin): """ def setup_class(self): + Param = Parameter( + doc="Description of example parameter.", + unit=u.m, + equivalencies=u.mass_energy(), + ) + class Example1(Cosmology): - param = Parameter( - doc="Description of example parameter.", - unit=u.m, - equivalencies=u.mass_energy(), - ) + param = Param def __init__(self, param=15): self.param = param @@ -284,7 +275,7 @@ class Example2(Example1): def __init__(self, param=15 * u.m): self.param = param - @Example1.param.validator + @Param.validator def param(self, param, value): return value.to(u.km) @@ -308,12 +299,12 @@ def cosmo(self, cosmo_cls): @pytest.fixture(scope="class") def param(self, cosmo_cls): """Get Parameter 'param' from cosmology class.""" - return cosmo_cls.param + return cosmo_cls.parameters["param"] @pytest.fixture(scope="class") - def param_cls(self, cosmo_cls): + def param_cls(self, param): """Get Parameter class from cosmology class.""" - return cosmo_cls.param.__class__ + return type(param) # ============================================================== @@ -453,8 +444,8 @@ def test_Parameter_clone(self, param): # ------------------------------------------- def test_Parameter_equality(self): - """ - Test Parameter equality. + """Test Parameter equality. + Determined from the processed initialization args (including defaults). """ p1 = Parameter(unit="km / (s Mpc)") @@ -495,35 +486,3 @@ def test_Parameter_repr_roundtrip(self, param): NP = eval(repr(P)) # Evaluate string representation back into a param. assert P == NP - - # ============================================================== - - def test_Parameter_doesnt_change_with_generic_class(self): - """Descriptors are initialized once and not updated on subclasses.""" - - class ExampleBase: - def __init__(self, param=15): - self._param = param - - sig = inspect.signature(__init__) - _init_signature = sig.replace(parameters=list(sig.parameters.values())[1:]) - - param = Parameter(doc="example parameter") - - class Example(ExampleBase): - pass - - assert Example.param is ExampleBase.param - - def test_Parameter_doesnt_change_with_cosmology(self, cosmo_cls): - """Cosmology reinitializes all descriptors when a subclass is defined.""" - - # define subclass to show param is same - class Example(cosmo_cls): - pass - - assert Example.param is cosmo_cls.param - - # unregister - _COSMOLOGY_CLASSES.pop(Example.__qualname__) - assert Example.__qualname__ not in _COSMOLOGY_CLASSES diff --git a/astropy/cosmology/tests/helper.py b/astropy/cosmology/tests/helper.py index a64133798977..77d209935f19 100644 --- a/astropy/cosmology/tests/helper.py +++ b/astropy/cosmology/tests/helper.py @@ -5,16 +5,10 @@ from the installed astropy. It makes use of the `pytest`_ testing framework. """ -############################################################################## -# IMPORTS - -# STDLIB import inspect -# THIRD PARTY import pytest -# LOCAL from astropy.cosmology import core __all__ = ["get_redshift_methods", "clean_registry"] diff --git a/astropy/cosmology/tests/test_core.py b/astropy/cosmology/tests/test_core.py index b7eecf7efb90..5bcb3acc86b8 100644 --- a/astropy/cosmology/tests/test_core.py +++ b/astropy/cosmology/tests/test_core.py @@ -14,12 +14,17 @@ from astropy.cosmology import Cosmology, FlatCosmologyMixin from astropy.cosmology.core import _COSMOLOGY_CLASSES from astropy.cosmology.parameter import Parameter +from astropy.cosmology.parameter.tests.test_descriptors import ( + ParametersAttributeTestMixin, +) +from astropy.cosmology.parameter.tests.test_parameter import ParameterTestMixin +from astropy.cosmology.tests.test_connect import ( + ReadWriteTestMixin, + ToFromFormatTestMixin, +) from astropy.table import Column, QTable, Table from astropy.utils.compat import PYTHON_LT_3_11 -from .test_connect import ReadWriteTestMixin, ToFromFormatTestMixin -from .test_parameter import ParameterTestMixin - ############################################################################## # SETUP / TEARDOWN @@ -99,14 +104,13 @@ def test_meta_mutable(self, cosmo): class CosmologyTest( ParameterTestMixin, + ParametersAttributeTestMixin, MetaTestMixin, ReadWriteTestMixin, ToFromFormatTestMixin, metaclass=abc.ABCMeta, ): - """ - Test subclasses of :class:`astropy.cosmology.Cosmology`. - """ + """Test subclasses of :class:`astropy.cosmology.Cosmology`.""" @abc.abstractmethod def setup_class(self): @@ -154,7 +158,7 @@ class InitSubclassTest(cosmo_cls): pass # test parameters - assert InitSubclassTest.__parameters__ == cosmo_cls.__parameters__ + assert InitSubclassTest.parameters == cosmo_cls.parameters # test and cleanup registry registrant = _COSMOLOGY_CLASSES.pop(InitSubclassTest.__qualname__) @@ -168,7 +172,7 @@ class UnRegisteredSubclassTest(cosmo_cls): def _register_cls(cls): """Override to not register.""" - assert UnRegisteredSubclassTest.__parameters__ == cosmo_cls.__parameters__ + assert UnRegisteredSubclassTest.parameters == cosmo_cls.parameters assert UnRegisteredSubclassTest.__qualname__ not in _COSMOLOGY_CLASSES def test_init_signature(self, cosmo_cls, cosmo): @@ -182,9 +186,7 @@ def test_init_signature(self, cosmo_cls, cosmo): # test matches __init__, but without 'self' sig = inspect.signature(cosmo.__init__) # (instances don't have self) - assert set(sig.parameters.keys()) == set( - cosmo._init_signature.parameters.keys() - ) + assert set(sig.parameters) == set(cosmo._init_signature.parameters) assert all( np.all(sig.parameters[k].default == p.default) for k, p in cosmo._init_signature.parameters.items() @@ -320,8 +322,7 @@ def test_repr(self, cosmo_cls, cosmo): r = r[6 + len(cosmo.name) + 3 :] # remove # parameters in string rep - ps = {k: getattr(cosmo, k) for k in cosmo.__parameters__} - for k, v in ps.items(): + for k, v in cosmo.parameters.items(): sv = f"{k}={v!r}" assert sv in r assert r.index(k) == 0 @@ -337,7 +338,7 @@ def test_astropy_table(self, cosmo, table_cls, in_meta): assert isinstance(tbl, table_cls) # the name & all parameters are columns - for n in ("name", *cosmo.__parameters__): + for n in ("name", *cosmo.parameters): assert n in tbl.colnames assert np.all(tbl[n] == getattr(cosmo, n)) # check if Cosmology is in metadata or a column @@ -359,7 +360,7 @@ def test_immutability(self, cosmo): Test immutability of cosmologies. The metadata is mutable: see ``test_meta_mutable``. """ - for n in cosmo.__all_parameters__: + for n in (*cosmo.parameters, *cosmo.derived_parameters): with pytest.raises(AttributeError): setattr(cosmo, n, getattr(cosmo, n)) diff --git a/astropy/cosmology/tests/test_parameters.py b/astropy/cosmology/tests/test_parameters.py index 487a69c595ca..242f1576d843 100644 --- a/astropy/cosmology/tests/test_parameters.py +++ b/astropy/cosmology/tests/test_parameters.py @@ -36,8 +36,8 @@ def test_getting_parameters(name): assert params["name"] == cosmo.name assert params["cosmology"] == cosmo.__class__.__qualname__ # All the cosmology parameters are equal - for n in cosmo.__parameters__: - assert np.array_equal(params[n], getattr(cosmo, n)) + for k, v in cosmo.parameters.items(): + np.testing.assert_array_equal(params[k], v) # All the metadata is included. Parameter values take precedence, so only # checking the keys. assert set(cosmo.meta.keys()).issubset(params.keys()) diff --git a/astropy/cosmology/tests/test_utils.py b/astropy/cosmology/tests/test_utils.py index e64d1de58d34..616e4a658b49 100644 --- a/astropy/cosmology/tests/test_utils.py +++ b/astropy/cosmology/tests/test_utils.py @@ -4,7 +4,7 @@ import pytest from astropy.cosmology import utils -from astropy.cosmology._utils import aszarr, vectorize_redshift_method +from astropy.cosmology._utils import all_cls_vars, aszarr, vectorize_redshift_method from astropy.utils.exceptions import AstropyDeprecationWarning from .test_core import invalid_zs, valid_zs, z_arr @@ -73,3 +73,27 @@ def test_invalid(self, z, exc): """Test :func:`astropy.cosmology._utils.aszarr`.""" with pytest.raises(exc): aszarr(z) + + +# ------------------------------------------------------------------- + + +def test_all_cls_vars(): + """Test :func:`astropy.cosmology._utils.all_cls_vars`.""" + + class ClassA: + a = 1 + b = 2 + + all_vars = all_cls_vars(ClassA) + public_all_vars = {k: v for k, v in all_vars.items() if not k.startswith("_")} + assert public_all_vars == {"a": 1, "b": 2} + + class ClassB(ClassA): + c = 3 + + all_vars = all_cls_vars(ClassB) + public_all_vars = {k: v for k, v in all_vars.items() if not k.startswith("_")} + assert public_all_vars == {"a": 1, "b": 2, "c": 3} + assert "a" not in vars(ClassB) + assert "b" not in vars(ClassB)

diff --git a/docs/changes/cosmology/15168.feature.rst b/docs/changes/cosmology/15168.feature.rst new file mode 100644 index 000000000000..f99ea2b93c7a --- /dev/null +++ b/docs/changes/cosmology/15168.feature.rst @@ -0,0 +1,5 @@ +The ``Cosmology`` class now has two new properties to access the parameters of the +cosmology: ``.parameters`` and ``.derived_parameters``. These properties return a +read-only dictionary of all the (derived) parameter values on the cosmology object. +When accessed from the class (not an instance) the dictionary contains ``Parameter`` +objects, not the values. diff --git a/docs/cosmology/dev.rst b/docs/cosmology/dev.rst index 05c70d773c8a..00742b81e94e 100644 --- a/docs/cosmology/dev.rst +++ b/docs/cosmology/dev.rst @@ -116,10 +116,10 @@ the definition of |FLRW|. raise ValueError("baryonic density can not be larger than total matter density.") return value -First note that all the parameters are also arguments in ``__init__``. This is -not strictly necessary, but is good practice. If the parameter has units (and -related equivalencies) these must be specified on the Parameter, as seen in -:attr:`~astropy.cosmology.FLRW.H0` and :attr:`~astropy.cosmology.FLRW.m_nu`. +First note that all the parameters are also arguments in ``__init__()``. This is not +strictly necessary, but is good practice. If the parameter has units (and related +equivalencies) these must be specified on the |Parameter|, as seen in +The "H0" item in :attr:`~astropy.cosmology.FLRW.parameters`. The next important thing to note is how the parameter value is set, in ``__init__``. |Parameter| allows for a value to be set once (before @@ -147,7 +147,7 @@ parameter and change any constructor argument. For example, see class FlatFLRWMixin(FlatCosmologyMixin): ... - Ode0 = FLRW.Ode0.clone(derived=True) # now a derived param. + Ode0 = FLRW.parameters["Ode0"].clone(derived=True) Mixins ------ diff --git a/docs/whatsnew/6.0.rst b/docs/whatsnew/6.0.rst index fd4bf7b27ff7..707cafaff840 100644 --- a/docs/whatsnew/6.0.rst +++ b/docs/whatsnew/6.0.rst @@ -187,6 +187,32 @@ format:: Planck18 67.66 0.30966 2.7255 3.046 0.0 .. 0.06 0.04897 +New properties to access |Cosmology| parameters +----------------------------------------------- + +The :class:`~astropy.cosmology.Cosmology` class now has two new properties +to access the parameters of the cosmology: :attr:`~astropy.cosmology.Cosmology.parameters` +and :attr:`~astropy.cosmology.Cosmology.derived_parameters`. These properties +return a :class:`~types.MappingProxyType` object, which is a read-only dictionary +of all the (derived-)parameter values on the |Cosmology| instance. For example:: + + >>> from astropy.cosmology import Planck18 + >>> Planck18.parameters["H0"] + <Quantity 67.66 km / (Mpc s)> + >>> Planck18.derived_parameters["Ode0"] + 0.6888463055445441 + +When accessed from the cosmology class itself, the returned dictionary is +not the parameter values but :class:`~astropy.cosmology.Parameter` objects +with information about the parameter used when setting up the cosmology:: + + >>> from astropy.cosmology import FlatLambdaCDM + >>> FlatLambdaCDM.parameters["H0"] + Parameter(derived=False, unit=Unit("km / (Mpc s)"), equivalencies=[], ...) + >>> FlatLambdaCDM.derived_parameters["Ode0"] + Parameter(derived=True, unit=None, equivalencies=[], ...) + + :class:`~astropy.cosmology.Parameter` as a :func:`~dataclasses.dataclass` ------------------------------------------------------------------------- @@ -196,7 +222,7 @@ This means that the :mod:`dataclasses` machinery can be used to work with >>> from dataclasses import replace >>> from astropy.cosmology import FlatLambdaCDM - >>> m_nu = FlatLambdaCDM.m_nu + >>> m_nu = FlatLambdaCDM.parameters["m_nu"] >>> m_nu Parameter(default=<Quantity 0. eV>, derived=False, unit=Unit("eV"), ...) >>> replace(m_nu, derived=True)

[ { "components": [ { "doc": "Return all variables in the whole class hierarchy.", "lines": [ 80, 83 ], "name": "all_cls_vars", "signature": "def all_cls_vars(obj: object | type, /) -> dict[str, Any]:", "type": "function" } ], ...

[ "astropy/cosmology/_io/tests/test_mapping.py::TestToFromMapping::test_to_mapping_default[cosmo0]", "astropy/cosmology/_io/tests/test_mapping.py::TestToFromMapping::test_to_mapping_wrong_cls[cosmo0]", "astropy/cosmology/_io/tests/test_mapping.py::TestToFromMapping::test_to_mapping_cls[cosmo0-dict]", "astropy/c...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Cosmo parameters properties I've added 2 properties to `Cosmology`: 1. `parameters` : an immutable dictionary of the non-derived ``Parameter``s defined on `Cosmology`. When accessed from the class the values are the Parameter objects. When accessed from the cosmology instance the values are the Parameter values on the cosmology instance. 2. `derived_parameters` : the same, but for the derived parameters, e.g `Ode0` in flat cosmologies. The idea is that when `Cosmology` is a dataclass you eventually won't be able to do `Cosmology.H0` to get the `Parameter` object. But it will be still be easy to access the `Parameter` object as `Cosmology.parameters["H0"]`. For v6.0 I do not plan to remove direct access to `Cosmology.H0`, etc. This will either be deprecated in a future version or will be supported through Python's [dataclass_transform](https://peps.python.org/pep-0681/) mechanism. Pros and cons to both. Please do NOT squash. ---------- Thank you for your contribution to Astropy! 🌌 This checklist is meant to remind the package maintainers who will review this pull request of some common things to look for. - [ ] Do the proposed changes actually accomplish desired goals? - [ ] Do the proposed changes follow the [Astropy coding guidelines](https://docs.astropy.org/en/latest/development/codeguide.html)? - [ ] Are tests added/updated as required? If so, do they follow the [Astropy testing guidelines](https://docs.astropy.org/en/latest/development/testguide.html)? - [ ] Are docs added/updated as required? If so, do they follow the [Astropy documentation guidelines](https://docs.astropy.org/en/latest/development/docguide.html#astropy-documentation-rules-and-guidelines)? - [ ] Is rebase and/or squash necessary? If so, please provide the author with appropriate instructions. Also see instructions for [rebase](https://docs.astropy.org/en/latest/development/workflow/development_workflow.html#rebase-if-necessary) and [squash](https://docs.astropy.org/en/latest/development/workflow/development_workflow.html#squash-if-necessary). - [ ] Did the CI pass? If no, are the failures related? If you need to run daily and weekly cron jobs as part of the PR, please apply the "Extra CI" label. Codestyle issues can be fixed by the [bot](https://docs.astropy.org/en/latest/development/workflow/development_workflow.html#pre-commit). - [ ] Is a change log needed? If yes, did the change log check pass? If no, add the "no-changelog-entry-needed" label. If this is a manual backport, use the "skip-changelog-checks" label unless special changelog handling is necessary. - [ ] Is this a big PR that makes a "What's new?" entry worthwhile and if so, is (1) a "what's new" entry included in this PR and (2) the "whatsnew-needed" label applied? - [ ] Is a milestone set? Milestone must be set but we cannot check for it on Actions; do not let the green checkmark fool you. - [ ] At the time of adding the milestone, if the milestone set requires a backport to release branch(es), apply the appropriate "backport-X.Y.x" label(s) *before* merge. 👋 Thank you for your draft pull request! Do you know that you can use `[ci skip]` or `[skip ci]` in your commit messages to skip running continuous integration tests until you are ready? I think the RTD failure is a bug in sphinx, or maybe `sphinx-automodapi`. If a descriptor-typed dataclass field without a default value is used in a class, then the field cannot be accessed from the class. Consequently when Sphinx tries to import the field it errors, halting the build! There are 2 solutions. 1 is to try to fix the bug upstream. 2 is to add default values to the Parameters and skirt this bug. Ok. I've registered the bug with Sphinx, but I don't think it will be resolved immediately nor will we immediately update our sphinx version to the most recent build, so it's probably best if I add default values to the `Parameter`. - [x] Need to add tests for the new field `default`. @eerovaher @WilliamJamieson, this PR isn't quite ready (see top comment) but I would appreciate your thoughts on how to solve the `Parameters` vs `parameters` issue, and also adding properties for derived parameters, e.g. `AllParameters` (and `allparameters`) or `get_Parameter`. Thanks! I've settled on using descriptors. This satisfies PEP-8 and keeps the number of additions to `Cosmology`'s namespace to a minimum. </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in astropy/cosmology/_utils.py] (definition of all_cls_vars:) def all_cls_vars(obj: object | type, /) -> dict[str, Any]: """Return all variables in the whole class hierarchy.""" [end of new definitions in astropy/cosmology/_utils.py] [start of new definitions in astropy/cosmology/parameter/_descriptors.py] (definition of ParametersAttribute:) class ParametersAttribute: """Immutable mapping of the Parameters. If accessed from the class, this returns a mapping of the Parameter objects themselves. If accessed from an instance, this returns a mapping of the values of the Parameters.""" (definition of ParametersAttribute.__set_name__:) def __set_name__(self, owner: type[Cosmology], name: str) -> None: (definition of ParametersAttribute.__get__:) def __get__( self, instance: Cosmology | None, owner: type[Cosmology] | None ) -> MappingProxyType[str, Any]: (definition of ParametersAttribute.__set__:) def __set__(self, instance: Any, value: Any) -> NoReturn: [end of new definitions in astropy/cosmology/parameter/_descriptors.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

32bd0ffb6898c6a57b9ec1a55c13c7a0efe8d273

softlayer__softlayer-python-2073

2,073

softlayer/softlayer-python

null

fe65dc3e4978e1497f242e0318ed6d43f6659b0b

2023-08-10T07:29:02Z

diff --git a/SoftLayer/CLI/routes.py b/SoftLayer/CLI/routes.py index 54c1deaad..dbaf1cfe0 100644 --- a/SoftLayer/CLI/routes.py +++ b/SoftLayer/CLI/routes.py @@ -403,6 +403,8 @@ ('user:device-access', 'SoftLayer.CLI.user.device_access:cli'), ('user:vpn-manual', 'SoftLayer.CLI.user.vpn_manual:cli'), ('user:vpn-subnet', 'SoftLayer.CLI.user.vpn_subnet:cli'), + ('user:vpn-enable', 'SoftLayer.CLI.user.vpn_enable_or_disable:vpn_enable'), + ('user:vpn-disable', 'SoftLayer.CLI.user.vpn_enable_or_disable:vpn_disable'), ('user:remove-access', 'SoftLayer.CLI.user.remove_access:cli'), ('user:grant-access', 'SoftLayer.CLI.user.grant_access:cli'), ('user:vpn-password', 'SoftLayer.CLI.user.vpn_password:cli'), diff --git a/SoftLayer/CLI/user/vpn_enable_or_disable.py b/SoftLayer/CLI/user/vpn_enable_or_disable.py new file mode 100644 index 000000000..2e8216d26 --- /dev/null +++ b/SoftLayer/CLI/user/vpn_enable_or_disable.py @@ -0,0 +1,49 @@ +"""Enable or Disable vpn for a user.""" +# :license: MIT, see LICENSE for more details. + + +import click + +import SoftLayer +from SoftLayer.CLI import environment +from SoftLayer.CLI import helpers + + +@click.command(cls=SoftLayer.CLI.command.SLCommand, ) +@click.argument('user') +@environment.pass_env +def vpn_enable(env, user): + """Enable vpn for a user. + + Example:: + slcli user vpn-enable 1234567 + """ + + mgr = SoftLayer.UserManager(env.client) + user_id = helpers.resolve_id(mgr.resolve_ids, user, 'username') + + result = mgr.vpn_enable_or_disable(user_id, True) + message = f"{user} vpn is successfully enabled" + + if result: + click.secho(message, fg='green') + + +@click.command(cls=SoftLayer.CLI.command.SLCommand, ) +@click.argument('user') +@environment.pass_env +def vpn_disable(env, user): + """Disable vpn for a user. + + Example:: + slcli user vpn-disable 1234567 + """ + + mgr = SoftLayer.UserManager(env.client) + user_id = helpers.resolve_id(mgr.resolve_ids, user, 'username') + + result = mgr.vpn_enable_or_disable(user_id, False) + message = f"{user} vpn is successfully disabled" + + if result: + click.secho(message, fg='green') diff --git a/SoftLayer/managers/user.py b/SoftLayer/managers/user.py index 6682c0cf5..cafdf1b8f 100644 --- a/SoftLayer/managers/user.py +++ b/SoftLayer/managers/user.py @@ -361,6 +361,17 @@ def vpn_manual(self, user_id, value): user_object = {'vpnManualConfig': value} return self.edit_user(user_id, user_object) + def vpn_enable_or_disable(self, user_id, value): + """Enable or Disable vpn for a user. + + :param int user_id: User to edit. + :param bool value: Value for vpn enable flag. + or + :param bool value: Value for vpn disable flag. + """ + user_object = {'sslVpnAllowedFlag': value} + return self.edit_user(user_id, user_object) + def vpn_subnet_add(self, user_id, subnet_ids): """Add subnets for a user. diff --git a/docs/cli/users.rst b/docs/cli/users.rst index e3d45bb1d..af86b4a94 100644 --- a/docs/cli/users.rst +++ b/docs/cli/users.rst @@ -64,6 +64,14 @@ Version 5.6.0 introduces the ability to interact with user accounts from the cli :prog: user vpn-password :show-nested: +.. click:: SoftLayer.CLI.user.vpn_enable_or_disable:vpn_enable + :prog: user vpn-enable + :show-nested: + +.. click:: SoftLayer.CLI.user.vpn_enable_or_disable:vpn_disable + :prog: user vpn-disable + :show-nested: + .. click:: SoftLayer.CLI.user.apikey:cli :prog: user apikey :show-nested:

diff --git a/tests/CLI/modules/user_tests.py b/tests/CLI/modules/user_tests.py index 02956e682..804c9ef1d 100644 --- a/tests/CLI/modules/user_tests.py +++ b/tests/CLI/modules/user_tests.py @@ -8,10 +8,9 @@ import sys import unittest -from unittest import mock as mock - from SoftLayer.fixtures import SoftLayer_User_Customer from SoftLayer import testing +from unittest import mock as mock class UserCLITests(testing.TestCase): @@ -416,3 +415,27 @@ def test_remove_api_authentication_key(self): def test_refresh_api_authentication_key(self): result = self.run_command(['user', 'apikey', '123456', '--refresh']) self.assert_no_fail(result) + + def test_vpn_disable(self): + result = self.run_command(['user', 'vpn-disable', '8344458']) + self.assert_no_fail(result) + self.assert_called_with('SoftLayer_User_Customer', 'editObject', identifier=8344458) + + result = self.run_command(['user', 'vpn-disable', '8344458']) + permission_m = self.set_mock('SoftLayer_User_Customer', 'editObject') + permission_m.return_value = {'sslVpnAllowedFlag': False} + self.assert_no_fail(result) + self.assert_called_with('SoftLayer_User_Customer', 'editObject', identifier=8344458) + self.assertEqual('8344458 vpn is successfully disabled\n', result.output) + + def test_vpn_enable(self): + result = self.run_command(['user', 'vpn-enable', '8344458']) + self.assert_no_fail(result) + self.assert_called_with('SoftLayer_User_Customer', 'editObject', identifier=8344458) + + result = self.run_command(['user', 'vpn-enable', '8344458']) + permission_m = self.set_mock('SoftLayer_User_Customer', 'editObject') + permission_m.return_value = {'sslVpnAllowedFlag': True} + self.assert_no_fail(result) + self.assert_called_with('SoftLayer_User_Customer', 'editObject', identifier=8344458) + self.assertEqual('8344458 vpn is successfully enabled\n', result.output)

diff --git a/docs/cli/users.rst b/docs/cli/users.rst index e3d45bb1d..af86b4a94 100644 --- a/docs/cli/users.rst +++ b/docs/cli/users.rst @@ -64,6 +64,14 @@ Version 5.6.0 introduces the ability to interact with user accounts from the cli :prog: user vpn-password :show-nested: +.. click:: SoftLayer.CLI.user.vpn_enable_or_disable:vpn_enable + :prog: user vpn-enable + :show-nested: + +.. click:: SoftLayer.CLI.user.vpn_enable_or_disable:vpn_disable + :prog: user vpn-disable + :show-nested: + .. click:: SoftLayer.CLI.user.apikey:cli :prog: user apikey :show-nested:

[ { "components": [ { "doc": "Enable vpn for a user.\n\nExample::\n slcli user vpn-enable 1234567", "lines": [ 15, 29 ], "name": "vpn_enable", "signature": "def vpn_enable(env, user):", "type": "function" }, { "doc": ...

[ "tests/CLI/modules/user_tests.py::UserCLITests::test_vpn_disable", "tests/CLI/modules/user_tests.py::UserCLITests::test_vpn_enable" ]

[ "tests/CLI/modules/user_tests.py::UserCLITests::test_add_api_authentication_key", "tests/CLI/modules/user_tests.py::UserCLITests::test_api_key_with_all_option", "tests/CLI/modules/user_tests.py::UserCLITests::test_api_key_without_option", "tests/CLI/modules/user_tests.py::UserCLITests::test_create_user", "t...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added new slcli user vpn-disable and slcli user vpn-enable command Hi @allmightyspiff, Fixes: #2069 **Title:** new slcli user vpn-enable command **Description:** I have added new features `slcli user vpn-disable` and `slcli user vpn-enable` commands. I have **tested** it. Please **review** it. Please find the screen shots. **Screen Shot: 1** <img width="745" alt="Screenshot 2023-08-09 at 8 21 07 PM" src="https://github.com/softlayer/softlayer-python/assets/125332006/48023c35-3ad1-4985-8236-2b326e66916b"> **Screen Shot: 2** <img width="678" alt="Screenshot 2023-08-09 at 8 22 33 PM" src="https://github.com/softlayer/softlayer-python/assets/125332006/a45bc21d-8cef-487c-87ba-b23be82628f6"> Thanks, Ramkishor Chaladi. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in SoftLayer/CLI/user/vpn_enable_or_disable.py] (definition of vpn_enable:) def vpn_enable(env, user): """Enable vpn for a user. Example:: slcli user vpn-enable 1234567""" (definition of vpn_disable:) def vpn_disable(env, user): """Disable vpn for a user. Example:: slcli user vpn-disable 1234567""" [end of new definitions in SoftLayer/CLI/user/vpn_enable_or_disable.py] [start of new definitions in SoftLayer/managers/user.py] (definition of UserManager.vpn_enable_or_disable:) def vpn_enable_or_disable(self, user_id, value): """Enable or Disable vpn for a user. :param int user_id: User to edit. :param bool value: Value for vpn enable flag. or :param bool value: Value for vpn disable flag.""" [end of new definitions in SoftLayer/managers/user.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

bd1ecce1ec4313b9ceefd3cfea52d1b9274fef9d

sqlfluff__sqlfluff-5076

5,076

sqlfluff/sqlfluff

2.1

cd52dcaaf570b3a36edce2bccefcb032d5abc47c

2023-08-09T13:24:59Z

diff --git a/src/sqlfluff/core/parser/grammar/sequence.py b/src/sqlfluff/core/parser/grammar/sequence.py index 9ca26b757e2..0c5f0d3214f 100644 --- a/src/sqlfluff/core/parser/grammar/sequence.py +++ b/src/sqlfluff/core/parser/grammar/sequence.py @@ -230,7 +230,7 @@ def match(self, segments, parse_context: ParseContext) -> MatchResult: # If we get to here, we've matched all of the elements (or skipped them) # but still have some segments left (or perhaps have precisely zero left). # In either case, we're golden. Return successfully, with any leftovers as - # the unmatched elements. Meta all go at the end regardless of wny trailing + # the unmatched elements. Meta all go at the end regardless of any trailing # whitespace. return MatchResult( diff --git a/src/sqlfluff/core/parser/segments/base.py b/src/sqlfluff/core/parser/segments/base.py index 99bb434782a..d9064d749dd 100644 --- a/src/sqlfluff/core/parser/segments/base.py +++ b/src/sqlfluff/core/parser/segments/base.py @@ -7,53 +7,49 @@ function failed on this block of segments and to prevent further analysis. """ +# Import annotations for py 3.7 to allow `weakref.ReferenceType["BaseSegment"]` +from __future__ import annotations +import logging +import weakref from collections import defaultdict from collections.abc import MutableSet -from copy import deepcopy, copy +from copy import copy, deepcopy from dataclasses import dataclass, field, replace from io import StringIO from itertools import chain from typing import ( + TYPE_CHECKING, Any, Callable, - cast, ClassVar, Dict, - Optional, - List, - Tuple, Iterator, + List, + Optional, Set, - TYPE_CHECKING, + Tuple, + cast, ) -import logging from uuid import UUID, uuid4 from tqdm import tqdm from sqlfluff.core.cached_property import cached_property from sqlfluff.core.config import progress_bar_configuration -from sqlfluff.core.string_helpers import ( - frame_msg, - curtail_string, -) - -from sqlfluff.core.parser.match_result import MatchResult +from sqlfluff.core.parser.context import ParseContext +from sqlfluff.core.parser.helpers import check_still_complete, trim_non_code_segments +from sqlfluff.core.parser.markers import PositionMarker from sqlfluff.core.parser.match_logging import parse_match_logging +from sqlfluff.core.parser.match_result import MatchResult from sqlfluff.core.parser.match_wrapper import match_wrapper -from sqlfluff.core.parser.helpers import ( - check_still_complete, - trim_non_code_segments, -) from sqlfluff.core.parser.matchable import Matchable -from sqlfluff.core.parser.markers import PositionMarker -from sqlfluff.core.parser.context import ParseContext +from sqlfluff.core.string_helpers import curtail_string, frame_msg from sqlfluff.core.templaters.base import TemplatedFile if TYPE_CHECKING: # pragma: no cover - from sqlfluff.core.rules import LintFix from sqlfluff.core.parser.segments import RawSegment + from sqlfluff.core.rules import LintFix # Instantiate the linter logger (only for use in methods involved with fixing.) linter_logger = logging.getLogger("sqlfluff.linter") @@ -263,6 +259,8 @@ class BaseSegment(metaclass=SegmentMetaclass): _cache_key: str # _preface_modifier used in ._preface() _preface_modifier: str = "" + # Optional reference to the parent. Stored as a weakref. + _parent: Optional[weakref.ReferenceType["BaseSegment"]] = None def __init__( self, @@ -304,6 +302,11 @@ def __setattr__(self, key, value) -> None: def __eq__(self, other): # NB: this should also work for RawSegment + if not isinstance(other, BaseSegment): + return False # pragma: no cover + # If the uuids match, then we can easily return early. + if self.uuid == other.uuid: + return True return ( # Same class NAME. (could be constructed elsewhere) self.__class__.__name__ == other.__class__.__name__ @@ -332,6 +335,18 @@ def __hash__(self) -> int: def __repr__(self) -> str: return f"<{self.__class__.__name__}: ({self.pos_marker})>" + def __getstate__(self): + s = self.__dict__.copy() + # Kill the parent ref. It won't pickle well. + s["_parent"] = None + return s + + def __setstate__(self, state): + self.__dict__ = state.copy() + # Once state is ingested - repopulate, NOT recursing. + # Child segments will do it for themselves on unpickling. + self.set_as_parent(recurse=False) + # ################ PRIVATE PROPERTIES @property @@ -372,6 +387,14 @@ def is_code(self) -> bool: """Return True if this segment contains any code.""" return any(seg.is_code for seg in self.segments) + @cached_property + def _code_indices(self) -> Tuple[int, ...]: + """The indices of code elements. + + This is used in the path_to algorithm for tree traversal. + """ + return tuple(idx for idx, seg in enumerate(self.segments) if seg.is_code) + @cached_property def is_comment(self) -> bool: # pragma: no cover TODO? """Return True if this is entirely made of comments.""" @@ -827,8 +850,9 @@ def _recalculate_caches(self) -> None: "first_non_whitespace_segment_raw_upper", "source_fixes", "full_type_set", - "descendant_type_set ", - "direct_descendant_type_set ", + "descendant_type_set", + "direct_descendant_type_set", + "_code_indices", ]: self.__dict__.pop(key, None) @@ -849,6 +873,42 @@ def _preface(self, ident, tabsize) -> str: # ################ PUBLIC INSTANCE METHODS + def set_as_parent(self, recurse=True) -> None: + """Set this segment as parent for child all segments.""" + for seg in self.segments: + seg.set_parent(self) + # Recurse if not disabled + if recurse: + seg.set_as_parent(recurse=recurse) + + def set_parent(self, parent: "BaseSegment") -> None: + """Set the weak reference to the parent. + + NOTE: Don't validate on set, because we might not have fully + initialised the parent yet (because we call this method during + the instantiation of the parent). + """ + self._parent = weakref.ref(parent) + + def get_parent(self) -> Optional["BaseSegment"]: + """Get the parent segment, with some validation. + + This is provided as a performance optimisation when searching + through the syntax tree. Any methods which depend on this should + have an alternative way of assessing position, and ideally also + set the parent of any segments found without them. + + NOTE: We only store a weak reference to the parent so it might + not be present. We also validate here that it's _still_ the parent + and potentially also return None if those checks fail. + """ + if not self._parent: + return None + _parent = self._parent() + if not _parent or self not in _parent.segments: + return None + return _parent + def get_type(self) -> str: """Returns the type of this segment as a string.""" return self.type @@ -1119,32 +1179,72 @@ def path_to(self, other: "BaseSegment") -> List[PathStep]: Technically this could be seen as a "half open interval" of the path between two segments: in that it includes the root segment, but not the leaf. + + We first use any existing parent references to work upward, and then if that + doesn't take us far enough we fill in from the top (setting any missing + references as we go). This tries to be as efficient in that process as + possible. """ # Return empty if they are the same segment. if self is other: return [] # pragma: no cover + # Do we have any child segments at all? + if not self.segments: + return [] + + # Identifying the highest parent we can using any preset parent values. + midpoint = other + lower_path = [] + while True: + _higher = midpoint.get_parent() + # If we've run out of parents, stop for now. + if not _higher: + break + lower_path.append( + PathStep( + _higher, + _higher.segments.index(midpoint), + len(_higher.segments), + _higher._code_indices, + ) + ) + midpoint = _higher + # If we're found the target segment we can also stop. + if midpoint == self: + break + + # Reverse the path so far + lower_path.reverse() + + # Have we already found the parent? + if midpoint == self: + return lower_path + # Have we gone all the way up to the file segment? + elif isinstance(midpoint, BaseFileSegment): + return [] # pragma: no cover # Are we in the right ballpark? # NOTE: Comparisons have a higher precedence than `not`. - if not self.get_start_loc() <= other.get_start_loc() <= self.get_end_loc(): + elif not self.get_start_loc() <= midpoint.get_start_loc() <= self.get_end_loc(): return [] - # Do we have any child segments at all? - if not self.segments: - return [] + # From here, we've worked "up" as far as we can, we now work "down". + # When working down, we only need to go as far as the `midpoint`. - # Check code idxs - code_idxs = tuple(idx for idx, seg in enumerate(self.segments) if seg.is_code) # Check through each of the child segments for idx, seg in enumerate(self.segments): - step = PathStep(self, idx, len(self.segments), code_idxs) + # Set the parent if it's not already set. + seg.set_parent(self) + # Build the step. + step = PathStep(self, idx, len(self.segments), self._code_indices) # Have we found the target? - if seg is other: - return [step] + # NOTE: Check for _equality_ not _identity_ here as that's most reliable. + if seg == midpoint: + return [step] + lower_path # Is there a path to the target? - res = seg.path_to(other) + res = seg.path_to(midpoint) if res: - return [step] + res + return [step] + res + lower_path # Not found. return [] # pragma: no cover @@ -1249,13 +1349,15 @@ def parse( parse_context.parse_depth + 1, self.__class__.__name__, self.stringify() ) ) - parse_context.logger.debug(parse_depth_msg) with parse_context.deeper_parse(name=self.__class__.__name__) as ctx: self.segments = self.expand( self.segments, parse_context=ctx, ) + # Once parsed, populate any parent relationships. + for _seg in self.segments: + _seg.set_as_parent() return (self,) @@ -1338,6 +1440,7 @@ def apply_fixes( # of a create_before/create_after pair, also add # this segment before the edit. seg_buffer.append(seg) + seg.set_parent(self) # We're doing a replacement (it could be a single # segment or an iterable) @@ -1345,6 +1448,7 @@ def apply_fixes( consumed_pos = False for s in f.edit: seg_buffer.append(s) + s.set_parent(self) # If one of them has the same raw representation # then the first that matches gets to take the # original position marker. @@ -1360,6 +1464,7 @@ def apply_fixes( # in the case of a creation before, also add this # segment on the end seg_buffer.append(seg) + seg.set_parent(self) else: # pragma: no cover raise ValueError( @@ -1369,6 +1474,7 @@ def apply_fixes( ) else: seg_buffer.append(seg) + seg.set_parent(self) # Invalidate any caches self.invalidate_caches()

diff --git a/test/core/parser/segments/__init__.py b/test/core/parser/segments/__init__.py new file mode 100644 index 00000000000..47449fecad1 --- /dev/null +++ b/test/core/parser/segments/__init__.py @@ -0,0 +1,1 @@ +"""Tests for the segments module.""" diff --git a/test/core/parser/segments/conftest.py b/test/core/parser/segments/conftest.py new file mode 100644 index 00000000000..79c53271efd --- /dev/null +++ b/test/core/parser/segments/conftest.py @@ -0,0 +1,41 @@ +"""Common fixtures for segment tests.""" + +import pytest + +from sqlfluff.core.parser import BaseSegment + + +@pytest.fixture(scope="module") +def raw_seg_list(generate_test_segments): + """Construct a list of raw segments as a fixture.""" + return generate_test_segments(["foobar", ".barfoo"]) + + +@pytest.fixture(scope="module") +def raw_seg(raw_seg_list): + """Construct a raw segment as a fixture.""" + return raw_seg_list[0] + + +@pytest.fixture(scope="session") +def DummySegment(): + """Construct a raw segment as a fixture.""" + + class DummySegment(BaseSegment): + """A dummy segment for testing with no grammar.""" + + type = "dummy" + + return DummySegment + + +@pytest.fixture(scope="session") +def DummyAuxSegment(): + """Construct a raw segment as a fixture.""" + + class DummyAuxSegment(BaseSegment): + """A different dummy segment for testing with no grammar.""" + + type = "dummy_aux" + + return DummyAuxSegment diff --git a/test/core/parser/segments_base_test.py b/test/core/parser/segments/segments_base_test.py similarity index 75% rename from test/core/parser/segments_base_test.py rename to test/core/parser/segments/segments_base_test.py index d34a882d873..549fafae84d 100644 --- a/test/core/parser/segments_base_test.py +++ b/test/core/parser/segments/segments_base_test.py @@ -1,44 +1,17 @@ -"""The Test file for The New Parser (Base Segment Classes).""" +"""Test the BaseSegment class.""" + +import pickle import pytest -from sqlfluff.core.parser import ( - PositionMarker, - RawSegment, - BaseSegment, - BaseFileSegment, -) -from sqlfluff.core.parser.segments.base import PathStep -from sqlfluff.core.templaters import TemplatedFile +from sqlfluff.core.parser import BaseSegment, PositionMarker, RawSegment from sqlfluff.core.parser.context import ParseContext +from sqlfluff.core.parser.segments.base import PathStep from sqlfluff.core.rules.base import LintFix +from sqlfluff.core.templaters import TemplatedFile -@pytest.fixture(scope="module") -def raw_seg_list(generate_test_segments): - """Construct a list of raw segments as a fixture.""" - return generate_test_segments(["foobar", ".barfoo"]) - - -@pytest.fixture(scope="module") -def raw_seg(raw_seg_list): - """Construct a raw segment as a fixture.""" - return raw_seg_list[0] - - -class DummySegment(BaseSegment): - """A dummy segment for testing with no grammar.""" - - type = "dummy" - - -class DummyAuxSegment(BaseSegment): - """A different dummy segment for testing with no grammar.""" - - type = "dummy_aux" - - -def test__parser__base_segments_type(): +def test__parser__base_segments_type(DummySegment): """Test the .is_type() method.""" assert BaseSegment.class_is_type("base") assert not BaseSegment.class_is_type("foo") @@ -48,24 +21,30 @@ def test__parser__base_segments_type(): assert DummySegment.class_is_type("base", "foo", "bar") -def test__parser__base_segments_class_types(): +def test__parser__base_segments_class_types(DummySegment): """Test the metaclass ._class_types attribute.""" assert DummySegment._class_types == {"dummy", "base"} -def test__parser__base_segments_descendant_type_set(raw_seg_list): +def test__parser__base_segments_descendant_type_set( + raw_seg_list, DummySegment, DummyAuxSegment +): """Test the .descendant_type_set() method.""" test_seg = DummySegment([DummyAuxSegment(raw_seg_list)]) assert test_seg.descendant_type_set == {"raw", "base", "dummy_aux"} -def test__parser__base_segments_direct_descendant_type_set(raw_seg_list): +def test__parser__base_segments_direct_descendant_type_set( + raw_seg_list, DummySegment, DummyAuxSegment +): """Test the .direct_descendant_type_set() method.""" test_seg = DummySegment([DummyAuxSegment(raw_seg_list)]) assert test_seg.direct_descendant_type_set == {"base", "dummy_aux"} -def test__parser__base_segments_count_segments(raw_seg_list): +def test__parser__base_segments_count_segments( + raw_seg_list, DummySegment, DummyAuxSegment +): """Test the .count_segments() method.""" test_seg = DummySegment([DummyAuxSegment(raw_seg_list)]) assert test_seg.count_segments() == 4 @@ -122,7 +101,7 @@ def test__parser_base_segments_compute_anchor_edit_info(raw_seg_list): ) -def test__parser__base_segments_path_to(raw_seg_list): +def test__parser__base_segments_path_to(raw_seg_list, DummySegment, DummyAuxSegment): """Test the .path_to() method.""" test_seg_a = DummyAuxSegment(raw_seg_list) test_seg_b = DummySegment([test_seg_a]) @@ -170,7 +149,7 @@ def test__parser__base_segments_raw(raw_seg): assert raw_seg.to_tuple(show_raw=True) == ("raw", "foobar") -def test__parser__base_segments_base(raw_seg_list, fresh_ansi_dialect): +def test__parser__base_segments_base(raw_seg_list, fresh_ansi_dialect, DummySegment): """Test base segments behave as expected.""" base_seg = DummySegment(raw_seg_list) # Check we assume the position correctly @@ -212,7 +191,7 @@ def test__parser__base_segments_raw_compare(): assert rs1 == rs2 -def test__parser__base_segments_base_compare(): +def test__parser__base_segments_base_compare(DummySegment, DummyAuxSegment): """Test comparison of base segments.""" template = TemplatedFile.from_string("foobar") rs1 = RawSegment("foobar", PositionMarker(slice(0, 6), slice(0, 6), template)) @@ -228,35 +207,12 @@ def test__parser__base_segments_base_compare(): assert ds1 != dsa2 -def test__parser__base_segments_file(raw_seg_list): - """Test BaseFileSegment to behave as expected.""" - base_seg = BaseFileSegment(raw_seg_list, fname="/some/dir/file.sql") - assert base_seg.type == "file" - assert base_seg.file_path == "/some/dir/file.sql" - assert base_seg.can_start_end_non_code - assert base_seg.allow_empty - - -def test__parser__raw_get_raw_segments(raw_seg_list): - """Test niche case of calling get_raw_segments on a raw segment.""" - for s in raw_seg_list: - assert s.get_raw_segments() == [s] - - -def test__parser__raw_segments_with_ancestors(raw_seg_list): - """Test raw_segments_with_ancestors. - - This is used in the reflow module to assess parse depth. - """ - test_seg = DummySegment([DummyAuxSegment(raw_seg_list[:1]), raw_seg_list[1]]) - # Result should be the same raw segment, but with appropriate parents - assert test_seg.raw_segments_with_ancestors == [ - ( - raw_seg_list[0], - [ - PathStep(test_seg, 0, 2, (0, 1)), - PathStep(test_seg.segments[0], 0, 1, (0,)), - ], - ), - (raw_seg_list[1], [PathStep(test_seg, 1, 2, (0, 1))]), - ] +def test__parser__base_segments_pickle_safe(raw_seg_list): + """Test pickling and unpickling of BaseSegment.""" + test_seg = BaseSegment([BaseSegment(raw_seg_list)]) + test_seg.set_as_parent() + pickled = pickle.dumps(test_seg) + result_seg = pickle.loads(pickled) + assert test_seg == result_seg + # Check specifically the treatment of the parent position. + assert result_seg.segments[0].get_parent() is result_seg diff --git a/test/core/parser/segments_common_test.py b/test/core/parser/segments/segments_common_test.py similarity index 96% rename from test/core/parser/segments_common_test.py rename to test/core/parser/segments/segments_common_test.py index 5fc71cb316d..272c4cf7fab 100644 --- a/test/core/parser/segments_common_test.py +++ b/test/core/parser/segments/segments_common_test.py @@ -1,4 +1,4 @@ -"""The Test file for The New Parser (Marker Classes).""" +"""Test the KeywordSegment and EphemeralSegment classes.""" import pytest @@ -8,6 +8,7 @@ from sqlfluff.core.parser.segments.base import UnparsableSegment +# NOTE: For legacy reasons we override this fixture for this module @pytest.fixture(scope="module") def raw_seg_list(generate_test_segments): """A generic list of raw segments to test against.""" diff --git a/test/core/parser/segments/segments_file_test.py b/test/core/parser/segments/segments_file_test.py new file mode 100644 index 00000000000..789a1ee6f80 --- /dev/null +++ b/test/core/parser/segments/segments_file_test.py @@ -0,0 +1,20 @@ +"""Test the BaseFileSegment class.""" + +import pytest + +from sqlfluff.core.parser import BaseFileSegment + + +@pytest.fixture(scope="module") +def raw_seg_list(generate_test_segments): + """Construct a list of raw segments as a fixture.""" + return generate_test_segments(["foobar", ".barfoo"]) + + +def test__parser__base_segments_file(raw_seg_list): + """Test BaseFileSegment to behave as expected.""" + base_seg = BaseFileSegment(raw_seg_list, fname="/some/dir/file.sql") + assert base_seg.type == "file" + assert base_seg.file_path == "/some/dir/file.sql" + assert base_seg.can_start_end_non_code + assert base_seg.allow_empty diff --git a/test/core/parser/segments/segments_raw_test.py b/test/core/parser/segments/segments_raw_test.py new file mode 100644 index 00000000000..d20369af2b6 --- /dev/null +++ b/test/core/parser/segments/segments_raw_test.py @@ -0,0 +1,30 @@ +"""Test the RawSegment class.""" + +from sqlfluff.core.parser.segments.base import PathStep + + +def test__parser__raw_get_raw_segments(raw_seg_list): + """Test niche case of calling get_raw_segments on a raw segment.""" + for s in raw_seg_list: + assert s.get_raw_segments() == [s] + + +def test__parser__raw_segments_with_ancestors( + raw_seg_list, DummySegment, DummyAuxSegment +): + """Test raw_segments_with_ancestors. + + This is used in the reflow module to assess parse depth. + """ + test_seg = DummySegment([DummyAuxSegment(raw_seg_list[:1]), raw_seg_list[1]]) + # Result should be the same raw segment, but with appropriate parents + assert test_seg.raw_segments_with_ancestors == [ + ( + raw_seg_list[0], + [ + PathStep(test_seg, 0, 2, (0, 1)), + PathStep(test_seg.segments[0], 0, 1, (0,)), + ], + ), + (raw_seg_list[1], [PathStep(test_seg, 1, 2, (0, 1))]), + ]

[ { "components": [ { "doc": "", "lines": [ 338, 342 ], "name": "BaseSegment.__getstate__", "signature": "def __getstate__(self):", "type": "function" }, { "doc": "", "lines": [ 344, 348 ...

[ "test/core/parser/segments/segments_base_test.py::test__parser__base_segments_pickle_safe" ]

[ "test/core/parser/segments/segments_base_test.py::test__parser__base_segments_type", "test/core/parser/segments/segments_base_test.py::test__parser__base_segments_class_types", "test/core/parser/segments/segments_base_test.py::test__parser__base_segments_descendant_type_set", "test/core/parser/segments/segmen...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Parent references and more efficient path_to @WittierDinosaur has been suggesting that segments should maintain a reference to their parent for a while. This PR implements that. I found during some performance investigations on the most recent release that some rules take disproportionately longer than others. Especially RF01, and most of that time was spent in `path_to`. The lack of a reference to the parent means that the algorithm used for searching here was especially slow. This introduces a `weakref` to the parent segment on `BaseSegment`. It's not populated on instantiation (because that proved difficult) and also includes a bit of validation on read because we definitely move segments around and there's a risk that the parent reference becomes out of date. That parent reference can then be used to speed up the `path_to` method and in my testing on some large files, this roughly halves the runtime of RF01, AL04, AL05 & AM04 🚀 (which are also some of the currently slowest rules). This same functionality should enable some speedups in the reflow libraries too, but I'll handle that in a second PR (currently this doesn't show a significant gain there). In the process, I also added a new pickle test for segments (similar to the ones done for errors), and that triggered me to break apart the segment tests into smaller file. The only change to the test suite is that new test - otherwise it's the same tests, just in smaller files (similar to #5078). ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/sqlfluff/core/parser/segments/base.py] (definition of BaseSegment.__getstate__:) def __getstate__(self): (definition of BaseSegment.__setstate__:) def __setstate__(self, state): (definition of BaseSegment._code_indices:) def _code_indices(self) -> Tuple[int, ...]: """The indices of code elements. This is used in the path_to algorithm for tree traversal.""" (definition of BaseSegment.set_as_parent:) def set_as_parent(self, recurse=True) -> None: """Set this segment as parent for child all segments.""" (definition of BaseSegment.set_parent:) def set_parent(self, parent: "BaseSegment") -> None: """Set the weak reference to the parent. NOTE: Don't validate on set, because we might not have fully initialised the parent yet (because we call this method during the instantiation of the parent).""" (definition of BaseSegment.get_parent:) def get_parent(self) -> Optional["BaseSegment"]: """Get the parent segment, with some validation. This is provided as a performance optimisation when searching through the syntax tree. Any methods which depend on this should have an alternative way of assessing position, and ideally also set the parent of any segments found without them. NOTE: We only store a weak reference to the parent so it might not be present. We also validate here that it's _still_ the parent and potentially also return None if those checks fail.""" [end of new definitions in src/sqlfluff/core/parser/segments/base.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

cd52dcaaf570b3a36edce2bccefcb032d5abc47c

tobymao__sqlglot-2006

2,006

tobymao/sqlglot

null

2a76eb8bcdf78c53f91f9e3f228dc6dad0223b03

2023-08-08T09:40:25Z

diff --git a/sqlglot/dialects/__init__.py b/sqlglot/dialects/__init__.py index fc342621ae..821266946b 100644 --- a/sqlglot/dialects/__init__.py +++ b/sqlglot/dialects/__init__.py @@ -60,6 +60,7 @@ class Generator(Generator): from sqlglot.dialects.clickhouse import ClickHouse from sqlglot.dialects.databricks import Databricks from sqlglot.dialects.dialect import Dialect, Dialects +from sqlglot.dialects.doris import Doris from sqlglot.dialects.drill import Drill from sqlglot.dialects.duckdb import DuckDB from sqlglot.dialects.hive import Hive diff --git a/sqlglot/dialects/dialect.py b/sqlglot/dialects/dialect.py index 1d0584c679..e73cfc8bd2 100644 --- a/sqlglot/dialects/dialect.py +++ b/sqlglot/dialects/dialect.py @@ -39,6 +39,7 @@ class Dialects(str, Enum): TERADATA = "teradata" TRINO = "trino" TSQL = "tsql" + Doris = "doris" class _Dialect(type): diff --git a/sqlglot/dialects/doris.py b/sqlglot/dialects/doris.py new file mode 100644 index 0000000000..50e18ad1f8 --- /dev/null +++ b/sqlglot/dialects/doris.py @@ -0,0 +1,105 @@ +from __future__ import annotations + +import typing as t + +from sqlglot import exp, generator +from sqlglot.dialects.dialect import ( + approx_count_distinct_sql, + arrow_json_extract_sql, + rename_func, +) +from sqlglot.dialects.mysql import MySQL +from sqlglot.helper import seq_get + + +def _to_date_sql(self: MySQL.Generator, expression: exp.TsOrDsToDate) -> str: + this = self.sql(expression, "this") + self.format_time(expression) + return f"TO_DATE({this})" + + +def _time_format( + self: generator.Generator, expression: exp.UnixToStr | exp.StrToUnix +) -> t.Optional[str]: + time_format = self.format_time(expression) + if time_format == Doris.TIME_FORMAT: + return None + return time_format + + +class Doris(MySQL): + DATE_FORMAT = "'yyyy-MM-dd'" + DATEINT_FORMAT = "'yyyyMMdd'" + TIME_FORMAT = "'yyyy-MM-dd HH:mm:ss'" + + TIME_MAPPING = { + "%M": "%B", + "%m": "%%-M", + "%c": "%-m", + "%e": "%-d", + "%h": "%I", + "%S": "%S", + "%u": "%W", + "%k": "%-H", + "%l": "%-I", + "%W": "%a", + "%Y": "%Y", + "%d": "%%-d", + "%H": "%%-H", + "%s": "%%-S", + "%D": "%%-j", + "%a": "%%p", + "%y": "%%Y", + "%": "%%", + } + + class Parser(MySQL.Parser): + FUNCTIONS = { + **MySQL.Parser.FUNCTIONS, + "DATE_TRUNC": lambda args: exp.TimestampTrunc( + this=seq_get(args, 1), unit=seq_get(args, 0) + ), + "REGEXP": exp.RegexpLike.from_arg_list, + } + + class Generator(MySQL.Generator): + CAST_MAPPING = {} + + TYPE_MAPPING = { + **MySQL.Generator.TYPE_MAPPING, + exp.DataType.Type.TEXT: "STRING", + exp.DataType.Type.TIMESTAMP: "DATETIME", + exp.DataType.Type.TIMESTAMPTZ: "DATETIME", + } + + TRANSFORMS = { + **MySQL.Generator.TRANSFORMS, + exp.ApproxDistinct: approx_count_distinct_sql, + exp.ArrayAgg: rename_func("COLLECT_LIST"), + exp.Coalesce: rename_func("NVL"), + exp.CurrentTimestamp: lambda *_: "NOW()", + exp.DateTrunc: lambda self, e: self.func( + "DATE_TRUNC", e.this, "'" + e.text("unit") + "'" + ), + exp.JSONExtractScalar: arrow_json_extract_sql, + exp.JSONExtract: arrow_json_extract_sql, + exp.RegexpLike: rename_func("REGEXP"), + exp.RegexpSplit: rename_func("SPLIT_BY_STRING"), + exp.SetAgg: rename_func("COLLECT_SET"), + exp.StrToUnix: lambda self, e: f"UNIX_TIMESTAMP({self.sql(e, 'this')}, {self.format_time(e)})", + exp.Split: rename_func("SPLIT_BY_STRING"), + exp.TimeStrToDate: rename_func("TO_DATE"), + exp.ToChar: lambda self, e: f"DATE_FORMAT({self.sql(e, 'this')}, {self.format_time(e)})", + exp.TsOrDsAdd: lambda self, e: f"DATE_ADD({self.sql(e, 'this')}, {self.sql(e, 'expression')})", # Only for day level + exp.TsOrDsToDate: lambda self, e: self.func("TO_DATE", e.this), + exp.TimeStrToUnix: rename_func("UNIX_TIMESTAMP"), + exp.TimeToUnix: rename_func("UNIX_TIMESTAMP"), + exp.TimestampTrunc: lambda self, e: self.func( + "DATE_TRUNC", e.this, "'" + e.text("unit") + "'" + ), + exp.UnixToStr: lambda self, e: self.func( + "FROM_UNIXTIME", e.this, _time_format(self, e) + ), + exp.UnixToTime: rename_func("FROM_UNIXTIME"), + exp.Map: rename_func("ARRAY_MAP"), + }

diff --git a/tests/dialects/test_dialect.py b/tests/dialects/test_dialect.py index aaaffab785..9873038f8f 100644 --- a/tests/dialects/test_dialect.py +++ b/tests/dialects/test_dialect.py @@ -90,6 +90,7 @@ def test_cast(self): "snowflake": "CAST(a AS TEXT)", "spark": "CAST(a AS STRING)", "starrocks": "CAST(a AS STRING)", + "doris": "CAST(a AS STRING)", }, ) self.validate_all( @@ -169,6 +170,7 @@ def test_cast(self): "snowflake": "CAST(a AS TEXT)", "spark": "CAST(a AS STRING)", "starrocks": "CAST(a AS STRING)", + "doris": "CAST(a AS STRING)", }, ) self.validate_all( @@ -186,6 +188,7 @@ def test_cast(self): "snowflake": "CAST(a AS VARCHAR)", "spark": "CAST(a AS STRING)", "starrocks": "CAST(a AS VARCHAR)", + "doris": "CAST(a AS VARCHAR)", }, ) self.validate_all( @@ -203,6 +206,7 @@ def test_cast(self): "snowflake": "CAST(a AS VARCHAR(3))", "spark": "CAST(a AS VARCHAR(3))", "starrocks": "CAST(a AS VARCHAR(3))", + "doris": "CAST(a AS VARCHAR(3))", }, ) self.validate_all( @@ -221,6 +225,7 @@ def test_cast(self): "spark": "CAST(a AS SMALLINT)", "sqlite": "CAST(a AS INTEGER)", "starrocks": "CAST(a AS SMALLINT)", + "doris": "CAST(a AS SMALLINT)", }, ) self.validate_all( @@ -234,6 +239,7 @@ def test_cast(self): "drill": "CAST(a AS DOUBLE)", "postgres": "CAST(a AS DOUBLE PRECISION)", "redshift": "CAST(a AS DOUBLE PRECISION)", + "doris": "CAST(a AS DOUBLE)", }, ) @@ -267,6 +273,7 @@ def test_cast(self): write={ "starrocks": "CAST(a AS DATETIME)", "redshift": "CAST(a AS TIMESTAMP)", + "doris": "CAST(a AS DATETIME)", }, ) self.validate_all( @@ -274,6 +281,7 @@ def test_cast(self): write={ "starrocks": "CAST(a AS DATETIME)", "redshift": "CAST(a AS TIMESTAMPTZ)", + "doris": "CAST(a AS DATETIME)", }, ) self.validate_all("CAST(a AS TINYINT)", write={"oracle": "CAST(a AS NUMBER)"}) @@ -408,6 +416,7 @@ def test_time(self): "hive": "UNIX_TIMESTAMP('2020-01-01', 'yyyy-mm-dd')", "presto": "TO_UNIXTIME(DATE_PARSE('2020-01-01', '%Y-%i-%d'))", "starrocks": "UNIX_TIMESTAMP('2020-01-01', '%Y-%i-%d')", + "doris": "UNIX_TIMESTAMP('2020-01-01', '%Y-%M-%d')", }, ) self.validate_all( @@ -418,6 +427,7 @@ def test_time(self): "hive": "TO_DATE('2020-01-01')", "presto": "CAST('2020-01-01' AS TIMESTAMP)", "starrocks": "TO_DATE('2020-01-01')", + "doris": "TO_DATE('2020-01-01')", }, ) self.validate_all( @@ -428,6 +438,7 @@ def test_time(self): "hive": "CAST('2020-01-01' AS TIMESTAMP)", "presto": "CAST('2020-01-01' AS TIMESTAMP)", "sqlite": "'2020-01-01'", + "doris": "CAST('2020-01-01' AS DATETIME)", }, ) self.validate_all( @@ -437,6 +448,7 @@ def test_time(self): "hive": "UNIX_TIMESTAMP('2020-01-01')", "mysql": "UNIX_TIMESTAMP('2020-01-01')", "presto": "TO_UNIXTIME(DATE_PARSE('2020-01-01', '%Y-%m-%d %T'))", + "doris": "UNIX_TIMESTAMP('2020-01-01')", }, ) self.validate_all( @@ -449,6 +461,7 @@ def test_time(self): "postgres": "TO_CHAR(x, 'YYYY-MM-DD')", "presto": "DATE_FORMAT(x, '%Y-%m-%d')", "redshift": "TO_CHAR(x, 'YYYY-MM-DD')", + "doris": "DATE_FORMAT(x, '%Y-%m-%d')", }, ) self.validate_all( @@ -459,6 +472,7 @@ def test_time(self): "hive": "CAST(x AS STRING)", "presto": "CAST(x AS VARCHAR)", "redshift": "CAST(x AS VARCHAR(MAX))", + "doris": "CAST(x AS STRING)", }, ) self.validate_all( @@ -468,6 +482,7 @@ def test_time(self): "duckdb": "EPOCH(x)", "hive": "UNIX_TIMESTAMP(x)", "presto": "TO_UNIXTIME(x)", + "doris": "UNIX_TIMESTAMP(x)", }, ) self.validate_all( @@ -476,6 +491,7 @@ def test_time(self): "duckdb": "SUBSTRING(CAST(x AS TEXT), 1, 10)", "hive": "SUBSTRING(CAST(x AS STRING), 1, 10)", "presto": "SUBSTRING(CAST(x AS VARCHAR), 1, 10)", + "doris": "SUBSTRING(CAST(x AS STRING), 1, 10)", }, ) self.validate_all( @@ -487,6 +503,7 @@ def test_time(self): "postgres": "CAST(x AS DATE)", "presto": "CAST(CAST(x AS TIMESTAMP) AS DATE)", "snowflake": "CAST(x AS DATE)", + "doris": "TO_DATE(x)", }, ) self.validate_all( @@ -505,6 +522,7 @@ def test_time(self): "hive": "FROM_UNIXTIME(x, y)", "presto": "DATE_FORMAT(FROM_UNIXTIME(x), y)", "starrocks": "FROM_UNIXTIME(x, y)", + "doris": "FROM_UNIXTIME(x, y)", }, ) self.validate_all( @@ -516,6 +534,7 @@ def test_time(self): "postgres": "TO_TIMESTAMP(x)", "presto": "FROM_UNIXTIME(x)", "starrocks": "FROM_UNIXTIME(x)", + "doris": "FROM_UNIXTIME(x)", }, ) self.validate_all( @@ -582,6 +601,7 @@ def test_time(self): "sqlite": "DATE(x, '1 DAY')", "starrocks": "DATE_ADD(x, INTERVAL 1 DAY)", "tsql": "DATEADD(DAY, 1, x)", + "doris": "DATE_ADD(x, INTERVAL 1 DAY)", }, ) self.validate_all( @@ -595,6 +615,7 @@ def test_time(self): "presto": "DATE_ADD('day', 1, x)", "spark": "DATE_ADD(x, 1)", "starrocks": "DATE_ADD(x, INTERVAL 1 DAY)", + "doris": "DATE_ADD(x, INTERVAL 1 DAY)", }, ) self.validate_all( @@ -612,6 +633,7 @@ def test_time(self): "snowflake": "DATE_TRUNC('day', x)", "starrocks": "DATE_TRUNC('day', x)", "spark": "TRUNC(x, 'day')", + "doris": "DATE_TRUNC(x, 'day')", }, ) self.validate_all( @@ -624,6 +646,7 @@ def test_time(self): "snowflake": "DATE_TRUNC('day', x)", "starrocks": "DATE_TRUNC('day', x)", "spark": "DATE_TRUNC('day', x)", + "doris": "DATE_TRUNC('day', x)", }, ) self.validate_all( @@ -684,6 +707,7 @@ def test_time(self): "snowflake": "DATE_TRUNC('year', x)", "starrocks": "DATE_TRUNC('year', x)", "spark": "TRUNC(x, 'year')", + "doris": "DATE_TRUNC(x, 'year')", }, ) self.validate_all( @@ -698,6 +722,7 @@ def test_time(self): write={ "bigquery": "TIMESTAMP_TRUNC(x, year)", "spark": "DATE_TRUNC('year', x)", + "doris": "DATE_TRUNC(x, 'year')", }, ) self.validate_all( @@ -719,6 +744,7 @@ def test_time(self): "hive": "CAST(FROM_UNIXTIME(UNIX_TIMESTAMP(x, 'yyyy-MM-ddTHH:mm:ss')) AS DATE)", "presto": "CAST(DATE_PARSE(x, '%Y-%m-%dT%T') AS DATE)", "spark": "TO_DATE(x, 'yyyy-MM-ddTHH:mm:ss')", + "doris": "STR_TO_DATE(x, '%Y-%m-%dT%H:%M:%S')", }, ) self.validate_all( @@ -730,6 +756,7 @@ def test_time(self): "hive": "CAST(x AS DATE)", "presto": "CAST(DATE_PARSE(x, '%Y-%m-%d') AS DATE)", "spark": "TO_DATE(x)", + "doris": "STR_TO_DATE(x, '%Y-%m-%d')", }, ) self.validate_all( @@ -784,6 +811,7 @@ def test_time(self): "mysql": "CAST('2022-01-01' AS TIMESTAMP)", "starrocks": "CAST('2022-01-01' AS DATETIME)", "hive": "CAST('2022-01-01' AS TIMESTAMP)", + "doris": "CAST('2022-01-01' AS DATETIME)", }, ) self.validate_all( @@ -792,6 +820,7 @@ def test_time(self): "mysql": "TIMESTAMP('2022-01-01')", "starrocks": "TIMESTAMP('2022-01-01')", "hive": "TIMESTAMP('2022-01-01')", + "doris": "TIMESTAMP('2022-01-01')", }, ) @@ -807,6 +836,7 @@ def test_time(self): "mysql", "presto", "starrocks", + "doris", ) }, write={ @@ -820,6 +850,7 @@ def test_time(self): "hive", "spark", "starrocks", + "doris", ) }, ) @@ -886,6 +917,7 @@ def test_json(self): "postgres": "x->'y'", "presto": "JSON_EXTRACT(x, 'y')", "starrocks": "x -> 'y'", + "doris": "x -> 'y'", }, write={ "mysql": "JSON_EXTRACT(x, 'y')", @@ -893,6 +925,7 @@ def test_json(self): "postgres": "x -> 'y'", "presto": "JSON_EXTRACT(x, 'y')", "starrocks": "x -> 'y'", + "doris": "x -> 'y'", }, ) self.validate_all( @@ -1115,6 +1148,7 @@ def test_operators(self): "sqlite": "LOWER(x) LIKE '%y'", "starrocks": "LOWER(x) LIKE '%y'", "trino": "LOWER(x) LIKE '%y'", + "doris": "LOWER(x) LIKE '%y'", }, ) self.validate_all( diff --git a/tests/dialects/test_doris.py b/tests/dialects/test_doris.py new file mode 100644 index 0000000000..63325a6b4d --- /dev/null +++ b/tests/dialects/test_doris.py @@ -0,0 +1,20 @@ +from tests.dialects.test_dialect import Validator + + +class TestDoris(Validator): + dialect = "doris" + + def test_identity(self): + self.validate_identity("SELECT CAST(`a`.`b` AS INT) FROM foo") + self.validate_identity("SELECT APPROX_COUNT_DISTINCT(a) FROM x") + + def test_time(self): + self.validate_identity("TIMESTAMP('2022-01-01')") + + def test_regex(self): + self.validate_all( + "SELECT REGEXP_LIKE(abc, '%foo%')", + write={ + "doris": "SELECT REGEXP(abc, '%foo%')", + }, + )

[]

[ "tests/dialects/test_dialect.py::TestDialect::test_cast", "tests/dialects/test_dialect.py::TestDialect::test_json", "tests/dialects/test_dialect.py::TestDialect::test_operators", "tests/dialects/test_dialect.py::TestDialect::test_time", "tests/dialects/test_doris.py::TestDoris::test_identity", "tests/dial...

[ "tests/dialects/test_dialect.py::TestDialect::test_alias", "tests/dialects/test_dialect.py::TestDialect::test_array", "tests/dialects/test_dialect.py::TestDialect::test_count_if", "tests/dialects/test_dialect.py::TestDialect::test_cross_join", "tests/dialects/test_dialect.py::TestDialect::test_decode", "t...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat: add apache doris dialect Implemented dialect support for Apache Doris ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

ceb42fabad60312699e4b15936aeebac00e22e4d

pvlib__pvlib-python-1827

1,827

pvlib/pvlib-python

0.9

ae848177c7cafae78e4a28a7f9871c29ac484f92

2023-08-03T20:49:37Z

diff --git a/docs/examples/reflections/plot_convert_iam_models.py b/docs/examples/reflections/plot_convert_iam_models.py new file mode 100644 index 0000000000..6b0ec78ab3 --- /dev/null +++ b/docs/examples/reflections/plot_convert_iam_models.py @@ -0,0 +1,162 @@ + +""" +IAM Model Conversion +==================== + +Illustrates how to convert from one IAM model to a different model using +:py:func:`~pvlib.iam.convert`. + +""" + +# %% +# An incidence angle modifier (IAM) model quantifies the fraction of direct +# irradiance that is reflected away from a module's surface. Three popular +# IAM models are Martin-Ruiz :py:func:`~pvlib.iam.martin_ruiz`, physical +# :py:func:`~pvlib.iam.physical`, and ASHRAE :py:func:`~pvlib.iam.ashrae`. +# Each model requires one or more parameters. +# +# Here, we show how to use +# :py:func:`~pvlib.iam.convert` to estimate parameters for a desired target +# IAM model from a source IAM model. Model conversion uses a weight +# function that can assign more influence to some AOI values than others. +# We illustrate how to provide a custom weight function to +# :py:func:`~pvlib.iam.convert`. + +import numpy as np +import matplotlib.pyplot as plt + +from pvlib.tools import cosd +from pvlib.iam import (ashrae, martin_ruiz, physical, convert) + +# %% +# Converting from one IAM model to another model +# ---------------------------------------------- +# +# Here we'll show how to convert from the Martin-Ruiz model to the +# physical and the ASHRAE models. + +# Compute IAM values using the martin_ruiz model. +aoi = np.linspace(0, 90, 100) +martin_ruiz_params = {'a_r': 0.16} +martin_ruiz_iam = martin_ruiz(aoi, **martin_ruiz_params) + +# Get parameters for the physical model and compute IAM using these parameters. +physical_params = convert('martin_ruiz', martin_ruiz_params, 'physical') +physical_iam = physical(aoi, **physical_params) + +# Get parameters for the ASHRAE model and compute IAM using these parameters. +ashrae_params = convert('martin_ruiz', martin_ruiz_params, 'ashrae') +ashrae_iam = ashrae(aoi, **ashrae_params) + +fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(11, 5), sharey=True) + +# Plot each model's IAM vs. angle-of-incidence (AOI). +ax1.plot(aoi, martin_ruiz_iam, label='Martin-Ruiz') +ax1.plot(aoi, physical_iam, label='physical') +ax1.set_xlabel('AOI (degrees)') +ax1.set_title('Convert from Martin-Ruiz to physical') +ax1.legend() + +ax2.plot(aoi, martin_ruiz_iam, label='Martin-Ruiz') +ax2.plot(aoi, ashrae_iam, label='ASHRAE') +ax2.set_xlabel('AOI (degrees)') +ax2.set_title('Convert from Martin-Ruiz to ASHRAE') +ax2.legend() + +ax1.set_ylabel('IAM') +plt.show() + + +# %% +# The weight function +# ------------------- +# :py:func:`pvlib.iam.convert` uses a weight function when computing residuals +# between the two models. The default weight +# function is :math:`1 - \sin(aoi)`. We can instead pass a custom weight +# function to :py:func:`pvlib.iam.convert`. +# +# In some cases, the choice of weight function has a minimal effect on the +# returned model parameters. This is especially true when converting between +# the Martin-Ruiz and physical models, because the curves described by these +# models can match quite closely. However, when conversion involves the ASHRAE +# model, the choice of weight function can have a meaningful effect on the +# returned parameters for the target model. +# +# Here we'll show examples of both of these cases, starting with an example +# where the choice of weight function does not have much impact. In doing +# so, we'll show how to pass in a custom weight function of our choice. + +# Compute IAM using the Martin-Ruiz model. +aoi = np.linspace(0, 90, 100) +martin_ruiz_params = {'a_r': 0.16} +martin_ruiz_iam = martin_ruiz(aoi, **martin_ruiz_params) + +# Get parameters for the physical model ... + +# ... using the default weight function. +physical_params_default = convert('martin_ruiz', martin_ruiz_params, + 'physical') +physical_iam_default = physical(aoi, **physical_params_default) + + +# ... using a custom weight function. The weight function must take ``aoi`` +# as its argument and return a vector of the same length as ``aoi``. +def weight_function(aoi): + return cosd(aoi) + + +physical_params_custom = convert('martin_ruiz', martin_ruiz_params, 'physical', + weight=weight_function) +physical_iam_custom = physical(aoi, **physical_params_custom) + +# Plot IAM vs AOI. +plt.plot(aoi, martin_ruiz_iam, label='Martin-Ruiz') +plt.plot(aoi, physical_iam_default, label='Default weight function') +plt.plot(aoi, physical_iam_custom, label='Custom weight function') +plt.xlabel('AOI (degrees)') +plt.ylabel('IAM') +plt.title('Martin-Ruiz to physical') +plt.legend() +plt.show() + +# %% +# For this choice of source and target models, the weight function has little +# effect on the target model's parameters. +# +# Now we'll look at an example where the weight function does affect the +# output. + +# Get parameters for the ASHRAE model ... + +# ... using the default weight function. +ashrae_params_default = convert('martin_ruiz', martin_ruiz_params, 'ashrae') +ashrae_iam_default = ashrae(aoi, **ashrae_params_default) + +# ... using the custom weight function +ashrae_params_custom = convert('martin_ruiz', martin_ruiz_params, 'ashrae', + weight=weight_function) +ashrae_iam_custom = ashrae(aoi, **ashrae_params_custom) + +# Plot IAM vs AOI. +plt.plot(aoi, martin_ruiz_iam, label='Martin-Ruiz') +plt.plot(aoi, ashrae_iam_default, label='Default weight function') +plt.plot(aoi, ashrae_iam_custom, label='Custom weight function') +plt.xlabel('AOI (degrees)') +plt.ylabel('IAM') +plt.title('Martin-Ruiz to ASHRAE') +plt.legend() +plt.show() + +# %% +# In this case, each of the two ASHRAE looks quite different. +# Finding the right weight function and parameters in such cases will require +# knowing where you want the target model to be more accurate. The default +# weight function was chosen because it yielded IAM models that produce +# similar annual insolation for a simulated PV system. + +# %% +# Reference +# --------- +# .. [1] Jones, A. R., Hansen, C. W., Anderson, K. S. Parameter estimation +# for incidence angle modifier models for photovoltaic modules. Sandia +# report SAND2023-13944 (2023). diff --git a/docs/examples/reflections/plot_fit_iam_models.py b/docs/examples/reflections/plot_fit_iam_models.py new file mode 100644 index 0000000000..6feb84423a --- /dev/null +++ b/docs/examples/reflections/plot_fit_iam_models.py @@ -0,0 +1,99 @@ + +""" +IAM Model Fitting +================================ + +Illustrates how to fit an IAM model to data using :py:func:`~pvlib.iam.fit`. + +""" + +# %% +# An incidence angle modifier (IAM) model quantifies the fraction of direct +# irradiance is that is reflected away from a module's surface. Three popular +# IAM models are Martin-Ruiz :py:func:`~pvlib.iam.martin_ruiz`, physical +# :py:func:`~pvlib.iam.physical`, and ASHRAE :py:func:`~pvlib.iam.ashrae`. +# Each model requires one or more parameters. +# +# Here, we show how to use +# :py:func:`~pvlib.iam.fit` to estimate a model's parameters from data. +# +# Model fitting require a weight function that can assign +# more influence to some AOI values than others. We illustrate how to provide +# a custom weight function to :py:func:`~pvlib.iam.fit`. + +import numpy as np +from random import uniform +import matplotlib.pyplot as plt + +from pvlib.tools import cosd +from pvlib.iam import (martin_ruiz, physical, fit) + + +# %% +# Fitting an IAM model to data +# ---------------------------- +# +# Here, we'll show how to fit an IAM model to data. +# We'll generate some data by perturbing output from the Martin-Ruiz model to +# mimic measured data and then we'll fit the physical model to the perturbed +# data. + +# Create some IAM data. +aoi = np.linspace(0, 85, 10) +params = {'a_r': 0.16} +iam = martin_ruiz(aoi, **params) +data = iam * np.array([uniform(0.98, 1.02) for _ in range(len(iam))]) + +# Get parameters for the physical model by fitting to the perturbed data. +physical_params = fit(aoi, data, 'physical') + +# Compute IAM with the fitted physical model parameters. +physical_iam = physical(aoi, **physical_params) + +# Plot IAM vs. AOI +plt.scatter(aoi, data, c='darkorange', label='Data') +plt.plot(aoi, physical_iam, label='physical') +plt.xlabel('AOI (degrees)') +plt.ylabel('IAM') +plt.title('Fitting the physical model to data') +plt.legend() +plt.show() + + +# %% +# The weight function +# ------------------- +# :py:func:`pvlib.iam.fit` uses a weight function when computing residuals +# between the model and data. The default weight +# function is :math:`1 - \sin(aoi)`. We can instead pass a custom weight +# function to :py:func:`pvlib.iam.fit`. +# + +# Define a custom weight function. The weight function must take ``aoi`` +# as its argument and return a vector of the same length as ``aoi``. +def weight_function(aoi): + return cosd(aoi) + + +physical_params_custom = fit(aoi, data, 'physical', weight=weight_function) + +physical_iam_custom = physical(aoi, **physical_params_custom) + +# Plot IAM vs AOI. +fig, ax = plt.subplots(2, 1, figsize=(5, 8)) +ax[0].plot(aoi, data, '.', label='Data (from Martin-Ruiz model)') +ax[0].plot(aoi, physical_iam, label='With default weight function') +ax[0].plot(aoi, physical_iam_custom, label='With custom weight function') +ax[0].set_xlabel('AOI (degrees)') +ax[0].set_ylabel('IAM') +ax[0].legend() + +ax[1].plot(aoi, physical_iam_custom - physical_iam, label='Custom - default') +ax[1].set_xlabel('AOI (degrees)') +ax[1].set_ylabel('Diff. in IAM') +ax[1].legend() +plt.tight_layout() +plt.show() + +print("Parameters with default weights: " + str(physical_params)) +print("Parameters with custom weights: " + str(physical_params_custom)) diff --git a/docs/sphinx/source/reference/pv_modeling/iam.rst b/docs/sphinx/source/reference/pv_modeling/iam.rst index 1871f9b4a2..e12a0c519e 100644 --- a/docs/sphinx/source/reference/pv_modeling/iam.rst +++ b/docs/sphinx/source/reference/pv_modeling/iam.rst @@ -17,3 +17,5 @@ Incident angle modifiers iam.marion_integrate iam.schlick iam.schlick_diffuse + iam.convert + iam.fit diff --git a/docs/sphinx/source/whatsnew/v0.10.3.rst b/docs/sphinx/source/whatsnew/v0.10.3.rst index 4d0cc774c8..30fd46648f 100644 --- a/docs/sphinx/source/whatsnew/v0.10.3.rst +++ b/docs/sphinx/source/whatsnew/v0.10.3.rst @@ -15,6 +15,8 @@ Enhancements * :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance` and :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance_poa` now include shaded fraction in returned variables. (:pull:`1871`) +* Added :py:func:`~pvlib.iam.convert` and :py:func:`~pvlib.iam.fit` that + convert between IAM models, and that fit an IAM model to data. (:issue:`1824`, :pull:`1827`) Bug fixes ~~~~~~~~~ @@ -50,6 +52,8 @@ Contributors * Miguel Sánchez de León Peque (:ghuser:`Peque`) * Will Hobbs (:ghuser:`williamhobbs`) * Anton Driesse (:ghuser:`adriesse`) +* Abigail Jones (:ghuser:`ajonesr`) +* Cliff Hansen (:ghuser:`cwhanse`) * Gilles Fischer (:ghuser:`GillesFischerV`) * Adam R. Jensen (:ghusuer:`AdamRJensen`) * :ghuser:`matsuobasho` diff --git a/pvlib/iam.py b/pvlib/iam.py index 4f32d352ee..83b8955e2f 100644 --- a/pvlib/iam.py +++ b/pvlib/iam.py @@ -11,7 +11,8 @@ import numpy as np import pandas as pd import functools -from pvlib.tools import cosd, sind +from scipy.optimize import minimize +from pvlib.tools import cosd, sind, acosd # a dict of required parameter names for each IAM model # keys are the function names for the IAM models @@ -856,7 +857,7 @@ def schlick_diffuse(surface_tilt): Unlike the Fresnel reflection factor itself, Schlick's approximation can be integrated analytically to derive a closed-form equation for diffuse IAM factors for the portions of the sky and ground visible - from a tilted surface if isotropic distributions are assumed. + from a tilted surface if isotropic distributions are assumed. This function implements the integration of the Schlick approximation provided by Xie et al. [2]_. @@ -940,3 +941,362 @@ def schlick_diffuse(surface_tilt): cug = pd.Series(cug, surface_tilt.index) return cuk, cug + + +def _get_model(model_name): + # check that model is implemented + model_dict = {'ashrae': ashrae, 'martin_ruiz': martin_ruiz, + 'physical': physical} + try: + model = model_dict[model_name] + except KeyError: + raise NotImplementedError(f"The {model_name} model has not been " + "implemented") + + return model + + +def _check_params(model_name, params): + # check that the parameters passed in with the model + # belong to the model + exp_params = _IAM_MODEL_PARAMS[model_name] + if set(params.keys()) != exp_params: + raise ValueError(f"The {model_name} model was expecting to be passed " + "{', '.join(list(exp_params))}, but " + "was handed {', '.join(list(params.keys()))}") + + +def _sin_weight(aoi): + return 1 - sind(aoi) + + +def _residual(aoi, source_iam, target, target_params, + weight=_sin_weight): + # computes a sum of weighted differences between the source model + # and target model, using the provided weight function + + weights = weight(aoi) + + # if aoi contains values outside of interval (0, 90), annihilate + # the associated weights (we don't want IAM values from AOI outside + # of (0, 90) to affect the fit; this is a possible issue when using + # `iam.fit`, but not an issue when using `iam.convert`, since in + # that case aoi is defined internally) + weights = weights * np.logical_and(aoi >= 0, aoi <= 90).astype(int) + + diff = np.abs(source_iam - np.nan_to_num(target(aoi, *target_params))) + return np.sum(diff * weights) + + +def _get_ashrae_intercept(b): + # find x-intercept of ashrae model + return acosd(b / (1 + b)) + + +def _ashrae_to_physical(aoi, ashrae_iam, weight, fix_n, b): + if fix_n: + # the ashrae model has an x-intercept less than 90 + # we solve for this intercept, and fix n so that the physical + # model will have the same x-intercept + intercept = _get_ashrae_intercept(b) + n = sind(intercept) + + # with n fixed, we will optimize for L (recall that K and L always + # appear in the physical model as a product, so it is enough to + # optimize for just L, and to fix K=4) + + # we will pass n to the optimizer to simplify things later on, + # but because we are setting (n, n) as the bounds, the optimizer + # will leave n fixed + bounds = [(1e-6, 0.08), (n, n)] + guess = [0.002, n] + + else: + # we don't fix n, so physical won't have same x-intercept as ashrae + # the fit will be worse, but the parameters returned for the physical + # model will be more realistic + bounds = [(1e-6, 0.08), (0.8, 2)] # L, n + guess = [0.002, 1.0] + + def residual_function(target_params): + L, n = target_params + return _residual(aoi, ashrae_iam, physical, [n, 4, L], weight) + + return residual_function, guess, bounds + + +def _martin_ruiz_to_physical(aoi, martin_ruiz_iam, weight, a_r): + # we will optimize for both n and L (recall that K and L always + # appear in the physical model as a product, so it is enough to + # optimize for just L, and to fix K=4) + # set lower bound for n at 1.0 so that x-intercept will be at 90 + # order for Powell's method depends on a_r value + bounds = [(1e-6, 0.08), (1.05, 2)] # L, n + guess = [0.002, 1.1] # L, n + # get better results if we reverse order to n, L at high a_r + if a_r > 0.22: + bounds.reverse() + guess.reverse() + + # the product of K and L is more important in determining an initial + # guess for the location of the minimum, so we pass L in first + def residual_function(target_params): + # unpack target_params for either search order + if target_params[0] < target_params[1]: + # L will always be less than n + L, n = target_params + else: + n, L = target_params + return _residual(aoi, martin_ruiz_iam, physical, [n, 4, L], weight) + + return residual_function, guess, bounds + + +def _minimize(residual_function, guess, bounds, xtol): + if xtol is not None: + options = {'xtol': xtol} + else: + options = None + with np.errstate(invalid='ignore'): + optimize_result = minimize(residual_function, guess, method="powell", + bounds=bounds, options=options) + + if not optimize_result.success: + try: + message = "Optimizer exited unsuccessfully:" \ + + optimize_result.message + except AttributeError: + message = "Optimizer exited unsuccessfully: \ + No message explaining the failure was returned. \ + If you would like to see this message, please \ + update your scipy version (try version 1.8.0 \ + or beyond)." + raise RuntimeError(message) + + return optimize_result + + +def _process_return(target_name, optimize_result): + if target_name == "ashrae": + target_params = {'b': optimize_result.x.item()} + + elif target_name == "martin_ruiz": + target_params = {'a_r': optimize_result.x.item()} + + elif target_name == "physical": + L, n = optimize_result.x + # have to unpack order because search order may be different + if L > n: + L, n = n, L + target_params = {'n': n, 'K': 4, 'L': L} + + return target_params + + +def convert(source_name, source_params, target_name, weight=_sin_weight, + fix_n=True, xtol=None): + """ + Convert a source IAM model to a target IAM model. + + Parameters + ---------- + source_name : str + Name of the source model. Must be ``'ashrae'``, ``'martin_ruiz'``, or + ``'physical'``. + + source_params : dict + A dictionary of parameters for the source model. + + If source model is ``'ashrae'``, the dictionary must contain + the key ``'b'``. + + If source model is ``'martin_ruiz'``, the dictionary must + contain the key ``'a_r'``. + + If source model is ``'physical'``, the dictionary must + contain the keys ``'n'``, ``'K'``, and ``'L'``. + + target_name : str + Name of the target model. Must be ``'ashrae'``, ``'martin_ruiz'``, or + ``'physical'``. + + weight : function, optional + A single-argument function of AOI (degrees) that calculates weights for + the residuals between models. Must return a float or an array-like + object. The default weight function is :math:`f(aoi) = 1 - sin(aoi)`. + + fix_n : bool, default True + A flag to determine which method is used when converting from the + ASHRAE model to the physical model. + + When ``source_name`` is ``'ashrae'`` and ``target_name`` is + ``'physical'``, if `fix_n` is ``True``, + :py:func:`iam.convert` will fix ``n`` so that the returned physical + model has the same x-intercept as the inputted ASHRAE model. + Fixing ``n`` like this improves the fit of the conversion, but often + returns unrealistic values for the parameters of the physical model. + If more physically meaningful parameters are wanted, + set `fix_n` to False. + + xtol : float, optional + Passed to scipy.optimize.minimize. + + Returns + ------- + dict + Parameters for the target model. + + If target model is ``'ashrae'``, the dictionary will contain + the key ``'b'``. + + If target model is ``'martin_ruiz'``, the dictionary will + contain the key ``'a_r'``. + + If target model is ``'physical'``, the dictionary will + contain the keys ``'n'``, ``'K'``, and ``'L'``. + + Note + ---- + Target model parameters are determined by minimizing + + .. math:: + + \\sum_{\\theta=0}^{90} weight \\left(\\theta \\right) \\times + \\| source \\left(\\theta \\right) - target \\left(\\theta \\right) \\| + + The sum is over :math:`\\theta = 0, 1, 2, ..., 90`. + + References + ---------- + .. [1] Jones, A. R., Hansen, C. W., Anderson, K. S. Parameter estimation + for incidence angle modifier models for photovoltaic modules. Sandia + report SAND2023-13944 (2023). + + See Also + -------- + pvlib.iam.fit + pvlib.iam.ashrae + pvlib.iam.martin_ruiz + pvlib.iam.physical + """ + source = _get_model(source_name) + target = _get_model(target_name) + + aoi = np.linspace(0, 90, 91) + _check_params(source_name, source_params) + source_iam = source(aoi, **source_params) + + if target_name == "physical": + # we can do some special set-up to improve the fit when the + # target model is physical + if source_name == "ashrae": + residual_function, guess, bounds = \ + _ashrae_to_physical(aoi, source_iam, weight, fix_n, + source_params['b']) + elif source_name == "martin_ruiz": + residual_function, guess, bounds = \ + _martin_ruiz_to_physical(aoi, source_iam, weight, + source_params['a_r']) + + else: + # otherwise, target model is ashrae or martin_ruiz, and scipy + # does fine without any special set-up + bounds = [(1e-04, 1)] + guess = [1e-03] + + def residual_function(target_param): + return _residual(aoi, source_iam, target, target_param, weight) + + optimize_result = _minimize(residual_function, guess, bounds, + xtol=xtol) + + return _process_return(target_name, optimize_result) + + +def fit(measured_aoi, measured_iam, model_name, weight=_sin_weight, xtol=None): + """ + Find model parameters that best fit the data. + + Parameters + ---------- + measured_aoi : array-like + Angle of incidence values associated with the + measured IAM values. [degrees] + + measured_iam : array-like + IAM values. [unitless] + + model_name : str + Name of the model to be fit. Must be ``'ashrae'``, ``'martin_ruiz'``, + or ``'physical'``. + + weight : function, optional + A single-argument function of AOI (degrees) that calculates weights for + the residuals between models. Must return a float or an array-like + object. The default weight function is :math:`f(aoi) = 1 - sin(aoi)`. + + xtol : float, optional + Passed to scipy.optimize.minimize. + + Returns + ------- + dict + Parameters for target model. + + If target model is ``'ashrae'``, the dictionary will contain + the key ``'b'``. + + If target model is ``'martin_ruiz'``, the dictionary will + contain the key ``'a_r'``. + + If target model is ``'physical'``, the dictionary will + contain the keys ``'n'``, ``'K'``, and ``'L'``. + + References + ---------- + .. [1] Jones, A. R., Hansen, C. W., Anderson, K. S. Parameter estimation + for incidence angle modifier models for photovoltaic modules. Sandia + report SAND2023-13944 (2023). + + Note + ---- + Model parameters are determined by minimizing + + .. math:: + + \\sum_{AOI} weight \\left( AOI \\right) \\times + \\| IAM \\left( AOI \\right) - model \\left( AOI \\right) \\| + + The sum is over ``measured_aoi`` and :math:`IAM \\left( AOI \\right)` + is ``measured_IAM``. + + See Also + -------- + pvlib.iam.convert + pvlib.iam.ashrae + pvlib.iam.martin_ruiz + pvlib.iam.physical + """ + target = _get_model(model_name) + + if model_name == "physical": + bounds = [(0, 0.08), (1, 2)] + guess = [0.002, 1+1e-08] + + def residual_function(target_params): + L, n = target_params + return _residual(measured_aoi, measured_iam, target, [n, 4, L], + weight) + + # otherwise, target_name is martin_ruiz or ashrae + else: + bounds = [(1e-08, 1)] + guess = [0.05] + + def residual_function(target_param): + return _residual(measured_aoi, measured_iam, target, + target_param, weight) + + optimize_result = _minimize(residual_function, guess, bounds, xtol) + + return _process_return(model_name, optimize_result)

diff --git a/pvlib/tests/conftest.py b/pvlib/tests/conftest.py index 15b0cd70e8..f579ef45f2 100644 --- a/pvlib/tests/conftest.py +++ b/pvlib/tests/conftest.py @@ -11,6 +11,7 @@ import pvlib from pvlib.location import Location + pvlib_base_version = Version(Version(pvlib.__version__).base_version) diff --git a/pvlib/tests/test_iam.py b/pvlib/tests/test_iam.py index 3d017ef7c2..f5ca231bd4 100644 --- a/pvlib/tests/test_iam.py +++ b/pvlib/tests/test_iam.py @@ -265,10 +265,10 @@ def test_marion_diffuse_model(mocker): assert physical_spy.call_count == 3 for k, v in ashrae_expected.items(): - np.testing.assert_allclose(ashrae_actual[k], v) + assert_allclose(ashrae_actual[k], v) for k, v in physical_expected.items(): - np.testing.assert_allclose(physical_actual[k], v) + assert_allclose(physical_actual[k], v) def test_marion_diffuse_kwargs(): @@ -281,7 +281,7 @@ def test_marion_diffuse_kwargs(): actual = _iam.marion_diffuse('ashrae', 20, b=0.04) for k, v in expected.items(): - np.testing.assert_allclose(actual[k], v) + assert_allclose(actual[k], v) def test_marion_diffuse_invalid(): @@ -395,3 +395,161 @@ def test_schlick_diffuse(): assert_series_equal(pd.Series(expected_sky, idx), actual_sky) assert_series_equal(pd.Series(expected_ground, idx), actual_ground, rtol=1e-6) + + +@pytest.mark.parametrize('source,source_params,target,expected', [ + ('physical', {'n': 1.5, 'K': 4.5, 'L': 0.004}, 'martin_ruiz', + {'a_r': 0.174037}), + ('physical', {'n': 1.5, 'K': 4.5, 'L': 0.004}, 'ashrae', + {'b': 0.042896}), + ('ashrae', {'b': 0.15}, 'physical', + {'n': 0.991457, 'K': 4, 'L': 0.037813}), + ('ashrae', {'b': 0.15}, 'martin_ruiz', {'a_r': 0.302390}), + ('martin_ruiz', {'a_r': 0.15}, 'physical', + {'n': 1.240190, 'K': 4, 'L': 0.002791055}), + ('martin_ruiz', {'a_r': 0.15}, 'ashrae', {'b': 0.025458})]) +def test_convert(source, source_params, target, expected): + target_params = _iam.convert(source, source_params, target) + exp = [expected[k] for k in expected] + tar = [target_params[k] for k in expected] + assert_allclose(exp, tar, rtol=1e-05) + + +@pytest.mark.parametrize('source,source_params', [ + ('ashrae', {'b': 0.15}), + ('ashrae', {'b': 0.05}), + ('martin_ruiz', {'a_r': 0.15})]) +def test_convert_recover(source, source_params): + # convert isn't set up to handle both source and target = 'physical' + target_params = _iam.convert(source, source_params, source, xtol=1e-7) + exp = [source_params[k] for k in source_params] + tar = [target_params[k] for k in source_params] + assert_allclose(exp, tar, rtol=1e-05) + + +def test_convert_ashrae_physical_no_fix_n(): + # convert ashrae to physical, without fixing n + source_params = {'b': 0.15} + target_params = _iam.convert('ashrae', source_params, 'physical', + fix_n=False) + expected = {'n': 0.989019, 'K': 4, 'L': 0.037382} + exp = [expected[k] for k in expected] + tar = [target_params[k] for k in expected] + assert_allclose(exp, tar, rtol=1e-05) + + +def test_convert_reverse_order_in_physical(): + source_params = {'a_r': 0.25} + target_params = _iam.convert('martin_ruiz', source_params, 'physical') + expected = {'n': 1.691398, 'K': 4, 'L': 0.071633} + exp = [expected[k] for k in expected] + tar = [target_params[k] for k in expected] + assert_allclose(exp, tar, rtol=1e-05) + + +def test_convert_xtol(): + source_params = {'b': 0.15} + target_params = _iam.convert('ashrae', source_params, 'physical', + xtol=1e-8) + expected = {'n': 0.9914568914, 'K': 4, 'L': 0.0378126985} + exp = [expected[k] for k in expected] + tar = [target_params[k] for k in expected] + assert_allclose(exp, tar, rtol=1e-6) + + +def test_convert_custom_weight_func(): + aoi = np.linspace(0, 90, 91) + + # convert physical to martin_ruiz, using custom weight function + source_params = {'n': 1.5, 'K': 4.5, 'L': 0.004} + source_iam = _iam.physical(aoi, **source_params) + + # define custom weight function that takes in other arguments + def scaled_weight(aoi): + return 2. * aoi + + # expected value calculated from computing residual function over + # a range of inputs, and taking minimum of these values + expected_min_res = 16.39724 + + actual_dict = _iam.convert('physical', source_params, 'martin_ruiz', + weight=scaled_weight) + actual_min_res = _iam._residual(aoi, source_iam, _iam.martin_ruiz, + [actual_dict['a_r']], scaled_weight) + + assert np.isclose(expected_min_res, actual_min_res, atol=1e-06) + + +def test_convert_model_not_implemented(): + with pytest.raises(NotImplementedError, match='model has not been'): + _iam.convert('ashrae', {'b': 0.1}, 'foo') + + +def test_convert_wrong_model_parameters(): + with pytest.raises(ValueError, match='model was expecting'): + _iam.convert('ashrae', {'B': 0.1}, 'physical') + + +def test_convert__minimize_fails(): + # to make scipy.optimize.minimize fail, we'll pass in a nonsense + # weight function that only outputs nans + def nan_weight(aoi): + return np.nan + + with pytest.raises(RuntimeError, match='Optimizer exited unsuccessfully'): + _iam.convert('ashrae', {'b': 0.1}, 'physical', weight=nan_weight) + + +def test_fit(): + aoi = np.linspace(0, 90, 5) + perturb = np.array([1.2, 1.01, 0.95, 1, 0.98]) + perturbed_iam = _iam.martin_ruiz(aoi, a_r=0.14) * perturb + + expected_a_r = 0.14 + + actual_dict = _iam.fit(aoi, perturbed_iam, 'martin_ruiz') + actual_a_r = actual_dict['a_r'] + + assert np.isclose(expected_a_r, actual_a_r, atol=1e-04) + + +def test_fit_custom_weight_func(): + # define custom weight function that takes in other arguments + def scaled_weight(aoi): + return 2. * aoi + + aoi = np.linspace(0, 90, 5) + perturb = np.array([1.2, 1.01, 0.95, 1, 0.98]) + perturbed_iam = _iam.martin_ruiz(aoi, a_r=0.14) * perturb + + expected_a_r = 0.14 + + actual_dict = _iam.fit(aoi, perturbed_iam, 'martin_ruiz', + weight=scaled_weight) + actual_a_r = actual_dict['a_r'] + + assert np.isclose(expected_a_r, actual_a_r, atol=1e-04) + + +def test_fit_model_not_implemented(): + with pytest.raises(NotImplementedError, match='model has not been'): + _iam.fit(np.array([0, 10]), np.array([1, 0.99]), 'foo') + + +def test_fit__minimize_fails(): + # to make scipy.optimize.minimize fail, we'll pass in a nonsense + # weight function that only outputs nans + def nan_weight(aoi): + return np.nan + + with pytest.raises(RuntimeError, match='Optimizer exited unsuccessfully'): + _iam.fit(np.array([0, 10]), np.array([1, 0.99]), 'physical', + weight=nan_weight) + + +def test__residual_zero_outside_range(): + # check that _residual annihilates any weights that come from aoi + # outside of interval [0, 90] (this is important for `iam.fit`, when + # the `measured_aoi` contains angles outside this range + residual = _iam._residual(101, _iam.ashrae(101), _iam.martin_ruiz, [0.16]) + assert residual == 0.0

diff --git a/docs/sphinx/source/reference/pv_modeling/iam.rst b/docs/sphinx/source/reference/pv_modeling/iam.rst index 1871f9b4a2..e12a0c519e 100644 --- a/docs/sphinx/source/reference/pv_modeling/iam.rst +++ b/docs/sphinx/source/reference/pv_modeling/iam.rst @@ -17,3 +17,5 @@ Incident angle modifiers iam.marion_integrate iam.schlick iam.schlick_diffuse + iam.convert + iam.fit diff --git a/docs/sphinx/source/whatsnew/v0.10.3.rst b/docs/sphinx/source/whatsnew/v0.10.3.rst index 4d0cc774c8..30fd46648f 100644 --- a/docs/sphinx/source/whatsnew/v0.10.3.rst +++ b/docs/sphinx/source/whatsnew/v0.10.3.rst @@ -15,6 +15,8 @@ Enhancements * :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance` and :py:func:`pvlib.bifacial.infinite_sheds.get_irradiance_poa` now include shaded fraction in returned variables. (:pull:`1871`) +* Added :py:func:`~pvlib.iam.convert` and :py:func:`~pvlib.iam.fit` that + convert between IAM models, and that fit an IAM model to data. (:issue:`1824`, :pull:`1827`) Bug fixes ~~~~~~~~~ @@ -50,6 +52,8 @@ Contributors * Miguel Sánchez de León Peque (:ghuser:`Peque`) * Will Hobbs (:ghuser:`williamhobbs`) * Anton Driesse (:ghuser:`adriesse`) +* Abigail Jones (:ghuser:`ajonesr`) +* Cliff Hansen (:ghuser:`cwhanse`) * Gilles Fischer (:ghuser:`GillesFischerV`) * Adam R. Jensen (:ghusuer:`AdamRJensen`) * :ghuser:`matsuobasho`

[ { "components": [ { "doc": "", "lines": [ 104, 105 ], "name": "weight_function", "signature": "def weight_function(aoi):", "type": "function" } ], "file": "docs/examples/reflections/plot_convert_iam_models.py" }, { "...

[ "pvlib/tests/test_iam.py::test_convert[physical-source_params0-martin_ruiz-expected0]", "pvlib/tests/test_iam.py::test_convert[physical-source_params1-ashrae-expected1]", "pvlib/tests/test_iam.py::test_convert[ashrae-source_params2-physical-expected2]", "pvlib/tests/test_iam.py::test_convert[ashrae-source_par...

[ "pvlib/tests/test_iam.py::test_ashrae", "pvlib/tests/test_iam.py::test_ashrae_scalar", "pvlib/tests/test_iam.py::test_physical", "pvlib/tests/test_iam.py::test_physical_n1_L0", "pvlib/tests/test_iam.py::test_physical_ar", "pvlib/tests/test_iam.py::test_physical_noar", "pvlib/tests/test_iam.py::test_phys...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add functions to fit and convert IAM models - [x] Closes #1824 - [x] I am familiar with the [contributing guidelines](https://pvlib-python.readthedocs.io/en/latest/contributing.html) - [x] Tests added - [x] Updates entries in [`docs/sphinx/source/reference`](https://github.com/pvlib/pvlib-python/blob/main/docs/sphinx/source/reference) for API changes. - [x] Adds description and name entries in the appropriate "what's new" file in [`docs/sphinx/source/whatsnew`](https://github.com/pvlib/pvlib-python/tree/main/docs/sphinx/source/whatsnew) for all changes. Includes link to the GitHub Issue with `` :issue:`num` `` or this Pull Request with `` :pull:`num` ``. Includes contributor name and/or GitHub username (link with `` :ghuser:`user` ``). - [x] New code is fully documented. Includes [numpydoc](https://numpydoc.readthedocs.io/en/latest/format.html) compliant docstrings, examples, and comments where necessary. - [x] Pull request is nearly complete and ready for detailed review. - [x] Maintainer: Appropriate GitHub Labels (including `remote-data`) and Milestone are assigned to the Pull Request and linked Issue. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in docs/examples/reflections/plot_convert_iam_models.py] (definition of weight_function:) def weight_function(aoi): [end of new definitions in docs/examples/reflections/plot_convert_iam_models.py] [start of new definitions in docs/examples/reflections/plot_fit_iam_models.py] (definition of weight_function:) def weight_function(aoi): [end of new definitions in docs/examples/reflections/plot_fit_iam_models.py] [start of new definitions in pvlib/iam.py] (definition of _get_model:) def _get_model(model_name): (definition of _check_params:) def _check_params(model_name, params): (definition of _sin_weight:) def _sin_weight(aoi): (definition of _residual:) def _residual(aoi, source_iam, target, target_params, weight=_sin_weight): (definition of _get_ashrae_intercept:) def _get_ashrae_intercept(b): (definition of _ashrae_to_physical:) def _ashrae_to_physical(aoi, ashrae_iam, weight, fix_n, b): (definition of _ashrae_to_physical.residual_function:) def residual_function(target_params): (definition of _martin_ruiz_to_physical:) def _martin_ruiz_to_physical(aoi, martin_ruiz_iam, weight, a_r): (definition of _martin_ruiz_to_physical.residual_function:) def residual_function(target_params): (definition of _minimize:) def _minimize(residual_function, guess, bounds, xtol): (definition of _process_return:) def _process_return(target_name, optimize_result): (definition of convert:) def convert(source_name, source_params, target_name, weight=_sin_weight, fix_n=True, xtol=None): """Convert a source IAM model to a target IAM model. Parameters ---------- source_name : str Name of the source model. Must be ``'ashrae'``, ``'martin_ruiz'``, or ``'physical'``. source_params : dict A dictionary of parameters for the source model. If source model is ``'ashrae'``, the dictionary must contain the key ``'b'``. If source model is ``'martin_ruiz'``, the dictionary must contain the key ``'a_r'``. If source model is ``'physical'``, the dictionary must contain the keys ``'n'``, ``'K'``, and ``'L'``. target_name : str Name of the target model. Must be ``'ashrae'``, ``'martin_ruiz'``, or ``'physical'``. weight : function, optional A single-argument function of AOI (degrees) that calculates weights for the residuals between models. Must return a float or an array-like object. The default weight function is :math:`f(aoi) = 1 - sin(aoi)`. fix_n : bool, default True A flag to determine which method is used when converting from the ASHRAE model to the physical model. When ``source_name`` is ``'ashrae'`` and ``target_name`` is ``'physical'``, if `fix_n` is ``True``, :py:func:`iam.convert` will fix ``n`` so that the returned physical model has the same x-intercept as the inputted ASHRAE model. Fixing ``n`` like this improves the fit of the conversion, but often returns unrealistic values for the parameters of the physical model. If more physically meaningful parameters are wanted, set `fix_n` to False. xtol : float, optional Passed to scipy.optimize.minimize. Returns ------- dict Parameters for the target model. If target model is ``'ashrae'``, the dictionary will contain the key ``'b'``. If target model is ``'martin_ruiz'``, the dictionary will contain the key ``'a_r'``. If target model is ``'physical'``, the dictionary will contain the keys ``'n'``, ``'K'``, and ``'L'``. Note ---- Target model parameters are determined by minimizing .. math:: \sum_{\theta=0}^{90} weight \left(\theta \right) \times \| source \left(\theta \right) - target \left(\theta \right) \| The sum is over :math:`\theta = 0, 1, 2, ..., 90`. References ---------- .. [1] Jones, A. R., Hansen, C. W., Anderson, K. S. Parameter estimation for incidence angle modifier models for photovoltaic modules. Sandia report SAND2023-13944 (2023). See Also -------- pvlib.iam.fit pvlib.iam.ashrae pvlib.iam.martin_ruiz pvlib.iam.physical""" (definition of convert.residual_function:) def residual_function(target_param): (definition of fit:) def fit(measured_aoi, measured_iam, model_name, weight=_sin_weight, xtol=None): """Find model parameters that best fit the data. Parameters ---------- measured_aoi : array-like Angle of incidence values associated with the measured IAM values. [degrees] measured_iam : array-like IAM values. [unitless] model_name : str Name of the model to be fit. Must be ``'ashrae'``, ``'martin_ruiz'``, or ``'physical'``. weight : function, optional A single-argument function of AOI (degrees) that calculates weights for the residuals between models. Must return a float or an array-like object. The default weight function is :math:`f(aoi) = 1 - sin(aoi)`. xtol : float, optional Passed to scipy.optimize.minimize. Returns ------- dict Parameters for target model. If target model is ``'ashrae'``, the dictionary will contain the key ``'b'``. If target model is ``'martin_ruiz'``, the dictionary will contain the key ``'a_r'``. If target model is ``'physical'``, the dictionary will contain the keys ``'n'``, ``'K'``, and ``'L'``. References ---------- .. [1] Jones, A. R., Hansen, C. W., Anderson, K. S. Parameter estimation for incidence angle modifier models for photovoltaic modules. Sandia report SAND2023-13944 (2023). Note ---- Model parameters are determined by minimizing .. math:: \sum_{AOI} weight \left( AOI \right) \times \| IAM \left( AOI \right) - model \left( AOI \right) \| The sum is over ``measured_aoi`` and :math:`IAM \left( AOI \right)` is ``measured_IAM``. See Also -------- pvlib.iam.convert pvlib.iam.ashrae pvlib.iam.martin_ruiz pvlib.iam.physical""" (definition of fit.residual_function:) def residual_function(target_param): [end of new definitions in pvlib/iam.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Functions to fit and convert IAM models It would be useful to be able to convert parameters between IAM models (e.g., physical to martin_ruiz). To convert from an interpolation approach to a model described by an equation, it would also be useful to have a "fit" function. **Describe the solution you'd like** Add `fit` and `convert` functions to `pvlib.iam.py`. `convert` could be implemented as ``` target_params = convert(source_model, source_params, target_model) ``` Add an example to the gallery showing how to use these functions, and demonstrating that a converted model yields similar effective insolation for a representative system. **Describe alternatives you've considered** An example showing how to do this. The example would contain the fit/convert code, which seems like a less-than-useful implementation. ---------- -------------------- </issues>

d53f97e984bfdd268aa92f8bf482ced0edda0110

scverse__scanpy-2590

2,590

scverse/scanpy

null

b4ba81dc9eab9f75b761d85e473e548a5c37b49e

2023-08-03T15:46:47Z

diff --git a/docs/api/get.md b/docs/api/get.md index 82f74ed411..039769d0a6 100644 --- a/docs/api/get.md +++ b/docs/api/get.md @@ -19,5 +19,6 @@ useful formats. get.obs_df get.var_df get.rank_genes_groups_df + get.aggregate ``` diff --git a/docs/release-notes/1.10.0.md b/docs/release-notes/1.10.0.md index 542ee15fd9..0266b2bdf9 100644 --- a/docs/release-notes/1.10.0.md +++ b/docs/release-notes/1.10.0.md @@ -15,6 +15,7 @@ * Enhanced dask support for some internal utilities, paving the way for more extensive dask support {pr}`2696` {smaller}`P Angerer` * {func}`scanpy.pp.pca`, {func}`scanpy.pp.scale`, {func}`scanpy.pl.embedding`, and {func}`scanpy.experimental.pp.normalize_pearson_residuals_pca` now support a `mask` parameter {pr}`2272` {smaller}`C Bright, T Marcella, & P Angerer` +* New function {func}`scanpy.get.aggregate` which allows grouped aggregations over your data. Useful for pseudobulking! {pr}`2590` {smaller}`Isaac Virshup` {smaller}`Ilan Gold` {smaller}`Jon Bloom` * {func}`scanpy.tl.rank_genes_groups` no longer warns that it's default was changed from t-test_overestim_var to t-test {pr}`2798` {smaller}`L Heumos` * {func}`scanpy.tl.leiden` now offers `igraph`'s implementation of the leiden algorithm via via `flavor` when set to `igraph`. `leidenalg`'s implementation is still default, but discouraged. {pr}`2815` {smaller}`I Gold` * {func}`scanpy.pp.highly_variable_genes` has new flavor `seurat_v3_paper` that is in its implementation consistent with the paper description in Stuart et al 2018. {pr}`2792` {smaller}`E Roellin` diff --git a/scanpy/_utils/__init__.py b/scanpy/_utils/__init__.py index 625e3b71e3..3ef16300aa 100644 --- a/scanpy/_utils/__init__.py +++ b/scanpy/_utils/__init__.py @@ -874,3 +874,13 @@ def _choose_graph(adata, obsp, neighbors_key): "to compute a neighborhood graph." ) return neighbors["connectivities"] + + +def _resolve_axis( + axis: Literal["obs", 0, "var", 1], +) -> tuple[Literal[0], Literal["obs"]] | tuple[Literal[1], Literal["var"]]: + if axis in {0, "obs"}: + return (0, "obs") + if axis in {1, "var"}: + return (1, "var") + raise ValueError(f"`axis` must be either 0, 1, 'obs', or 'var', was {axis!r}") diff --git a/scanpy/get/__init__.py b/scanpy/get/__init__.py index 08567cfc6e..56c0d3c130 100644 --- a/scanpy/get/__init__.py +++ b/scanpy/get/__init__.py @@ -1,7 +1,6 @@ -# Public -# Private from __future__ import annotations +from ._aggregated import aggregate from .get import ( _check_mask, _get_obs_rep, @@ -15,6 +14,7 @@ "_check_mask", "_get_obs_rep", "_set_obs_rep", + "aggregate", "obs_df", "rank_genes_groups_df", "var_df", diff --git a/scanpy/get/_aggregated.py b/scanpy/get/_aggregated.py new file mode 100644 index 0000000000..159f7572e3 --- /dev/null +++ b/scanpy/get/_aggregated.py @@ -0,0 +1,387 @@ +from __future__ import annotations + +from functools import singledispatch +from typing import TYPE_CHECKING, Literal, Union, get_args + +import numpy as np +import pandas as pd +from anndata import AnnData, utils +from scipy import sparse + +from .._utils import _resolve_axis +from .get import _check_mask + +if TYPE_CHECKING: + from collections.abc import Collection, Iterable + + from numpy.typing import NDArray + +Array = Union[np.ndarray, sparse.csc_matrix, sparse.csr_matrix] +AggType = Literal["count_nonzero", "mean", "sum", "var"] + + +class Aggregate: + """\ + Functionality for generic grouping and aggregating. + + There is currently support for count_nonzero, sum, mean, and variance. + + **Implementation** + + Moments are computed using weighted sum aggregation of data by some feature + via multiplication by a sparse coordinate matrix A. + + Runtime is effectively computation of the product `A @ X`, i.e. the count of (non-zero) + entries in X with multiplicity the number of group memberships for that entry. + This is `O(data)` for partitions (each observation belonging to exactly one group), + independent of the number of groups. + + Params + ------ + groupby + :class:`~pandas.Categorical` containing values for grouping by. + data + Data matrix for aggregation. + mask + Mask to be used for aggregation. + """ + + def __init__( + self, + groupby: pd.Categorical, + data: Array, + *, + mask: NDArray[np.bool_] | None = None, + ) -> None: + self.groupby = groupby + self.indicator_matrix = sparse_indicator(groupby, mask=mask) + self.data = data + + groupby: pd.Categorical + indicator_matrix: sparse.coo_matrix + data: Array + + def count_nonzero(self) -> NDArray[np.integer]: + """\ + Count the number of observations in each group. + + Returns + ------- + Array of counts. + """ + # pattern = self.data._with_data(np.broadcast_to(1, len(self.data.data))) + # return self.indicator_matrix @ pattern + return self.indicator_matrix @ (self.data != 0) + + def sum(self) -> Array: + """\ + Compute the sum per feature per group of observations. + + Returns + ------- + Array of sum. + """ + return utils.asarray(self.indicator_matrix @ self.data) + + def mean(self) -> Array: + """\ + Compute the mean per feature per group of observations. + + Returns + ------- + Array of mean. + """ + return ( + utils.asarray(self.indicator_matrix @ self.data) + / np.bincount(self.groupby.codes)[:, None] + ) + + def mean_var(self, dof: int = 1) -> tuple[np.ndarray, np.ndarray]: + """\ + Compute the count, as well as mean and variance per feature, per group of observations. + + The formula `Var(X) = E(X^2) - E(X)^2` suffers loss of precision when the variance is a + very small fraction of the squared mean. In particular, when X is constant, the formula may + nonetheless be non-zero. By default, our implementation resets the variance to exactly zero + when the computed variance, relative to the squared mean, nears limit of precision of the + floating-point significand. + + Params + ------ + dof + Degrees of freedom for variance. + + Returns + ------- + Object with `count`, `mean`, and `var` attributes. + """ + assert dof >= 0 + + group_counts = np.bincount(self.groupby.codes) + mean_ = self.mean() + # sparse matrices do not support ** for elementwise power. + mean_sq = ( + utils.asarray(self.indicator_matrix @ _power(self.data, 2)) + / group_counts[:, None] + ) + sq_mean = mean_**2 + var_ = mean_sq - sq_mean + # TODO: Why these values exactly? Because they are high relative to the datatype? + # (unchanged from original code: https://github.com/scverse/anndata/pull/564) + precision = 2 << (42 if self.data.dtype == np.float64 else 20) + # detects loss of precision in mean_sq - sq_mean, which suggests variance is 0 + var_[precision * var_ < sq_mean] = 0 + if dof != 0: + var_ *= (group_counts / (group_counts - dof))[:, np.newaxis] + return mean_, var_ + + +def _power(X: Array, power: float | int) -> Array: + """\ + Generate elementwise power of a matrix. + + Needed for non-square sparse matrices because they do not support `**` so the `.power` function is used. + + Params + ------ + X + Matrix whose power is to be raised. + power + Integer power value + + Returns + ------- + Matrix whose power has been raised. + """ + return X**power if isinstance(X, np.ndarray) else X.power(power) + + +@singledispatch +def aggregate( + adata: AnnData, + by: str | Collection[str], + func: AggType | Iterable[AggType], + *, + axis: Literal["obs", 0, "var", 1] | None = None, + mask: NDArray[np.bool_] | str | None = None, + dof: int = 1, + layer: str | None = None, + obsm: str | None = None, + varm: str | None = None, +) -> AnnData: + """\ + Aggregate data matrix based on some categorical grouping. + + This function is useful for pseudobulking as well as plotting. + + Aggregation to perform is specified by `func`, which can be a single metric or a + list of metrics. Each metric is computed over the group and results in a new layer + in the output `AnnData` object. + + If none of `layer`, `obsm`, or `varm` are passed in, `X` will be used for aggregation data. + If `func` only has length 1 or is just an `AggType`, then aggregation data is written to `X`. + Otherwise, it is written to `layers` or `xxxm` as appropriate for the dimensions of the aggregation data. + + Params + ------ + adata + :class:`~anndata.AnnData` to be aggregated. + by + Key of the column to be grouped-by. + func + How to aggregate. + axis + Axis on which to find group by column. + mask + Boolean mask (or key to column containing mask) to apply along the axis. + dof + Degrees of freedom for variance. Defaults to 1. + layer + If not None, key for aggregation data. + obsm + If not None, key for aggregation data. + varm + If not None, key for aggregation data. + + Returns + ------- + Aggregated :class:`~anndata.AnnData`. + + Examples + -------- + + Calculating mean expression and number of nonzero entries per cluster: + + >>> import scanpy as sc, pandas as pd + >>> pbmc = sc.datasets.pbmc3k_processed().raw.to_adata() + >>> pbmc.shape + (2638, 13714) + >>> aggregated = sc.get.aggregate(pbmc, by="louvain", func=["mean", "count_nonzero"]) + >>> aggregated + AnnData object with n_obs × n_vars = 8 × 13714 + obs: 'louvain' + var: 'n_cells' + layers: 'mean', 'count_nonzero' + + We can group over multiple columns: + + >>> pbmc.obs["percent_mito_binned"] = pd.cut(pbmc.obs["percent_mito"], bins=5) + >>> sc.get.aggregate(pbmc, by=["louvain", "percent_mito_binned"], func=["mean", "count_nonzero"]) + AnnData object with n_obs × n_vars = 40 × 13714 + obs: 'louvain', 'percent_mito_binned' + var: 'n_cells' + layers: 'mean', 'count_nonzero' + + Note that this filters out any combination of groups that wasn't present in the original data. + """ + if axis is None: + axis = 1 if varm else 0 + axis, axis_name = _resolve_axis(axis) + if mask is not None: + mask = _check_mask(adata, mask, axis_name) + data = adata.X + if sum(p is not None for p in [varm, obsm, layer]) > 1: + raise TypeError("Please only provide one (or none) of varm, obsm, or layer") + + if varm is not None: + if axis != 1: + raise ValueError("varm can only be used when axis is 1") + data = adata.varm[varm] + elif obsm is not None: + if axis != 0: + raise ValueError("obsm can only be used when axis is 0") + data = adata.obsm[obsm] + elif layer is not None: + data = adata.layers[layer] + if axis == 1: + data = data.T + elif axis == 1: + # i.e., all of `varm`, `obsm`, `layers` are None so we use `X` which must be transposed + data = data.T + + dim_df = getattr(adata, axis_name) + categorical, new_label_df = _combine_categories(dim_df, by) + # Actual computation + layers = aggregate( + data, + by=categorical, + func=func, + mask=mask, + dof=dof, + ) + result = AnnData( + layers=layers, + obs=new_label_df, + var=getattr(adata, "var" if axis == 0 else "obs"), + ) + + if axis == 1: + return result.T + else: + return result + + +@aggregate.register(np.ndarray) +@aggregate.register(sparse.spmatrix) +def aggregate_array( + data, + by: pd.Categorical, + func: AggType | Iterable[AggType], + *, + mask: NDArray[np.bool_] | None = None, + dof: int = 1, +) -> dict[AggType, np.ndarray]: + groupby = Aggregate(groupby=by, data=data, mask=mask) + result = {} + + funcs = set([func] if isinstance(func, str) else func) + if unknown := funcs - set(get_args(AggType)): + raise ValueError(f"func {unknown} is not one of {get_args(AggType)}") + + if "sum" in funcs: # sum is calculated separately from the rest + agg = groupby.sum() + result["sum"] = agg + # here and below for count, if var is present, these can be calculate alongside var + if "mean" in funcs and "var" not in funcs: + agg = groupby.mean() + result["mean"] = agg + if "count_nonzero" in funcs: + result["count_nonzero"] = groupby.count_nonzero() + if "var" in funcs: + mean_, var_ = groupby.mean_var(dof) + result["var"] = var_ + if "mean" in funcs: + result["mean"] = mean_ + + return result + + +def _combine_categories( + label_df: pd.DataFrame, cols: Collection[str] | str +) -> tuple[pd.Categorical, pd.DataFrame]: + """ + Returns both the result categories and a dataframe labelling each row + """ + from itertools import product + + if isinstance(cols, str): + cols = [cols] + + df = pd.DataFrame( + {c: pd.Categorical(label_df[c]).remove_unused_categories() for c in cols}, + ) + n_categories = [len(df[c].cat.categories) for c in cols] + + # It's like np.concatenate([x for x in product(*[range(n) for n in n_categories])]) + code_combinations = np.indices(n_categories).reshape(len(n_categories), -1) + result_categories = pd.Index( + ["_".join(map(str, x)) for x in product(*[df[c].cat.categories for c in cols])] + ) + + # Dataframe with unique combination of categories for each row + new_label_df = pd.DataFrame( + { + c: pd.Categorical.from_codes(code_combinations[i], df[c].cat.categories) + for i, c in enumerate(cols) + }, + index=result_categories, + ) + + # Calculating result codes + factors = np.ones(len(cols) + 1, dtype=np.int32) # First factor needs to be 1 + np.cumsum(n_categories[::-1], out=factors[1:]) + factors = factors[:-1][::-1] + + code_array = np.zeros((len(cols), df.shape[0]), dtype=np.int32) + for i, c in enumerate(cols): + code_array[i] = df[c].cat.codes + code_array *= factors[:, None] + + result_categorical = pd.Categorical.from_codes( + code_array.sum(axis=0), categories=result_categories + ) + + # Filter unused categories + result_categorical = result_categorical.remove_unused_categories() + new_label_df = new_label_df.loc[result_categorical.categories] + + return result_categorical, new_label_df + + +def sparse_indicator( + categorical: pd.Categorical, + *, + mask: NDArray[np.bool_] | None = None, + weight: NDArray[np.floating] | None = None, +) -> sparse.coo_matrix: + if mask is not None and weight is None: + weight = mask.astype(np.float32) + elif mask is not None and weight is not None: + weight = mask * weight + elif mask is None and weight is None: + weight = np.broadcast_to(1.0, len(categorical)) + A = sparse.coo_matrix( + (weight, (categorical.codes, np.arange(len(categorical)))), + shape=(len(categorical.categories), len(categorical)), + ) + return A

diff --git a/scanpy/tests/test_aggregated.py b/scanpy/tests/test_aggregated.py new file mode 100644 index 0000000000..4439f3e0eb --- /dev/null +++ b/scanpy/tests/test_aggregated.py @@ -0,0 +1,373 @@ +from __future__ import annotations + +import anndata as ad +import numpy as np +import pandas as pd +import pytest +from scipy.sparse import csr_matrix + +import scanpy as sc +from scanpy._utils import _resolve_axis +from scanpy.testing._helpers import assert_equal +from scanpy.testing._helpers.data import pbmc3k_processed +from scanpy.testing._pytest.params import ARRAY_TYPES_MEM + + +@pytest.fixture +def df_base(): + ax_base = ["A", "B"] + return pd.DataFrame(index=ax_base) + + +@pytest.fixture +def df_groupby(): + ax_groupby = [ + *["v0", "v1", "v2"], + *["w0", "w1"], + *["a1", "a2", "a3"], + *["b1", "b2"], + *["c1", "c2"], + "d0", + ] + + df_groupby = pd.DataFrame(index=pd.Index(ax_groupby, name="cell")) + df_groupby["key"] = pd.Categorical([c[0] for c in ax_groupby]) + df_groupby["key_superset"] = pd.Categorical([c[0] for c in ax_groupby]).map( + {"v": "v", "w": "v", "a": "a", "b": "a", "c": "a", "d": "a"} + ) + df_groupby["key_subset"] = pd.Categorical([c[1] for c in ax_groupby]) + df_groupby["weight"] = 2.0 + return df_groupby + + +@pytest.fixture +def X(): + data = [ + *[[0, -2], [1, 13], [2, 1]], # v + *[[3, 12], [4, 2]], # w + *[[5, 11], [6, 3], [7, 10]], # a + *[[8, 4], [9, 9]], # b + *[[10, 5], [11, 8]], # c + [12, 6], # d + ] + return np.array(data, dtype=np.float32) + + +def gen_adata(data_key, dim, df_base, df_groupby, X): + if (data_key == "varm" and dim == "obs") or (data_key == "obsm" and dim == "var"): + pytest.skip("invalid parameter combination") + + obs_df, var_df = (df_groupby, df_base) if dim == "obs" else (df_base, df_groupby) + data = X.T if dim == "var" and data_key != "varm" else X + if data_key != "X": + data_dict_sparse = {data_key: {"test": csr_matrix(data)}} + data_dict_dense = {data_key: {"test": data}} + else: + data_dict_sparse = {data_key: csr_matrix(data)} + data_dict_dense = {data_key: data} + + adata_sparse = ad.AnnData(obs=obs_df, var=var_df, **data_dict_sparse) + adata_dense = ad.AnnData(obs=obs_df, var=var_df, **data_dict_dense) + return adata_sparse, adata_dense + + +@pytest.mark.parametrize("axis", [0, 1]) +def test_mask(axis): + blobs = sc.datasets.blobs() + mask = blobs.obs["blobs"] == 0 + blobs.obs["mask_col"] = mask + if axis == 1: + blobs = blobs.T + by_name = sc.get.aggregate(blobs, "blobs", "sum", axis=axis, mask="mask_col") + by_value = sc.get.aggregate(blobs, "blobs", "sum", axis=axis, mask=mask) + + assert_equal(by_name, by_value) + + assert np.all(by_name["0"].layers["sum"] == 0) + + +@pytest.mark.parametrize("array_type", ARRAY_TYPES_MEM) +@pytest.mark.parametrize("metric", ["sum", "mean", "var", "count_nonzero"]) +def test_aggregate_vs_pandas(metric, array_type): + adata = pbmc3k_processed().raw.to_adata() + adata = adata[ + adata.obs["louvain"].isin(adata.obs["louvain"].cat.categories[:5]), :1_000 + ].copy() + adata.X = array_type(adata.X) + adata.obs["percent_mito_binned"] = pd.cut(adata.obs["percent_mito"], bins=5) + result = sc.get.aggregate(adata, ["louvain", "percent_mito_binned"], metric) + + if metric == "count_nonzero": + expected = ( + (adata.to_df() != 0) + .astype(np.float64) + .join(adata.obs[["louvain", "percent_mito_binned"]]) + .groupby(["louvain", "percent_mito_binned"], observed=True) + .agg("sum") + ) + else: + expected = ( + adata.to_df() + .astype(np.float64) + .join(adata.obs[["louvain", "percent_mito_binned"]]) + .groupby(["louvain", "percent_mito_binned"], observed=True) + .agg(metric) + ) + # TODO: figure out the axis names + expected.index = expected.index.to_frame().apply( + lambda x: "_".join(map(str, x)), axis=1 + ) + expected.index.name = None + expected.columns.name = None + + result_df = result.to_df(layer=metric) + result_df.index.name = None + result_df.columns.name = None + + pd.testing.assert_frame_equal(result_df, expected, check_dtype=False, atol=1e-5) + + +@pytest.mark.parametrize("array_type", ARRAY_TYPES_MEM) +@pytest.mark.parametrize("metric", ["sum", "mean", "var", "count_nonzero"]) +def test_aggregate_axis(array_type, metric): + adata = pbmc3k_processed().raw.to_adata() + adata = adata[ + adata.obs["louvain"].isin(adata.obs["louvain"].cat.categories[:5]), :1_000 + ].copy() + adata.X = array_type(adata.X) + expected = sc.get.aggregate(adata, ["louvain"], metric) + actual = sc.get.aggregate(adata.T, ["louvain"], metric, axis=1).T + + assert_equal(expected, actual) + + +def test_aggregate_entry(): + args = ("blobs", ["mean", "var", "count_nonzero"]) + + adata = sc.datasets.blobs() + X_result = sc.get.aggregate(adata, *args) + # layer adata + layer_adata = ad.AnnData( + obs=adata.obs, + var=adata.var, + layers={"test": adata.X.copy()}, + ) + layer_result = sc.get.aggregate(layer_adata, *args, layer="test") + obsm_adata = ad.AnnData( + obs=adata.obs, + var=adata.var, + obsm={"test": adata.X.copy()}, + ) + obsm_result = sc.get.aggregate(obsm_adata, *args, obsm="test") + varm_adata = ad.AnnData( + obs=adata.var, + var=adata.obs, + varm={"test": adata.X.copy()}, + ) + varm_result = sc.get.aggregate(varm_adata, *args, varm="test") + + X_result_min = X_result.copy() + del X_result_min.var + X_result_min.var_names = [str(x) for x in np.arange(X_result_min.n_vars)] + + assert_equal(X_result, layer_result) + assert_equal(X_result_min, obsm_result) + assert_equal(X_result.layers, obsm_result.layers) + assert_equal(X_result.layers, varm_result.T.layers) + + +def test_aggregate_incorrect_dim(): + adata = pbmc3k_processed().raw.to_adata() + + with pytest.raises(ValueError, match="was 'foo'"): + sc.get.aggregate(adata, ["louvain"], "sum", axis="foo") + + +@pytest.mark.parametrize("axis_name", ["obs", "var"]) +def test_aggregate_axis_specification(axis_name): + axis, axis_name = _resolve_axis(axis_name) + by = "blobs" if axis == 0 else "labels" + + adata = sc.datasets.blobs() + adata.var["labels"] = np.tile(["a", "b"], adata.shape[1])[: adata.shape[1]] + + agg_index = sc.get.aggregate(adata, by=by, func="mean", axis=axis) + agg_name = sc.get.aggregate(adata, by=by, func="mean", axis=axis_name) + + np.testing.assert_equal(agg_index.layers["mean"], agg_name.layers["mean"]) + + if axis_name == "obs": + agg_unspecified = sc.get.aggregate(adata, by=by, func="mean") + np.testing.assert_equal(agg_name.layers["mean"], agg_unspecified.layers["mean"]) + + +@pytest.mark.parametrize( + ("matrix", "df", "keys", "metrics", "expected"), + [ + pytest.param( + np.block( + [ + [np.ones((2, 2)), np.zeros((2, 2))], + [np.zeros((2, 2)), np.ones((2, 2))], + ] + ), + pd.DataFrame( + { + "a": ["a", "a", "b", "b"], + "b": ["c", "d", "d", "d"], + } + ), + ["a", "b"], + ["count_nonzero"], # , "sum", "mean"], + ad.AnnData( + obs=pd.DataFrame( + {"a": ["a", "a", "b"], "b": ["c", "d", "d"]}, + index=["a_c", "a_d", "b_d"], + ).astype("category"), + var=pd.DataFrame(index=[f"gene_{i}" for i in range(4)]), + layers={ + "count_nonzero": np.array( + [[1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 2, 2]] + ), + # "sum": np.array([[2, 0], [0, 2]]), + # "mean": np.array([[1, 0], [0, 1]]), + }, + ), + id="count_nonzero", + ), + pytest.param( + np.block( + [ + [np.ones((2, 2)), np.zeros((2, 2))], + [np.zeros((2, 2)), np.ones((2, 2))], + ] + ), + pd.DataFrame( + { + "a": ["a", "a", "b", "b"], + "b": ["c", "d", "d", "d"], + } + ), + ["a", "b"], + ["sum", "mean", "count_nonzero"], + ad.AnnData( + obs=pd.DataFrame( + {"a": ["a", "a", "b"], "b": ["c", "d", "d"]}, + index=["a_c", "a_d", "b_d"], + ).astype("category"), + var=pd.DataFrame(index=[f"gene_{i}" for i in range(4)]), + layers={ + "sum": np.array([[1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 2, 2]]), + "mean": np.array([[1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 1, 1]]), + "count_nonzero": np.array( + [[1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 2, 2]] + ), + }, + ), + id="sum-mean-count_nonzero", + ), + pytest.param( + np.block( + [ + [np.ones((2, 2)), np.zeros((2, 2))], + [np.zeros((2, 2)), np.ones((2, 2))], + ] + ), + pd.DataFrame( + { + "a": ["a", "a", "b", "b"], + "b": ["c", "d", "d", "d"], + } + ), + ["a", "b"], + ["mean"], + ad.AnnData( + obs=pd.DataFrame( + {"a": ["a", "a", "b"], "b": ["c", "d", "d"]}, + index=["a_c", "a_d", "b_d"], + ).astype("category"), + var=pd.DataFrame(index=[f"gene_{i}" for i in range(4)]), + layers={ + "mean": np.array([[1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 1, 1]]), + }, + ), + id="mean", + ), + ], +) +def test_aggregate_examples(matrix, df, keys, metrics, expected): + adata = ad.AnnData( + X=matrix, + obs=df, + var=pd.DataFrame(index=[f"gene_{i}" for i in range(matrix.shape[1])]), + ) + result = sc.get.aggregate(adata, by=keys, func=metrics) + + print(result) + print(expected) + + assert_equal(expected, result) + + +@pytest.mark.parametrize( + ("label_cols", "cols", "expected"), + [ + pytest.param( + dict( + a=pd.Categorical(["a", "b", "c"]), + b=pd.Categorical(["d", "d", "f"]), + ), + ["a", "b"], + pd.Categorical(["a_d", "b_d", "c_f"]), + id="two_of_two", + ), + pytest.param( + dict( + a=pd.Categorical(["a", "b", "c"]), + b=pd.Categorical(["d", "d", "f"]), + c=pd.Categorical(["g", "h", "h"]), + ), + ["a", "b", "c"], + pd.Categorical(["a_d_g", "b_d_h", "c_f_h"]), + id="three_of_three", + ), + pytest.param( + dict( + a=pd.Categorical(["a", "b", "c"]), + b=pd.Categorical(["d", "d", "f"]), + c=pd.Categorical(["g", "h", "h"]), + ), + ["a", "c"], + pd.Categorical(["a_g", "b_h", "c_h"]), + id="two_of_three-1", + ), + pytest.param( + dict( + a=pd.Categorical(["a", "b", "c"]), + b=pd.Categorical(["d", "d", "f"]), + c=pd.Categorical(["g", "h", "h"]), + ), + ["b", "c"], + pd.Categorical(["d_g", "d_h", "f_h"]), + id="two_of_three-2", + ), + ], +) +def test_combine_categories(label_cols, cols, expected): + from scanpy.get._aggregated import _combine_categories + + label_df = pd.DataFrame(label_cols) + result, result_label_df = _combine_categories(label_df, cols) + + assert isinstance(result, pd.Categorical) + + pd.testing.assert_extension_array_equal(result, expected) + + pd.testing.assert_index_equal( + pd.Index(result), result_label_df.index.astype("category") + ) + + reconstructed_df = pd.DataFrame( + [x.split("_") for x in result], columns=cols, index=result.astype(str) + ).astype("category") + pd.testing.assert_frame_equal(reconstructed_df, result_label_df)

diff --git a/docs/api/get.md b/docs/api/get.md index 82f74ed411..039769d0a6 100644 --- a/docs/api/get.md +++ b/docs/api/get.md @@ -19,5 +19,6 @@ useful formats. get.obs_df get.var_df get.rank_genes_groups_df + get.aggregate ``` diff --git a/docs/release-notes/1.10.0.md b/docs/release-notes/1.10.0.md index 542ee15fd9..0266b2bdf9 100644 --- a/docs/release-notes/1.10.0.md +++ b/docs/release-notes/1.10.0.md @@ -15,6 +15,7 @@ * Enhanced dask support for some internal utilities, paving the way for more extensive dask support {pr}`2696` {smaller}`P Angerer` * {func}`scanpy.pp.pca`, {func}`scanpy.pp.scale`, {func}`scanpy.pl.embedding`, and {func}`scanpy.experimental.pp.normalize_pearson_residuals_pca` now support a `mask` parameter {pr}`2272` {smaller}`C Bright, T Marcella, & P Angerer` +* New function {func}`scanpy.get.aggregate` which allows grouped aggregations over your data. Useful for pseudobulking! {pr}`2590` {smaller}`Isaac Virshup` {smaller}`Ilan Gold` {smaller}`Jon Bloom` * {func}`scanpy.tl.rank_genes_groups` no longer warns that it's default was changed from t-test_overestim_var to t-test {pr}`2798` {smaller}`L Heumos` * {func}`scanpy.tl.leiden` now offers `igraph`'s implementation of the leiden algorithm via via `flavor` when set to `igraph`. `leidenalg`'s implementation is still default, but discouraged. {pr}`2815` {smaller}`I Gold` * {func}`scanpy.pp.highly_variable_genes` has new flavor `seurat_v3_paper` that is in its implementation consistent with the paper description in Stuart et al 2018. {pr}`2792` {smaller}`E Roellin`

[ { "components": [ { "doc": "", "lines": [ 879, 886 ], "name": "_resolve_axis", "signature": "def _resolve_axis( axis: Literal[\"obs\", 0, \"var\", 1], ) -> tuple[Literal[0], Literal[\"obs\"]] | tuple[Literal[1], Literal[\"var\"]]:", "type...

[ "scanpy/tests/test_aggregated.py::test_mask[0]", "scanpy/tests/test_aggregated.py::test_mask[1]", "scanpy/tests/test_aggregated.py::test_aggregate_vs_pandas[sum-numpy_ndarray]", "scanpy/tests/test_aggregated.py::test_aggregate_vs_pandas[sum-scipy_csr]", "scanpy/tests/test_aggregated.py::test_aggregate_vs_pa...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> (feat): Aggregation via group-by in `sc.get`  Modified (for `scanpy`) version of https://github.com/scverse/anndata/pull/564. Fixes https://github.com/scverse/anndata/issues/556 Big points of change: 1. No more tuple-indices and related functionality (i.e., scoring pairwise) 2. Allow for `obs` and `var` group-by +`varm`, `obsm`, `layers` as options for data to aggregate 3. Output is `AnnData` object instead of `DataFrame` 4. `scanpy`-style public API ## TODO (by @ivirshup): Necessary: - [x] Docs - [x] Aggregate along other axis - [x] Keep grouping cols in result - [x] Reconsider API for non-anndata version (maybe return a dict of arrays?) - [ ] Decide on naming convention for `"nonzero"` variations, should this be `"nonzero_count"` so it's a little like `"nanmean"` Optional, can do later: - [ ] Weighted (although.... Idk, maybe can skip. Does "weights" affect "count_nonzero"?) - [ ] Option for keeping around unseen groups, probably needs `fill_value` argument for those values - [x] Support for `obsm`, `varm` - [ ] Directly pass Series to groupby - [ ] More aggregation functions (mean_nonzero, min, max, std, `nan*` variations) - [ ] Mask argument - [ ] Dask support ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in scanpy/_utils/__init__.py] (definition of _resolve_axis:) def _resolve_axis( axis: Literal["obs", 0, "var", 1], ) -> tuple[Literal[0], Literal["obs"]] | tuple[Literal[1], Literal["var"]]: [end of new definitions in scanpy/_utils/__init__.py] [start of new definitions in scanpy/get/_aggregated.py] (definition of Aggregate:) class Aggregate: """Functionality for generic grouping and aggregating. There is currently support for count_nonzero, sum, mean, and variance. **Implementation** Moments are computed using weighted sum aggregation of data by some feature via multiplication by a sparse coordinate matrix A. Runtime is effectively computation of the product `A @ X`, i.e. the count of (non-zero) entries in X with multiplicity the number of group memberships for that entry. This is `O(data)` for partitions (each observation belonging to exactly one group), independent of the number of groups. Params ------ groupby :class:`~pandas.Categorical` containing values for grouping by. data Data matrix for aggregation. mask Mask to be used for aggregation.""" (definition of Aggregate.__init__:) def __init__( self, groupby: pd.Categorical, data: Array, *, mask: NDArray[np.bool_] | None = None, ) -> None: (definition of Aggregate.count_nonzero:) def count_nonzero(self) -> NDArray[np.integer]: """Count the number of observations in each group. Returns ------- Array of counts.""" (definition of Aggregate.sum:) def sum(self) -> Array: """Compute the sum per feature per group of observations. Returns ------- Array of sum.""" (definition of Aggregate.mean:) def mean(self) -> Array: """Compute the mean per feature per group of observations. Returns ------- Array of mean.""" (definition of Aggregate.mean_var:) def mean_var(self, dof: int = 1) -> tuple[np.ndarray, np.ndarray]: """Compute the count, as well as mean and variance per feature, per group of observations. The formula `Var(X) = E(X^2) - E(X)^2` suffers loss of precision when the variance is a very small fraction of the squared mean. In particular, when X is constant, the formula may nonetheless be non-zero. By default, our implementation resets the variance to exactly zero when the computed variance, relative to the squared mean, nears limit of precision of the floating-point significand. Params ------ dof Degrees of freedom for variance. Returns ------- Object with `count`, `mean`, and `var` attributes.""" (definition of _power:) def _power(X: Array, power: float | int) -> Array: """Generate elementwise power of a matrix. Needed for non-square sparse matrices because they do not support `**` so the `.power` function is used. Params ------ X Matrix whose power is to be raised. power Integer power value Returns ------- Matrix whose power has been raised.""" (definition of aggregate:) def aggregate( adata: AnnData, by: str | Collection[str], func: AggType | Iterable[AggType], *, axis: Literal["obs", 0, "var", 1] | None = None, mask: NDArray[np.bool_] | str | None = None, dof: int = 1, layer: str | None = None, obsm: str | None = None, varm: str | None = None, ) -> AnnData: """Aggregate data matrix based on some categorical grouping. This function is useful for pseudobulking as well as plotting. Aggregation to perform is specified by `func`, which can be a single metric or a list of metrics. Each metric is computed over the group and results in a new layer in the output `AnnData` object. If none of `layer`, `obsm`, or `varm` are passed in, `X` will be used for aggregation data. If `func` only has length 1 or is just an `AggType`, then aggregation data is written to `X`. Otherwise, it is written to `layers` or `xxxm` as appropriate for the dimensions of the aggregation data. Params ------ adata :class:`~anndata.AnnData` to be aggregated. by Key of the column to be grouped-by. func How to aggregate. axis Axis on which to find group by column. mask Boolean mask (or key to column containing mask) to apply along the axis. dof Degrees of freedom for variance. Defaults to 1. layer If not None, key for aggregation data. obsm If not None, key for aggregation data. varm If not None, key for aggregation data. Returns ------- Aggregated :class:`~anndata.AnnData`. Examples -------- Calculating mean expression and number of nonzero entries per cluster: >>> import scanpy as sc, pandas as pd >>> pbmc = sc.datasets.pbmc3k_processed().raw.to_adata() >>> pbmc.shape (2638, 13714) >>> aggregated = sc.get.aggregate(pbmc, by="louvain", func=["mean", "count_nonzero"]) >>> aggregated AnnData object with n_obs × n_vars = 8 × 13714 obs: 'louvain' var: 'n_cells' layers: 'mean', 'count_nonzero' We can group over multiple columns: >>> pbmc.obs["percent_mito_binned"] = pd.cut(pbmc.obs["percent_mito"], bins=5) >>> sc.get.aggregate(pbmc, by=["louvain", "percent_mito_binned"], func=["mean", "count_nonzero"]) AnnData object with n_obs × n_vars = 40 × 13714 obs: 'louvain', 'percent_mito_binned' var: 'n_cells' layers: 'mean', 'count_nonzero' Note that this filters out any combination of groups that wasn't present in the original data.""" (definition of aggregate_array:) def aggregate_array( data, by: pd.Categorical, func: AggType | Iterable[AggType], *, mask: NDArray[np.bool_] | None = None, dof: int = 1, ) -> dict[AggType, np.ndarray]: (definition of _combine_categories:) def _combine_categories( label_df: pd.DataFrame, cols: Collection[str] | str ) -> tuple[pd.Categorical, pd.DataFrame]: """Returns both the result categories and a dataframe labelling each row""" (definition of sparse_indicator:) def sparse_indicator( categorical: pd.Categorical, *, mask: NDArray[np.bool_] | None = None, weight: NDArray[np.floating] | None = None, ) -> sparse.coo_matrix: [end of new definitions in scanpy/get/_aggregated.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

2f0afac72be3644624cf996323197239580f14f9

conan-io__conan-14382

14,382

conan-io/conan

null

bc4ed4d79fd92edd825fc846dfa515c7b3912138

2023-07-27T18:08:40Z

diff --git a/conan/tools/system/package_manager.py b/conan/tools/system/package_manager.py index 25bc96d6a0a..b5476f376df 100644 --- a/conan/tools/system/package_manager.py +++ b/conan/tools/system/package_manager.py @@ -40,6 +40,7 @@ def get_default_tool(self): elif os_name == "Windows" and self._conanfile.conf.get("tools.microsoft.bash:subsystem") == "msys2": os_name = "msys2" manager_mapping = {"apt-get": ["Linux", "ubuntu", "debian", "raspbian"], + "apk": ["alpine"], "yum": ["pidora", "scientific", "xenserver", "amazon", "oracle", "amzn", "almalinux", "rocky"], "dnf": ["fedora", "rhel", "centos", "mageia"], @@ -332,6 +333,25 @@ def __init__(self, conanfile, arch_names=None): self._arch_separator = "-" +class Apk(_SystemPackageManagerTool): + tool_name = "apk" + install_command = "{sudo}{tool} add --no-cache {packages}" + update_command = "{sudo}{tool} update" + check_command = "{tool} info -e {package}" + + def __init__(self, conanfile, _arch_names=None): + """ + Constructor method. + Note that *Apk* does not support architecture names since Alpine Linux does not support + multiarch. Therefore, the ``arch_names`` argument is ignored. + + :param conanfile: the current recipe object. Always use ``self``. + """ + super(Apk, self).__init__(conanfile) + self._arch_names = {} + self._arch_separator = "" + + class Zypper(_SystemPackageManagerTool): tool_name = "zypper" install_command = "{sudo}{tool} --non-interactive in {packages}"

diff --git a/conans/test/integration/tools/system/package_manager_test.py b/conans/test/integration/tools/system/package_manager_test.py index 07f7bdf02b6..a533f647ccf 100644 --- a/conans/test/integration/tools/system/package_manager_test.py +++ b/conans/test/integration/tools/system/package_manager_test.py @@ -5,8 +5,8 @@ import pytest from unittest.mock import PropertyMock -from conan.tools.system.package_manager import Apt, Dnf, Yum, Brew, Pkg, PkgUtil, Chocolatey, Zypper, \ - PacMan, _SystemPackageManagerTool +from conan.tools.system.package_manager import Apt, Apk, Dnf, Yum, Brew, Pkg, PkgUtil, Chocolatey, \ + Zypper, PacMan, _SystemPackageManagerTool from conans.errors import ConanException from conans.model.conf import Conf from conans.model.settings import Settings @@ -58,6 +58,7 @@ def test_msys2(): ("opensuse-leap", "zypper"), ("opensuse-next_version", "zypper"), ("freebsd", "pkg"), + ("alpine", "apk"), ]) @pytest.mark.skipif(platform.system() != "Linux", reason="Only linux") def test_package_manager_distro(distro, tool): @@ -107,7 +108,7 @@ def test_apt_install_recommends(recommends, recommends_str): @pytest.mark.parametrize("tool_class", - [Apt, Yum, Dnf, Brew, Pkg, PkgUtil, Chocolatey, PacMan, Zypper]) + [Apk, Apt, Yum, Dnf, Brew, Pkg, PkgUtil, Chocolatey, PacMan, Zypper]) def test_tools_install_mode_check(tool_class): conanfile = ConanFileMock() conanfile.conf = Conf() @@ -132,6 +133,7 @@ def fake_check(*args, **kwargs): @pytest.mark.parametrize("tool_class, result", [ + (Apk, "apk update"), (Apt, "apt-get update"), (Yum, "yum check-update -y"), (Dnf, "dnf check-update -y"), @@ -198,6 +200,7 @@ def fake_run(command, win_bash=False, subsystem=None, env=None, ignore_errors=Fa @pytest.mark.parametrize("tool_class, arch_host, result", [ # not cross-compile -> do not add host architecture + (Apk, 'x86_64', 'apk add --no-cache package1 package2'), (Apt, 'x86_64', 'apt-get install -y --no-install-recommends package1 package2'), (Yum, 'x86_64', 'yum install -y package1 package2'), (Dnf, 'x86_64', 'dnf install -y package1 package2'), @@ -221,7 +224,7 @@ def fake_run(command, win_bash=False, subsystem=None, env=None, ignore_errors=Fa def test_tools_install_mode_install_different_archs(tool_class, arch_host, result): conanfile = ConanFileMock() conanfile.conf = Conf() - conanfile.settings = MockSettings({"arch": f"{arch_host}"}) + conanfile.settings = MockSettings({"arch": arch_host}) conanfile.settings_build = MockSettings({"arch": "x86_64"}) conanfile.conf.define("tools.system.package_manager:tool", tool_class.tool_name) conanfile.conf.define("tools.system.package_manager:mode", "install") @@ -267,6 +270,7 @@ def fake_check(*args, **kwargs): @pytest.mark.parametrize("tool_class, result", [ + (Apk, 'apk info -e package'), (Apt, 'dpkg-query -W -f=\'${Status}\' package | grep -q "ok installed"'), (Yum, 'rpm -q package'), (Dnf, 'rpm -q package'),

[ { "components": [ { "doc": "", "lines": [ 336, 352 ], "name": "Apk", "signature": "class Apk(_SystemPackageManagerTool):", "type": "class" }, { "doc": "Constructor method.\nNote that *Apk* does not support architecture...

[ "conans/test/integration/tools/system/package_manager_test.py::test_package_manager_platform[Linux-apt-get]", "conans/test/integration/tools/system/package_manager_test.py::test_package_manager_platform[Windows-choco]", "conans/test/integration/tools/system/package_manager_test.py::test_package_manager_platform...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> tools: Add support for Alpine Linux This commit closes #14307. Changelog: Feature: Added support for `apk` package manager and Alpine Linux Docs: https://github.com/conan-io/docs/pull/3312 - [X] Refer to the issue that supports this Pull Request. - [X] I've read the [Contributing guide](https://github.com/conan-io/conan/blob/develop/.github/CONTRIBUTING.md). - [X] I've followed the PEP8 style guides for Python code. - [X] I've opened another PR in the Conan docs repo to the ``develop2`` branch, documenting this one. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conan/tools/system/package_manager.py] (definition of Apk:) class Apk(_SystemPackageManagerTool): (definition of Apk.__init__:) def __init__(self, conanfile, _arch_names=None): """Constructor method. Note that *Apk* does not support architecture names since Alpine Linux does not support multiarch. Therefore, the ``arch_names`` argument is ignored. :param conanfile: the current recipe object. Always use ``self``.""" [end of new definitions in conan/tools/system/package_manager.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> [feature] Support Alpine Linux system package manager ### What is your suggestion? Hi, The system manager support in conan is really handy and already covers a large list of distributions/tools. It would be very nice though if it could also support [`apk`](https://wiki.alpinelinux.org/wiki/Alpine_Package_Keeper) for the Alpine Linux distribution. ### Have you read the CONTRIBUTING guide? - [X] I've read the CONTRIBUTING guide ---------- Hi @Sahnvour Thanks for your suggestion. Just to be sure, this is to add the ``Apk`` package manager to the Conan tool, but that doesn't mean that package recipes in ConanCenter will necessarily add its usage (Alpine not tested in ConanCenter CI). So it is for your own private recipes, isn't it? We don't know much about ``apk``, would you like to contribute the feature yourself? It should be relatively straightforward, copying one of the existing ones. Hi @memsharded, > So it is for your own private recipes, isn't it? Yes, I am building my projects on Alpine in CI because it's a musl-based distribution that improves coverage, and I also think it is quite used in the docker space because of its small default size. As such, I'd be glad to let conan install system dependencies by itself instead of manually listing them myself. I understand ConanCenter would probably not have prebuilt binaries but it's ok. I don't know much about `apk` myself, however if you can give me some pointers on where to start in conan I will have a look at it (no promises). > I don't know much about apk myself, however if you can give me some pointers on where to start in conan I will have a look at it (no promises). Sure, no commitment here at all, just if you like to do it. Some pointers: - The entry point, and possibly the only file necessary to change is this one: https://github.com/conan-io/conan/blob/release/2.0/conan/tools/system/package_manager.py - Copy and paste the ``Apt`` or the ``Yum`` class, and then start customizing for the ``apk`` case. - If you clone and pip-install as editable the source project (https://github.com/conan-io/conan#setup), you can run ``conan`` commands using your clone changes - Write a small recipe ``conanfile.py`` with a ``system_requirements()`` method that uses your new ``Apk`` class - Try things. - Finally, some integration tests would be enough, in this file: https://github.com/conan-io/conan/blob/release/2.0/conans/test/integration/tools/system/package_manager_test.py Hey @memsharded ! Thanks for the pointers! One issue I realized while poking into that is the fact that Alpine is a no-multilib distro. Hence, the concept of adding an arch separator and an explicit architecture to the package name is not applicable there. So far I'm not sure how much of a problem this is. Let's see. -------------------- </issues>

4a5b19a75db9225316c8cb022a2dfb9705a2af34

roboflow__supervision-245

245

roboflow/supervision

null

36cdcf1b128e38cb9a086290fbfb0130fa64ac5b

2023-07-26T08:25:02Z

diff --git a/supervision/dataset/core.py b/supervision/dataset/core.py index ce7e0edb5..6e47d747f 100644 --- a/supervision/dataset/core.py +++ b/supervision/dataset/core.py @@ -31,7 +31,6 @@ train_test_split, ) from supervision.detection.core import Detections -from supervision.utils.file import list_files_with_extensions @dataclass @@ -197,7 +196,10 @@ def as_pascal_voc( @classmethod def from_pascal_voc( - cls, images_directory_path: str, annotations_directory_path: str + cls, + images_directory_path: str, + annotations_directory_path: str, + force_masks: bool = False, ) -> DetectionDataset: """ Creates a Dataset instance from PASCAL VOC formatted data. @@ -205,6 +207,7 @@ def from_pascal_voc( Args: images_directory_path (str): The path to the directory containing the images. annotations_directory_path (str): The path to the directory containing the PASCAL VOC XML annotations. + force_masks (bool, optional): If True, forces masks to be loaded for all annotations, regardless of whether they are present. Returns: DetectionDataset: A DetectionDataset instance containing the loaded images and annotations. @@ -222,7 +225,7 @@ def from_pascal_voc( >>> project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID) >>> dataset = project.version(PROJECT_VERSION).download("voc") - >>> ds = sv.DetectionDataset.from_yolo( + >>> ds = sv.DetectionDataset.from_pascal_voc( ... images_directory_path=f"{dataset.location}/train/images", ... annotations_directory_path=f"{dataset.location}/train/labels" ... ) @@ -231,34 +234,13 @@ def from_pascal_voc( ['dog', 'person'] ``` """ - image_paths = list_files_with_extensions( - directory=images_directory_path, extensions=["jpg", "jpeg", "png"] - ) - annotation_paths = list_files_with_extensions( - directory=annotations_directory_path, extensions=["xml"] - ) - raw_annotations: List[Tuple[str, Detections, List[str]]] = [ - load_pascal_voc_annotations(annotation_path=str(annotation_path)) - for annotation_path in annotation_paths - ] - - classes = [] - for annotation in raw_annotations: - classes.extend(annotation[2]) - classes = list(set(classes)) - - for annotation in raw_annotations: - class_id = [classes.index(class_name) for class_name in annotation[2]] - annotation[1].class_id = np.array(class_id) - - images = { - image_path.name: cv2.imread(str(image_path)) for image_path in image_paths - } + classes, images, annotations = load_pascal_voc_annotations( + images_directory_path=images_directory_path, + annotations_directory_path=annotations_directory_path, + force_masks=force_masks, + ) - annotations = { - image_name: detections for image_name, detections, _ in raw_annotations - } return DetectionDataset(classes=classes, images=images, annotations=annotations) @classmethod diff --git a/supervision/dataset/formats/pascal_voc.py b/supervision/dataset/formats/pascal_voc.py index a3005eb90..4efb29173 100644 --- a/supervision/dataset/formats/pascal_voc.py +++ b/supervision/dataset/formats/pascal_voc.py @@ -1,12 +1,16 @@ -from typing import List, Optional, Tuple +import os +from pathlib import Path +from typing import Dict, List, Optional, Tuple from xml.dom.minidom import parseString from xml.etree.ElementTree import Element, SubElement, parse, tostring +import cv2 import numpy as np from supervision.dataset.utils import approximate_mask_with_polygons from supervision.detection.core import Detections -from supervision.detection.utils import polygon_to_xyxy +from supervision.detection.utils import polygon_to_mask, polygon_to_xyxy +from supervision.utils.file import list_files_with_extensions def object_to_pascal_voc( @@ -120,24 +124,91 @@ def detections_to_pascal_voc( def load_pascal_voc_annotations( - annotation_path: str, -) -> Tuple[str, Detections, List[str]]: + images_directory_path: str, + annotations_directory_path: str, + force_masks: bool = False, +) -> Tuple[List[str], Dict[str, np.ndarray], Dict[str, Detections]]: """ - Loads PASCAL VOC XML annotations and returns the image name, a Detections instance, and a list of class names. + Loads PASCAL VOC annotations and returns class names, images, and their corresponding detections. Args: - annotation_path (str): The path to the PASCAL VOC XML annotations file. + images_directory_path (str): The path to the directory containing the images. + annotations_directory_path (str): The path to the directory containing the PASCAL VOC annotation files. + force_masks (bool, optional): If True, forces masks to be loaded for all annotations, regardless of whether they are present. Returns: - Tuple[str, Detections, List[str]]: A tuple containing the image name, a Detections instance, and a list of class names of objects in the detections. + Tuple[List[str], Dict[str, np.ndarray], Dict[str, Detections]]: A tuple containing a list of class names, a dictionary with image names as keys and images as values, and a dictionary with image names as keys and corresponding Detections instances as values. """ - tree = parse(annotation_path) - root = tree.getroot() - image_name = root.find("filename").text + image_paths = list_files_with_extensions( + directory=images_directory_path, extensions=["jpg", "jpeg", "png"] + ) + classes = [] + images = {} + annotations = {} + + for image_path in image_paths: + image_name = Path(image_path).stem + image = cv2.imread(str(image_path)) + + annotation_path = os.path.join(annotations_directory_path, f"{image_name}.xml") + if not os.path.exists(annotation_path): + images[image_path.name] = image + annotations[image_path.name] = Detections.empty() + continue + + tree = parse(annotation_path) + root = tree.getroot() + + resolution_wh = (image.shape[1], image.shape[0]) + annotation, classes = detections_from_xml_obj( + root, classes, resolution_wh, force_masks + ) + + images[image_path.name] = image + annotations[image_path.name] = annotation + + return classes, images, annotations + + +def detections_from_xml_obj( + root: Element, classes: List[str], resolution_wh, force_masks: bool = False +) -> Tuple[Detections, List[str]]: + """ + Converts an XML object in Pascal VOC format to a Detections object. + Expected XML format: + <annotation> + ... + <object> + <name>dog</name> + <bndbox> + <xmin>48</xmin> + <ymin>240</ymin> + <xmax>195</xmax> + <ymax>371</ymax> + </bndbox> + <polygon> + <x1>48</x1> + <y1>240</y1> + <x2>195</x2> + <y2>240</y2> + <x3>195</x3> + <y3>371</y3> + <x4>48</x4> + <y4>371</y4> + </polygon> + </object> + </annotation> + + Returns: + Tuple[Detections, List[str]]: A tuple containing a Detections object and an updated list of class names, extended with the class names from the XML object. + """ xyxy = [] class_names = [] + masks = [] + with_masks = False + extended_classes = classes[:] for obj in root.findall("object"): class_name = obj.find("name").text class_names.append(class_name) @@ -150,7 +221,40 @@ def load_pascal_voc_annotations( xyxy.append([x1, y1, x2, y2]) - xyxy = np.array(xyxy) - detections = Detections(xyxy=xyxy) + with_masks = obj.find("polygon") is not None + with_masks = force_masks if force_masks else with_masks + + for polygon in obj.findall("polygon"): + polygon_points = parse_polygon_points(polygon) + + mask_from_polygon = polygon_to_mask( + polygon=np.array(polygon_points), + resolution_wh=resolution_wh, + ) + masks.append(mask_from_polygon) + + xyxy = np.array(xyxy) if len(xyxy) > 0 else np.empty((0, 4)) + for k in set(class_names): + if k not in extended_classes: + extended_classes.append(k) + class_id = np.array( + [extended_classes.index(class_name) for class_name in class_names] + ) + + if with_masks: + annotation = Detections( + xyxy=xyxy, mask=np.array(masks).astype(bool), class_id=class_id + ) + else: + annotation = Detections(xyxy=xyxy, class_id=class_id) + return annotation, extended_classes + - return image_name, detections, class_names +def parse_polygon_points(polygon: Element) -> List[List[int]]: + polygon_points = [] + coords = polygon.findall(".//*") + for i in range(0, len(coords), 2): + x = int(coords[i].text) + y = int(coords[i + 1].text) + polygon_points.append([x, y]) + return polygon_points diff --git a/supervision/detection/utils.py b/supervision/detection/utils.py index 63206ddcc..e30e6a053 100644 --- a/supervision/detection/utils.py +++ b/supervision/detection/utils.py @@ -17,7 +17,7 @@ def polygon_to_mask(polygon: np.ndarray, resolution_wh: Tuple[int, int]) -> np.n np.ndarray: The generated 2D mask, where the polygon is marked with `1`'s and the rest is filled with `0`'s. """ width, height = resolution_wh - mask = np.zeros((height, width), dtype=np.uint8) + mask = np.zeros((height, width)) cv2.fillPoly(mask, [polygon], color=1) return mask

diff --git a/test/dataset/formats/test_pascal_voc.py b/test/dataset/formats/test_pascal_voc.py new file mode 100644 index 000000000..fa3f11244 --- /dev/null +++ b/test/dataset/formats/test_pascal_voc.py @@ -0,0 +1,147 @@ +import xml.etree.ElementTree as ET +from contextlib import ExitStack as DoesNotRaise +from test.utils import mock_detections +from typing import List, Optional + +import numpy as np +import pytest + +from supervision.dataset.formats.pascal_voc import ( + detections_from_xml_obj, + object_to_pascal_voc, + parse_polygon_points, +) + + +def are_xml_elements_equal(elem1, elem2): + if ( + elem1.tag != elem2.tag + or elem1.attrib != elem2.attrib + or elem1.text != elem2.text + or len(elem1) != len(elem2) + ): + return False + + for child1, child2 in zip(elem1, elem2): + if not are_xml_elements_equal(child1, child2): + return False + + return True + + +@pytest.mark.parametrize( + "xyxy, name, polygon, expected_result, exception", + [ + ( + [0, 0, 10, 10], + "test", + None, + ET.fromstring( + """<object><name>test</name><bndbox><xmin>0</xmin><ymin>0</ymin><xmax>10</xmax><ymax>10</ymax></bndbox></object>""" + ), + DoesNotRaise(), + ), + ( + [0, 0, 10, 10], + "test", + [[0, 0], [10, 0], [10, 10], [0, 10]], + ET.fromstring( + """<object><name>test</name><bndbox><xmin>0</xmin><ymin>0</ymin><xmax>10</xmax><ymax>10</ymax></bndbox><polygon><x1>0</x1><y1>0</y1><x2>10</x2><y2>0</y2><x3>10</x3><y3>10</y3><x4>0</x4><y4>10</y4></polygon></object>""" + ), + DoesNotRaise(), + ), + ], +) +def test_object_to_pascal_voc( + xyxy: np.ndarray, + name: str, + polygon: Optional[np.ndarray], + expected_result, + exception: Exception, +): + with exception: + result = object_to_pascal_voc(xyxy=xyxy, name=name, polygon=polygon) + assert are_xml_elements_equal(result, expected_result) + + +@pytest.mark.parametrize( + "polygon_element, expected_result, exception", + [ + ( + ET.fromstring( + """<polygon><x1>0</x1><y1>0</y1><x2>10</x2><y2>0</y2><x3>10</x3><y3>10</y3><x4>0</x4><y4>10</y4></polygon>""" + ), + [[0, 0], [10, 0], [10, 10], [0, 10]], + DoesNotRaise(), + ) + ], +) +def test_parse_polygon_points( + polygon_element, + expected_result: List[list], + exception, +): + with exception: + result = parse_polygon_points(polygon_element) + assert result == expected_result + + +ONE_CLASS_N_BBOX = """<annotation><object><name>test</name><bndbox><xmin>0</xmin><ymin>0</ymin><xmax>10</xmax><ymax>10</ymax></bndbox></object><object><name>test</name><bndbox><xmin>10</xmin><ymin>10</ymin><xmax>20</xmax><ymax>20</ymax></bndbox></object></annotation>""" + + +ONE_CLASS_ONE_BBOX = """<annotation><object><name>test</name><bndbox><xmin>0</xmin><ymin>0</ymin><xmax>10</xmax><ymax>10</ymax></bndbox></object></annotation>""" + + +N_CLASS_N_BBOX = """<annotation><object><name>test</name><bndbox><xmin>0</xmin><ymin>0</ymin><xmax>10</xmax><ymax>10</ymax></bndbox></object><object><name>test</name><bndbox><xmin>20</xmin><ymin>30</ymin><xmax>30</xmax><ymax>40</ymax></bndbox></object><object><name>test2</name><bndbox><xmin>10</xmin><ymin>10</ymin><xmax>20</xmax><ymax>20</ymax></bndbox></object></annotation>""" + +NO_DETECTIONS = """<annotation></annotation>""" + + +@pytest.mark.parametrize( + "xml_string, classes, resolution_wh, force_masks, expected_result, exception", + [ + ( + ONE_CLASS_ONE_BBOX, + ["test"], + (100, 100), + False, + mock_detections(np.array([[0, 0, 10, 10]]), None, [0]), + DoesNotRaise(), + ), + ( + ONE_CLASS_N_BBOX, + ["test"], + (100, 100), + False, + mock_detections(np.array([[0, 0, 10, 10], [10, 10, 20, 20]]), None, [0, 0]), + DoesNotRaise(), + ), + ( + N_CLASS_N_BBOX, + ["test", "test2"], + (100, 100), + False, + mock_detections( + np.array([[0, 0, 10, 10], [20, 30, 30, 40], [10, 10, 20, 20]]), + None, + [0, 0, 1], + ), + DoesNotRaise(), + ), + ( + NO_DETECTIONS, + [], + (100, 100), + False, + mock_detections(np.empty((0, 4)), None, []), + DoesNotRaise(), + ), + ], +) +def test_detections_from_xml_obj( + xml_string, classes, resolution_wh, force_masks, expected_result, exception +): + with exception: + root = ET.fromstring(xml_string) + result, _ = detections_from_xml_obj(root, classes, resolution_wh, force_masks) + assert result == expected_result

[ { "components": [ { "doc": "Converts an XML object in Pascal VOC format to a Detections object.\nExpected XML format:\n<annotation>\n ...\n <object>\n <name>dog</name>\n <bndbox>\n <xmin>48</xmin>\n <ymin>240</ymin>\n <xmax>195</xmax>\n ...

[ "test/dataset/formats/test_pascal_voc.py::test_object_to_pascal_voc[xyxy0-test-None-expected_result0-exception0]", "test/dataset/formats/test_pascal_voc.py::test_object_to_pascal_voc[xyxy1-test-polygon1-expected_result1-exception1]", "test/dataset/formats/test_pascal_voc.py::test_parse_polygon_points[polygon_el...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add support for loading segmentation datasets in Pascal VOC format # Description Add possibility to load PASCAL VOC segmentation masks in addition to object detection ([related issue](https://github.com/roboflow/supervision/issues/244)). Changes were made to core.DetectionDataset.from_pascal_voc and format.pascal_voc.load_pascal_voc_annotations. ## Type of change Please delete options that are not relevant. - [+] New feature (non-breaking change which adds functionality) ## How has this change been tested, please provide a testcase or example of how you tested the change? Via new tests. ## Any specific deployment considerations For example, documentation changes, usability, usage/costs, secrets, etc. ## Docs - [ ] Docs updated? What were the changes: ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in supervision/dataset/formats/pascal_voc.py] (definition of detections_from_xml_obj:) def detections_from_xml_obj( root: Element, classes: List[str], resolution_wh, force_masks: bool = False ) -> Tuple[Detections, List[str]]: """Converts an XML object in Pascal VOC format to a Detections object. Expected XML format: <annotation> ... <object> <name>dog</name> <bndbox> <xmin>48</xmin> <ymin>240</ymin> <xmax>195</xmax> <ymax>371</ymax> </bndbox> <polygon> <x1>48</x1> <y1>240</y1> <x2>195</x2> <y2>240</y2> <x3>195</x3> <y3>371</y3> <x4>48</x4> <y4>371</y4> </polygon> </object> </annotation> Returns: Tuple[Detections, List[str]]: A tuple containing a Detections object and an updated list of class names, extended with the class names from the XML object.""" (definition of parse_polygon_points:) def parse_polygon_points(polygon: Element) -> List[List[int]]: [end of new definitions in supervision/dataset/formats/pascal_voc.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

3eb5c0b024e3e46877b7fe4fd66e6177d1308ba0

roboflow__supervision-236

236

roboflow/supervision

null

36cdcf1b128e38cb9a086290fbfb0130fa64ac5b

2023-07-24T18:37:19Z

diff --git a/docs/metrics/detection.md b/docs/metrics/detection.md index 9e7844645..feea7cce8 100644 --- a/docs/metrics/detection.md +++ b/docs/metrics/detection.md @@ -6,3 +6,7 @@ ## ConfusionMatrix :::supervision.metrics.detection.ConfusionMatrix + +## MeanAveragePrecision + +:::supervision.metrics.detection.MeanAveragePrecision diff --git a/supervision/__init__.py b/supervision/__init__.py index 9c0252fb0..edb9675dc 100644 --- a/supervision/__init__.py +++ b/supervision/__init__.py @@ -30,7 +30,7 @@ from supervision.draw.utils import draw_filled_rectangle, draw_polygon, draw_text from supervision.geometry.core import Point, Position, Rect from supervision.geometry.utils import get_polygon_center -from supervision.metrics.detection import ConfusionMatrix +from supervision.metrics.detection import ConfusionMatrix, MeanAveragePrecision from supervision.utils.file import list_files_with_extensions from supervision.utils.image import ImageSink, crop from supervision.utils.notebook import plot_image, plot_images_grid diff --git a/supervision/metrics/detection.py b/supervision/metrics/detection.py index 5b5f710a9..d126f82e4 100644 --- a/supervision/metrics/detection.py +++ b/supervision/metrics/detection.py @@ -12,6 +12,59 @@ from supervision.detection.utils import box_iou_batch +def detections_to_tensor( + detections: Detections, with_confidence: bool = False +) -> np.ndarray: + """ + Convert Supervision Detections to numpy tensors for further computation + Args: + detections (sv.Detections): Detections/Targets in the format of sv.Detections + with_confidence (bool): Whether to include confidence in the tensor + Returns: + (np.ndarray): Detections as numpy tensors as in (xyxy, class_id, confidence) order + """ + if detections.class_id is None: + raise ValueError( + "ConfusionMatrix can only be calculated for Detections with class_id" + ) + + arrays_to_concat = [detections.xyxy, np.expand_dims(detections.class_id, 1)] + + if with_confidence: + if detections.confidence is None: + raise ValueError( + "ConfusionMatrix can only be calculated for Detections with confidence" + ) + arrays_to_concat.append(np.expand_dims(detections.confidence, 1)) + + return np.concatenate(arrays_to_concat, axis=1) + + +def validate_input_tensors(predictions: List[np.ndarray], targets: List[np.ndarray]): + """ + Checks for shape consistency of input tensors. + """ + if len(predictions) != len(targets): + raise ValueError( + f"Number of predictions ({len(predictions)}) and targets ({len(targets)}) must be equal." + ) + if len(predictions) > 0: + if not isinstance(predictions[0], np.ndarray) or not isinstance( + targets[0], np.ndarray + ): + raise ValueError( + f"Predictions and targets must be lists of numpy arrays. Got {type(predictions[0])} and {type(targets[0])} instead." + ) + if predictions[0].shape[1] != 6: + raise ValueError( + f"Predictions must have shape (N, 6). Got {predictions[0].shape} instead." + ) + if targets[0].shape[1] != 5: + raise ValueError( + f"Targets must have shape (N, 5). Got {targets[0].shape} instead." + ) + + @dataclass class ConfusionMatrix: """ @@ -85,11 +138,9 @@ def from_detections( target_tensors = [] for prediction, target in zip(predictions, targets): prediction_tensors.append( - ConfusionMatrix.detections_to_tensor(prediction, with_confidence=True) - ) - target_tensors.append( - ConfusionMatrix.detections_to_tensor(target, with_confidence=False) + detections_to_tensor(prediction, with_confidence=True) ) + target_tensors.append(detections_to_tensor(target, with_confidence=False)) return cls.from_tensors( predictions=prediction_tensors, targets=target_tensors, @@ -98,26 +149,6 @@ def from_detections( iou_threshold=iou_threshold, ) - @staticmethod - def detections_to_tensor( - detections: Detections, with_confidence: bool = False - ) -> np.ndarray: - if detections.class_id is None: - raise ValueError( - "ConfusionMatrix can only be calculated for Detections with class_id" - ) - - arrays_to_concat = [detections.xyxy, np.expand_dims(detections.class_id, 1)] - - if with_confidence: - if detections.confidence is None: - raise ValueError( - "ConfusionMatrix can only be calculated for Detections with confidence" - ) - arrays_to_concat.append(np.expand_dims(detections.confidence, 1)) - - return np.concatenate(arrays_to_concat, axis=1) - @classmethod def from_tensors( cls, @@ -184,7 +215,7 @@ def from_tensors( ]) ``` """ - cls._validate_input_tensors(predictions, targets) + validate_input_tensors(predictions, targets) num_classes = len(classes) matrix = np.zeros((num_classes + 1, num_classes + 1)) @@ -203,33 +234,6 @@ def from_tensors( iou_threshold=iou_threshold, ) - @classmethod - def _validate_input_tensors( - cls, predictions: List[np.ndarray], targets: List[np.ndarray] - ): - """ - Checks for shape consistency of input tensors. - """ - if len(predictions) != len(targets): - raise ValueError( - f"Number of predictions ({len(predictions)}) and targets ({len(targets)}) must be equal." - ) - if len(predictions) > 0: - if not isinstance(predictions[0], np.ndarray) or not isinstance( - targets[0], np.ndarray - ): - raise ValueError( - f"Predictions and targets must be lists of numpy arrays. Got {type(predictions[0])} and {type(targets[0])} instead." - ) - if predictions[0].shape[1] != 6: - raise ValueError( - f"Predictions must have shape (N, 6). Got {predictions[0].shape} instead." - ) - if targets[0].shape[1] != 5: - raise ValueError( - f"Targets must have shape (N, 5). Got {targets[0].shape} instead." - ) - @staticmethod def evaluate_detection_batch( predictions: np.ndarray, @@ -319,7 +323,7 @@ def benchmark( iou_threshold: float = 0.5, ) -> ConfusionMatrix: """ - Create confusion matrix from dataset and callback function. + Calculate confusion matrix from dataset and callback function. Args: dataset (DetectionDataset): Object detection dataset used for evaluation. @@ -456,3 +460,331 @@ def plot( save_path, dpi=250, facecolor=fig.get_facecolor(), transparent=True ) return fig + + +@dataclass(frozen=True) +class MeanAveragePrecision: + """ + Mean Average Precision for object detection tasks. + + Attributes: + map (float): mAP value. + map50 (float): mAP value at IoU `threshold = 0.5`. + map75 (float): mAP value at IoU `threshold = 0.75`. + per_class_ap (np.ndarray): values for every classes. + """ + + map: float + map50: float + map75: float + per_class_ap: np.ndarray + + @classmethod + def from_detections( + cls, + predictions: List[Detections], + targets: List[Detections], + ) -> MeanAveragePrecision: + """ + Calculate mean average precision based on predicted and ground-truth detections. + + Args: + targets (List[Detections]): Detections objects from ground-truth. + predictions (List[Detections]): Detections objects predicted by the model. + Returns: + MeanAveragePrecision: New instance of ConfusionMatrix. + + Example: + ```python + >>> import supervision as sv + + >>> targets = [ + ... sv.Detections(...), + ... sv.Detections(...) + ... ] + + >>> predictions = [ + ... sv.Detections(...), + ... sv.Detections(...) + ... ] + + >>> mean_average_precision = sv.MeanAveragePrecision.from_detections( + ... predictions=predictions, + ... targets=target, + ... ) + + >>> mean_average_precison.map + 0.2899 + ``` + """ + prediction_tensors = [] + target_tensors = [] + for prediction, target in zip(predictions, targets): + prediction_tensors.append( + detections_to_tensor(prediction, with_confidence=True) + ) + target_tensors.append(detections_to_tensor(target, with_confidence=False)) + return cls.from_tensors( + predictions=prediction_tensors, + targets=target_tensors, + ) + + @classmethod + def benchmark( + cls, + dataset: DetectionDataset, + callback: Callable[[np.ndarray], Detections], + ) -> MeanAveragePrecision: + """ + Calculate mean average precision from dataset and callback function. + + Args: + dataset (DetectionDataset): Object detection dataset used for evaluation. + callback (Callable[[np.ndarray], Detections]): Function that takes an image as input and returns Detections object. + Returns: + MeanAveragePrecision: New instance of MeanAveragePrecision. + + Example: + ```python + >>> import supervision as sv + >>> from ultralytics import YOLO + + >>> dataset = sv.DetectionDataset.from_yolo(...) + + >>> model = YOLO(...) + >>> def callback(image: np.ndarray) -> sv.Detections: + ... result = model(image)[0] + ... return sv.Detections.from_yolov8(result) + + >>> mean_average_precision = sv.MeanAveragePrecision.benchmark( + ... dataset = dataset, + ... callback = callback + ... ) + + >>> mean_average_precision.map + 0.433 + ``` + """ + predictions, targets = [], [] + for img_name, img in dataset.images.items(): + predictions_batch = callback(img) + predictions.append(predictions_batch) + targets_batch = dataset.annotations[img_name] + targets.append(targets_batch) + return cls.from_detections( + predictions=predictions, + targets=targets, + ) + + @classmethod + def from_tensors( + cls, + predictions: List[np.ndarray], + targets: List[np.ndarray], + ) -> MeanAveragePrecision: + """ + Calculate Mean Average Precision based on predicted and ground-truth detections at different threshold. + + Args: + predictions (List[np.ndarray]): Each element of the list describes a single image and has `shape = (M, 6)` where `M` is the number of detected objects. Each row is expected to be in `(x_min, y_min, x_max, y_max, class, conf)` format. + targets (List[np.ndarray]): Each element of the list describes a single image and has `shape = (N, 5)` where `N` is the number of ground-truth objects. Each row is expected to be in `(x_min, y_min, x_max, y_max, class)` format. + Returns: + MeanAveragePrecision: New instance of MeanAveragePrecision. + + Example: + ```python + >>> import supervision as sv + + >>> targets = ( + ... [ + ... array( + ... [ + ... [0.0, 0.0, 3.0, 3.0, 1], + ... [2.0, 2.0, 5.0, 5.0, 1], + ... [6.0, 1.0, 8.0, 3.0, 2], + ... ] + ... ), + ... array([1.0, 1.0, 2.0, 2.0, 2]), + ... ] + ... ) + + >>> predictions = [ + ... array( + ... [ + ... [0.0, 0.0, 3.0, 3.0, 1, 0.9], + ... [0.1, 0.1, 3.0, 3.0, 0, 0.9], + ... [6.0, 1.0, 8.0, 3.0, 1, 0.8], + ... [1.0, 6.0, 2.0, 7.0, 1, 0.8], + ... ] + ... ), + ... array([[1.0, 1.0, 2.0, 2.0, 2, 0.8]]) + ... ] + + >>> mean_average_precison = sv.MeanAveragePrecision.from_tensors( + ... predictions=predictions, + ... targets=targets, + ... ) + + >>> mean_average_precison.map + 0.2899 + ``` + """ + validate_input_tensors(predictions, targets) + map, map50, map75 = 0, 0, 0 + + class_index = 4 + conf_index = 5 + + stats, average_precisions = [], [] + iou_levels = np.linspace(0.5, 0.95, 10) + num_ious = iou_levels.size + + for true_batch, detection_batch in zip(targets, predictions): + nl, npr = ( + true_batch.shape[0], + detection_batch.shape[0], + ) + correct = np.zeros((npr, num_ious), dtype=bool) + + if npr == 0: + if nl: + stats.append((correct, *np.zeros((2, 0)), true_batch[:, 4])) + continue + if nl: + correct = MeanAveragePrecision._match_detection_batch( + predictions=detection_batch, + targets=true_batch, + iou_levels=iou_levels, + ) + stats.append( + ( + correct, + detection_batch[:, conf_index], + detection_batch[:, class_index], + true_batch[:, class_index], + ) + ) + + stats = [np.concatenate(x, 0) for x in zip(*stats)] + + if len(stats) and stats[0].any(): + average_precisions = cls._average_precisions_per_class(*stats) + ap50, ap75, average_precisions = ( + average_precisions[:, 0], + average_precisions[:, 5], + average_precisions.mean(1), + ) + map50, map75, map = ap50.mean(), ap75.mean(), average_precisions.mean() + + return cls(map=map, map50=map50, map75=map75, per_class_ap=average_precisions) + + @staticmethod + def _match_detection_batch( + predictions: np.ndarray, targets: np.ndarray, iou_levels: np.ndarray + ) -> np.ndarray: + """ + Args: + predictions (np.ndarray): batch prediction + targets (np.ndarray): batch target labels + iou_levels (np.ndarray): iou levels array contains different iou levels + + Returns: + (np.ndarray): matched prediction with target lebels result + """ + correct = np.zeros((predictions.shape[0], iou_levels.shape[0])).astype(bool) + iou = box_iou_batch(targets[:, :4], predictions[:, :4]) + + correct_class = targets[:, 4:5] == predictions[:, 4] + + for i in range(len(iou_levels)): + x = np.where((iou >= iou_levels[i]) & correct_class) + + if x[0].shape[0]: + _X1 = np.concatenate( + [np.expand_dims(x[0], 1), np.expand_dims(x[1], 1)], axis=1 + ) + _x2 = iou[x[0], x[1]][:, None] + matches = np.concatenate([_X1, _x2], axis=1) + if x[0].shape[0] > 1: + matches = matches[matches[:, 2].argsort()[::-1]] + matches = matches[np.unique(matches[:, 1], return_index=True)[1]] + matches = matches[np.unique(matches[:, 0], return_index=True)[1]] + correct[matches[:, 1].astype(int), i] = True + correct[matches[:, 1].astype(int), i] = True + return correct + + @staticmethod + def compute_average_precision(recall: np.ndarray, precision: np.ndarray) -> float: + """ + Compute the average precision using 101-point interpolation (COCO), given the recall and precision curves. + + Args: + recall (np.ndarray): The recall curve. + precision (np.ndarray): The precision curve. + + Returns: + float: Average precision. + """ + extended_recall = np.concatenate(([0.0], recall, [1.0])) + extended_precision = np.concatenate(([1.0], precision, [0.0])) + max_accumulated_precision = np.flip( + np.maximum.accumulate(np.flip(extended_precision)) + ) + interpolated_recall_levels = np.linspace(0, 1, 101) + interpolated_precision = np.interp( + interpolated_recall_levels, extended_recall, max_accumulated_precision + ) + average_precision = np.trapz(interpolated_precision, interpolated_recall_levels) + return average_precision + + @staticmethod + def _average_precisions_per_class( + matches: np.ndarray, + prediction_confidence: np.ndarray, + prediction_class_ids: np.ndarray, + true_batch_class_ids: np.ndarray, + eps: float = 1e-16, + ) -> np.ndarray: + """ + Compute the average precision, given the recall and precision curves. + Source: https://github.com/rafaelpadilla/Object-Detection-Metrics. + Args: + matches (np.ndarray): True positives (nparray, nx1 or nx10). + prediction_confidence (np.ndarray): Objectness value from 0-1 (nparray). + prediction_class_ids (np.ndarray): Predicted object classes (nparray). + true_batch_class_ids (np.ndarray): True object classes (nparray). + Returns: + (np.ndarray): Average precision for different iou level array + """ + sorted_confidences = np.argsort(-prediction_confidence) + matches = matches[sorted_confidences] + prediction_class_ids = prediction_class_ids[sorted_confidences] + + # Find unique classes + unique_classes, class_counts = np.unique( + true_batch_class_ids, return_counts=True + ) + num_classes = unique_classes.shape[0] # number of classes, number of detections + + average_precisions = np.zeros((num_classes, matches.shape[1])) + for ci, c in enumerate(unique_classes): + valid = prediction_class_ids == c + num_targets = class_counts[ci] # number of labels + num_predictions = valid.sum() # number of predictions + if num_predictions == 0 or num_targets == 0: + continue + + fp_pool = (1 - matches[valid]).cumsum(0) + tp_pool = matches[valid].cumsum(0) + + recall = tp_pool / (num_targets + eps) + precision = tp_pool / (tp_pool + fp_pool) + + for j in range(matches.shape[1]): + average_precisions[ + ci, j + ] = MeanAveragePrecision.compute_average_precision( + recall[:, j], precision[:, j] + ) + + return average_precisions

diff --git a/test/metrics/test_detection.py b/test/metrics/test_detection.py index 0ecab3f0b..e0a5f2ced 100644 --- a/test/metrics/test_detection.py +++ b/test/metrics/test_detection.py @@ -5,8 +5,8 @@ import pytest from supervision.detection.core import Detections -from supervision.metrics.detection import ConfusionMatrix -from test.utils import mock_detections +from supervision.metrics.detection import ConfusionMatrix, detections_to_tensor, MeanAveragePrecision +from test.utils import mock_detections, assert_almost_equal CLASSES = np.arange(80) NUM_CLASSES = len(CLASSES) @@ -167,7 +167,7 @@ def test_detections_to_tensor( exception: Exception ): with exception: - result = ConfusionMatrix.detections_to_tensor( + result = detections_to_tensor( detections=detections, with_confidence=with_confidence ) @@ -400,3 +400,43 @@ def test_drop_extra_matches( result = ConfusionMatrix._drop_extra_matches(matches) assert np.array_equal(result, expected_result) + + +@pytest.mark.parametrize( + 'recall, precision, expected_result, exception', + [ + ( + np.array([1.0]), + np.array([1.0]), + 1.0, + DoesNotRaise() + ), # perfect recall and precision + ( + np.array([0.0]), + np.array([0.0]), + 0.0, + DoesNotRaise() + ), # no recall and precision + ( + np.array([0.0, 0.2, 0.2, 0.8, 0.8, 1.0]), + np.array([0.7, 0.8, 0.4, 0.5, 0.1, 0.2]), + 0.5, + DoesNotRaise() + ), + ( + np.array([0.0, 0.5, 0.5, 1.0]), + np.array([0.75, 0.75, 0.75, 0.75]), + 0.75, + DoesNotRaise() + ) + ] +) +def test_compute_average_precision( + recall: np.ndarray, + precision: np.ndarray, + expected_result: float, + exception: Exception +) -> None: + with exception: + result = MeanAveragePrecision.compute_average_precision(recall=recall, precision=precision) + assert_almost_equal(result, expected_result, tolerance=0.01) diff --git a/test/utils.py b/test/utils.py index 20c294e5b..a1d6907eb 100644 --- a/test/utils.py +++ b/test/utils.py @@ -21,3 +21,7 @@ def mock_detections( if tracker_id is None else np.array(tracker_id, dtype=int), ) + + +def assert_almost_equal(actual, expected, tolerance=1e-5): + assert abs(actual - expected) < tolerance, f"Expected {expected}, but got {actual}."

diff --git a/docs/metrics/detection.md b/docs/metrics/detection.md index 9e7844645..feea7cce8 100644 --- a/docs/metrics/detection.md +++ b/docs/metrics/detection.md @@ -6,3 +6,7 @@ ## ConfusionMatrix :::supervision.metrics.detection.ConfusionMatrix + +## MeanAveragePrecision + +:::supervision.metrics.detection.MeanAveragePrecision

[ { "components": [ { "doc": "Convert Supervision Detections to numpy tensors for further computation\nArgs:\n detections (sv.Detections): Detections/Targets in the format of sv.Detections\n with_confidence (bool): Whether to include confidence in the tensor\nReturns:\n (np.ndarray): Detect...

[ "test/metrics/test_detection.py::test_detections_to_tensor[detections0-False-expected_result0-exception0]", "test/metrics/test_detection.py::test_detections_to_tensor[detections1-True-expected_result1-exception1]", "test/metrics/test_detection.py::test_detections_to_tensor[detections2-False-expected_result2-exc...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feature MeanAveragePrecision 🔥 # Description This pr is related to feature #206 and #232. ## Type of change - [x] New feature (non-breaking change which adds functionality) - [x] This change requires a documentation update ## How has this change been tested, please provide a testcase or example of how you tested the change? Google colab for testing:https://colab.research.google.com/drive/1MT5wc6H8WPshQfPoQITr6mLOcfd47x5E?usp=sharing ## Any specific deployment considerations For example, documentation changes, usability, usage/costs, secrets, etc. ## Docs - [x] Docs updated at `docs/supervision/metrics/detection` ## Basline Metrics for comparision: - Ultralytics - Torchmetrics (utilizes CocoApi) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in supervision/metrics/detection.py] (definition of detections_to_tensor:) def detections_to_tensor( detections: Detections, with_confidence: bool = False ) -> np.ndarray: """Convert Supervision Detections to numpy tensors for further computation Args: detections (sv.Detections): Detections/Targets in the format of sv.Detections with_confidence (bool): Whether to include confidence in the tensor Returns: (np.ndarray): Detections as numpy tensors as in (xyxy, class_id, confidence) order""" (definition of validate_input_tensors:) def validate_input_tensors(predictions: List[np.ndarray], targets: List[np.ndarray]): """Checks for shape consistency of input tensors.""" (definition of MeanAveragePrecision:) class MeanAveragePrecision: """Mean Average Precision for object detection tasks. Attributes: map (float): mAP value. map50 (float): mAP value at IoU `threshold = 0.5`. map75 (float): mAP value at IoU `threshold = 0.75`. per_class_ap (np.ndarray): values for every classes.""" (definition of MeanAveragePrecision.from_detections:) def from_detections( cls, predictions: List[Detections], targets: List[Detections], ) -> MeanAveragePrecision: """Calculate mean average precision based on predicted and ground-truth detections. Args: targets (List[Detections]): Detections objects from ground-truth. predictions (List[Detections]): Detections objects predicted by the model. Returns: MeanAveragePrecision: New instance of ConfusionMatrix. Example: ```python >>> import supervision as sv >>> targets = [ ... sv.Detections(...), ... sv.Detections(...) ... ] >>> predictions = [ ... sv.Detections(...), ... sv.Detections(...) ... ] >>> mean_average_precision = sv.MeanAveragePrecision.from_detections( ... predictions=predictions, ... targets=target, ... ) >>> mean_average_precison.map 0.2899 ```""" (definition of MeanAveragePrecision.benchmark:) def benchmark( cls, dataset: DetectionDataset, callback: Callable[[np.ndarray], Detections], ) -> MeanAveragePrecision: """Calculate mean average precision from dataset and callback function. Args: dataset (DetectionDataset): Object detection dataset used for evaluation. callback (Callable[[np.ndarray], Detections]): Function that takes an image as input and returns Detections object. Returns: MeanAveragePrecision: New instance of MeanAveragePrecision. Example: ```python >>> import supervision as sv >>> from ultralytics import YOLO >>> dataset = sv.DetectionDataset.from_yolo(...) >>> model = YOLO(...) >>> def callback(image: np.ndarray) -> sv.Detections: ... result = model(image)[0] ... return sv.Detections.from_yolov8(result) >>> mean_average_precision = sv.MeanAveragePrecision.benchmark( ... dataset = dataset, ... callback = callback ... ) >>> mean_average_precision.map 0.433 ```""" (definition of MeanAveragePrecision.from_tensors:) def from_tensors( cls, predictions: List[np.ndarray], targets: List[np.ndarray], ) -> MeanAveragePrecision: """Calculate Mean Average Precision based on predicted and ground-truth detections at different threshold. Args: predictions (List[np.ndarray]): Each element of the list describes a single image and has `shape = (M, 6)` where `M` is the number of detected objects. Each row is expected to be in `(x_min, y_min, x_max, y_max, class, conf)` format. targets (List[np.ndarray]): Each element of the list describes a single image and has `shape = (N, 5)` where `N` is the number of ground-truth objects. Each row is expected to be in `(x_min, y_min, x_max, y_max, class)` format. Returns: MeanAveragePrecision: New instance of MeanAveragePrecision. Example: ```python >>> import supervision as sv >>> targets = ( ... [ ... array( ... [ ... [0.0, 0.0, 3.0, 3.0, 1], ... [2.0, 2.0, 5.0, 5.0, 1], ... [6.0, 1.0, 8.0, 3.0, 2], ... ] ... ), ... array([1.0, 1.0, 2.0, 2.0, 2]), ... ] ... ) >>> predictions = [ ... array( ... [ ... [0.0, 0.0, 3.0, 3.0, 1, 0.9], ... [0.1, 0.1, 3.0, 3.0, 0, 0.9], ... [6.0, 1.0, 8.0, 3.0, 1, 0.8], ... [1.0, 6.0, 2.0, 7.0, 1, 0.8], ... ] ... ), ... array([[1.0, 1.0, 2.0, 2.0, 2, 0.8]]) ... ] >>> mean_average_precison = sv.MeanAveragePrecision.from_tensors( ... predictions=predictions, ... targets=targets, ... ) >>> mean_average_precison.map 0.2899 ```""" (definition of MeanAveragePrecision._match_detection_batch:) def _match_detection_batch( predictions: np.ndarray, targets: np.ndarray, iou_levels: np.ndarray ) -> np.ndarray: """Args: predictions (np.ndarray): batch prediction targets (np.ndarray): batch target labels iou_levels (np.ndarray): iou levels array contains different iou levels Returns: (np.ndarray): matched prediction with target lebels result""" (definition of MeanAveragePrecision.compute_average_precision:) def compute_average_precision(recall: np.ndarray, precision: np.ndarray) -> float: """Compute the average precision using 101-point interpolation (COCO), given the recall and precision curves. Args: recall (np.ndarray): The recall curve. precision (np.ndarray): The precision curve. Returns: float: Average precision.""" (definition of MeanAveragePrecision._average_precisions_per_class:) def _average_precisions_per_class( matches: np.ndarray, prediction_confidence: np.ndarray, prediction_class_ids: np.ndarray, true_batch_class_ids: np.ndarray, eps: float = 1e-16, ) -> np.ndarray: """Compute the average precision, given the recall and precision curves. Source: https://github.com/rafaelpadilla/Object-Detection-Metrics. Args: matches (np.ndarray): True positives (nparray, nx1 or nx10). prediction_confidence (np.ndarray): Objectness value from 0-1 (nparray). prediction_class_ids (np.ndarray): Predicted object classes (nparray). true_batch_class_ids (np.ndarray): True object classes (nparray). Returns: (np.ndarray): Average precision for different iou level array""" [end of new definitions in supervision/metrics/detection.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

3eb5c0b024e3e46877b7fe4fd66e6177d1308ba0

scrapy__scrapy-5979

5,979

scrapy/scrapy

null

8055a948dc2544c4d8ebe7aa1c6227e19b1583ac

2023-07-18T10:33:03Z

diff --git a/docs/topics/extensions.rst b/docs/topics/extensions.rst index 96e0216b8f0..8d4749ab33d 100644 --- a/docs/topics/extensions.rst +++ b/docs/topics/extensions.rst @@ -258,6 +258,7 @@ The conditions for closing a spider can be configured through the following settings: * :setting:`CLOSESPIDER_TIMEOUT` +* :setting:`CLOSESPIDER_TIMEOUT_NO_ITEM` * :setting:`CLOSESPIDER_ITEMCOUNT` * :setting:`CLOSESPIDER_PAGECOUNT` * :setting:`CLOSESPIDER_ERRORCOUNT` @@ -280,6 +281,18 @@ more than that number of second, it will be automatically closed with the reason ``closespider_timeout``. If zero (or non set), spiders won't be closed by timeout. +.. setting:: CLOSESPIDER_TIMEOUT_NO_ITEM + +CLOSESPIDER_TIMEOUT_NO_ITEM +""""""""""""""""""""""""""" + +Default: ``0`` + +An integer which specifies a number of seconds. If the spider has not produced +any items in the last number of seconds, it will be closed with the reason +``closespider_timeout_no_item``. If zero (or non set), spiders won't be closed +regardless if it hasn't produced any items. + .. setting:: CLOSESPIDER_ITEMCOUNT CLOSESPIDER_ITEMCOUNT diff --git a/scrapy/extensions/closespider.py b/scrapy/extensions/closespider.py index bb6f832f296..4307b417028 100644 --- a/scrapy/extensions/closespider.py +++ b/scrapy/extensions/closespider.py @@ -4,11 +4,14 @@ See documentation in docs/topics/extensions.rst """ +import logging from collections import defaultdict from scrapy import signals from scrapy.exceptions import NotConfigured +logger = logging.getLogger(__name__) + class CloseSpider: def __init__(self, crawler): @@ -19,6 +22,7 @@ def __init__(self, crawler): "itemcount": crawler.settings.getint("CLOSESPIDER_ITEMCOUNT"), "pagecount": crawler.settings.getint("CLOSESPIDER_PAGECOUNT"), "errorcount": crawler.settings.getint("CLOSESPIDER_ERRORCOUNT"), + "timeout_no_item": crawler.settings.getint("CLOSESPIDER_TIMEOUT_NO_ITEM"), } if not any(self.close_on.values()): @@ -34,6 +38,15 @@ def __init__(self, crawler): crawler.signals.connect(self.spider_opened, signal=signals.spider_opened) if self.close_on.get("itemcount"): crawler.signals.connect(self.item_scraped, signal=signals.item_scraped) + if self.close_on.get("timeout_no_item"): + self.timeout_no_item = self.close_on["timeout_no_item"] + self.items_in_period = 0 + crawler.signals.connect( + self.spider_opened_no_item, signal=signals.spider_opened + ) + crawler.signals.connect( + self.item_scraped_no_item, signal=signals.item_scraped + ) crawler.signals.connect(self.spider_closed, signal=signals.spider_closed) @classmethod @@ -69,3 +82,31 @@ def spider_closed(self, spider): task = getattr(self, "task", False) if task and task.active(): task.cancel() + + task_no_item = getattr(self, "task_no_item", False) + if task_no_item and task_no_item.running: + task_no_item.stop() + + def spider_opened_no_item(self, spider): + from twisted.internet import task + + self.task_no_item = task.LoopingCall(self._count_items_produced, spider) + self.task_no_item.start(self.timeout_no_item, now=False) + + logger.info( + f"Spider will stop when no items are produced after " + f"{self.timeout_no_item} seconds." + ) + + def item_scraped_no_item(self, item, spider): + self.items_in_period += 1 + + def _count_items_produced(self, spider): + if self.items_in_period >= 1: + self.items_in_period = 0 + else: + logger.info( + f"Closing spider since no items were produced in the last " + f"{self.timeout_no_item} seconds." + ) + self.crawler.engine.close_spider(spider, "closespider_timeout_no_item")

diff --git a/tests/spiders.py b/tests/spiders.py index 6ff48f4710c..f29dea2a12b 100644 --- a/tests/spiders.py +++ b/tests/spiders.py @@ -77,6 +77,22 @@ def errback(self, failure): self.t2_err = time.time() +class SlowSpider(DelaySpider): + name = "slow" + + def start_requests(self): + # 1st response is fast + url = self.mockserver.url("/delay?n=0&b=0") + yield Request(url, callback=self.parse, errback=self.errback) + + # 2nd response is slow + url = self.mockserver.url(f"/delay?n={self.n}&b={self.b}") + yield Request(url, callback=self.parse, errback=self.errback) + + def parse(self, response): + yield Item() + + class SimpleSpider(MetaSpider): name = "simple" diff --git a/tests/test_closespider.py b/tests/test_closespider.py index 9b39187d583..38ede70e449 100644 --- a/tests/test_closespider.py +++ b/tests/test_closespider.py @@ -3,7 +3,7 @@ from scrapy.utils.test import get_crawler from tests.mockserver import MockServer -from tests.spiders import ErrorSpider, FollowAllSpider, ItemSpider +from tests.spiders import ErrorSpider, FollowAllSpider, ItemSpider, SlowSpider class TestCloseSpider(TestCase): @@ -54,3 +54,13 @@ def test_closespider_timeout(self): self.assertEqual(reason, "closespider_timeout") total_seconds = crawler.stats.get_value("elapsed_time_seconds") self.assertTrue(total_seconds >= close_on) + + @defer.inlineCallbacks + def test_closespider_timeout_no_item(self): + timeout = 1 + crawler = get_crawler(SlowSpider, {"CLOSESPIDER_TIMEOUT_NO_ITEM": timeout}) + yield crawler.crawl(n=3, mockserver=self.mockserver) + reason = crawler.spider.meta["close_reason"] + self.assertEqual(reason, "closespider_timeout_no_item") + total_seconds = crawler.stats.get_value("elapsed_time_seconds") + self.assertTrue(total_seconds >= timeout)

diff --git a/docs/topics/extensions.rst b/docs/topics/extensions.rst index 96e0216b8f0..8d4749ab33d 100644 --- a/docs/topics/extensions.rst +++ b/docs/topics/extensions.rst @@ -258,6 +258,7 @@ The conditions for closing a spider can be configured through the following settings: * :setting:`CLOSESPIDER_TIMEOUT` +* :setting:`CLOSESPIDER_TIMEOUT_NO_ITEM` * :setting:`CLOSESPIDER_ITEMCOUNT` * :setting:`CLOSESPIDER_PAGECOUNT` * :setting:`CLOSESPIDER_ERRORCOUNT` @@ -280,6 +281,18 @@ more than that number of second, it will be automatically closed with the reason ``closespider_timeout``. If zero (or non set), spiders won't be closed by timeout. +.. setting:: CLOSESPIDER_TIMEOUT_NO_ITEM + +CLOSESPIDER_TIMEOUT_NO_ITEM +""""""""""""""""""""""""""" + +Default: ``0`` + +An integer which specifies a number of seconds. If the spider has not produced +any items in the last number of seconds, it will be closed with the reason +``closespider_timeout_no_item``. If zero (or non set), spiders won't be closed +regardless if it hasn't produced any items. + .. setting:: CLOSESPIDER_ITEMCOUNT CLOSESPIDER_ITEMCOUNT

[ { "components": [ { "doc": "", "lines": [ 90, 98 ], "name": "CloseSpider.spider_opened_no_item", "signature": "def spider_opened_no_item(self, spider):", "type": "function" }, { "doc": "", "lines": [ ...

[ "tests/test_closespider.py::TestCloseSpider::test_closespider_timeout_no_item" ]

[ "tests/test_closespider.py::TestCloseSpider::test_closespider_errorcount", "tests/test_closespider.py::TestCloseSpider::test_closespider_itemcount", "tests/test_closespider.py::TestCloseSpider::test_closespider_pagecount", "tests/test_closespider.py::TestCloseSpider::test_closespider_timeout" ]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> introduce CLOSESPIDER_TIMEOUT_NO_ITEM in CloseSpider **Motivation:** Sometimes spiders still keep running without producing any items. This could be due to a variety of reasons like poor dupe URL filtration, bad crawling strategy, etc. **Proposal:** Auto-close the spider if it hasn't produced any items in the past number of seconds. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in scrapy/extensions/closespider.py] (definition of CloseSpider.spider_opened_no_item:) def spider_opened_no_item(self, spider): (definition of CloseSpider.item_scraped_no_item:) def item_scraped_no_item(self, item, spider): (definition of CloseSpider._count_items_produced:) def _count_items_produced(self, spider): [end of new definitions in scrapy/extensions/closespider.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

57a5460529ff71c42e4d0381265b1b512b1eb09b

sqlfluff__sqlfluff-4974

4,974

sqlfluff/sqlfluff

2.0

33916fc72f7576a985efa22dfcdd728348544899

2023-07-17T08:44:38Z

diff --git a/src/sqlfluff/core/default_config.cfg b/src/sqlfluff/core/default_config.cfg index cfd85cf4dc6..b3f385c9bb0 100644 --- a/src/sqlfluff/core/default_config.cfg +++ b/src/sqlfluff/core/default_config.cfg @@ -384,3 +384,6 @@ wildcard_policy = single [sqlfluff:rules:structure.subquery] # By default, allow subqueries in from clauses, but not join clauses forbid_subquery_in = join + +[sqlfluff:rules:structure.first_table] +preferred_first_table_in_join_clause = earlier diff --git a/src/sqlfluff/core/rules/config_info.py b/src/sqlfluff/core/rules/config_info.py index 28e067bb375..62e7235501c 100644 --- a/src/sqlfluff/core/rules/config_info.py +++ b/src/sqlfluff/core/rules/config_info.py @@ -213,6 +213,13 @@ "validation": ["consistent", "shorthand", "convert", "cast"], "definition": ("The expectation for using sql type casting"), }, + "preferred_first_table_in_join_clause": { + "validation": ["earlier", "later"], + "definition": ( + "Which table to list first when joining two tables. " + "Defaults to ``earlier``." + ), + }, } diff --git a/src/sqlfluff/rules/structure/ST09.py b/src/sqlfluff/rules/structure/ST09.py new file mode 100644 index 00000000000..b0732d77e47 --- /dev/null +++ b/src/sqlfluff/rules/structure/ST09.py @@ -0,0 +1,291 @@ +"""Implementation of Rule ST09.""" +from typing import Optional, Tuple, List, cast +from sqlfluff.core.parser.segments.raw import BaseSegment, SymbolSegment +from sqlfluff.core.rules import BaseRule, LintFix, LintResult, RuleContext +from sqlfluff.core.rules.crawlers import SegmentSeekerCrawler +from sqlfluff.utils.functional import Segments, FunctionalContext +from sqlfluff.dialects.dialect_ansi import ( + FromExpressionElementSegment, + JoinClauseSegment, +) + + +class Rule_ST09(BaseRule): + """Joins should list the table referenced earlier/later first. + + This rule will break conditions from join clauses down into subconditions + using the "and" and "or" binary operators. + + Subconditions that are made up of a qualified column reference, + a comparison operator and another qualified column reference + are then evaluated to check whether they list the table that was referenced + earlier - or later, depending on the ``preferred_first_table_in_join_clause`` + configuration. + + Subconditions that do not follow that pattern are ignored by this rule. + + .. note:: + Joins in ``WHERE`` clauses are currently not supported by this rule. + + **Anti-pattern** + + In this example, the tables that were referenced later are listed first + and the ``preferred_first_table_in_join_clause`` configuration + is set to ``earlier``. + + .. code-block:: sql + + select + foo.a, + foo.b, + bar.c + from foo + left join bar + -- This subcondition does not list + -- the table referenced earlier first: + on bar.a = foo.a + -- Neither does this subcondition: + and bar.b = foo.b + + **Best practice** + + List the tables that were referenced earlier first. + + .. code-block:: sql + + select + foo.a, + foo.b, + bar.c + from foo + left join bar + on foo.a = bar.a + and foo.b = bar.b + """ + + name = "structure.first_table" + aliases = () + groups: Tuple[str, ...] = ("all", "structure") + config_keywords = ["preferred_first_table_in_join_clause"] + crawl_behaviour = SegmentSeekerCrawler({"from_expression"}) + is_fix_compatible = True + + def _eval(self, context: RuleContext) -> Optional[LintResult]: + """Find rule violations and provide fixes. + + 0. Grab all table aliases into a table_aliases list. + 1. Grab all conditions from the different join_on_condition segments. + 2. Break conditions down into subconditions using the "and" and "or" + binary operators. + 3. Keep subconditions that are made up of a qualified column_reference, + a comparison_operator and another qualified column_reference segments. + 4. Check whether the table associated with the first column_reference segment + has a greater index in table_aliases than the second column_reference segment. + If so, populate the fixes list (lower index instead of greater index + if preferred_first_table_in_join_clause == "later"). + 5.a. If fixes is empty the rule passes. + 5.b. If fixes isn't empty we return a LintResult object with fixable violations. + """ + self.preferred_first_table_in_join_clause: str + + assert context.segment.is_type("from_expression") + + # STEP 0. + table_aliases: List[str] = [] + + children = FunctionalContext(context).segment.children() + + # we use recursive_crawl to deal with brackets + join_clauses = children.recursive_crawl("join_clause") + + join_on_conditions = join_clauses.children().recursive_crawl( + "join_on_condition" + ) + + # we only care about join_on_condition segments + if len(join_on_conditions) == 0: + return None + + # the first alias comes from the from clause + from_expression_alias: str = ( + cast( + FromExpressionElementSegment, + children.recursive_crawl("from_expression_element")[0], + ) + .get_eventual_alias() + .ref_str + ) + + table_aliases.append(from_expression_alias) + + # the rest of the aliases come from the different join clauses + join_clause_aliases: List[str] = [ + cast(JoinClauseSegment, join_clause).get_eventual_aliases()[0][1].ref_str + for join_clause in [clause for clause in join_clauses] + ] + + table_aliases = table_aliases + join_clause_aliases + + table_aliases = [alias.upper() for alias in table_aliases] + + # STEP 1. + conditions: List[List[BaseSegment]] = [] + + join_on_condition__expressions = join_on_conditions.children().recursive_crawl( + "expression" + ) + + for expression in join_on_condition__expressions: + expression_group = [] + for element in Segments(expression).children(): + if element.type not in ("whitespace", "newline"): + expression_group.append(element) + conditions.append(expression_group) + + # STEP 2. + subconditions: List[List[List[BaseSegment]]] = [] + + for expression_group in conditions: + subconditions.append( + self._split_list_by_segment_type( + segment_list=expression_group, + delimiter_type="binary_operator", + delimiters=["and", "or"], + ) + ) + + subconditions_flattened: List[List[BaseSegment]] = [ + item for sublist in subconditions for item in sublist + ] + + # STEP 3. + column_operator_column_subconditions: List[List[BaseSegment]] = [ + subcondition + for subcondition in subconditions_flattened + if self._is_qualified_column_operator_qualified_column_sequence( + subcondition + ) + ] + + # STEP 4. + fixes: List[LintFix] = [] + + for subcondition in column_operator_column_subconditions: + comparison_operator = subcondition[1] + first_column_reference = subcondition[0] + second_column_reference = subcondition[2] + raw_comparison_operators = comparison_operator.get_children( + "raw_comparison_operator" + ) + + first_table = first_column_reference.get_child("naked_identifier").raw_upper + second_table = second_column_reference.get_child( + "naked_identifier" + ).raw_upper + + # if we swap the two column references around the comparison operator + # we might have to replace the comparison operator with a different one + raw_comparison_operator_opposites = {"<": ">", ">": "<"} + + # there seem to be edge cases where either the first table or the second + # table is not in table_aliases, in which case we cannot provide any fix + if first_table not in table_aliases or second_table not in table_aliases: + continue + + if ( + table_aliases.index(first_table) > table_aliases.index(second_table) + and self.preferred_first_table_in_join_clause == "earlier" + ) or ( + table_aliases.index(first_table) < table_aliases.index(second_table) + and self.preferred_first_table_in_join_clause == "later" + ): + fixes = ( + fixes + + [ + LintFix.replace( + first_column_reference, + [second_column_reference], + ) + ] + + [ + LintFix.replace( + second_column_reference, + [first_column_reference], + ) + ] + + ( + [ + LintFix.replace( + raw_comparison_operators[0], + [ + SymbolSegment( + raw=raw_comparison_operator_opposites[ + raw_comparison_operators[0].raw + ], + type="raw_comparison_operator", + ) + ], + ) + ] + if raw_comparison_operators[0].raw + in raw_comparison_operator_opposites + and [r.raw for r in raw_comparison_operators] != ["<", ">"] + else [] + ) + ) + + # STEP 5.a. + if fixes == []: + return None + + # STEP 5.b. + else: + return LintResult( + anchor=context.segment, + fixes=fixes, + description=( + "Joins should list the table referenced " + f"{self.preferred_first_table_in_join_clause} first." + ), + ) + + @staticmethod + def _split_list_by_segment_type( + segment_list: List[BaseSegment], delimiter_type: str, delimiters: List[str] + ) -> List: + # Break down a list into multiple sub-lists using a set of delimiters + delimiters = [delimiter.upper() for delimiter in delimiters] + new_list = [] + sub_list = [] + for i in range(len(segment_list)): + if i == len(segment_list) - 1: + sub_list.append(segment_list[i]) + new_list.append(sub_list) + elif ( + segment_list[i].type == delimiter_type + and segment_list[i].raw_upper in delimiters + ): + new_list.append(sub_list) + sub_list = [] + else: + sub_list.append(segment_list[i]) + + return new_list + + @staticmethod + def _is_qualified_column_operator_qualified_column_sequence( + segment_list: List[BaseSegment], + ) -> bool: + # Check if list is made up of a qualified column_reference segment, + # a comparison_operator segment and another qualified column_reference segment + if len(segment_list) != 3: + return False + if ( + segment_list[0].type == "column_reference" + and "dot" in segment_list[0].direct_descendant_type_set + and segment_list[1].type == "comparison_operator" + and segment_list[2].type == "column_reference" + and "dot" in segment_list[2].direct_descendant_type_set + ): + return True + return False diff --git a/src/sqlfluff/rules/structure/__init__.py b/src/sqlfluff/rules/structure/__init__.py index fdb48e021c5..5ece4f71de0 100644 --- a/src/sqlfluff/rules/structure/__init__.py +++ b/src/sqlfluff/rules/structure/__init__.py @@ -20,6 +20,7 @@ def get_rules() -> List[Type[BaseRule]]: from sqlfluff.rules.structure.ST06 import Rule_ST06 from sqlfluff.rules.structure.ST07 import Rule_ST07 from sqlfluff.rules.structure.ST08 import Rule_ST08 + from sqlfluff.rules.structure.ST09 import Rule_ST09 return [ Rule_ST01, @@ -30,4 +31,5 @@ def get_rules() -> List[Type[BaseRule]]: Rule_ST06, Rule_ST07, Rule_ST08, + Rule_ST09, ]

diff --git a/test/cli/commands_test.py b/test/cli/commands_test.py index 292a5ac51d8..0a3ad125f2c 100644 --- a/test/cli/commands_test.py +++ b/test/cli/commands_test.py @@ -1432,7 +1432,7 @@ def test__cli__command_lint_serialize_multiple_files(serialize, write_file, tmp_ print("Result length:", payload_length) if serialize == "human": - assert payload_length == 23 if write_file else 32 + assert payload_length == 25 if write_file else 34 elif serialize == "none": assert payload_length == 1 # There will be a single newline. elif serialize == "json": @@ -1450,7 +1450,7 @@ def test__cli__command_lint_serialize_multiple_files(serialize, write_file, tmp_ # SQLFluff produces trailing newline if result[-1] == "": del result[-1] - assert len(result) == 11 + assert len(result) == 12 else: raise Exception @@ -1960,8 +1960,10 @@ def test_cli_fix_disabled_progress_bar_deprecated_option( multiple_expected_output = """==== finding fixable violations ==== == [test/fixtures/linter/multiple_sql_errors.sql] FAIL L: 12 | P: 1 | LT02 | Expected indent of 4 spaces. [layout.indent] +L: 40 | P: 10 | ST09 | Joins should list the table referenced earlier first. + | [structure.first_table] ==== fixing violations ==== -1 fixable linting violations found +2 fixable linting violations found Are you sure you wish to attempt to fix these? [Y/n] ... Invalid input, please enter 'Y' or 'N' Aborting... @@ -2008,7 +2010,7 @@ def test__cli__fix_multiple_errors_quiet_force(): normalised_output = result.output.replace("\\", "/") assert normalised_output.startswith( """== [test/fixtures/linter/multiple_sql_errors.sql] FIXED -1 fixable linting violations found""" +2 fixable linting violations found""" ) @@ -2031,7 +2033,7 @@ def test__cli__fix_multiple_errors_quiet_no_force(): ) normalised_output = result.output.replace("\\", "/") assert normalised_output.startswith( - """1 fixable linting violations found + """2 fixable linting violations found Are you sure you wish to attempt to fix these? [Y/n] ... == [test/fixtures/linter/multiple_sql_errors.sql] FIXED All Finished"""

diff --git a/src/sqlfluff/core/default_config.cfg b/src/sqlfluff/core/default_config.cfg index cfd85cf4dc6..b3f385c9bb0 100644 --- a/src/sqlfluff/core/default_config.cfg +++ b/src/sqlfluff/core/default_config.cfg @@ -384,3 +384,6 @@ wildcard_policy = single [sqlfluff:rules:structure.subquery] # By default, allow subqueries in from clauses, but not join clauses forbid_subquery_in = join + +[sqlfluff:rules:structure.first_table] +preferred_first_table_in_join_clause = earlier

[ { "components": [ { "doc": "Joins should list the table referenced earlier/later first.\n\nThis rule will break conditions from join clauses down into subconditions\nusing the \"and\" and \"or\" binary operators.\n\nSubconditions that are made up of a qualified column reference,\na comparison oper...

[ "test/cli/commands_test.py::test__cli__command_lint_serialize_multiple_files[None-github-annotation-native]", "test/cli/commands_test.py::test__cli__command_lint_serialize_multiple_files[outfile-human]", "test/cli/commands_test.py::test__cli__command_lint_serialize_multiple_files[outfile-github-annotation-nativ...

[ "test/cli/commands_test.py::test__cli__command_directed", "test/cli/commands_test.py::test__cli__command_dialect", "test/cli/commands_test.py::test__cli__command_no_dialect", "test/cli/commands_test.py::test__cli__command_parse_error_dialect_explicit_warning", "test/cli/commands_test.py::test__cli__command_...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add new rule ST09: Joins should list the table referenced earlier (default)/later first   ### Brief summary of the change made  Fixes #2395. ### Are there any other side effects of this change that we should be aware of? There shouldn't be any. ### Pull Request checklist - [x] Please confirm you have completed any of the necessary steps below. - Included test cases to demonstrate any code changes, which may be one or more of the following: - `.yml` rule test cases in `test/fixtures/rules/std_rule_cases`. - `.sql`/`.yml` parser test cases in `test/fixtures/dialects` (note YML files can be auto generated with `tox -e generate-fixture-yml`). - Full autofix test cases in `test/fixtures/linter/autofix`. - Other. - Added appropriate documentation for the change. - Created GitHub issues for any relevant followup/future enhancements if appropriate. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/sqlfluff/rules/structure/ST09.py] (definition of Rule_ST09:) class Rule_ST09(BaseRule): """Joins should list the table referenced earlier/later first. This rule will break conditions from join clauses down into subconditions using the "and" and "or" binary operators. Subconditions that are made up of a qualified column reference, a comparison operator and another qualified column reference are then evaluated to check whether they list the table that was referenced earlier - or later, depending on the ``preferred_first_table_in_join_clause`` configuration. Subconditions that do not follow that pattern are ignored by this rule. .. note:: Joins in ``WHERE`` clauses are currently not supported by this rule. **Anti-pattern** In this example, the tables that were referenced later are listed first and the ``preferred_first_table_in_join_clause`` configuration is set to ``earlier``. .. code-block:: sql select foo.a, foo.b, bar.c from foo left join bar -- This subcondition does not list -- the table referenced earlier first: on bar.a = foo.a -- Neither does this subcondition: and bar.b = foo.b **Best practice** List the tables that were referenced earlier first. .. code-block:: sql select foo.a, foo.b, bar.c from foo left join bar on foo.a = bar.a and foo.b = bar.b""" (definition of Rule_ST09._eval:) def _eval(self, context: RuleContext) -> Optional[LintResult]: """Find rule violations and provide fixes. 0. Grab all table aliases into a table_aliases list. 1. Grab all conditions from the different join_on_condition segments. 2. Break conditions down into subconditions using the "and" and "or" binary operators. 3. Keep subconditions that are made up of a qualified column_reference, a comparison_operator and another qualified column_reference segments. 4. Check whether the table associated with the first column_reference segment has a greater index in table_aliases than the second column_reference segment. If so, populate the fixes list (lower index instead of greater index if preferred_first_table_in_join_clause == "later"). 5.a. If fixes is empty the rule passes. 5.b. If fixes isn't empty we return a LintResult object with fixable violations.""" (definition of Rule_ST09._split_list_by_segment_type:) def _split_list_by_segment_type( segment_list: List[BaseSegment], delimiter_type: str, delimiters: List[str] ) -> List: (definition of Rule_ST09._is_qualified_column_operator_qualified_column_sequence:) def _is_qualified_column_operator_qualified_column_sequence( segment_list: List[BaseSegment], ) -> bool: [end of new definitions in src/sqlfluff/rules/structure/ST09.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> New Rule: In ON clause of JOIN statement specify source table first and join table second  From GitLab SQL style guide: https://about.gitlab.com/handbook/business-technology/data-team/platform/sql-style-guide/#joins `Specify the order of a join with the FROM table first and JOIN table second:` ```sql -- Good FROM source LEFT JOIN other_source ON source.id = other_source.id WHERE ... -- Bad FROM source LEFT JOIN other_source ON other_source.id = source.id WHERE ... ``` More generally put the SOURCE table first and JOIN table second (since the source isn't always necessarily with a FROM clause): ```sql -- Good FROM source LEFT JOIN other_source ON source.id = other_source.id LEFT JOIN different_source ON other_source.id = different_source.id WHERE ... -- Bad FROM source LEFT JOIN other_source ON other_source.id = source.id LEFT JOIN different_source ON different_source.id = other_source.id WHERE ... ``` The motivation is that we already know the JOIN table from the JOIN clause so we want to be able to quickly scan for the SOURCE table. ---------- though i personally prefer the other way arround, it would be awesome to have such a rule. Consistent ordering in ONs is really appreciated... I would also love to have such a rule, it's definitely one of the rules from the [dbt Style Guide](https://github.com/dbt-labs/corp/blob/main/dbt_style_guide.md#sql-style-guide) that I hate seeing breached... -------------------- </issues>

3629c3e702939c07264cc5ea903566ddc9ea2bb0

tobymao__sqlglot-1925

1,925

tobymao/sqlglot

null

aaee59457eca7255540c27a4aa13a7a4f87e6acc

2023-07-16T23:05:32Z

diff --git a/sqlglot/dataframe/sql/functions.py b/sqlglot/dataframe/sql/functions.py index bdc1fb4083..353bdc0f02 100644 --- a/sqlglot/dataframe/sql/functions.py +++ b/sqlglot/dataframe/sql/functions.py @@ -875,8 +875,16 @@ def regexp_extract(str: ColumnOrName, pattern: str, idx: t.Optional[int] = None) ) -def regexp_replace(str: ColumnOrName, pattern: str, replacement: str) -> Column: - return Column.invoke_anonymous_function(str, "REGEXP_REPLACE", lit(pattern), lit(replacement)) +def regexp_replace( + str: ColumnOrName, pattern: str, replacement: str, position: t.Optional[int] = None +) -> Column: + return Column.invoke_expression_over_column( + str, + expression.RegexpReplace, + expression=lit(pattern), + replacement=lit(replacement), + position=position, + ) def initcap(col: ColumnOrName) -> Column: diff --git a/sqlglot/dialects/bigquery.py b/sqlglot/dialects/bigquery.py index 35892f73ac..ae1eaf0d7f 100644 --- a/sqlglot/dialects/bigquery.py +++ b/sqlglot/dialects/bigquery.py @@ -15,6 +15,7 @@ min_or_least, no_ilike_sql, parse_date_delta_with_interval, + regexp_replace_sql, rename_func, timestrtotime_sql, ts_or_ds_to_date_sql, @@ -415,6 +416,7 @@ class Generator(generator.Generator): e.args.get("position"), e.args.get("occurrence"), ), + exp.RegexpReplace: regexp_replace_sql, exp.RegexpLike: rename_func("REGEXP_CONTAINS"), exp.ReturnsProperty: _returnsproperty_sql, exp.Select: transforms.preprocess( diff --git a/sqlglot/dialects/dialect.py b/sqlglot/dialects/dialect.py index 5376dffdb5..938440a3c2 100644 --- a/sqlglot/dialects/dialect.py +++ b/sqlglot/dialects/dialect.py @@ -630,6 +630,16 @@ def regexp_extract_sql(self: Generator, expression: exp.RegexpExtract) -> str: ) +def regexp_replace_sql(self: Generator, expression: exp.RegexpReplace) -> str: + bad_args = list(filter(expression.args.get, ("position", "occurrence", "parameters"))) + if bad_args: + self.unsupported(f"REGEXP_REPLACE does not support the following arg(s): {bad_args}") + + return self.func( + "REGEXP_REPLACE", expression.this, expression.expression, expression.args["replacement"] + ) + + def pivot_column_names(aggregations: t.List[exp.Expression], dialect: DialectType) -> t.List[str]: names = [] for agg in aggregations: diff --git a/sqlglot/dialects/duckdb.py b/sqlglot/dialects/duckdb.py index 1d8a7fbb7b..ae48474a62 100644 --- a/sqlglot/dialects/duckdb.py +++ b/sqlglot/dialects/duckdb.py @@ -16,6 +16,7 @@ no_safe_divide_sql, pivot_column_names, regexp_extract_sql, + regexp_replace_sql, rename_func, str_position_sql, str_to_time_sql, @@ -219,6 +220,7 @@ class Generator(generator.Generator): exp.LogicalAnd: rename_func("BOOL_AND"), exp.Properties: no_properties_sql, exp.RegexpExtract: regexp_extract_sql, + exp.RegexpReplace: regexp_replace_sql, exp.RegexpLike: rename_func("REGEXP_MATCHES"), exp.RegexpSplit: rename_func("STR_SPLIT_REGEX"), exp.SafeDivide: no_safe_divide_sql, diff --git a/sqlglot/dialects/hive.py b/sqlglot/dialects/hive.py index 8d322912da..42a29ffcba 100644 --- a/sqlglot/dialects/hive.py +++ b/sqlglot/dialects/hive.py @@ -18,6 +18,7 @@ no_safe_divide_sql, no_trycast_sql, regexp_extract_sql, + regexp_replace_sql, rename_func, right_to_substring_sql, strposition_to_locate_sql, @@ -369,6 +370,7 @@ class Generator(generator.Generator): exp.Quantile: rename_func("PERCENTILE"), exp.ApproxQuantile: rename_func("PERCENTILE_APPROX"), exp.RegexpExtract: regexp_extract_sql, + exp.RegexpReplace: regexp_replace_sql, exp.RegexpLike: lambda self, e: self.binary(e, "RLIKE"), exp.RegexpSplit: rename_func("SPLIT"), exp.Right: right_to_substring_sql, diff --git a/sqlglot/dialects/snowflake.py b/sqlglot/dialects/snowflake.py index dea33e65ac..499e085810 100644 --- a/sqlglot/dialects/snowflake.py +++ b/sqlglot/dialects/snowflake.py @@ -30,7 +30,7 @@ def _check_int(s: str) -> bool: # from https://docs.snowflake.com/en/sql-reference/functions/to_timestamp.html -def _snowflake_to_timestamp(args: t.List) -> t.Union[exp.StrToTime, exp.UnixToTime]: +def _parse_to_timestamp(args: t.List) -> t.Union[exp.StrToTime, exp.UnixToTime]: if len(args) == 2: first_arg, second_arg = args if second_arg.is_string: @@ -137,7 +137,7 @@ def _parse_date_part(self: parser.Parser) -> t.Optional[exp.Expression]: # https://docs.snowflake.com/en/sql-reference/functions/div0 -def _div0_to_if(args: t.List) -> exp.Expression: +def _div0_to_if(args: t.List) -> exp.If: cond = exp.EQ(this=seq_get(args, 1), expression=exp.Literal.number(0)) true = exp.Literal.number(0) false = exp.Div(this=seq_get(args, 0), expression=seq_get(args, 1)) @@ -145,13 +145,13 @@ def _div0_to_if(args: t.List) -> exp.Expression: # https://docs.snowflake.com/en/sql-reference/functions/zeroifnull -def _zeroifnull_to_if(args: t.List) -> exp.Expression: +def _zeroifnull_to_if(args: t.List) -> exp.If: cond = exp.Is(this=seq_get(args, 0), expression=exp.Null()) return exp.If(this=cond, true=exp.Literal.number(0), false=seq_get(args, 0)) # https://docs.snowflake.com/en/sql-reference/functions/zeroifnull -def _nullifzero_to_if(args: t.List) -> exp.Expression: +def _nullifzero_to_if(args: t.List) -> exp.If: cond = exp.EQ(this=seq_get(args, 0), expression=exp.Literal.number(0)) return exp.If(this=cond, true=exp.Null(), false=seq_get(args, 0)) @@ -164,12 +164,21 @@ def _datatype_sql(self: generator.Generator, expression: exp.DataType) -> str: return self.datatype_sql(expression) -def _parse_convert_timezone(args: t.List) -> exp.Expression: +def _parse_convert_timezone(args: t.List) -> t.Union[exp.Anonymous, exp.AtTimeZone]: if len(args) == 3: return exp.Anonymous(this="CONVERT_TIMEZONE", expressions=args) return exp.AtTimeZone(this=seq_get(args, 1), zone=seq_get(args, 0)) +def _parse_regexp_replace(args: t.List) -> exp.RegexpReplace: + regexp_replace = exp.RegexpReplace.from_arg_list(args) + + if not regexp_replace.args.get("replacement"): + regexp_replace.set("replacement", exp.Literal.string("")) + + return regexp_replace + + class Snowflake(Dialect): # https://docs.snowflake.com/en/sql-reference/identifiers-syntax RESOLVES_IDENTIFIERS_AS_UPPERCASE = True @@ -223,13 +232,14 @@ class Parser(parser.Parser): "IFF": exp.If.from_arg_list, "NULLIFZERO": _nullifzero_to_if, "OBJECT_CONSTRUCT": _parse_object_construct, + "REGEXP_REPLACE": _parse_regexp_replace, "REGEXP_SUBSTR": exp.RegexpExtract.from_arg_list, "RLIKE": exp.RegexpLike.from_arg_list, "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)), "TIMEDIFF": _parse_datediff, "TIMESTAMPDIFF": _parse_datediff, "TO_ARRAY": exp.Array.from_arg_list, - "TO_TIMESTAMP": _snowflake_to_timestamp, + "TO_TIMESTAMP": _parse_to_timestamp, "TO_VARCHAR": exp.ToChar.from_arg_list, "ZEROIFNULL": _zeroifnull_to_if, } diff --git a/sqlglot/dialects/spark2.py b/sqlglot/dialects/spark2.py index f9e287ac24..2d0137e480 100644 --- a/sqlglot/dialects/spark2.py +++ b/sqlglot/dialects/spark2.py @@ -197,6 +197,13 @@ class Generator(Hive.Generator): exp.Map: _map_sql, exp.Pivot: transforms.preprocess([_unqualify_pivot_columns]), exp.Reduce: rename_func("AGGREGATE"), + exp.RegexpReplace: lambda self, e: self.func( + "REGEXP_REPLACE", + e.this, + e.expression, + e.args["replacement"], + e.args.get("position"), + ), exp.StrToDate: _str_to_date, exp.StrToTime: lambda self, e: f"TO_TIMESTAMP({self.sql(e, 'this')}, {self.format_time(e)})", exp.TimestampTrunc: lambda self, e: self.func( diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index fb2575d4d3..29c0a0bf6b 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -4431,6 +4431,17 @@ class RegexpExtract(Func): } +class RegexpReplace(Func): + arg_types = { + "this": True, + "expression": True, + "replacement": True, + "position": False, + "occurrence": False, + "parameters": False, + } + + class RegexpLike(Func): arg_types = {"this": True, "expression": True, "flag": False}

diff --git a/tests/dialects/test_snowflake.py b/tests/dialects/test_snowflake.py index ee8a11ff0e..82762e8aa1 100644 --- a/tests/dialects/test_snowflake.py +++ b/tests/dialects/test_snowflake.py @@ -915,6 +915,58 @@ def test_regexp_substr(self, logger): }, ) + @mock.patch("sqlglot.generator.logger") + def test_regexp_replace(self, logger): + self.validate_all( + "REGEXP_REPLACE(subject, pattern)", + write={ + "bigquery": "REGEXP_REPLACE(subject, pattern, '')", + "duckdb": "REGEXP_REPLACE(subject, pattern, '')", + "hive": "REGEXP_REPLACE(subject, pattern, '')", + "snowflake": "REGEXP_REPLACE(subject, pattern, '')", + "spark": "REGEXP_REPLACE(subject, pattern, '')", + }, + ) + self.validate_all( + "REGEXP_REPLACE(subject, pattern, replacement)", + read={ + "bigquery": "REGEXP_REPLACE(subject, pattern, replacement)", + "duckdb": "REGEXP_REPLACE(subject, pattern, replacement)", + "hive": "REGEXP_REPLACE(subject, pattern, replacement)", + "spark": "REGEXP_REPLACE(subject, pattern, replacement)", + }, + write={ + "bigquery": "REGEXP_REPLACE(subject, pattern, replacement)", + "duckdb": "REGEXP_REPLACE(subject, pattern, replacement)", + "hive": "REGEXP_REPLACE(subject, pattern, replacement)", + "snowflake": "REGEXP_REPLACE(subject, pattern, replacement)", + "spark": "REGEXP_REPLACE(subject, pattern, replacement)", + }, + ) + self.validate_all( + "REGEXP_REPLACE(subject, pattern, replacement, position)", + read={ + "spark": "REGEXP_REPLACE(subject, pattern, replacement, position)", + }, + write={ + "bigquery": "REGEXP_REPLACE(subject, pattern, replacement)", + "duckdb": "REGEXP_REPLACE(subject, pattern, replacement)", + "hive": "REGEXP_REPLACE(subject, pattern, replacement)", + "snowflake": "REGEXP_REPLACE(subject, pattern, replacement, position)", + "spark": "REGEXP_REPLACE(subject, pattern, replacement, position)", + }, + ) + self.validate_all( + "REGEXP_REPLACE(subject, pattern, replacement, position, occurrence, parameters)", + write={ + "bigquery": "REGEXP_REPLACE(subject, pattern, replacement)", + "duckdb": "REGEXP_REPLACE(subject, pattern, replacement)", + "hive": "REGEXP_REPLACE(subject, pattern, replacement)", + "snowflake": "REGEXP_REPLACE(subject, pattern, replacement, position, occurrence, parameters)", + "spark": "REGEXP_REPLACE(subject, pattern, replacement, position)", + }, + ) + def test_match_recognize(self): for row in ( "ONE ROW PER MATCH",

[]

[ "tests/dialects/test_snowflake.py::TestSnowflake::test_regexp_replace" ]

[ "tests/dialects/test_snowflake.py::TestSnowflake::test_ddl", "tests/dialects/test_snowflake.py::TestSnowflake::test_describe_table", "tests/dialects/test_snowflake.py::TestSnowflake::test_flatten", "tests/dialects/test_snowflake.py::TestSnowflake::test_match_recognize", "tests/dialects/test_snowflake.py::Te...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat: add RegexpReplace expression References: - https://docs.snowflake.com/en/sql-reference/functions/regexp_replace - https://spark.apache.org/docs/latest/api/sql/index.html#regexp_replace - https://cwiki.apache.org/confluence/display/hive/languagemanual+udf - https://cloud.google.com/bigquery/docs/reference/standard-sql/string_functions#regexp_replace - https://duckdb.org/docs/sql/functions/patternmatching.html ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

ceb42fabad60312699e4b15936aeebac00e22e4d

matplotlib__matplotlib-26293

26,293

matplotlib/matplotlib

3.7

a4dca24d04f928a9e614db403c716237446140b2

2023-07-12T06:31:49Z

diff --git a/doc/api/axes_api.rst b/doc/api/axes_api.rst index 3457368fa51c..8b01a120da5b 100644 --- a/doc/api/axes_api.rst +++ b/doc/api/axes_api.rst @@ -335,6 +335,8 @@ Autoscaling and margins Axes.use_sticky_edges Axes.margins + Axes.get_xmargin + Axes.get_ymargin Axes.set_xmargin Axes.set_ymargin diff --git a/doc/api/toolkits/mplot3d/axes3d.rst b/doc/api/toolkits/mplot3d/axes3d.rst index f6d8e2529896..b581494e4883 100644 --- a/doc/api/toolkits/mplot3d/axes3d.rst +++ b/doc/api/toolkits/mplot3d/axes3d.rst @@ -137,6 +137,7 @@ Autoscaling and margins :template: autosummary.rst :nosignatures: + get_zmargin set_zmargin margins autoscale diff --git a/doc/users/next_whats_new/margin_getters.rst b/doc/users/next_whats_new/margin_getters.rst new file mode 100644 index 000000000000..c43709a17d52 --- /dev/null +++ b/doc/users/next_whats_new/margin_getters.rst @@ -0,0 +1,4 @@ +Getters for xmargin, ymargin and zmargin +---------------------------------------- +``.Axes.get_xmargin()``, ``.Axes.get_ymargin()`` and ``.Axes3D.get_zmargin()`` methods have been added to return +the margin values set by ``.Axes.set_xmargin()``, ``.Axes.set_ymargin()`` and ``.Axes3D.set_zmargin()``, respectively. diff --git a/lib/matplotlib/axes/_base.py b/lib/matplotlib/axes/_base.py index 3796d9bbe508..ad06e6d552bc 100644 --- a/lib/matplotlib/axes/_base.py +++ b/lib/matplotlib/axes/_base.py @@ -2617,6 +2617,38 @@ def use_sticky_edges(self, b): self._use_sticky_edges = bool(b) # No effect until next autoscaling, which will mark the Axes as stale. + def get_xmargin(self): + """ + Retrieve autoscaling margin of the x-axis. + + .. versionadded:: 3.9 + + Returns + ------- + xmargin : float + + See Also + -------- + matplotlib.axes.Axes.set_xmargin + """ + return self._xmargin + + def get_ymargin(self): + """ + Retrieve autoscaling margin of the y-axis. + + .. versionadded:: 3.9 + + Returns + ------- + ymargin : float + + See Also + -------- + matplotlib.axes.Axes.set_ymargin + """ + return self._ymargin + def set_xmargin(self, m): """ Set padding of X data limits prior to autoscaling. diff --git a/lib/matplotlib/axes/_base.pyi b/lib/matplotlib/axes/_base.pyi index d41ecae1803c..e3644585296d 100644 --- a/lib/matplotlib/axes/_base.pyi +++ b/lib/matplotlib/axes/_base.pyi @@ -242,6 +242,8 @@ class _AxesBase(martist.Artist): def use_sticky_edges(self) -> bool: ... @use_sticky_edges.setter def use_sticky_edges(self, b: bool) -> None: ... + def get_xmargin(self) -> float: ... + def get_ymargin(self) -> float: ... def set_xmargin(self, m: float) -> None: ... def set_ymargin(self, m: float) -> None: ... diff --git a/lib/mpl_toolkits/mplot3d/axes3d.py b/lib/mpl_toolkits/mplot3d/axes3d.py index aeb6a66d2c98..e7abdc0767b5 100644 --- a/lib/mpl_toolkits/mplot3d/axes3d.py +++ b/lib/mpl_toolkits/mplot3d/axes3d.py @@ -513,6 +513,22 @@ def update_datalim(self, xys, **kwargs): get_autoscalez_on = _axis_method_wrapper("zaxis", "_get_autoscale_on") set_autoscalez_on = _axis_method_wrapper("zaxis", "_set_autoscale_on") + def get_zmargin(self): + """ + Retrieve autoscaling margin of the z-axis. + + .. versionadded:: 3.9 + + Returns + ------- + zmargin : float + + See Also + -------- + mpl_toolkits.mplot3d.axes3d.Axes3D.set_zmargin + """ + return self._zmargin + def set_zmargin(self, m): """ Set padding of Z data limits prior to autoscaling.

diff --git a/lib/matplotlib/tests/test_axes.py b/lib/matplotlib/tests/test_axes.py index 0fcb2eb26cbb..6dea39a702fc 100644 --- a/lib/matplotlib/tests/test_axes.py +++ b/lib/matplotlib/tests/test_axes.py @@ -6153,6 +6153,14 @@ def test_margins(): ymax + (ymax - ymin) * 0.5) +def test_margin_getters(): + fig = plt.figure() + ax = fig.add_subplot() + ax.margins(0.2, 0.3) + assert ax.get_xmargin() == 0.2 + assert ax.get_ymargin() == 0.3 + + def test_set_margin_updates_limits(): mpl.style.use("default") fig, ax = plt.subplots() diff --git a/lib/mpl_toolkits/mplot3d/tests/test_axes3d.py b/lib/mpl_toolkits/mplot3d/tests/test_axes3d.py index 1f8764cbab9d..df9f2ae52fd7 100644 --- a/lib/mpl_toolkits/mplot3d/tests/test_axes3d.py +++ b/lib/mpl_toolkits/mplot3d/tests/test_axes3d.py @@ -1994,6 +1994,15 @@ def test_margins(): assert ax.margins() == (0, 0.1, 0) +def test_margin_getters(): + fig = plt.figure() + ax = fig.add_subplot(projection='3d') + ax.margins(0.1, 0.2, 0.3) + assert ax.get_xmargin() == 0.1 + assert ax.get_ymargin() == 0.2 + assert ax.get_zmargin() == 0.3 + + @pytest.mark.parametrize('err, args, kwargs, match', ( (ValueError, (-1,), {}, r'margin must be greater than -0\.5'), (ValueError, (1, -1, 1), {}, r'margin must be greater than -0\.5'),

diff --git a/doc/api/axes_api.rst b/doc/api/axes_api.rst index 3457368fa51c..8b01a120da5b 100644 --- a/doc/api/axes_api.rst +++ b/doc/api/axes_api.rst @@ -335,6 +335,8 @@ Autoscaling and margins Axes.use_sticky_edges Axes.margins + Axes.get_xmargin + Axes.get_ymargin Axes.set_xmargin Axes.set_ymargin diff --git a/doc/api/toolkits/mplot3d/axes3d.rst b/doc/api/toolkits/mplot3d/axes3d.rst index f6d8e2529896..b581494e4883 100644 --- a/doc/api/toolkits/mplot3d/axes3d.rst +++ b/doc/api/toolkits/mplot3d/axes3d.rst @@ -137,6 +137,7 @@ Autoscaling and margins :template: autosummary.rst :nosignatures: + get_zmargin set_zmargin margins autoscale diff --git a/doc/users/next_whats_new/margin_getters.rst b/doc/users/next_whats_new/margin_getters.rst new file mode 100644 index 000000000000..c43709a17d52 --- /dev/null +++ b/doc/users/next_whats_new/margin_getters.rst @@ -0,0 +1,4 @@ +Getters for xmargin, ymargin and zmargin +---------------------------------------- +``.Axes.get_xmargin()``, ``.Axes.get_ymargin()`` and ``.Axes3D.get_zmargin()`` methods have been added to return +the margin values set by ``.Axes.set_xmargin()``, ``.Axes.set_ymargin()`` and ``.Axes3D.set_zmargin()``, respectively. diff --git a/lib/matplotlib/axes/_base.pyi b/lib/matplotlib/axes/_base.pyi index d41ecae1803c..e3644585296d 100644 --- a/lib/matplotlib/axes/_base.pyi +++ b/lib/matplotlib/axes/_base.pyi @@ -242,6 +242,8 @@ class _AxesBase(martist.Artist): def use_sticky_edges(self) -> bool: ... @use_sticky_edges.setter def use_sticky_edges(self, b: bool) -> None: ... + def get_xmargin(self) -> float: ... + def get_ymargin(self) -> float: ... def set_xmargin(self, m: float) -> None: ... def set_ymargin(self, m: float) -> None: ...

[ { "components": [ { "doc": "Retrieve autoscaling margin of the x-axis.\n\n.. versionadded:: 3.9\n\nReturns\n-------\nxmargin : float\n\nSee Also\n--------\nmatplotlib.axes.Axes.set_xmargin", "lines": [ 2620, 2634 ], "name": "_AxesBase.get_xmargin", ...

[ "lib/matplotlib/tests/test_axes.py::test_margin_getters", "lib/mpl_toolkits/mplot3d/tests/test_axes3d.py::test_margin_getters" ]

[ "lib/matplotlib/tests/test_axes.py::test_invisible_axes[png]", "lib/matplotlib/tests/test_axes.py::test_get_labels", "lib/matplotlib/tests/test_axes.py::test_repr", "lib/matplotlib/tests/test_axes.py::test_label_loc_vertical[png]", "lib/matplotlib/tests/test_axes.py::test_label_loc_horizontal[png]", "lib/...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added get_xmargin(), get_ymargin() and get_zmargin() and tests. ## PR summary Closes #26281 by adding `get_xmargin()`, `get_ymargin()` for` _AxesBase` and `get_zmargin()` for `Axes3D`, as well as tests for them. ## PR checklist  - [x] "closes #0000" is in the body of the PR description to [link the related issue](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue) - [x] new and changed code is [tested](https://matplotlib.org/devdocs/devel/testing.html) - [N/A] *Plotting related* features are demonstrated in an [example](https://matplotlib.org/devdocs/devel/documenting_mpl.html#writing-examples-and-tutorials) - [ ] *New Features* and *API Changes* are noted with a [directive and release note](https://matplotlib.org/devdocs/devel/coding_guide.html#new-features-and-api-changes) - [ ] Documentation complies with [general](https://matplotlib.org/devdocs/devel/documenting_mpl.html#writing-rest-pages) and [docstring](https://matplotlib.org/devdocs/devel/documenting_mpl.html#writing-docstrings) guidelines  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in lib/matplotlib/axes/_base.py] (definition of _AxesBase.get_xmargin:) def get_xmargin(self): """Retrieve autoscaling margin of the x-axis. .. versionadded:: 3.9 Returns ------- xmargin : float See Also -------- matplotlib.axes.Axes.set_xmargin""" (definition of _AxesBase.get_ymargin:) def get_ymargin(self): """Retrieve autoscaling margin of the y-axis. .. versionadded:: 3.9 Returns ------- ymargin : float See Also -------- matplotlib.axes.Axes.set_ymargin""" [end of new definitions in lib/matplotlib/axes/_base.py] [start of new definitions in lib/mpl_toolkits/mplot3d/axes3d.py] (definition of Axes3D.get_zmargin:) def get_zmargin(self): """Retrieve autoscaling margin of the z-axis. .. versionadded:: 3.9 Returns ------- zmargin : float See Also -------- mpl_toolkits.mplot3d.axes3d.Axes3D.set_zmargin""" [end of new definitions in lib/mpl_toolkits/mplot3d/axes3d.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> [ENH]: Add get_xmargin, get_ymargin, get_zmargin axes methods ### Problem Currently, I think the only public API to retrieve the margins settings on an Axes is ax.margins(), which has a somewhat peculiar API (basically inherited from pyplot/matlab); adding get_xmargin/get_ymargin/get_zmargin Axes methods would be nice (there's already the corresponding setters). Bonus points for moving the private _xmargin/_ymargin/_zmargin to the Axis instances, adding Axis.{get,set}_margin, and using axis_method_wrapper, though I haven't checked it'll actually work. ### Proposed solution _No response_ ---------- Hi! Does zmargin exist? I couldn't find it -- both the public docs and the code in _base.py only have xmargin and ymargin. Am I missing something? It is in Axes3D. -------------------- </issues>

a4dca24d04f928a9e614db403c716237446140b2

tobymao__sqlglot-1907

1,907

tobymao/sqlglot

null

69a69f67d06ebf8d328eb30fd0ef7d717758a4c9

2023-07-10T23:56:18Z

diff --git a/sqlglot/dialects/tsql.py b/sqlglot/dialects/tsql.py index b77c2c0bb7..efb49bd9a9 100644 --- a/sqlglot/dialects/tsql.py +++ b/sqlglot/dialects/tsql.py @@ -138,7 +138,8 @@ def _format_sql(self: generator.Generator, expression: exp.NumberToStr | exp.Tim if isinstance(expression, exp.NumberToStr) else exp.Literal.string( format_time( - expression.text("format"), t.cast(t.Dict[str, str], TSQL.INVERSE_TIME_MAPPING) + expression.text("format"), + t.cast(t.Dict[str, str], TSQL.INVERSE_TIME_MAPPING), ) ) ) @@ -314,7 +315,9 @@ class Parser(parser.Parser): FUNCTIONS = { **parser.Parser.FUNCTIONS, "CHARINDEX": lambda args: exp.StrPosition( - this=seq_get(args, 1), substr=seq_get(args, 0), position=seq_get(args, 2) + this=seq_get(args, 1), + substr=seq_get(args, 0), + position=seq_get(args, 2), ), "DATEADD": parse_date_delta(exp.DateAdd, unit_mapping=DATE_DELTA_INTERVAL), "DATEDIFF": parse_date_delta(exp.DateDiff, unit_mapping=DATE_DELTA_INTERVAL), @@ -365,6 +368,57 @@ class Parser(parser.Parser): CONCAT_NULL_OUTPUTS_STRING = True + def _parse_commit_or_rollback(self) -> exp.Commit | exp.Rollback: + """Applies to SQL Server and Azure SQL Database + COMMIT [ { TRAN | TRANSACTION } + [ transaction_name | @tran_name_variable ] ] + [ WITH ( DELAYED_DURABILITY = { OFF | ON } ) ] + [ ; ] + + ROLLBACK { TRAN | TRANSACTION } + [ transaction_name | @tran_name_variable + | savepoint_name | @savepoint_variable ] + [ ; ] + """ + rollback = self._prev.token_type == TokenType.ROLLBACK + + self._match_texts({"TRAN", "TRANSACTION"}) + txn_name = self._parse_id_var() + + durability = None + if self._match_pair(TokenType.WITH, TokenType.L_PAREN): + self._match_text_seq("DELAYED_DURABILITY") + self._match(TokenType.EQ) + if self._match_text_seq("OFF"): + durability = False + else: + self._match(TokenType.ON) + durability = True + + self._match_r_paren() + + if rollback: + return self.expression(exp.Rollback, this=txn_name) + + return self.expression(exp.Commit, this=txn_name, durability=durability) + + def _parse_transaction(self) -> exp.Transaction | exp.Command: + """Applies to SQL Server and Azure SQL Database + BEGIN { TRAN | TRANSACTION } + [ { transaction_name | @tran_name_variable } + [ WITH MARK [ 'description' ] ] + ] + [ ; ] + """ + if self._match_texts(("TRAN", "TRANSACTION")): + # we have a transaction and not a BEGIN + transaction = self.expression(exp.Transaction, this=self._parse_id_var()) + if self._match_text_seq("WITH", "MARK"): + transaction.set("mark", self._parse_string()) + return transaction + + return self._parse_as_command(self._prev) + def _parse_system_time(self) -> t.Optional[exp.Expression]: if not self._match_text_seq("FOR", "SYSTEM_TIME"): return None @@ -496,7 +550,9 @@ class Generator(generator.Generator): exp.Select: transforms.preprocess([transforms.eliminate_distinct_on]), exp.SHA: lambda self, e: self.func("HASHBYTES", exp.Literal.string("SHA1"), e.this), exp.SHA2: lambda self, e: self.func( - "HASHBYTES", exp.Literal.string(f"SHA2_{e.args.get('length', 256)}"), e.this + "HASHBYTES", + exp.Literal.string(f"SHA2_{e.args.get('length', 256)}"), + e.this, ), exp.TimeToStr: _format_sql, } @@ -539,3 +595,31 @@ def returning_sql(self, expression: exp.Returning) -> str: into = self.sql(expression, "into") into = self.seg(f"INTO {into}") if into else "" return f"{self.seg('OUTPUT')} {self.expressions(expression, flat=True)}{into}" + + def transaction_sql(self, expression: exp.Transaction) -> str: + this = self.sql(expression, "this") + if this in ["TRAN", "TRANSACTION"]: + mark = self.sql(expression, "mark") + mark = f" WITH MARK {mark}" if mark else "" + return f"BEGIN TRANSACTION{mark}" + else: + this = f" {this}" if this else "" + mark = self.sql(expression, "mark") + mark = f" WITH MARK {mark}" if mark else "" + return f"BEGIN TRANSACTION{this}{mark}" + + def commit_sql(self, expression: exp.Commit) -> str: + this = self.sql(expression, "this") + this = f" {this}" if this else "" + durability = expression.args.get("durability") + durability = ( + f" WITH (DELAYED_DURABILITY = {'ON' if durability else 'OFF'})" + if durability is not None + else "" + ) + return f"COMMIT TRANSACTION{this}{durability}" + + def rollback_sql(self, expression: exp.Rollback) -> str: + this = self.sql(expression, "this") + this = f" {this}" if this else "" + return f"ROLLBACK TRANSACTION{this}" diff --git a/sqlglot/expressions.py b/sqlglot/expressions.py index 1efedc7b78..e4edeed1cf 100644 --- a/sqlglot/expressions.py +++ b/sqlglot/expressions.py @@ -3472,15 +3472,15 @@ class Command(Expression): class Transaction(Expression): - arg_types = {"this": False, "modes": False} + arg_types = {"this": False, "modes": False, "mark": False} class Commit(Expression): - arg_types = {"chain": False} + arg_types = {"chain": False, "this": False, "durability": False} class Rollback(Expression): - arg_types = {"savepoint": False} + arg_types = {"savepoint": False, "this": False} class AlterTable(Expression): diff --git a/sqlglot/parser.py b/sqlglot/parser.py index 508a273705..166e3b8e66 100644 --- a/sqlglot/parser.py +++ b/sqlglot/parser.py @@ -4351,7 +4351,7 @@ def _parse_ddl_select(self) -> t.Optional[exp.Expression]: self._parse_set_operations(self._parse_select(nested=True, parse_subquery_alias=False)) ) - def _parse_transaction(self) -> exp.Transaction: + def _parse_transaction(self) -> exp.Transaction | exp.Command: this = None if self._match_texts(self.TRANSACTION_KIND): this = self._prev.text

diff --git a/tests/dialects/test_dialect.py b/tests/dialects/test_dialect.py index 05738cf34e..3ca47aba2b 100644 --- a/tests/dialects/test_dialect.py +++ b/tests/dialects/test_dialect.py @@ -1512,6 +1512,7 @@ def test_transactions(self): "redshift": "BEGIN", "snowflake": "BEGIN", "sqlite": "BEGIN TRANSACTION", + "tsql": "BEGIN TRANSACTION", }, ) self.validate_all( diff --git a/tests/dialects/test_tsql.py b/tests/dialects/test_tsql.py index 065cdd09f9..5fa881b616 100644 --- a/tests/dialects/test_tsql.py +++ b/tests/dialects/test_tsql.py @@ -389,7 +389,58 @@ def test_types_bin(self): }, ) + def test_ddl(self): + self.validate_all( + "CREATE TABLE #mytemp (a INTEGER, b CHAR(2), c TIME(4), d FLOAT(24))", + write={ + "tsql": "CREATE TABLE #mytemp (a INTEGER, b CHAR(2), c TIMESTAMP(4), d FLOAT(24))" + }, + ) + + def test_transaction(self): + # BEGIN { TRAN | TRANSACTION } + # [ { transaction_name | @tran_name_variable } + # [ WITH MARK [ 'description' ] ] + # ] + # [ ; ] + self.validate_identity("BEGIN TRANSACTION") + self.validate_all("BEGIN TRAN", write={"tsql": "BEGIN TRANSACTION"}) + self.validate_identity("BEGIN TRANSACTION transaction_name") + self.validate_identity("BEGIN TRANSACTION @tran_name_variable") + self.validate_identity("BEGIN TRANSACTION transaction_name WITH MARK 'description'") + + def test_commit(self): + # COMMIT [ { TRAN | TRANSACTION } [ transaction_name | @tran_name_variable ] ] [ WITH ( DELAYED_DURABILITY = { OFF | ON } ) ] [ ; ] + + self.validate_all("COMMIT", write={"tsql": "COMMIT TRANSACTION"}) + self.validate_all("COMMIT TRAN", write={"tsql": "COMMIT TRANSACTION"}) + self.validate_identity("COMMIT TRANSACTION") + self.validate_identity("COMMIT TRANSACTION transaction_name") + self.validate_identity("COMMIT TRANSACTION @tran_name_variable") + + self.validate_identity( + "COMMIT TRANSACTION @tran_name_variable WITH (DELAYED_DURABILITY = ON)" + ) + self.validate_identity( + "COMMIT TRANSACTION transaction_name WITH (DELAYED_DURABILITY = OFF)" + ) + + def test_rollback(self): + # Applies to SQL Server and Azure SQL Database + # ROLLBACK { TRAN | TRANSACTION } + # [ transaction_name | @tran_name_variable + # | savepoint_name | @savepoint_variable ] + # [ ; ] + self.validate_all("ROLLBACK", write={"tsql": "ROLLBACK TRANSACTION"}) + self.validate_all("ROLLBACK TRAN", write={"tsql": "ROLLBACK TRANSACTION"}) + self.validate_identity("ROLLBACK TRANSACTION") + self.validate_identity("ROLLBACK TRANSACTION transaction_name") + self.validate_identity("ROLLBACK TRANSACTION @tran_name_variable") + def test_udf(self): + self.validate_identity( + "DECLARE @DWH_DateCreated DATETIME = CONVERT(DATETIME, getdate(), 104)" + ) self.validate_identity( "CREATE PROCEDURE foo @a INTEGER, @b INTEGER AS SELECT @a = SUM(bla) FROM baz AS bar" ) @@ -446,6 +497,12 @@ def test_udf(self): pretty=True, ) + def test_procedure_keywords(self): + self.validate_identity("BEGIN") + self.validate_identity("END") + self.validate_identity("SET XACT_ABORT ON") + + def test_fullproc(self): sql = """ CREATE procedure [TRANSF].[SP_Merge_Sales_Real] @Loadid INTEGER @@ -838,7 +895,8 @@ def test_format(self): write={"spark": "SELECT FORMAT_NUMBER(1000000.01, '###,###.###')"}, ) self.validate_all( - "SELECT FORMAT(1234567, 'f')", write={"spark": "SELECT FORMAT_NUMBER(1234567, 'f')"} + "SELECT FORMAT(1234567, 'f')", + write={"spark": "SELECT FORMAT_NUMBER(1234567, 'f')"}, ) self.validate_all( "SELECT FORMAT('01-01-1991', 'dd.mm.yyyy')", @@ -853,7 +911,8 @@ def test_format(self): write={"spark": "SELECT DATE_FORMAT(date_col, 'MMMM d')"}, ) self.validate_all( - "SELECT FORMAT(num_col, 'c')", write={"spark": "SELECT FORMAT_NUMBER(num_col, 'c')"} + "SELECT FORMAT(num_col, 'c')", + write={"spark": "SELECT FORMAT_NUMBER(num_col, 'c')"}, ) def test_string(self):

[]

[ "tests/dialects/test_dialect.py::TestDialect::test_transactions", "tests/dialects/test_tsql.py::TestTSQL::test_commit", "tests/dialects/test_tsql.py::TestTSQL::test_rollback", "tests/dialects/test_tsql.py::TestTSQL::test_transaction" ]

[ "tests/dialects/test_dialect.py::TestDialect::test_alias", "tests/dialects/test_dialect.py::TestDialect::test_array", "tests/dialects/test_dialect.py::TestDialect::test_cast", "tests/dialects/test_dialect.py::TestDialect::test_count_if", "tests/dialects/test_dialect.py::TestDialect::test_cross_join", "tes...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat(tsql): improve support for transaction statements Enrich syntax parsing for BEGIN, COMMIT and ROLLBACK Transactions. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

ceb42fabad60312699e4b15936aeebac00e22e4d

Textualize__textual-2906

2,906

Textualize/textual

null

90a93e08abe813da495712ad99d4d6da5215728b

2023-07-09T17:04:07Z

diff --git a/src/textual/_fuzzy.py b/src/textual/_fuzzy.py new file mode 100644 index 0000000000..2d9766e054 --- /dev/null +++ b/src/textual/_fuzzy.py @@ -0,0 +1,82 @@ +from re import compile, escape + +import rich.repr +from rich.text import Text + +from ._cache import LRUCache + + +@rich.repr.auto +class Matcher: + """A fuzzy matcher.""" + + def __init__(self, query: str) -> None: + """ + Args: + query: A query as typed in by the user. + """ + self.query = query + self._query_regex = ".*?".join(f"({escape(character)})" for character in query) + self._query_regex_compiled = compile(self._query_regex) + self._cache: LRUCache[str, float] = LRUCache(1024 * 4) + + def match(self, input: str) -> float: + """Match the input against the query + + Args: + input: Input string to match against. + + Returns: + Strength of the match from 0 to 1. + """ + cached = self._cache.get(input) + if cached is not None: + return cached + match = self._query_regex_compiled.search(input) + if match is None: + score = 0.0 + else: + assert match.lastindex is not None + offsets = [ + match.span(group_no)[0] for group_no in range(1, match.lastindex + 1) + ] + group_count = 0 + last_offset = -2 + for offset in offsets: + if offset > last_offset + 1: + group_count += 1 + last_offset = offset + + score = 1.0 - ((group_count - 1) / len(input)) + self._cache[input] = score + return score + + def highlight(self, input: str) -> Text: + """Highlight the input with the fuzzy match. + + Args: + input: User input. + + Returns: + A Text object with matched letters in bold. + """ + match = self._query_regex_compiled.search(input) + text = Text(input) + if match is None: + return text + assert match.lastindex is not None + offsets = [ + match.span(group_no)[0] for group_no in range(1, match.lastindex + 1) + ] + for offset in offsets: + text.stylize("bold", offset, offset + 1) + + return text + + +if __name__ == "__main__": + from rich import print + + matcher = Matcher("foo.bar") + print(matcher.match("xz foo.bar sdf")) + print(matcher.highlight("xz foo.bar sdf"))

diff --git a/tests/test_fuzzy.py b/tests/test_fuzzy.py new file mode 100644 index 0000000000..71c073d9f2 --- /dev/null +++ b/tests/test_fuzzy.py @@ -0,0 +1,40 @@ +from rich.text import Span + +from textual._fuzzy import Matcher + + +def test_match(): + matcher = Matcher("foo.bar") + + # No match + assert matcher.match("egg") == 0 + assert matcher.match("") == 0 + + # Perfect match + assert matcher.match("foo.bar") == 1.0 + # Perfect match (with superfluous characters) + assert matcher.match("foo.bar sdf") == 1.0 + assert matcher.match("xz foo.bar sdf") == 1.0 + + # Partial matches + # 2 Groups + assert matcher.match("foo egg.bar") == 1.0 - 1 / 11 + + # 3 Groups + assert matcher.match("foo .ba egg r") == 1.0 - 2 / 13 + + +def test_highlight(): + matcher = Matcher("foo.bar") + + spans = matcher.highlight("foo/egg.bar").spans + print(spans) + assert spans == [ + Span(0, 1, "bold"), + Span(1, 2, "bold"), + Span(2, 3, "bold"), + Span(7, 8, "bold"), + Span(8, 9, "bold"), + Span(9, 10, "bold"), + Span(10, 11, "bold"), + ]

[ { "components": [ { "doc": "A fuzzy matcher.", "lines": [ 10, 74 ], "name": "Matcher", "signature": "class Matcher:", "type": "class" }, { "doc": "Args:\n query: A query as typed in by the user.", "lines": [...

[ "tests/test_fuzzy.py::test_match", "tests/test_fuzzy.py::test_highlight" ]

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> fuzzy matcher Some initial work for the "command palette", which will use "fuzzy matching". This implements the fuzzy part. Commands will be matched against the user's input. A match is recorded if all the users characters are in the command and in the correct order. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/textual/_fuzzy.py] (definition of Matcher:) class Matcher: """A fuzzy matcher.""" (definition of Matcher.__init__:) def __init__(self, query: str) -> None: """Args: query: A query as typed in by the user.""" (definition of Matcher.match:) def match(self, input: str) -> float: """Match the input against the query Args: input: Input string to match against. Returns: Strength of the match from 0 to 1.""" (definition of Matcher.highlight:) def highlight(self, input: str) -> Text: """Highlight the input with the fuzzy match. Args: input: User input. Returns: A Text object with matched letters in bold.""" [end of new definitions in src/textual/_fuzzy.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

86e93536b991014e0ea4bf993068202b446bb698

conan-io__conan-14233

14,233

conan-io/conan

null

57c7049c758a685cdc02e870eb77617af5e45da6

2023-07-06T06:04:41Z

diff --git a/conan/tools/gnu/pkgconfigdeps.py b/conan/tools/gnu/pkgconfigdeps.py index e793711ee81..1aa86e9d472 100644 --- a/conan/tools/gnu/pkgconfigdeps.py +++ b/conan/tools/gnu/pkgconfigdeps.py @@ -1,12 +1,13 @@ import os +import re import textwrap from collections import namedtuple from jinja2 import Template, StrictUndefined +from conan.errors import ConanException from conan.internal import check_duplicated_generator from conan.tools.gnu.gnudeps_flags import GnuDepsFlags -from conan.errors import ConanException from conans.model.dependencies import get_transitive_requires from conans.util.files import save @@ -75,8 +76,8 @@ def _get_suffix(req, build_context_suffix=None): return build_context_suffix.get(req.ref.name, "") -def _get_formatted_dirs(folders, prefix_path_): - ret = [] +def _get_formatted_dirs(folder_name, folders, prefix_path_): + ret = {} for i, directory in enumerate(folders): directory = os.path.normpath(directory).replace("\\", "/") prefix = "" @@ -85,7 +86,9 @@ def _get_formatted_dirs(folders, prefix_path_): elif directory.startswith(prefix_path_): prefix = "${prefix}/" directory = os.path.relpath(directory, prefix_path_).replace("\\", "/") - ret.append("%s%s" % (prefix, directory)) + suffix = str(i) if i else "" + var_name = f"{folder_name}{suffix}" + ret[var_name] = f"{prefix}{directory}" return ret @@ -95,71 +98,19 @@ def _get_formatted_dirs(folders, prefix_path_): class _PCContentGenerator: template = textwrap.dedent("""\ - {%- macro get_libs(libdirs, cpp_info, gnudeps_flags) -%} - {%- for _ in libdirs -%} - {{ '-L"${libdir%s}"' % (loop.index0 or "") + " " }} - {%- endfor -%} - {%- for sys_lib in (cpp_info.libs + cpp_info.system_libs) -%} - {{ "-l%s" % sys_lib + " " }} - {%- endfor -%} - {%- for shared_flag in (cpp_info.sharedlinkflags + cpp_info.exelinkflags) -%} - {{ shared_flag + " " }} - {%- endfor -%} - {%- for framework in (gnudeps_flags.frameworks + gnudeps_flags.framework_paths) -%} - {{ framework + " " }} - {%- endfor -%} - {%- endmacro -%} - - {%- macro get_cflags(includedirs, cxxflags, cflags, defines) -%} - {%- for _ in includedirs -%} - {{ '-I"${includedir%s}"' % (loop.index0 or "") + " " }} - {%- endfor -%} - {%- for cxxflag in cxxflags -%} - {{ cxxflag + " " }} - {%- endfor -%} - {%- for cflag in cflags-%} - {{ cflag + " " }} - {%- endfor -%} - {%- for define in defines-%} - {{ "-D%s" % define + " " }} - {%- endfor -%} - {%- endmacro -%} - - prefix={{ prefix_path }} - {% for path in libdirs %} - {{ "libdir{}={}".format((loop.index0 or ""), path) }} - {% endfor %} - {% for path in includedirs %} - {{ "includedir%s=%s" % ((loop.index0 or ""), path) }} - {% endfor %} - {% for path in bindirs %} - {{ "bindir{}={}".format((loop.index0 or ""), path) }} + {% for k, v in pc_variables.items() %} + {{ "{}={}".format(k, v) }} {% endfor %} - {% if pkg_config_custom_content %} - # Custom PC content - {{ pkg_config_custom_content }} - {% endif %} Name: {{ name }} Description: {{ description }} Version: {{ version }} - Libs: {{ get_libs(libdirs, cpp_info, gnudeps_flags) }} - Cflags: {{ get_cflags(includedirs, cxxflags, cflags, defines) }} - {% if requires|length %} - Requires: {{ requires|join(' ') }} + {% if libflags %} + Libs: {{ libflags }} {% endif %} - """) - - shortened_template = textwrap.dedent("""\ - prefix={{ prefix_path }} - {% if pkg_config_custom_content %} - # Custom PC content - {{ pkg_config_custom_content }} + {% if cflags %} + Cflags: {{ cflags }} {% endif %} - - Name: {{ name }} - Description: {{ description }} - Version: {{ version }} {% if requires|length %} Requires: {{ requires|join(' ') }} {% endif %} @@ -175,50 +126,74 @@ def _get_prefix_path(self): else self._dep.package_folder return root_folder.replace("\\", "/") - def content(self, info): - assert isinstance(info, _PCInfo) and info.cpp_info is not None - + def _get_pc_variables(self, cpp_info): + """ + Get all the freeform variables defined by Conan and + users (through ``pkg_config_custom_content``). This last ones will override the + Conan defined variables. + """ prefix_path = self._get_prefix_path() - version = info.cpp_info.get_property("component_version") or self._dep.ref.version - libdirs = _get_formatted_dirs(info.cpp_info.libdirs, prefix_path) - includedirs = _get_formatted_dirs(info.cpp_info.includedirs, prefix_path) - bindirs = _get_formatted_dirs(info.cpp_info.bindirs, prefix_path) - custom_content = info.cpp_info.get_property("pkg_config_custom_content") - + pc_variables = {"prefix": prefix_path} + if cpp_info is None: + return pc_variables + # Already formatted directories + pc_variables.update(_get_formatted_dirs("libdir", cpp_info.libdirs, prefix_path)) + pc_variables.update(_get_formatted_dirs("includedir", cpp_info.includedirs, prefix_path)) + pc_variables.update(_get_formatted_dirs("bindir", cpp_info.bindirs, prefix_path)) + # Get the custom content introduced by user and sanitize it + custom_content = cpp_info.get_property("pkg_config_custom_content") + if isinstance(custom_content, dict): + pc_variables.update(custom_content) + elif custom_content: # Legacy: custom content is string + pc_variable_pattern = re.compile("^(.*)=(.*)") + for line in custom_content.splitlines(): + match = pc_variable_pattern.match(line) + if match: + key, value = match.group(1).strip(), match.group(2).strip() + pc_variables[key] = value + return pc_variables + + def _get_lib_flags(self, libdirvars, cpp_info): + gnudeps_flags = GnuDepsFlags(self._conanfile, cpp_info) + libdirsflags = ['-L"${%s}"' % d for d in libdirvars] + system_libs = ["-l%s" % l for l in (cpp_info.libs + cpp_info.system_libs)] + shared_flags = cpp_info.sharedlinkflags + cpp_info.exelinkflags + framework_flags = gnudeps_flags.frameworks + gnudeps_flags.framework_paths + return " ".join(libdirsflags + system_libs + shared_flags + framework_flags) + + def _get_cflags(self, includedirvars, cpp_info): + includedirsflags = ['-I"${%s}"' % d for d in includedirvars] + cxxflags = [var.replace('"', '\\"') for var in cpp_info.cxxflags] + cflags = [var.replace('"', '\\"') for var in cpp_info.cflags] + defines = ["-D%s" % var.replace('"', '\\"') for var in cpp_info.defines] + return " ".join(includedirsflags + cxxflags + cflags + defines) + + def _get_context(self, info): + pc_variables = self._get_pc_variables(info.cpp_info) context = { - "prefix_path": prefix_path, - "libdirs": libdirs, - "includedirs": includedirs, - "bindirs": bindirs, - "pkg_config_custom_content": custom_content, "name": info.name, "description": info.description, - "version": version, + "version": self._dep.ref.version, "requires": info.requires, - "cpp_info": info.cpp_info, - "cxxflags": [var.replace('"', '\\"') for var in info.cpp_info.cxxflags], - "cflags": [var.replace('"', '\\"') for var in info.cpp_info.cflags], - "defines": [var.replace('"', '\\"') for var in info.cpp_info.defines], - "gnudeps_flags": GnuDepsFlags(self._conanfile, info.cpp_info) + "pc_variables": pc_variables, + "cflags": "", + "libflags": "" } - template = Template(self.template, trim_blocks=True, lstrip_blocks=True, - undefined=StrictUndefined) - return template.render(context) + if info.cpp_info is not None: + context.update({ + "version": info.cpp_info.get_property("component_version") or self._dep.ref.version, + "cflags": self._get_cflags([d for d in pc_variables if d.startswith("includedir")], + info.cpp_info), + "libflags": self._get_lib_flags([d for d in pc_variables if d.startswith("libdir")], + info.cpp_info) + }) + return context - def shortened_content(self, info): + def content(self, info): assert isinstance(info, _PCInfo) - custom_content = info.cpp_info.get_property("pkg_config_custom_content") if info.cpp_info \ - else None - context = { - "prefix_path": self._get_prefix_path(), - "pkg_config_custom_content": custom_content, - "name": info.name, - "description": info.description, - "version": self._dep.ref.version, - "requires": info.requires - } - template = Template(self.shortened_template, trim_blocks=True, - lstrip_blocks=True, undefined=StrictUndefined) + context = self._get_context(info) + template = Template(self.template, trim_blocks=True, lstrip_blocks=True, + undefined=StrictUndefined) return template.render(context) @@ -340,7 +315,7 @@ def _update_pc_files(info): pc_files[f"{info.name}.pc"] = self._content_generator.content(info) for alias in info.aliases: alias_info = _PCInfo(alias, [info.name], f"Alias {alias} for {info.name}", None, []) - pc_files[f"{alias}.pc"] = self._content_generator.shortened_content(alias_info) + pc_files[f"{alias}.pc"] = self._content_generator.content(alias_info) pc_files = {} # If the package has no components, then we have to calculate only the root pc file @@ -365,11 +340,11 @@ def _update_pc_files(info): package_info = _PCInfo(pkg_name, pkg_requires, f"Conan package: {pkg_name}", self._dep.cpp_info, _get_package_aliases(self._dep)) # It'll be enough creating a shortened PC file. This file will be like an alias - pc_files[f"{package_info.name}.pc"] = self._content_generator.shortened_content(package_info) + pc_files[f"{package_info.name}.pc"] = self._content_generator.content(package_info) for alias in package_info.aliases: alias_info = _PCInfo(alias, [package_info.name], f"Alias {alias} for {package_info.name}", None, []) - pc_files[f"{alias}.pc"] = self._content_generator.shortened_content(alias_info) + pc_files[f"{alias}.pc"] = self._content_generator.content(alias_info) return pc_files

diff --git a/conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py b/conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py index e211bd6e889..fb6bc02c644 100644 --- a/conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py +++ b/conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py @@ -94,9 +94,7 @@ def package_info(self): expected = textwrap.dedent(""" Name: mylib Description: Conan package: mylib - Version: 0.1 - Libs:%s - Cflags: """ % " ") # ugly hack for trailing whitespace removed by IDEs + Version: 0.1""") assert "\n".join(pc_content.splitlines()[1:]) == expected @@ -173,9 +171,10 @@ def package(self): def package_info(self): custom_content = textwrap.dedent(\""" + bindir=${prefix}/my/bin/folder + fakelibdir=${prefix}/my/lib/folder datadir=${prefix}/share schemasdir=${datadir}/mylib/schemas - bindir=${prefix}/bin \""") self.cpp_info.set_property("pkg_config_custom_content", custom_content) self.cpp_info.includedirs = ["include"] @@ -187,11 +186,23 @@ def package_info(self): client.run("install --requires=pkg/0.1@ -g PkgConfigDeps") pc_content = client.load("pkg.pc") - assert "libdir=${prefix}/lib" in pc_content - assert "datadir=${prefix}/share" in pc_content - assert "schemasdir=${datadir}/mylib/schemas" in pc_content - assert "bindir=${prefix}/bin" in pc_content - assert "Name: pkg" in pc_content + prefix = pc_content.splitlines()[0] + expected = textwrap.dedent(f"""\ + {prefix} + libdir=${{prefix}}/lib + includedir=${{prefix}}/include + bindir=${{prefix}}/my/bin/folder + fakelibdir=${{prefix}}/my/lib/folder + datadir=${{prefix}}/share + schemasdir=${{datadir}}/mylib/schemas + + Name: pkg + Description: Conan package: pkg + Version: 0.1 + Libs: -L"${{libdir}}" + Cflags: -I"${{includedir}}" + """) + assert expected == pc_content def test_custom_content_and_version_components(): @@ -446,15 +457,17 @@ def package_info(self): pc_content = client.load("pkg_other_name.pc") content = textwrap.dedent(f"""\ {prefix} - # Custom PC content - + libdir=${{prefix}}/lib + includedir=${{prefix}}/include + bindir=${{prefix}}/bin datadir=${{prefix}}/share schemasdir=${{datadir}}/mylib/schemas - Name: pkg_other_name Description: Conan package: pkg_other_name Version: 0.3 + Libs: -L"${{libdir}}" + Cflags: -I"${{includedir}}" Requires: compo1 """) assert content == pc_content

[ { "components": [ { "doc": "Get all the freeform variables defined by Conan and\nusers (through ``pkg_config_custom_content``). This last ones will override the\nConan defined variables.", "lines": [ 129, 154 ], "name": "_PCContentGenerator._get_pc_varia...

[ "conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py::test_empty_dirs", "conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py::test_custom_content", "conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py::test_pkg_config_name_full_aliases" ]

[ "conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py::test_pkg_config_dirs", "conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py::test_system_libs", "conans/test/integration/toolchains/gnu/test_pkgconfigdeps.py::test_multiple_include", "conans/test/integration/toolchains/gnu/test_pkgconfigd...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [PkgConfigDeps] `pkg_config_custom_content` property overwrites variables Changelog: Feature: Let `pkg_config_custom_content` overwrite default `*.pc` variables created by `PkgConfigDeps`. Changelog: Feature: Let `pkg_config_custom_content` be a dict-like object too. Docs: https://github.com/conan-io/docs/pull/3293 UPDATED: * Simplified internal `PkgConfigDeps` logic: only one template and more straightforward, one context, Python is formatting the template, etc. * `pkg_config_custom_content` overwrites Conan-defined freeform variables, not keyword metadata ones. * `pkg_config_custom_content` could be defined as a dictionary instead of a string. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conan/tools/gnu/pkgconfigdeps.py] (definition of _PCContentGenerator._get_pc_variables:) def _get_pc_variables(self, cpp_info): """Get all the freeform variables defined by Conan and users (through ``pkg_config_custom_content``). This last ones will override the Conan defined variables.""" (definition of _PCContentGenerator._get_lib_flags:) def _get_lib_flags(self, libdirvars, cpp_info): (definition of _PCContentGenerator._get_cflags:) def _get_cflags(self, includedirvars, cpp_info): (definition of _PCContentGenerator._get_context:) def _get_context(self, info): [end of new definitions in conan/tools/gnu/pkgconfigdeps.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

4a5b19a75db9225316c8cb022a2dfb9705a2af34

django__django-17045

17,045

django/django

5.0

2ddfa3e2b63d7a77270711dbe63aafb86abf4ddd

2023-07-04T13:41:24Z

diff --git a/AUTHORS b/AUTHORS index 40df3589c024..6cafad023aa5 100644 --- a/AUTHORS +++ b/AUTHORS @@ -62,6 +62,7 @@ answer newbie questions, and generally made Django that much better: Aljaž Košir <aljazkosir5@gmail.com> Aljosa Mohorovic <aljosa.mohorovic@gmail.com> Alokik Vijay <alokik.roe@gmail.com> + Amir Karimi <amk9978@gmail.com> Amit Chakradeo <https://amit.chakradeo.net/> Amit Ramon <amit.ramon@gmail.com> Amit Upadhyay <http://www.amitu.com/blog/> diff --git a/django/urls/resolvers.py b/django/urls/resolvers.py index b021673772a1..432bf50076e2 100644 --- a/django/urls/resolvers.py +++ b/django/urls/resolvers.py @@ -318,7 +318,10 @@ def match(self, path): return None def check(self): - warnings = self._check_pattern_startswith_slash() + warnings = [ + *self._check_pattern_startswith_slash(), + *self._check_pattern_unmatched_angle_brackets(), + ] route = self._route if "(?P<" in route or route.startswith("^") or route.endswith("$"): warnings.append( @@ -331,6 +334,34 @@ def check(self): ) return warnings + def _check_pattern_unmatched_angle_brackets(self): + warnings = [] + segments = self._route.split("/") + for segment in segments: + open_bracket_counter = 0 + unmatched_angle_bracket = None + for char in segment: + if char == "<": + open_bracket_counter += 1 + elif char == ">": + open_bracket_counter -= 1 + if open_bracket_counter < 0: + unmatched_angle_bracket = ">" + break + else: + if open_bracket_counter > 0: + unmatched_angle_bracket = "<" + + if unmatched_angle_bracket is not None: + warnings.append( + Warning( + "Your URL pattern %s has an unmatched '%s' bracket." + % (self.describe(), unmatched_angle_bracket), + id="urls.W010", + ) + ) + return warnings + def _compile(self, route): return re.compile(_route_to_regex(route, self._is_endpoint)[0])

diff --git a/tests/check_framework/test_urls.py b/tests/check_framework/test_urls.py index a9038c6f13ce..4b6a4a6f3eb3 100644 --- a/tests/check_framework/test_urls.py +++ b/tests/check_framework/test_urls.py @@ -161,6 +161,47 @@ def test_check_view_not_class(self): ], ) + @override_settings( + ROOT_URLCONF="check_framework.urls.path_compatibility.matched_angle_brackets" + ) + def test_no_warnings_matched_angle_brackets(self): + self.assertEqual(check_url_config(None), []) + + @override_settings( + ROOT_URLCONF="check_framework.urls.path_compatibility.unmatched_angle_brackets" + ) + def test_warning_unmatched_angle_brackets(self): + self.assertEqual( + check_url_config(None), + [ + Warning( + "Your URL pattern 'beginning-with/<angle_bracket' has an unmatched " + "'<' bracket.", + id="urls.W010", + ), + Warning( + "Your URL pattern 'ending-with/angle_bracket>' has an unmatched " + "'>' bracket.", + id="urls.W010", + ), + Warning( + "Your URL pattern 'closed_angle>/x/<opened_angle' has an unmatched " + "'>' bracket.", + id="urls.W010", + ), + Warning( + "Your URL pattern 'closed_angle>/x/<opened_angle' has an unmatched " + "'<' bracket.", + id="urls.W010", + ), + Warning( + "Your URL pattern '<mixed>angle_bracket>' has an unmatched '>' " + "bracket.", + id="urls.W010", + ), + ], + ) + class UpdatedToPathTests(SimpleTestCase): @override_settings( diff --git a/tests/check_framework/urls/path_compatibility/matched_angle_brackets.py b/tests/check_framework/urls/path_compatibility/matched_angle_brackets.py new file mode 100644 index 000000000000..de3076942d92 --- /dev/null +++ b/tests/check_framework/urls/path_compatibility/matched_angle_brackets.py @@ -0,0 +1,5 @@ +from django.urls import path + +urlpatterns = [ + path("<int:angle_bracket>", lambda x: x), +] diff --git a/tests/check_framework/urls/path_compatibility/unmatched_angle_brackets.py b/tests/check_framework/urls/path_compatibility/unmatched_angle_brackets.py new file mode 100644 index 000000000000..e53685ec7a3a --- /dev/null +++ b/tests/check_framework/urls/path_compatibility/unmatched_angle_brackets.py @@ -0,0 +1,8 @@ +from django.urls import path + +urlpatterns = [ + path("beginning-with/<angle_bracket", lambda x: x), + path("ending-with/angle_bracket>", lambda x: x), + path("closed_angle>/x/<opened_angle", lambda x: x), + path("<mixed>angle_bracket>", lambda x: x), +]

diff --git a/AUTHORS b/AUTHORS index 40df3589c024..6cafad023aa5 100644 --- a/AUTHORS +++ b/AUTHORS @@ -62,6 +62,7 @@ answer newbie questions, and generally made Django that much better: Aljaž Košir <aljazkosir5@gmail.com> Aljosa Mohorovic <aljosa.mohorovic@gmail.com> Alokik Vijay <alokik.roe@gmail.com> + Amir Karimi <amk9978@gmail.com> Amit Chakradeo <https://amit.chakradeo.net/> Amit Ramon <amit.ramon@gmail.com> Amit Upadhyay <http://www.amitu.com/blog/>

[ { "components": [ { "doc": "", "lines": [ 337, 363 ], "name": "RoutePattern._check_pattern_unmatched_angle_brackets", "signature": "def _check_pattern_unmatched_angle_brackets(self):", "type": "function" } ], "file": "django...

[ "test_warning_unmatched_angle_brackets (check_framework.test_urls.CheckUrlConfigTests.test_warning_unmatched_angle_brackets)" ]

[ "test_empty_string_no_errors (check_framework.test_urls.CheckURLSettingsTests.test_empty_string_no_errors)", "test_media_url_no_slash (check_framework.test_urls.CheckURLSettingsTests.test_media_url_no_slash)", "test_slash_no_errors (check_framework.test_urls.CheckURLSettingsTests.test_slash_no_errors)", "test...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Fixed #34691 -- Added system check for unmatched angle brackets in path(). I added the bracket checker like what we have for $. This is my first contribution to the Django project! Let me know if there is anything to modify :) I'm doubtful of naming the warning id (I know it might happen by upgrading Django, but I don't know in which version it will be used). Do I need to update it to 5? or what? Plus, do I need to include it in the docs/releases/4.3.txt? or docs/releases/5.0.txt? ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in django/urls/resolvers.py] (definition of RoutePattern._check_pattern_unmatched_angle_brackets:) def _check_pattern_unmatched_angle_brackets(self): [end of new definitions in django/urls/resolvers.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Add a system check for unmatched URL paths' < / > Description Currently, unmatched angle brackets are silently ignored: path('<int:question_id/vote/', views.vote, name='vote'), This leads to a frustrating debugging experience, where a 404 or NoReverseMatch could occur and only the eagle-eyed could spot why. Similar to the ^/$ system check added in #28663, I propose a new check in RoutePattern.check() for unmatched < or >. It's rather unlikely those characters are legitimately used in URLs. (Inspired by a new user making this mistake and asking for help on the forum.) ---------- Seems essential. I can work on it by splitting the routes based on '/' and checking if each part having started with '<' must have ended with '>'. Sounds reasonable, this should raise a system check warning, not an error. https://github.com/django/django/pull/17045 -------------------- </issues>

8edaf07a28a3e3848ab1edbdcd2fdc25e6bd6015

roboflow__supervision-170

170

roboflow/supervision

null

dd80753b2b17389ca0645c067d7f218bc9caa762

2023-07-02T21:27:03Z

diff --git a/docs/detection/annotate.md b/docs/detection/annotate.md index d37f14823..cc0be9fc1 100644 --- a/docs/detection/annotate.md +++ b/docs/detection/annotate.md @@ -1,11 +1,19 @@ -## BoxAnnotator +## BoundingBoxAnnotator -:::supervision.detection.annotate.BoxAnnotator +:::supervision.annotators.core.BoundingBoxAnnotator ## MaskAnnotator -:::supervision.detection.annotate.MaskAnnotator +:::supervision.annotators.core.MaskAnnotator -## TraceAnnotator +## EllipseAnnotator -:::supervision.detection.annotate.TraceAnnotator +:::supervision.annotators.core.EllipseAnnotator + +## BoxCornerAnnotator + +:::supervision.annotators.core.BoxCornerAnnotator + +## LabelAnnotator + +:::supervision.annotators.core.LabelAnnotator diff --git a/docs/geometry/core.md b/docs/geometry/core.md new file mode 100644 index 000000000..978ad2cf6 --- /dev/null +++ b/docs/geometry/core.md @@ -0,0 +1,3 @@ +## Position + +:::supervision.geometry.core.Position diff --git a/examples/tracking/script.py b/examples/tracking/script.py index 4b7d51ed9..51367896d 100644 --- a/examples/tracking/script.py +++ b/examples/tracking/script.py @@ -16,7 +16,8 @@ def process_video( model = YOLO(source_weights_path) tracker = sv.ByteTrack() - box_annotator = sv.BoxAnnotator() + box_annotator = sv.BoundingBoxAnnotator() + label_annotator = sv.LabelAnnotator(classes=model.names) frame_generator = sv.get_video_frames_generator(source_path=source_video_path) video_info = sv.VideoInfo.from_video_path(video_path=source_video_path) @@ -28,16 +29,15 @@ def process_video( detections = sv.Detections.from_ultralytics(results) detections = tracker.update_with_detections(detections) - labels = [ - f"#{tracker_id} {model.model.names[class_id]}" - for _, _, _, class_id, tracker_id in detections - ] - annotated_frame = box_annotator.annotate( - scene=frame.copy(), detections=detections, labels=labels + scene=frame.copy(), detections=detections + ) + + annotated_labeled_frame = label_annotator.annotate( + scene=annotated_frame, detections=detections ) - sink.write_frame(frame=annotated_frame) + sink.write_frame(frame=annotated_labeled_frame) if __name__ == "__main__": diff --git a/examples/traffic_analysis/requirements.txt b/examples/traffic_analysis/requirements.txt index 3103d0056..c793f725e 100644 --- a/examples/traffic_analysis/requirements.txt +++ b/examples/traffic_analysis/requirements.txt @@ -1,4 +1,4 @@ -supervision==0.15.0rc1 +supervision>=0.15.0rc1 tqdm ultralytics gdown diff --git a/supervision/__init__.py b/supervision/__init__.py index 2599393ce..517602e00 100644 --- a/supervision/__init__.py +++ b/supervision/__init__.py @@ -6,14 +6,20 @@ except importlib_metadata.PackageNotFoundError: __version__ = "development" - +from supervision.annotators.core import ( + BoundingBoxAnnotator, + BoxCornerAnnotator, + EllipseAnnotator, + LabelAnnotator, + MaskAnnotator, +) from supervision.classification.core import Classifications from supervision.dataset.core import ( BaseDataset, ClassificationDataset, DetectionDataset, ) -from supervision.detection.annotate import BoxAnnotator, MaskAnnotator, TraceAnnotator +from supervision.detection.annotate import BoxAnnotator, TraceAnnotator from supervision.detection.core import Detections from supervision.detection.line_counter import LineZone, LineZoneAnnotator from supervision.detection.tools.inference_slicer import InferenceSlicer diff --git a/supervision/annotators/__init__.py b/supervision/annotators/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/supervision/annotators/base.py b/supervision/annotators/base.py new file mode 100644 index 000000000..d9a6e29ac --- /dev/null +++ b/supervision/annotators/base.py @@ -0,0 +1,58 @@ +from abc import ABC, abstractmethod +from enum import Enum +from typing import Union + +import numpy as np + +from supervision.detection.core import Detections +from supervision.draw.color import Color, ColorPalette + + +class ColorMap(Enum): + """ + Enum for annotator color mapping. + """ + + INDEX = "index" + CLASS = "class" + TRACK = "track" + + +def resolve_color_idx( + detections: Detections, detection_idx: int, color_map: ColorMap = ColorMap.CLASS +) -> int: + if detection_idx >= len(detections): + raise ValueError( + f"Detection index {detection_idx}" + f"is out of bounds for detections of length {len(detections)}" + ) + + if color_map == ColorMap.INDEX: + return detection_idx + elif color_map == ColorMap.CLASS: + if detections.class_id is None: + raise ValueError( + "Could not resolve color by class because" + "Detections do not have class_id" + ) + return detections.class_id[detection_idx] + elif color_map == ColorMap.TRACK: + if detections.tracker_id is None: + raise ValueError( + "Could not resolve color by track because" + "Detections do not have tracker_id" + ) + return detections.tracker_id[detection_idx] + + +def resolve_color(color: Union[Color, ColorPalette], idx: int) -> Color: + if isinstance(color, ColorPalette): + return color.by_idx(idx) + else: + return color + + +class BaseAnnotator(ABC): + @abstractmethod + def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: + pass diff --git a/supervision/annotators/core.py b/supervision/annotators/core.py new file mode 100644 index 000000000..481a17b73 --- /dev/null +++ b/supervision/annotators/core.py @@ -0,0 +1,478 @@ +from typing import List, Tuple, Union + +import cv2 +import numpy as np + +from supervision.annotators.base import ( + BaseAnnotator, + ColorMap, + resolve_color, + resolve_color_idx, +) +from supervision.detection.core import Detections +from supervision.draw.color import Color, ColorPalette +from supervision.geometry.core import Position + + +class BoundingBoxAnnotator(BaseAnnotator): + """ + A class for drawing bounding boxes on an image using provided detections. + """ + + def __init__( + self, + color: Union[Color, ColorPalette] = ColorPalette.default(), + thickness: int = 2, + color_map: str = "class", + ): + """ + Args: + color (Union[Color, ColorPalette]): The color or color palette to use for + annotating detections. + thickness (int): Thickness of the bounding box lines. + color_map (str): Strategy for mapping colors to annotations. + Options are `index`, `class`, or `track`. + """ + self.color: Union[Color, ColorPalette] = color + self.thickness: int = thickness + self.color_map: ColorMap = ColorMap(color_map) + + def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: + """ + Annotates the given scene with bounding boxes based on the provided detections. + + Args: + scene (np.ndarray): The image where bounding boxes will be drawn. + detections (Detections): Object detections to annotate. + + Returns: + np.ndarray: The annotated image. + + Example: + ```python + >>> import supervision as sv + + >>> image = ... + >>> detections = sv.Detections(...) + + >>> bounding_box_annotator = sv.BoundingBoxAnnotator() + >>> annotated_frame = bounding_box_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + ``` + + ![bounding-box-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/bounding-box-annotator-example.png) + """ + for detection_idx in range(len(detections)): + x1, y1, x2, y2 = detections.xyxy[detection_idx].astype(int) + idx = resolve_color_idx( + detections=detections, + detection_idx=detection_idx, + color_map=self.color_map, + ) + color = resolve_color(color=self.color, idx=idx) + cv2.rectangle( + img=scene, + pt1=(x1, y1), + pt2=(x2, y2), + color=color.as_bgr(), + thickness=self.thickness, + ) + return scene + + +class MaskAnnotator(BaseAnnotator): + """ + A class for drawing masks on an image using provided detections. + """ + + def __init__( + self, + color: Union[Color, ColorPalette] = ColorPalette.default(), + opacity: float = 0.5, + color_map: str = "class", + ): + """ + Args: + color (Union[Color, ColorPalette]): The color or color palette to use for + annotating detections. + opacity (float): Opacity of the overlay mask. Must be between `0` and `1`. + color_map (str): Strategy for mapping colors to annotations. + Options are `index`, `class`, or `track`. + """ + self.color: Union[Color, ColorPalette] = color + self.opacity = opacity + self.color_map: ColorMap = ColorMap(color_map) + + def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: + """ + Annotates the given scene with masks based on the provided detections. + + Args: + scene (np.ndarray): The image where masks will be drawn. + detections (Detections): Object detections to annotate. + + Returns: + np.ndarray: The annotated image. + + Example: + ```python + >>> import supervision as sv + + >>> image = ... + >>> detections = sv.Detections(...) + + >>> mask_annotator = sv.MaskAnnotator() + >>> annotated_frame = mask_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + ``` + + ![mask-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/mask-annotator-example.png) + """ + if detections.mask is None: + return scene + + for detection_idx in np.flip(np.argsort(detections.area)): + idx = resolve_color_idx( + detections=detections, + detection_idx=detection_idx, + color_map=self.color_map, + ) + color = resolve_color(color=self.color, idx=idx) + mask = detections.mask[detection_idx] + colored_mask = np.zeros_like(scene, dtype=np.uint8) + colored_mask[:] = color.as_bgr() + + scene = np.where( + np.expand_dims(mask, axis=-1), + np.uint8(self.opacity * colored_mask + (1 - self.opacity) * scene), + scene, + ) + return scene + + +class EllipseAnnotator(BaseAnnotator): + """ + A class for drawing ellipses on an image using provided detections. + """ + + def __init__( + self, + color: Union[Color, ColorPalette] = ColorPalette.default(), + thickness: int = 2, + start_angle: int = -45, + end_angle: int = 235, + color_map: str = "class", + ): + """ + Args: + color (Union[Color, ColorPalette]): The color or color palette to use for + annotating detections. + thickness (int): Thickness of the ellipse lines. + start_angle (int): Starting angle of the ellipse. + end_angle (int): Ending angle of the ellipse. + color_map (str): Strategy for mapping colors to annotations. + Options are `index`, `class`, or `track`. + """ + self.color: Union[Color, ColorPalette] = color + self.thickness: int = thickness + self.start_angle: int = start_angle + self.end_angle: int = end_angle + self.color_map: ColorMap = ColorMap(color_map) + + def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: + """ + Annotates the given scene with ellipses based on the provided detections. + + Args: + scene (np.ndarray): The image where ellipses will be drawn. + detections (Detections): Object detections to annotate. + + Returns: + np.ndarray: The annotated image. + + Example: + ```python + >>> import supervision as sv + + >>> image = ... + >>> detections = sv.Detections(...) + + >>> ellipse_annotator = sv.EllipseAnnotator() + >>> annotated_frame = ellipse_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + ``` + + ![ellipse-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/ellipse-annotator-example.png) + """ + for detection_idx in range(len(detections)): + x1, y1, x2, y2 = detections.xyxy[detection_idx].astype(int) + idx = resolve_color_idx( + detections=detections, + detection_idx=detection_idx, + color_map=self.color_map, + ) + color = resolve_color(color=self.color, idx=idx) + + center = (int((x1 + x2) / 2), y2) + width = x2 - x1 + cv2.ellipse( + scene, + center=center, + axes=(int(width), int(0.35 * width)), + angle=0.0, + startAngle=self.start_angle, + endAngle=self.end_angle, + color=color.as_bgr(), + thickness=self.thickness, + lineType=cv2.LINE_4, + ) + return scene + + +class BoxCornerAnnotator(BaseAnnotator): + """ + A class for drawing box corners on an image using provided detections. + """ + + def __init__( + self, + color: Union[Color, ColorPalette] = ColorPalette.default(), + thickness: int = 4, + corner_length: int = 25, + color_map: str = "class", + ): + """ + Args: + color (Union[Color, ColorPalette]): The color or color palette to use for + annotating detections. + thickness (int): Thickness of the corner lines. + corner_length (int): Length of each corner line. + color_map (str): Strategy for mapping colors to annotations. + Options are `index`, `class`, or `track`. + """ + self.color: Union[Color, ColorPalette] = color + self.thickness: int = thickness + self.corner_length: int = corner_length + self.color_map: ColorMap = ColorMap(color_map) + + def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: + """ + Annotates the given scene with box corners based on the provided detections. + + Args: + scene (np.ndarray): The image where box corners will be drawn. + detections (Detections): Object detections to annotate. + + Returns: + np.ndarray: The annotated image. + + Example: + ```python + >>> import supervision as sv + + >>> image = ... + >>> detections = sv.Detections(...) + + >>> corner_annotator = sv.BoxCornerAnnotator() + >>> annotated_frame = corner_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + ``` + + ![box-corner-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/box-corner-annotator-example.png) + """ + for detection_idx in range(len(detections)): + x1, y1, x2, y2 = detections.xyxy[detection_idx].astype(int) + idx = resolve_color_idx( + detections=detections, + detection_idx=detection_idx, + color_map=self.color_map, + ) + color = resolve_color(color=self.color, idx=idx) + corners = [(x1, y1), (x2, y1), (x1, y2), (x2, y2)] + + for x, y in corners: + x_end = x + self.corner_length if x == x1 else x - self.corner_length + cv2.line( + scene, (x, y), (x_end, y), color.as_bgr(), thickness=self.thickness + ) + + y_end = y + self.corner_length if y == y1 else y - self.corner_length + cv2.line( + scene, (x, y), (x, y_end), color.as_bgr(), thickness=self.thickness + ) + return scene + + +class LabelAnnotator: + """ + A class for annotating labels on an image using provided detections. + """ + + def __init__( + self, + color: Union[Color, ColorPalette] = ColorPalette.default(), + text_color: Color = Color.black(), + text_scale: float = 0.5, + text_thickness: int = 1, + text_padding: int = 10, + text_position: Position = Position.TOP_LEFT, + color_map: str = "class", + ): + """ + Args: + color (Union[Color, ColorPalette]): The color or color palette to use for + annotating the text background. + text_color (Color): The color to use for the text. + text_scale (float): Font scale for the text. + text_thickness (int): Thickness of the text characters. + text_padding (int): Padding around the text within its background box. + text_position (Position): Position of the text relative to the detection. + Possible values are defined in the `Position` enum. + color_map (str): Strategy for mapping colors to annotations. + Options are `index`, `class`, or `track`. + """ + self.color: Union[Color, ColorPalette] = color + self.text_color: Color = text_color + self.text_scale: float = text_scale + self.text_thickness: int = text_thickness + self.text_padding: int = text_padding + self.text_position: Position = text_position + self.color_map: ColorMap = ColorMap(color_map) + + @staticmethod + def resolve_text_background_xyxy( + detection_xyxy: Tuple[int, int, int, int], + text_wh: Tuple[int, int], + text_padding: int, + position: Position, + ) -> Tuple[int, int, int, int]: + padded_text_wh = (text_wh[0] + 2 * text_padding, text_wh[1] + 2 * text_padding) + x1, y1, x2, y2 = detection_xyxy + center_x = (x1 + x2) // 2 + center_y = (y1 + y2) // 2 + + if position == Position.TOP_LEFT: + return x1, y1 - padded_text_wh[1], x1 + padded_text_wh[0], y1 + elif position == Position.TOP_RIGHT: + return x2 - padded_text_wh[0], y1 - padded_text_wh[1], x2, y1 + elif position == Position.TOP_CENTER: + return ( + center_x - padded_text_wh[0] // 2, + y1 - padded_text_wh[1], + center_x + padded_text_wh[0] // 2, + y1, + ) + elif position == Position.CENTER: + return ( + center_x - padded_text_wh[0] // 2, + center_y - padded_text_wh[1] // 2, + center_x + padded_text_wh[0] // 2, + center_y + padded_text_wh[1] // 2, + ) + elif position == Position.BOTTOM_LEFT: + return x1, y2, x1 + padded_text_wh[0], y2 + padded_text_wh[1] + elif position == Position.BOTTOM_RIGHT: + return x2 - padded_text_wh[0], y2, x2, y2 + padded_text_wh[1] + elif position == Position.BOTTOM_CENTER: + return ( + center_x - padded_text_wh[0] // 2, + y2, + center_x + padded_text_wh[0] // 2, + y2 + padded_text_wh[1], + ) + + def annotate( + self, + scene: np.ndarray, + detections: Detections, + labels: List[str] = None, + ) -> np.ndarray: + """ + Annotates the given scene with labels based on the provided detections. + + Args: + scene (np.ndarray): The image where labels will be drawn. + detections (Detections): Object detections to annotate. + labels (List[str]): Optional. Custom labels for each detection. + + Returns: + np.ndarray: The annotated image. + + Example: + ```python + >>> import supervision as sv + + >>> image = ... + >>> detections = sv.Detections(...) + + >>> label_annotator = sv.LabelAnnotator(text_position=sv.Position.CENTER) + >>> annotated_frame = label_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + ``` + + ![label-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/label-annotator-example-2.png) + """ + font = cv2.FONT_HERSHEY_SIMPLEX + for detection_idx in range(len(detections)): + detection_xyxy = detections.xyxy[detection_idx].astype(int) + idx = resolve_color_idx( + detections=detections, + detection_idx=detection_idx, + color_map=self.color_map, + ) + color = resolve_color(color=self.color, idx=idx) + text = ( + f"{detections.class_id[detection_idx]}" + if (labels is None or len(detections) != len(labels)) + else labels[detection_idx] + ) + text_wh = cv2.getTextSize( + text=text, + fontFace=font, + fontScale=self.text_scale, + thickness=self.text_thickness, + )[0] + + text_background_xyxy = self.resolve_text_background_xyxy( + detection_xyxy=detection_xyxy, + text_wh=text_wh, + text_padding=self.text_padding, + position=self.text_position, + ) + + text_x = text_background_xyxy[0] + self.text_padding + text_y = text_background_xyxy[1] + self.text_padding + text_wh[1] + + cv2.rectangle( + img=scene, + pt1=(text_background_xyxy[0], text_background_xyxy[1]), + pt2=(text_background_xyxy[2], text_background_xyxy[3]), + color=color.as_bgr(), + thickness=cv2.FILLED, + ) + cv2.putText( + img=scene, + text=text, + org=(text_x, text_y), + fontFace=font, + fontScale=self.text_scale, + color=self.text_color.as_rgb(), + thickness=self.text_thickness, + lineType=cv2.LINE_AA, + ) + return scene diff --git a/supervision/detection/annotate.py b/supervision/detection/annotate.py index c84ca826c..83b6e0f89 100644 --- a/supervision/detection/annotate.py +++ b/supervision/detection/annotate.py @@ -147,64 +147,6 @@ def annotate( return scene -class MaskAnnotator: - """ - A class for overlaying masks on an image using detections provided. - - Attributes: - color (Union[Color, ColorPalette]): The color to fill the mask, - can be a single color or a color palette - """ - - def __init__( - self, - color: Union[Color, ColorPalette] = ColorPalette.default(), - ): - self.color: Union[Color, ColorPalette] = color - - def annotate( - self, scene: np.ndarray, detections: Detections, opacity: float = 0.5 - ) -> np.ndarray: - """ - Overlays the masks on the given image based on the provided detections, - with a specified opacity. - - Args: - scene (np.ndarray): The image on which the masks will be overlaid - detections (Detections): The detections for which the - masks will be overlaid - opacity (float): The opacity of the masks, between 0 and 1, default is 0.5 - - Returns: - np.ndarray: The image with the masks overlaid - """ - if detections.mask is None: - return scene - - for i in np.flip(np.argsort(detections.area)): - class_id = ( - detections.class_id[i] if detections.class_id is not None else None - ) - idx = class_id if class_id is not None else i - color = ( - self.color.by_idx(idx) - if isinstance(self.color, ColorPalette) - else self.color - ) - - mask = detections.mask[i] - colored_mask = np.zeros_like(scene, dtype=np.uint8) - colored_mask[:] = color.as_bgr() - - scene = np.where( - np.expand_dims(mask, axis=-1), - np.uint8(opacity * colored_mask + (1 - opacity) * scene), - scene, - ) - - return scene - - class Trace: def __init__( self, diff --git a/supervision/detection/core.py b/supervision/detection/core.py index a67eefbc5..f7f1bb5f7 100644 --- a/supervision/detection/core.py +++ b/supervision/detection/core.py @@ -644,15 +644,23 @@ def __all_not_none(item_list: List[Any]): def get_anchor_coordinates(self, anchor: Position) -> np.ndarray: """ - Returns the bounding box coordinates for a specific anchor. + Calculates and returns the coordinates of a specific anchor point + within the bounding boxes defined by the `xyxy` attribute. The anchor + point can be any of the predefined positions in the `Position` enum, + such as `CENTER`, `CENTER_LEFT`, `BOTTOM_RIGHT`, etc. Args: - anchor (Position): Position of bounding box anchor - for which to return the coordinates. + anchor (Position): An enum specifying the position of the anchor point + within the bounding box. Supported positions are defined in the + `Position` enum. Returns: - np.ndarray: An array of shape `(n, 2)` containing the bounding - box anchor coordinates in format `[x, y]`. + np.ndarray: An array of shape `(n, 2)`, where `n` is the number of bounding + boxes. Each row contains the `[x, y]` coordinates of the specified + anchor point for the corresponding bounding box. + + Raises: + ValueError: If the provided `anchor` is not supported. """ if anchor == Position.CENTER: return np.array( @@ -661,10 +669,36 @@ def get_anchor_coordinates(self, anchor: Position) -> np.ndarray: (self.xyxy[:, 1] + self.xyxy[:, 3]) / 2, ] ).transpose() + elif anchor == Position.CENTER_LEFT: + return np.array( + [ + self.xyxy[:, 0], + (self.xyxy[:, 1] + self.xyxy[:, 3]) / 2, + ] + ).transpose() + elif anchor == Position.CENTER_RIGHT: + return np.array( + [ + self.xyxy[:, 2], + (self.xyxy[:, 1] + self.xyxy[:, 3]) / 2, + ] + ).transpose() elif anchor == Position.BOTTOM_CENTER: return np.array( [(self.xyxy[:, 0] + self.xyxy[:, 2]) / 2, self.xyxy[:, 3]] ).transpose() + elif anchor == Position.BOTTOM_LEFT: + return np.array([self.xyxy[:, 0], self.xyxy[:, 3]]).transpose() + elif anchor == Position.BOTTOM_RIGHT: + return np.array([self.xyxy[:, 2], self.xyxy[:, 3]]).transpose() + elif anchor == Position.TOP_CENTER: + return np.array( + [(self.xyxy[:, 0] + self.xyxy[:, 2]) / 2, self.xyxy[:, 1]] + ).transpose() + elif anchor == Position.TOP_LEFT: + return np.array([self.xyxy[:, 0], self.xyxy[:, 1]]).transpose() + elif anchor == Position.TOP_RIGHT: + return np.array([self.xyxy[:, 2], self.xyxy[:, 1]]).transpose() raise ValueError(f"{anchor} is not supported.") diff --git a/supervision/geometry/core.py b/supervision/geometry/core.py index fc352f558..1771a356d 100644 --- a/supervision/geometry/core.py +++ b/supervision/geometry/core.py @@ -6,8 +6,19 @@ class Position(Enum): + """ + Enum representing the position of an anchor point. + """ + CENTER = "CENTER" + CENTER_LEFT = "CENTER_LEFT" + CENTER_RIGHT = "CENTER_RIGHT" + TOP_CENTER = "TOP_CENTER" + TOP_LEFT = "TOP_LEFT" + TOP_RIGHT = "TOP_RIGHT" + BOTTOM_LEFT = "BOTTOM_LEFT" BOTTOM_CENTER = "BOTTOM_CENTER" + BOTTOM_RIGHT = "BOTTOM_RIGHT" @classmethod def list(cls):

diff --git a/test/annotators/__init__.py b/test/annotators/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/test/annotators/test_base.py b/test/annotators/test_base.py new file mode 100644 index 000000000..73d5a147d --- /dev/null +++ b/test/annotators/test_base.py @@ -0,0 +1,94 @@ +from contextlib import ExitStack as DoesNotRaise +from test.utils import mock_detections +from typing import Optional + +import pytest + +from supervision.annotators.core import ColorMap, resolve_color_idx +from supervision.detection.core import Detections + + +@pytest.mark.parametrize( + "detections, detection_idx, color_map, expected_result, exception", + [ + ( + mock_detections( + xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]], + class_id=[5, 3], + tracker_id=[2, 6], + ), + 0, + ColorMap.INDEX, + 0, + DoesNotRaise(), + ), # multiple detections; index mapping + ( + mock_detections( + xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]], + class_id=[5, 3], + tracker_id=[2, 6], + ), + 0, + ColorMap.CLASS, + 5, + DoesNotRaise(), + ), # multiple detections; class mapping + ( + mock_detections( + xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]], + class_id=[5, 3], + tracker_id=[2, 6], + ), + 0, + ColorMap.TRACK, + 2, + DoesNotRaise(), + ), # multiple detections; track mapping + ( + Detections.empty(), + 0, + ColorMap.INDEX, + None, + pytest.raises(ValueError), + ), # no detections; index mapping; out of bounds + ( + mock_detections( + xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]], + class_id=[5, 3], + tracker_id=[2, 6], + ), + 2, + ColorMap.INDEX, + None, + pytest.raises(ValueError), + ), # multiple detections; index mapping; out of bounds + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + 0, + ColorMap.CLASS, + None, + pytest.raises(ValueError), + ), # multiple detections; class mapping; no class_id + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + 0, + ColorMap.TRACK, + None, + pytest.raises(ValueError), + ), # multiple detections; class mapping; no track_id + ], +) +def test_resolve_color_idx( + detections: Detections, + detection_idx: int, + color_map: ColorMap, + expected_result: Optional[int], + exception: Exception, +) -> None: + with exception: + result = resolve_color_idx( + detections=detections, + detection_idx=detection_idx, + color_map=color_map, + ) + assert result == expected_result diff --git a/test/detection/test_core.py b/test/detection/test_core.py index aaa1f236e..02595d973 100644 --- a/test/detection/test_core.py +++ b/test/detection/test_core.py @@ -5,7 +5,8 @@ import numpy as np import pytest -from supervision import Detections +from supervision.detection.core import Detections +from supervision.geometry.core import Position PREDICTIONS = np.array( [ @@ -190,3 +191,85 @@ def test_merge( with exception: result = Detections.merge(detections_list=detections_list) assert result == expected_result + + +@pytest.mark.parametrize( + "detections, anchor, expected_result, exception", + [ + ( + Detections.empty(), + Position.CENTER, + np.empty((0, 2), dtype=np.float32), + DoesNotRaise(), + ), # empty detections + ( + mock_detections(xyxy=[[10, 10, 20, 20]]), + Position.CENTER, + np.array([[15, 15]], dtype=np.float32), + DoesNotRaise(), + ), # single detection; center anchor + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + Position.CENTER, + np.array([[15, 15], [25, 25]], dtype=np.float32), + DoesNotRaise(), + ), # two detections; center anchor + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + Position.CENTER_LEFT, + np.array([[10, 15], [20, 25]], dtype=np.float32), + DoesNotRaise(), + ), # two detections; center left anchor + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + Position.CENTER_RIGHT, + np.array([[20, 15], [30, 25]], dtype=np.float32), + DoesNotRaise(), + ), # two detections; center right anchor + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + Position.TOP_CENTER, + np.array([[15, 10], [25, 20]], dtype=np.float32), + DoesNotRaise(), + ), # two detections; top center anchor + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + Position.TOP_LEFT, + np.array([[10, 10], [20, 20]], dtype=np.float32), + DoesNotRaise(), + ), # two detections; top left anchor + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + Position.TOP_RIGHT, + np.array([[20, 10], [30, 20]], dtype=np.float32), + DoesNotRaise(), + ), # two detections; top right anchor + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + Position.BOTTOM_CENTER, + np.array([[15, 20], [25, 30]], dtype=np.float32), + DoesNotRaise(), + ), # two detections; bottom center anchor + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + Position.BOTTOM_LEFT, + np.array([[10, 20], [20, 30]], dtype=np.float32), + DoesNotRaise(), + ), # two detections; bottom left anchor + ( + mock_detections(xyxy=[[10, 10, 20, 20], [20, 20, 30, 30]]), + Position.BOTTOM_RIGHT, + np.array([[20, 20], [30, 30]], dtype=np.float32), + DoesNotRaise(), + ), # two detections; bottom right anchor + ], +) +def test_get_anchor_coordinates( + detections: Detections, + anchor: Position, + expected_result: np.ndarray, + exception: Exception, +) -> None: + result = detections.get_anchor_coordinates(anchor) + with exception: + assert np.array_equal(result, expected_result)

diff --git a/docs/detection/annotate.md b/docs/detection/annotate.md index d37f14823..cc0be9fc1 100644 --- a/docs/detection/annotate.md +++ b/docs/detection/annotate.md @@ -1,11 +1,19 @@ -## BoxAnnotator +## BoundingBoxAnnotator -:::supervision.detection.annotate.BoxAnnotator +:::supervision.annotators.core.BoundingBoxAnnotator ## MaskAnnotator -:::supervision.detection.annotate.MaskAnnotator +:::supervision.annotators.core.MaskAnnotator -## TraceAnnotator +## EllipseAnnotator -:::supervision.detection.annotate.TraceAnnotator +:::supervision.annotators.core.EllipseAnnotator + +## BoxCornerAnnotator + +:::supervision.annotators.core.BoxCornerAnnotator + +## LabelAnnotator + +:::supervision.annotators.core.LabelAnnotator diff --git a/docs/geometry/core.md b/docs/geometry/core.md new file mode 100644 index 000000000..978ad2cf6 --- /dev/null +++ b/docs/geometry/core.md @@ -0,0 +1,3 @@ +## Position + +:::supervision.geometry.core.Position diff --git a/examples/traffic_analysis/requirements.txt b/examples/traffic_analysis/requirements.txt index 3103d0056..c793f725e 100644 --- a/examples/traffic_analysis/requirements.txt +++ b/examples/traffic_analysis/requirements.txt @@ -1,4 +1,4 @@ -supervision==0.15.0rc1 +supervision>=0.15.0rc1 tqdm ultralytics gdown

[ { "components": [ { "doc": "Enum for annotator color mapping.", "lines": [ 11, 18 ], "name": "ColorMap", "signature": "class ColorMap(Enum):", "type": "class" }, { "doc": "", "lines": [ 21, ...

[ "test/annotators/test_base.py::test_resolve_color_idx[detections0-0-ColorMap.INDEX-0-exception0]", "test/annotators/test_base.py::test_resolve_color_idx[detections1-0-ColorMap.CLASS-5-exception1]", "test/annotators/test_base.py::test_resolve_color_idx[detections2-0-ColorMap.TRACK-2-exception2]", "test/annotat...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> redesigned annotators This PR expands our range of Annotators and makes them more reusable. ![bounding-box-annotator-example](https://github.com/roboflow/supervision/assets/26109316/ba6943f8-3744-4dd7-898f-68a0fd570d5c) ![box-corner-annotator-example](https://github.com/roboflow/supervision/assets/26109316/f2f0e441-761b-42de-9b1f-64e45d21c594) ![ellipse-annotator-example](https://github.com/roboflow/supervision/assets/26109316/85bfcc10-5af9-45ab-b63e-e2e82dd93aa4) ![label-annotator-example-2](https://github.com/roboflow/supervision/assets/26109316/bc57a81d-87e8-4d22-91c8-dca9e6af8f7b) ![mask-annotator-example](https://github.com/roboflow/supervision/assets/26109316/30367bb4-c6ff-4319-b987-8357a6e27457) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in supervision/annotators/base.py] (definition of ColorMap:) class ColorMap(Enum): """Enum for annotator color mapping.""" (definition of resolve_color_idx:) def resolve_color_idx( detections: Detections, detection_idx: int, color_map: ColorMap = ColorMap.CLASS ) -> int: (definition of resolve_color:) def resolve_color(color: Union[Color, ColorPalette], idx: int) -> Color: (definition of BaseAnnotator:) class BaseAnnotator(ABC): @abstractmethod (definition of BaseAnnotator.annotate:) def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: [end of new definitions in supervision/annotators/base.py] [start of new definitions in supervision/annotators/core.py] (definition of BoundingBoxAnnotator:) class BoundingBoxAnnotator(BaseAnnotator): """A class for drawing bounding boxes on an image using provided detections.""" (definition of BoundingBoxAnnotator.__init__:) def __init__( self, color: Union[Color, ColorPalette] = ColorPalette.default(), thickness: int = 2, color_map: str = "class", ): """Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating detections. thickness (int): Thickness of the bounding box lines. color_map (str): Strategy for mapping colors to annotations. Options are `index`, `class`, or `track`.""" (definition of BoundingBoxAnnotator.annotate:) def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: """Annotates the given scene with bounding boxes based on the provided detections. Args: scene (np.ndarray): The image where bounding boxes will be drawn. detections (Detections): Object detections to annotate. Returns: np.ndarray: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> bounding_box_annotator = sv.BoundingBoxAnnotator() >>> annotated_frame = bounding_box_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![bounding-box-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/bounding-box-annotator-example.png)""" (definition of MaskAnnotator:) class MaskAnnotator(BaseAnnotator): """A class for drawing masks on an image using provided detections.""" (definition of MaskAnnotator.__init__:) def __init__( self, color: Union[Color, ColorPalette] = ColorPalette.default(), opacity: float = 0.5, color_map: str = "class", ): """Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating detections. opacity (float): Opacity of the overlay mask. Must be between `0` and `1`. color_map (str): Strategy for mapping colors to annotations. Options are `index`, `class`, or `track`.""" (definition of MaskAnnotator.annotate:) def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: """Annotates the given scene with masks based on the provided detections. Args: scene (np.ndarray): The image where masks will be drawn. detections (Detections): Object detections to annotate. Returns: np.ndarray: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> mask_annotator = sv.MaskAnnotator() >>> annotated_frame = mask_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![mask-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/mask-annotator-example.png)""" (definition of EllipseAnnotator:) class EllipseAnnotator(BaseAnnotator): """A class for drawing ellipses on an image using provided detections.""" (definition of EllipseAnnotator.__init__:) def __init__( self, color: Union[Color, ColorPalette] = ColorPalette.default(), thickness: int = 2, start_angle: int = -45, end_angle: int = 235, color_map: str = "class", ): """Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating detections. thickness (int): Thickness of the ellipse lines. start_angle (int): Starting angle of the ellipse. end_angle (int): Ending angle of the ellipse. color_map (str): Strategy for mapping colors to annotations. Options are `index`, `class`, or `track`.""" (definition of EllipseAnnotator.annotate:) def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: """Annotates the given scene with ellipses based on the provided detections. Args: scene (np.ndarray): The image where ellipses will be drawn. detections (Detections): Object detections to annotate. Returns: np.ndarray: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> ellipse_annotator = sv.EllipseAnnotator() >>> annotated_frame = ellipse_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![ellipse-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/ellipse-annotator-example.png)""" (definition of BoxCornerAnnotator:) class BoxCornerAnnotator(BaseAnnotator): """A class for drawing box corners on an image using provided detections.""" (definition of BoxCornerAnnotator.__init__:) def __init__( self, color: Union[Color, ColorPalette] = ColorPalette.default(), thickness: int = 4, corner_length: int = 25, color_map: str = "class", ): """Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating detections. thickness (int): Thickness of the corner lines. corner_length (int): Length of each corner line. color_map (str): Strategy for mapping colors to annotations. Options are `index`, `class`, or `track`.""" (definition of BoxCornerAnnotator.annotate:) def annotate(self, scene: np.ndarray, detections: Detections) -> np.ndarray: """Annotates the given scene with box corners based on the provided detections. Args: scene (np.ndarray): The image where box corners will be drawn. detections (Detections): Object detections to annotate. Returns: np.ndarray: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> corner_annotator = sv.BoxCornerAnnotator() >>> annotated_frame = corner_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![box-corner-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/box-corner-annotator-example.png)""" (definition of LabelAnnotator:) class LabelAnnotator: """A class for annotating labels on an image using provided detections.""" (definition of LabelAnnotator.__init__:) def __init__( self, color: Union[Color, ColorPalette] = ColorPalette.default(), text_color: Color = Color.black(), text_scale: float = 0.5, text_thickness: int = 1, text_padding: int = 10, text_position: Position = Position.TOP_LEFT, color_map: str = "class", ): """Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating the text background. text_color (Color): The color to use for the text. text_scale (float): Font scale for the text. text_thickness (int): Thickness of the text characters. text_padding (int): Padding around the text within its background box. text_position (Position): Position of the text relative to the detection. Possible values are defined in the `Position` enum. color_map (str): Strategy for mapping colors to annotations. Options are `index`, `class`, or `track`.""" (definition of LabelAnnotator.resolve_text_background_xyxy:) def resolve_text_background_xyxy( detection_xyxy: Tuple[int, int, int, int], text_wh: Tuple[int, int], text_padding: int, position: Position, ) -> Tuple[int, int, int, int]: (definition of LabelAnnotator.annotate:) def annotate( self, scene: np.ndarray, detections: Detections, labels: List[str] = None, ) -> np.ndarray: """Annotates the given scene with labels based on the provided detections. Args: scene (np.ndarray): The image where labels will be drawn. detections (Detections): Object detections to annotate. labels (List[str]): Optional. Custom labels for each detection. Returns: np.ndarray: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> label_annotator = sv.LabelAnnotator(text_position=sv.Position.CENTER) >>> annotated_frame = label_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![label-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/label-annotator-example-2.png)""" [end of new definitions in supervision/annotators/core.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

3eb5c0b024e3e46877b7fe4fd66e6177d1308ba0

scikit-learn__scikit-learn-26734

26,734

scikit-learn/scikit-learn

1.4

1fbf5fb317034e604d7ae71f368cd9e5b236ec0c

2023-06-29T21:37:42Z

diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 7f6f5c910a3fc..f4ae4ffbf8911 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -995,6 +995,8 @@ details. metrics.median_absolute_error metrics.mean_absolute_percentage_error metrics.r2_score + metrics.root_mean_squared_log_error + metrics.root_mean_squared_error metrics.mean_poisson_deviance metrics.mean_gamma_deviance metrics.mean_tweedie_deviance diff --git a/doc/modules/model_evaluation.rst b/doc/modules/model_evaluation.rst index c989f49c0fc7d..eac1cde567595 100644 --- a/doc/modules/model_evaluation.rst +++ b/doc/modules/model_evaluation.rst @@ -94,8 +94,9 @@ Scoring Function 'max_error' :func:`metrics.max_error` 'neg_mean_absolute_error' :func:`metrics.mean_absolute_error` 'neg_mean_squared_error' :func:`metrics.mean_squared_error` -'neg_root_mean_squared_error' :func:`metrics.mean_squared_error` +'neg_root_mean_squared_error' :func:`metrics.root_mean_squared_error` 'neg_mean_squared_log_error' :func:`metrics.mean_squared_log_error` +'neg_root_mean_squared_log_error' :func:`metrics.root_mean_squared_log_error` 'neg_median_absolute_error' :func:`metrics.median_absolute_error` 'r2' :func:`metrics.r2_score` 'neg_mean_poisson_deviance' :func:`metrics.mean_poisson_deviance` @@ -2310,6 +2311,10 @@ function:: for an example of mean squared error usage to evaluate gradient boosting regression. +Taking the square root of the MSE, called the root mean squared error (RMSE), is another +common metric that provides a measure in the same units as the target variable. RSME is +available through the :func:`root_mean_squared_error` function. + .. _mean_squared_log_error: Mean squared logarithmic error @@ -2347,6 +2352,9 @@ function:: >>> mean_squared_log_error(y_true, y_pred) 0.044... +The root mean squared logarithmic error (RMSLE) is available through the +:func:`root_mean_squared_log_error` function. + .. _mean_absolute_percentage_error: Mean absolute percentage error diff --git a/doc/whats_new/v1.4.rst b/doc/whats_new/v1.4.rst index 367315dc3c60d..8dbd867b0c9ba 100644 --- a/doc/whats_new/v1.4.rst +++ b/doc/whats_new/v1.4.rst @@ -238,6 +238,18 @@ Changelog - |Enhancement| :class:`preprocessing.TargetEncoder` now supports `target_type` 'multiclass'. :pr:`26674` by :user:`Lucy Liu <lucyleeow>`. +:mod:`sklearn.metrics` +...................... + +- |API| The `squared` parameter of :func:`metrics.mean_squared_error` and + :func:`metrics.mean_squared_log_error` is deprecated and will be removed in 1.6. + Use the new functions :func:`metrics.root_mean_squared_error` and + :func:`root_mean_squared_log_error` instead. + :pr:`26734` by :user:`Alejandro Martin Gil <101AlexMartin>`. + +- |Enhancement| Added `neg_root_mean_squared_log_error_scorer` as scorer + :pr:`26734` by :user:`Alejandro Martin Gil <101AlexMartin>`. + :mod:`sklearn.model_selection` .............................. diff --git a/sklearn/metrics/__init__.py b/sklearn/metrics/__init__.py index 488c776ae9a86..713c5fe651dbb 100644 --- a/sklearn/metrics/__init__.py +++ b/sklearn/metrics/__init__.py @@ -62,6 +62,8 @@ mean_tweedie_deviance, median_absolute_error, r2_score, + root_mean_squared_error, + root_mean_squared_log_error, ) from ._scorer import check_scoring, get_scorer, get_scorer_names, make_scorer from .cluster import ( @@ -166,6 +168,8 @@ "RocCurveDisplay", "roc_auc_score", "roc_curve", + "root_mean_squared_log_error", + "root_mean_squared_error", "get_scorer_names", "silhouette_samples", "silhouette_score", diff --git a/sklearn/metrics/_regression.py b/sklearn/metrics/_regression.py index a6dfacf30d3e1..77a93f4c17513 100644 --- a/sklearn/metrics/_regression.py +++ b/sklearn/metrics/_regression.py @@ -24,6 +24,7 @@ # Uttam kumar <bajiraouttamsinha@gmail.com> # Sylvain Marie <sylvain.marie@se.com> # Ohad Michel <ohadmich@gmail.com> +# Alejandro Martin Gil <almagil98@gmail.com> # License: BSD 3 clause import warnings @@ -33,7 +34,7 @@ from scipy.special import xlogy from ..exceptions import UndefinedMetricWarning -from ..utils._param_validation import Interval, StrOptions, validate_params +from ..utils._param_validation import Hidden, Interval, StrOptions, validate_params from ..utils.stats import _weighted_percentile from ..utils.validation import ( _check_sample_weight, @@ -52,6 +53,8 @@ "mean_absolute_percentage_error", "mean_pinball_loss", "r2_score", + "root_mean_squared_log_error", + "root_mean_squared_error", "explained_variance_score", "mean_tweedie_deviance", "mean_poisson_deviance", @@ -407,12 +410,17 @@ def mean_absolute_percentage_error( "y_pred": ["array-like"], "sample_weight": ["array-like", None], "multioutput": [StrOptions({"raw_values", "uniform_average"}), "array-like"], - "squared": ["boolean"], + "squared": [Hidden(StrOptions({"deprecated"})), "boolean"], }, prefer_skip_nested_validation=True, ) def mean_squared_error( - y_true, y_pred, *, sample_weight=None, multioutput="uniform_average", squared=True + y_true, + y_pred, + *, + sample_weight=None, + multioutput="uniform_average", + squared="deprecated", ): """Mean squared error regression loss. @@ -443,6 +451,11 @@ def mean_squared_error( squared : bool, default=True If True returns MSE value, if False returns RMSE value. + .. deprecated:: 1.4 + `squared` is deprecated in 1.4 and will be removed in 1.6. + Use :func:`~sklearn.metrics.root_mean_squared_error` + instead to calculate the root mean squared error. + Returns ------- loss : float or ndarray of floats @@ -456,29 +469,110 @@ def mean_squared_error( >>> y_pred = [2.5, 0.0, 2, 8] >>> mean_squared_error(y_true, y_pred) 0.375 - >>> y_true = [3, -0.5, 2, 7] - >>> y_pred = [2.5, 0.0, 2, 8] - >>> mean_squared_error(y_true, y_pred, squared=False) - 0.612... >>> y_true = [[0.5, 1],[-1, 1],[7, -6]] >>> y_pred = [[0, 2],[-1, 2],[8, -5]] >>> mean_squared_error(y_true, y_pred) 0.708... - >>> mean_squared_error(y_true, y_pred, squared=False) - 0.822... >>> mean_squared_error(y_true, y_pred, multioutput='raw_values') array([0.41666667, 1. ]) >>> mean_squared_error(y_true, y_pred, multioutput=[0.3, 0.7]) 0.825... """ + # TODO(1.6): remove + if squared != "deprecated": + warnings.warn( + ( + "'squared' is deprecated in version 1.4 and " + "will be removed in 1.6. To calculate the " + "root mean squared error, use the function" + "'root_mean_squared_error'." + ), + FutureWarning, + ) + if not squared: + return root_mean_squared_error( + y_true, y_pred, sample_weight=sample_weight, multioutput=multioutput + ) + y_type, y_true, y_pred, multioutput = _check_reg_targets( y_true, y_pred, multioutput ) check_consistent_length(y_true, y_pred, sample_weight) output_errors = np.average((y_true - y_pred) ** 2, axis=0, weights=sample_weight) - if not squared: - output_errors = np.sqrt(output_errors) + if isinstance(multioutput, str): + if multioutput == "raw_values": + return output_errors + elif multioutput == "uniform_average": + # pass None as weights to np.average: uniform mean + multioutput = None + + return np.average(output_errors, weights=multioutput) + + +@validate_params( + { + "y_true": ["array-like"], + "y_pred": ["array-like"], + "sample_weight": ["array-like", None], + "multioutput": [StrOptions({"raw_values", "uniform_average"}), "array-like"], + }, + prefer_skip_nested_validation=True, +) +def root_mean_squared_error( + y_true, y_pred, *, sample_weight=None, multioutput="uniform_average" +): + """Root mean squared error regression loss. + + Read more in the :ref:`User Guide <mean_squared_error>`. + + .. versionadded:: 1.4 + + Parameters + ---------- + y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) + Ground truth (correct) target values. + + y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) + Estimated target values. + + sample_weight : array-like of shape (n_samples,), default=None + Sample weights. + + multioutput : {'raw_values', 'uniform_average'} or array-like of shape \ + (n_outputs,), default='uniform_average' + Defines aggregating of multiple output values. + Array-like value defines weights used to average errors. + + 'raw_values' : + Returns a full set of errors in case of multioutput input. + + 'uniform_average' : + Errors of all outputs are averaged with uniform weight. + + Returns + ------- + loss : float or ndarray of floats + A non-negative floating point value (the best value is 0.0), or an + array of floating point values, one for each individual target. + + Examples + -------- + >>> from sklearn.metrics import root_mean_squared_error + >>> y_true = [3, -0.5, 2, 7] + >>> y_pred = [2.5, 0.0, 2, 8] + >>> root_mean_squared_error(y_true, y_pred) + 0.612... + >>> y_true = [[0.5, 1],[-1, 1],[7, -6]] + >>> y_pred = [[0, 2],[-1, 2],[8, -5]] + >>> root_mean_squared_error(y_true, y_pred) + 0.822... + """ + output_errors = np.sqrt( + mean_squared_error( + y_true, y_pred, sample_weight=sample_weight, multioutput="raw_values" + ) + ) if isinstance(multioutput, str): if multioutput == "raw_values": @@ -496,12 +590,17 @@ def mean_squared_error( "y_pred": ["array-like"], "sample_weight": ["array-like", None], "multioutput": [StrOptions({"raw_values", "uniform_average"}), "array-like"], - "squared": ["boolean"], + "squared": [Hidden(StrOptions({"deprecated"})), "boolean"], }, prefer_skip_nested_validation=True, ) def mean_squared_log_error( - y_true, y_pred, *, sample_weight=None, multioutput="uniform_average", squared=True + y_true, + y_pred, + *, + sample_weight=None, + multioutput="uniform_average", + squared="deprecated", ): """Mean squared logarithmic error regression loss. @@ -530,10 +629,16 @@ def mean_squared_log_error( 'uniform_average' : Errors of all outputs are averaged with uniform weight. + squared : bool, default=True If True returns MSLE (mean squared log error) value. If False returns RMSLE (root mean squared log error) value. + .. deprecated:: 1.4 + `squared` is deprecated in 1.4 and will be removed in 1.6. + Use :func:`~sklearn.metrics.root_mean_squared_log_error` + instead to calculate the root mean squared logarithmic error. + Returns ------- loss : float or ndarray of floats @@ -547,8 +652,6 @@ def mean_squared_log_error( >>> y_pred = [2.5, 5, 4, 8] >>> mean_squared_log_error(y_true, y_pred) 0.039... - >>> mean_squared_log_error(y_true, y_pred, squared=False) - 0.199... >>> y_true = [[0.5, 1], [1, 2], [7, 6]] >>> y_pred = [[0.5, 2], [1, 2.5], [8, 8]] >>> mean_squared_log_error(y_true, y_pred) @@ -558,6 +661,22 @@ def mean_squared_log_error( >>> mean_squared_log_error(y_true, y_pred, multioutput=[0.3, 0.7]) 0.060... """ + # TODO(1.6): remove + if squared != "deprecated": + warnings.warn( + ( + "'squared' is deprecated in version 1.4 and " + "will be removed in 1.6. To calculate the " + "root mean squared logarithmic error, use the function" + "'root_mean_squared_log_error'." + ), + FutureWarning, + ) + if not squared: + return root_mean_squared_log_error( + y_true, y_pred, sample_weight=sample_weight, multioutput=multioutput + ) + y_type, y_true, y_pred, multioutput = _check_reg_targets( y_true, y_pred, multioutput ) @@ -574,7 +693,79 @@ def mean_squared_log_error( np.log1p(y_pred), sample_weight=sample_weight, multioutput=multioutput, - squared=squared, + ) + + +@validate_params( + { + "y_true": ["array-like"], + "y_pred": ["array-like"], + "sample_weight": ["array-like", None], + "multioutput": [StrOptions({"raw_values", "uniform_average"}), "array-like"], + }, + prefer_skip_nested_validation=True, +) +def root_mean_squared_log_error( + y_true, y_pred, *, sample_weight=None, multioutput="uniform_average" +): + """Root mean squared logarithmic error regression loss. + + Read more in the :ref:`User Guide <mean_squared_log_error>`. + + .. versionadded:: 1.4 + + Parameters + ---------- + y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) + Ground truth (correct) target values. + + y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) + Estimated target values. + + sample_weight : array-like of shape (n_samples,), default=None + Sample weights. + + multioutput : {'raw_values', 'uniform_average'} or array-like of shape \ + (n_outputs,), default='uniform_average' + + Defines aggregating of multiple output values. + Array-like value defines weights used to average errors. + + 'raw_values' : + Returns a full set of errors when the input is of multioutput + format. + + 'uniform_average' : + Errors of all outputs are averaged with uniform weight. + + Returns + ------- + loss : float or ndarray of floats + A non-negative floating point value (the best value is 0.0), or an + array of floating point values, one for each individual target. + + Examples + -------- + >>> from sklearn.metrics import root_mean_squared_log_error + >>> y_true = [3, 5, 2.5, 7] + >>> y_pred = [2.5, 5, 4, 8] + >>> root_mean_squared_log_error(y_true, y_pred) + 0.199... + """ + _, y_true, y_pred, multioutput = _check_reg_targets(y_true, y_pred, multioutput) + check_consistent_length(y_true, y_pred, sample_weight) + + if (y_true < 0).any() or (y_pred < 0).any(): + raise ValueError( + "Root Mean Squared Logarithmic Error cannot be used when " + "targets contain negative values." + ) + + return root_mean_squared_error( + np.log1p(y_true), + np.log1p(y_pred), + sample_weight=sample_weight, + multioutput=multioutput, ) diff --git a/sklearn/metrics/_scorer.py b/sklearn/metrics/_scorer.py index 302831366aa54..50880080dd3cb 100644 --- a/sklearn/metrics/_scorer.py +++ b/sklearn/metrics/_scorer.py @@ -64,6 +64,8 @@ r2_score, recall_score, roc_auc_score, + root_mean_squared_error, + root_mean_squared_log_error, top_k_accuracy_score, ) from .cluster import ( @@ -762,7 +764,10 @@ def make_scorer( median_absolute_error, greater_is_better=False ) neg_root_mean_squared_error_scorer = make_scorer( - mean_squared_error, greater_is_better=False, squared=False + root_mean_squared_error, greater_is_better=False +) +neg_root_mean_squared_log_error_scorer = make_scorer( + root_mean_squared_log_error, greater_is_better=False ) neg_mean_poisson_deviance_scorer = make_scorer( mean_poisson_deviance, greater_is_better=False @@ -837,10 +842,11 @@ def negative_likelihood_ratio(y_true, y_pred): matthews_corrcoef=matthews_corrcoef_scorer, neg_median_absolute_error=neg_median_absolute_error_scorer, neg_mean_absolute_error=neg_mean_absolute_error_scorer, - neg_mean_absolute_percentage_error=neg_mean_absolute_percentage_error_scorer, # noqa + neg_mean_absolute_percentage_error=neg_mean_absolute_percentage_error_scorer, neg_mean_squared_error=neg_mean_squared_error_scorer, neg_mean_squared_log_error=neg_mean_squared_log_error_scorer, neg_root_mean_squared_error=neg_root_mean_squared_error_scorer, + neg_root_mean_squared_log_error=neg_root_mean_squared_log_error_scorer, neg_mean_poisson_deviance=neg_mean_poisson_deviance_scorer, neg_mean_gamma_deviance=neg_mean_gamma_deviance_scorer, accuracy=accuracy_scorer,

diff --git a/sklearn/metrics/tests/test_regression.py b/sklearn/metrics/tests/test_regression.py index f0486d1e942e6..29afac5cbc824 100644 --- a/sklearn/metrics/tests/test_regression.py +++ b/sklearn/metrics/tests/test_regression.py @@ -23,6 +23,8 @@ mean_tweedie_deviance, median_absolute_error, r2_score, + root_mean_squared_error, + root_mean_squared_log_error, ) from sklearn.metrics._regression import _check_reg_targets from sklearn.model_selection import GridSearchCV @@ -123,12 +125,12 @@ def test_regression_metrics(n_samples=50): ) -def test_mean_squared_error_multioutput_raw_value_squared(): +def test_root_mean_squared_error_multioutput_raw_value(): # non-regression test for # https://github.com/scikit-learn/scikit-learn/pull/16323 - mse1 = mean_squared_error([[1]], [[10]], multioutput="raw_values", squared=True) - mse2 = mean_squared_error([[1]], [[10]], multioutput="raw_values", squared=False) - assert np.sqrt(mse1) == pytest.approx(mse2) + mse = mean_squared_error([[1]], [[10]], multioutput="raw_values") + rmse = root_mean_squared_error([[1]], [[10]], multioutput="raw_values") + assert np.sqrt(mse) == pytest.approx(rmse) def test_multioutput_regression(): @@ -138,12 +140,15 @@ def test_multioutput_regression(): error = mean_squared_error(y_true, y_pred) assert_almost_equal(error, (1.0 / 3 + 2.0 / 3 + 2.0 / 3) / 4.0) - error = mean_squared_error(y_true, y_pred, squared=False) + error = root_mean_squared_error(y_true, y_pred) assert_almost_equal(error, 0.454, decimal=2) error = mean_squared_log_error(y_true, y_pred) assert_almost_equal(error, 0.200, decimal=2) + error = root_mean_squared_log_error(y_true, y_pred) + assert_almost_equal(error, 0.315, decimal=2) + # mean_absolute_error and mean_squared_error are equal because # it is a binary problem. error = mean_absolute_error(y_true, y_pred) @@ -219,7 +224,7 @@ def test_regression_metrics_at_limits(): # Single-sample case # Note: for r2 and d2_tweedie see also test_regression_single_sample assert_almost_equal(mean_squared_error([0.0], [0.0]), 0.0) - assert_almost_equal(mean_squared_error([0.0], [0.0], squared=False), 0.0) + assert_almost_equal(root_mean_squared_error([0.0], [0.0]), 0.0) assert_almost_equal(mean_squared_log_error([0.0], [0.0]), 0.0) assert_almost_equal(mean_absolute_error([0.0], [0.0]), 0.0) assert_almost_equal(mean_pinball_loss([0.0], [0.0]), 0.0) @@ -257,6 +262,12 @@ def test_regression_metrics_at_limits(): ) with pytest.raises(ValueError, match=msg): mean_squared_log_error([1.0, -2.0, 3.0], [1.0, 2.0, 3.0]) + msg = ( + "Root Mean Squared Logarithmic Error cannot be used when targets " + "contain negative values." + ) + with pytest.raises(ValueError, match=msg): + root_mean_squared_log_error([1.0, -2.0, 3.0], [1.0, 2.0, 3.0]) # Tweedie deviance error power = -1.2 @@ -438,7 +449,7 @@ def test_regression_custom_weights(): y_pred = [[1, 1], [2, -1], [5, 4], [5, 6.5]] msew = mean_squared_error(y_true, y_pred, multioutput=[0.4, 0.6]) - rmsew = mean_squared_error(y_true, y_pred, multioutput=[0.4, 0.6], squared=False) + rmsew = root_mean_squared_error(y_true, y_pred, multioutput=[0.4, 0.6]) maew = mean_absolute_error(y_true, y_pred, multioutput=[0.4, 0.6]) mapew = mean_absolute_percentage_error(y_true, y_pred, multioutput=[0.4, 0.6]) rw = r2_score(y_true, y_pred, multioutput=[0.4, 0.6]) @@ -611,3 +622,50 @@ def test_pinball_loss_relation_with_mae(): mean_absolute_error(y_true, y_pred) == mean_pinball_loss(y_true, y_pred, alpha=0.5) * 2 ) + + +# TODO(1.6): remove this test +@pytest.mark.parametrize("metric", [mean_squared_error, mean_squared_log_error]) +def test_mean_squared_deprecation_squared(metric): + """Check the deprecation warning of the squared parameter""" + depr_msg = "'squared' is deprecated in version 1.4 and will be removed in 1.6." + y_true, y_pred = np.arange(10), np.arange(1, 11) + with pytest.warns(FutureWarning, match=depr_msg): + metric(y_true, y_pred, squared=False) + + +# TODO(1.6): remove this test +@pytest.mark.filterwarnings("ignore:'squared' is deprecated") +@pytest.mark.parametrize( + "old_func, new_func", + [ + (mean_squared_error, root_mean_squared_error), + (mean_squared_log_error, root_mean_squared_log_error), + ], +) +def test_rmse_rmsle_parameter(old_func, new_func): + # Check that the new rmse/rmsle function is equivalent to + # the old mse/msle + squared=False function. + y_true = np.array([[1, 0, 0, 1], [0, 1, 1, 1], [1, 1, 0, 1]]) + y_pred = np.array([[0, 0, 0, 1], [1, 0, 1, 1], [0, 0, 0, 1]]) + y_true = np.array([[0.5, 1], [1, 2], [7, 6]]) + y_pred = np.array([[0.5, 2], [1, 2.5], [8, 8]]) + sw = np.arange(len(y_true)) + + expected = old_func(y_true, y_pred, squared=False) + actual = new_func(y_true, y_pred) + assert_allclose(expected, actual) + + expected = old_func(y_true, y_pred, sample_weight=sw, squared=False) + actual = new_func(y_true, y_pred, sample_weight=sw) + assert_allclose(expected, actual) + + expected = old_func(y_true, y_pred, multioutput="raw_values", squared=False) + actual = new_func(y_true, y_pred, multioutput="raw_values") + assert_allclose(expected, actual) + + expected = old_func( + y_true, y_pred, sample_weight=sw, multioutput="raw_values", squared=False + ) + actual = new_func(y_true, y_pred, sample_weight=sw, multioutput="raw_values") + assert_allclose(expected, actual) diff --git a/sklearn/metrics/tests/test_score_objects.py b/sklearn/metrics/tests/test_score_objects.py index 10d991c477f1b..0bd1def6a500d 100644 --- a/sklearn/metrics/tests/test_score_objects.py +++ b/sklearn/metrics/tests/test_score_objects.py @@ -73,6 +73,7 @@ "neg_mean_squared_log_error", "neg_median_absolute_error", "neg_root_mean_squared_error", + "neg_root_mean_squared_log_error", "mean_absolute_error", "mean_absolute_percentage_error", "mean_squared_error", diff --git a/sklearn/tests/test_public_functions.py b/sklearn/tests/test_public_functions.py index 20ac2e1e1615e..22e70b39e1c6f 100644 --- a/sklearn/tests/test_public_functions.py +++ b/sklearn/tests/test_public_functions.py @@ -295,6 +295,8 @@ def _check_function_param_validation( "sklearn.metrics.recall_score", "sklearn.metrics.roc_auc_score", "sklearn.metrics.roc_curve", + "sklearn.metrics.root_mean_squared_error", + "sklearn.metrics.root_mean_squared_log_error", "sklearn.metrics.top_k_accuracy_score", "sklearn.metrics.v_measure_score", "sklearn.metrics.zero_one_loss",

diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 7f6f5c910a3fc..f4ae4ffbf8911 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -995,6 +995,8 @@ details. metrics.median_absolute_error metrics.mean_absolute_percentage_error metrics.r2_score + metrics.root_mean_squared_log_error + metrics.root_mean_squared_error metrics.mean_poisson_deviance metrics.mean_gamma_deviance metrics.mean_tweedie_deviance diff --git a/doc/modules/model_evaluation.rst b/doc/modules/model_evaluation.rst index c989f49c0fc7d..eac1cde567595 100644 --- a/doc/modules/model_evaluation.rst +++ b/doc/modules/model_evaluation.rst @@ -94,8 +94,9 @@ Scoring Function 'max_error' :func:`metrics.max_error` 'neg_mean_absolute_error' :func:`metrics.mean_absolute_error` 'neg_mean_squared_error' :func:`metrics.mean_squared_error` -'neg_root_mean_squared_error' :func:`metrics.mean_squared_error` +'neg_root_mean_squared_error' :func:`metrics.root_mean_squared_error` 'neg_mean_squared_log_error' :func:`metrics.mean_squared_log_error` +'neg_root_mean_squared_log_error' :func:`metrics.root_mean_squared_log_error` 'neg_median_absolute_error' :func:`metrics.median_absolute_error` 'r2' :func:`metrics.r2_score` 'neg_mean_poisson_deviance' :func:`metrics.mean_poisson_deviance` @@ -2310,6 +2311,10 @@ function:: for an example of mean squared error usage to evaluate gradient boosting regression. +Taking the square root of the MSE, called the root mean squared error (RMSE), is another +common metric that provides a measure in the same units as the target variable. RSME is +available through the :func:`root_mean_squared_error` function. + .. _mean_squared_log_error: Mean squared logarithmic error @@ -2347,6 +2352,9 @@ function:: >>> mean_squared_log_error(y_true, y_pred) 0.044... +The root mean squared logarithmic error (RMSLE) is available through the +:func:`root_mean_squared_log_error` function. + .. _mean_absolute_percentage_error: Mean absolute percentage error diff --git a/doc/whats_new/v1.4.rst b/doc/whats_new/v1.4.rst index 367315dc3c60d..8dbd867b0c9ba 100644 --- a/doc/whats_new/v1.4.rst +++ b/doc/whats_new/v1.4.rst @@ -238,6 +238,18 @@ Changelog - |Enhancement| :class:`preprocessing.TargetEncoder` now supports `target_type` 'multiclass'. :pr:`26674` by :user:`Lucy Liu <lucyleeow>`. +:mod:`sklearn.metrics` +...................... + +- |API| The `squared` parameter of :func:`metrics.mean_squared_error` and + :func:`metrics.mean_squared_log_error` is deprecated and will be removed in 1.6. + Use the new functions :func:`metrics.root_mean_squared_error` and + :func:`root_mean_squared_log_error` instead. + :pr:`26734` by :user:`Alejandro Martin Gil <101AlexMartin>`. + +- |Enhancement| Added `neg_root_mean_squared_log_error_scorer` as scorer + :pr:`26734` by :user:`Alejandro Martin Gil <101AlexMartin>`. + :mod:`sklearn.model_selection` ..............................

[ { "components": [ { "doc": "Root mean squared error regression loss.\n\nRead more in the :ref:`User Guide <mean_squared_error>`.\n\n.. versionadded:: 1.4\n\nParameters\n----------\ny_true : array-like of shape (n_samples,) or (n_samples, n_outputs)\n Ground truth (correct) target values.\n\ny_p...

[ "sklearn/metrics/tests/test_regression.py::test_regression_metrics", "sklearn/metrics/tests/test_regression.py::test_root_mean_squared_error_multioutput_raw_value", "sklearn/metrics/tests/test_regression.py::test_multioutput_regression", "sklearn/metrics/tests/test_regression.py::test_regression_metrics_at_li...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> API replace mean_squared_error(square=False) by root_mean_squared_error  #### Reference Issues/PRs  #### What does this implement/fix? Explain your changes. Create ad-hoc function to calculate RMSE #### Any other comments? As an external user of scikit-learn, I found it counter-intuitive to have a flag inside the MSE function to get RMSE. I think it is difficult to find. In fact, I'm not the only one: https://stackoverflow.com/questions/17197492/is-there-a-library-function-for-root-mean-square-error-rmse-in-python If you also think this PR might be worth it, I will further elaborate it, generating the tests and creating also an ad-hoc function for the root_mean_square_log_error.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/metrics/_regression.py] (definition of root_mean_squared_error:) def root_mean_squared_error( y_true, y_pred, *, sample_weight=None, multioutput="uniform_average" ): """Root mean squared error regression loss. Read more in the :ref:`User Guide <mean_squared_error>`. .. versionadded:: 1.4 Parameters ---------- y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. multioutput : {'raw_values', 'uniform_average'} or array-like of shape (n_outputs,), default='uniform_average' Defines aggregating of multiple output values. Array-like value defines weights used to average errors. 'raw_values' : Returns a full set of errors in case of multioutput input. 'uniform_average' : Errors of all outputs are averaged with uniform weight. Returns ------- loss : float or ndarray of floats A non-negative floating point value (the best value is 0.0), or an array of floating point values, one for each individual target. Examples -------- >>> from sklearn.metrics import root_mean_squared_error >>> y_true = [3, -0.5, 2, 7] >>> y_pred = [2.5, 0.0, 2, 8] >>> root_mean_squared_error(y_true, y_pred) 0.612... >>> y_true = [[0.5, 1],[-1, 1],[7, -6]] >>> y_pred = [[0, 2],[-1, 2],[8, -5]] >>> root_mean_squared_error(y_true, y_pred) 0.822...""" (definition of root_mean_squared_log_error:) def root_mean_squared_log_error( y_true, y_pred, *, sample_weight=None, multioutput="uniform_average" ): """Root mean squared logarithmic error regression loss. Read more in the :ref:`User Guide <mean_squared_log_error>`. .. versionadded:: 1.4 Parameters ---------- y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. multioutput : {'raw_values', 'uniform_average'} or array-like of shape (n_outputs,), default='uniform_average' Defines aggregating of multiple output values. Array-like value defines weights used to average errors. 'raw_values' : Returns a full set of errors when the input is of multioutput format. 'uniform_average' : Errors of all outputs are averaged with uniform weight. Returns ------- loss : float or ndarray of floats A non-negative floating point value (the best value is 0.0), or an array of floating point values, one for each individual target. Examples -------- >>> from sklearn.metrics import root_mean_squared_log_error >>> y_true = [3, 5, 2.5, 7] >>> y_pred = [2.5, 5, 4, 8] >>> root_mean_squared_log_error(y_true, y_pred) 0.199...""" [end of new definitions in sklearn/metrics/_regression.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

ae2c80a21007d8295fb3ec3a927fce17b3d60ab8

snowflakedb__snowflake-connector-python-1621

1,621

snowflakedb/snowflake-connector-python

null

320dbcee525fd83847f8f059044a6bc645905a21

2023-06-28T23:57:22Z

diff --git a/DESCRIPTION.md b/DESCRIPTION.md index dd658ccacf..728e8ca54d 100644 --- a/DESCRIPTION.md +++ b/DESCRIPTION.md @@ -15,6 +15,7 @@ Source code is also available at: https://github.com/snowflakedb/snowflake-conne - Added a parameter `server_session_keep_alive` in `SnowflakeConnection` that skips session deletion when client connection closes. - Tightened our pinning of platformdirs, to prevent their new releases breaking us. - Fixed a bug where SFPlatformDirs would incorrectly append application_name/version to its path. + - Added retry reason for queries that are retried by the client. - Fixed a bug where `write_pandas` fails when user does not have the privilege to create stage or file format in the target schema, but has the right privilege for the current schema. - v3.0.4(May 23,2023) diff --git a/src/snowflake/connector/connection.py b/src/snowflake/connector/connection.py index e308db87c6..9d36a060ee 100644 --- a/src/snowflake/connector/connection.py +++ b/src/snowflake/connector/connection.py @@ -220,6 +220,10 @@ def DefaultConverterClass() -> type: False, bool, ), # Whether to keep session alive after connector shuts down + "enable_retry_reason_in_query_response": ( + True, + bool, + ), # Enable sending retryReason in response header for query-requests } APPLICATION_RE = re.compile(r"[\w\d_]+") diff --git a/src/snowflake/connector/errors.py b/src/snowflake/connector/errors.py index f31f3d6443..cb8757f15e 100644 --- a/src/snowflake/connector/errors.py +++ b/src/snowflake/connector/errors.py @@ -536,6 +536,19 @@ def __init__(self, **kwargs) -> None: ) +class TooManyRequests(Error): + """Exception for 429 HTTP error for retry.""" + + def __init__(self, **kwargs) -> None: + Error.__init__( + self, + msg=kwargs.get("msg") or "HTTP 429: Too Many Requests", + errno=kwargs.get("errno"), + sqlstate=kwargs.get("sqlstate"), + sfqid=kwargs.get("sfqid"), + ) + + class OtherHTTPRetryableError(Error): """Exception for other HTTP error for retry.""" diff --git a/src/snowflake/connector/network.py b/src/snowflake/connector/network.py index 566f32fe5f..a51955ec21 100644 --- a/src/snowflake/connector/network.py +++ b/src/snowflake/connector/network.py @@ -82,6 +82,7 @@ OtherHTTPRetryableError, ProgrammingError, ServiceUnavailableError, + TooManyRequests, ) from .sqlstate import ( SQLSTATE_CONNECTION_NOT_EXISTS, @@ -173,6 +174,7 @@ BAD_REQUEST: BadRequest, BAD_GATEWAY: BadGatewayError, METHOD_NOT_ALLOWED: MethodNotAllowed, + TOO_MANY_REQUESTS: TooManyRequests, } DEFAULT_AUTHENTICATOR = "SNOWFLAKE" # default authenticator name @@ -784,16 +786,32 @@ def fetch( """Carry out API request with session management.""" class RetryCtx: - def __init__(self, timeout, _include_retry_params: bool = False) -> None: + def __init__( + self, + timeout, + _include_retry_params: bool = False, + _include_retry_reason: bool = False, + ) -> None: self.total_timeout = timeout self.timeout = timeout self.cnt = 0 + self.reason = 0 self.sleeping_time = 1 self.start_time = get_time_millis() self._include_retry_params = _include_retry_params + self._include_retry_reason = _include_retry_reason # backoff between 1 and 16 seconds self._backoff = DecorrelateJitterBackoff(1, 16) + def increment_retry(self, reason: int = 0) -> None: + """Increment retry count and update the reason for retry + + Args: + reason: HTTP response code that caused retry. Defaults to 0. + """ + self.cnt += 1 + self.reason = reason + def next_sleep(self) -> int: self.sleeping_time = self._backoff.next_sleep( self.cnt, self.sleeping_time @@ -802,18 +820,23 @@ def next_sleep(self) -> int: def add_retry_params(self, full_url: str) -> str: if self._include_retry_params and self.cnt > 0: - suffix = urlencode( - {"clientStartTime": self.start_time, "retryCount": self.cnt} - ) + retry_params = { + "clientStartTime": self.start_time, + "retryCount": self.cnt, + } + if self._include_retry_reason: + retry_params.update({"retryReason": self.reason}) + suffix = urlencode(retry_params) sep = "&" if urlparse(full_url).query else "?" return full_url + sep + suffix else: return full_url + include_retry_reason = self._connection._enable_retry_reason_in_query_response include_retry_params = kwargs.pop("_include_retry_params", False) with self._use_requests_session(full_url) as session: - retry_ctx = RetryCtx(timeout, include_retry_params) + retry_ctx = RetryCtx(timeout, include_retry_params, include_retry_reason) while True: ret = self._request_exec_wrapper( session, method, full_url, headers, data, retry_ctx, **kwargs @@ -932,7 +955,8 @@ def _request_exec_wrapper( sleeping_time, ) time.sleep(sleeping_time) - retry_ctx.cnt += 1 + reason = getattr(cause, "errno", 0) + retry_ctx.increment_retry(reason) if retry_ctx.timeout is not None: retry_ctx.timeout -= sleeping_time return None # retry

diff --git a/test/unit/test_result_batch.py b/test/unit/test_result_batch.py index 3d3b86241a..315d8089d3 100644 --- a/test/unit/test_result_batch.py +++ b/test/unit/test_result_batch.py @@ -23,6 +23,7 @@ OK, REQUEST_TIMEOUT, SERVICE_UNAVAILABLE, + TOO_MANY_REQUESTS, UNAUTHORIZED, ) from snowflake.connector.errorcode import ( @@ -41,23 +42,21 @@ ) try: + from snowflake.connector.errors import TooManyRequests from snowflake.connector.result_batch import MAX_DOWNLOAD_RETRY, JSONResultBatch + from snowflake.connector.vendored import requests # NOQA + + REQUEST_MODULE_PATH = "snowflake.connector.vendored.requests" except ImportError: MAX_DOWNLOAD_RETRY = None JSONResultBatch = None + REQUEST_MODULE_PATH = "requests" + TooManyRequests = None from snowflake.connector.sqlstate import ( SQLSTATE_CONNECTION_REJECTED, SQLSTATE_CONNECTION_WAS_NOT_ESTABLISHED, ) -try: - from snowflake.connector.vendored import requests # NOQA - - REQUEST_MODULE_PATH = "snowflake.connector.vendored.requests" -except ImportError: - REQUEST_MODULE_PATH = "requests" - - MockRemoteChunkInfo = namedtuple("MockRemoteChunkInfo", "url") chunk_info = MockRemoteChunkInfo("http://www.chunk-url.com") result_batch = ( @@ -76,6 +75,7 @@ def test_ok_response_download(mock_get): assert response.status_code == 200 +@pytest.mark.skipolddriver @pytest.mark.parametrize( "errcode,error_class", [ @@ -83,6 +83,7 @@ def test_ok_response_download(mock_get): (FORBIDDEN, ForbiddenError), # 403 (METHOD_NOT_ALLOWED, MethodNotAllowed), # 405 (REQUEST_TIMEOUT, OtherHTTPRetryableError), # 408 + (TOO_MANY_REQUESTS, TooManyRequests), # 429 (INTERNAL_SERVER_ERROR, InternalServerError), # 500 (BAD_GATEWAY, BadGatewayError), # 502 (SERVICE_UNAVAILABLE, ServiceUnavailableError), # 503 diff --git a/test/unit/test_retry_network.py b/test/unit/test_retry_network.py index 236d9fb974..9939a7f2b8 100644 --- a/test/unit/test_retry_network.py +++ b/test/unit/test_retry_network.py @@ -6,14 +6,17 @@ from __future__ import annotations import errno +import json import logging import os import time -from unittest.mock import MagicMock, Mock, PropertyMock +from unittest.mock import MagicMock, Mock, PropertyMock, patch +from uuid import uuid4 import OpenSSL.SSL import pytest +import snowflake.connector from snowflake.connector.compat import ( BAD_GATEWAY, BAD_REQUEST, @@ -48,6 +51,116 @@ THIS_DIR = os.path.dirname(os.path.realpath(__file__)) +class Cnt: + def __init__(self): + self.c = 0 + + def set(self, cnt): + self.c = cnt + + def reset(self): + self.set(0) + + +def fake_connector() -> snowflake.connector.SnowflakeConnection: + return snowflake.connector.connect( + user="user", + account="account", + password="testpassword", + database="TESTDB", + warehouse="TESTWH", + ) + + +@patch("snowflake.connector.network.SnowflakeRestful._request_exec") +@patch("snowflake.connector.network.DecorrelateJitterBackoff.next_sleep") +def test_retry_reason(mockNextSleep, mockRequestExec): + url = "" + cnt = Cnt() + + def mock_exec(session, method, full_url, headers, data, token, **kwargs): + # take actions based on data["sqlText"] + nonlocal url + url = full_url + data = json.loads(data) + sql = data.get("sqlText", "default") + success_result = { + "success": True, + "message": None, + "data": { + "token": "TOKEN", + "masterToken": "MASTER_TOKEN", + "idToken": None, + "parameters": [{"name": "SERVICE_NAME", "value": "FAKE_SERVICE_NAME"}], + }, + } + cnt.c += 1 + if "retry" in sql: + # error = HTTP Error 429 + if cnt.c < 3: # retry twice for 429 error + raise RetryRequest(OtherHTTPRetryableError(errno=429)) + return success_result + elif "unknown error" in sql: + # Raise unknown http error + if cnt.c == 1: # retry once for 100 error + raise RetryRequest(OtherHTTPRetryableError(errno=100)) + return success_result + elif "flip" in sql: + if cnt.c == 1: # retry first with 100 + raise RetryRequest(OtherHTTPRetryableError(errno=100)) + elif cnt.c == 2: # then with 429 + raise RetryRequest(OtherHTTPRetryableError(errno=429)) + return success_result + + return success_result + + conn = fake_connector() + mockNextSleep.side_effect = lambda cnt, sleep: 0 + mockRequestExec.side_effect = mock_exec + + # ensure query requests don't have the retryReason if retryCount == 0 + cnt.reset() + conn.cmd_query("success", 0, uuid4()) + assert "retryReason" not in url + assert "retryCount" not in url + + # ensure query requests have correct retryReason when retry reason is sent by server + cnt.reset() + conn.cmd_query("retry", 0, uuid4()) + assert "retryReason=429" in url + assert "retryCount=2" in url + + cnt.reset() + conn.cmd_query("unknown error", 0, uuid4()) + assert "retryReason=100" in url + assert "retryCount=1" in url + + # ensure query requests have retryReason reset to 0 when no reason is given + cnt.reset() + conn.cmd_query("success", 0, uuid4()) + assert "retryReason" not in url + assert "retryCount" not in url + + # ensure query requests have retryReason gets updated with updated error code + cnt.reset() + conn.cmd_query("flip", 0, uuid4()) + assert "retryReason=429" in url + assert "retryCount=2" in url + + # ensure that disabling works and only suppresses retryReason + conn._enable_retry_reason_in_query_response = False + + cnt.reset() + conn.cmd_query("retry", 0, uuid4()) + assert "retryReason" not in url + assert "retryCount=2" in url + + cnt.reset() + conn.cmd_query("unknown error", 0, uuid4()) + assert "retryReason" not in url + assert "retryCount=1" in url + + def test_request_exec(): rest = SnowflakeRestful(host="testaccount.snowflakecomputing.com", port=443) @@ -164,16 +277,6 @@ def test_fetch(): host="testaccount.snowflakecomputing.com", port=443, connection=connection ) - class Cnt: - def __init__(self): - self.c = 0 - - def set(self, cnt): - self.c = cnt - - def reset(self): - self.set(0) - cnt = Cnt() default_parameters = { "method": "POST",

diff --git a/DESCRIPTION.md b/DESCRIPTION.md index dd658ccacf..728e8ca54d 100644 --- a/DESCRIPTION.md +++ b/DESCRIPTION.md @@ -15,6 +15,7 @@ Source code is also available at: https://github.com/snowflakedb/snowflake-conne - Added a parameter `server_session_keep_alive` in `SnowflakeConnection` that skips session deletion when client connection closes. - Tightened our pinning of platformdirs, to prevent their new releases breaking us. - Fixed a bug where SFPlatformDirs would incorrectly append application_name/version to its path. + - Added retry reason for queries that are retried by the client. - Fixed a bug where `write_pandas` fails when user does not have the privilege to create stage or file format in the target schema, but has the right privilege for the current schema. - v3.0.4(May 23,2023)

[ { "components": [ { "doc": "Exception for 429 HTTP error for retry.", "lines": [ 539, 548 ], "name": "TooManyRequests", "signature": "class TooManyRequests(Error):", "type": "class" }, { "doc": "", "lines": [ ...

[ "test/unit/test_result_batch.py::test_ok_response_download", "test/unit/test_result_batch.py::test_retryable_response_download[HTTPStatus.BAD_REQUEST-BadRequest]", "test/unit/test_result_batch.py::test_retryable_response_download[HTTPStatus.FORBIDDEN-ForbiddenError]", "test/unit/test_result_batch.py::test_ret...

[ "test/unit/test_retry_network.py::test_request_exec", "test/unit/test_retry_network.py::test_fetch", "test/unit/test_retry_network.py::test_secret_masking" ]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> SNOW-736326: Add retry reason for retried queries Please answer these questions before submitting your pull requests. Thanks! 1. What GitHub issue is this PR addressing? Make sure that there is an accompanying issue to your PR. Fixes #SNOW-736326 2. Fill out the following pre-review checklist: - [x] I am adding a new automated test(s) to verify correctness of my new code - [ ] I am adding new logging messages - [ ] I am adding a new telemetry message - [ ] I am modifying authorization mechanisms - [ ] I am adding new credentials - [ ] I am modifying OCSP code - [ ] I am adding a new dependency 3. Please describe how your code solves the related issue. Following requirements based on [this](https://docs.google.com/document/d/1aymRr14WJ-OF3Xgtlpt_Xkfq-TyCB-GK-YV-0i8if34/edit) spec. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in src/snowflake/connector/errors.py] (definition of TooManyRequests:) class TooManyRequests(Error): """Exception for 429 HTTP error for retry.""" (definition of TooManyRequests.__init__:) def __init__(self, **kwargs) -> None: [end of new definitions in src/snowflake/connector/errors.py] [start of new definitions in src/snowflake/connector/network.py] (definition of SnowflakeRestful.fetch.RetryCtx.increment_retry:) def increment_retry(self, reason: int = 0) -> None: """Increment retry count and update the reason for retry Args: reason: HTTP response code that caused retry. Defaults to 0.""" [end of new definitions in src/snowflake/connector/network.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

138241c3604e78fd35fe38a2c0bc55ebc2d47f66

tobymao__sqlglot-1847

1,847

tobymao/sqlglot

null

898f1a2ed4f575d11f7d8680c2d642c3d5b8320c

2023-06-28T17:03:05Z

diff --git a/sqlglot/dialects/bigquery.py b/sqlglot/dialects/bigquery.py index 94ea365f4f..d156d66b05 100644 --- a/sqlglot/dialects/bigquery.py +++ b/sqlglot/dialects/bigquery.py @@ -1,5 +1,6 @@ from __future__ import annotations +import logging import re import typing as t @@ -21,6 +22,8 @@ from sqlglot.helper import seq_get, split_num_words from sqlglot.tokens import TokenType +logger = logging.getLogger("sqlglot") + def _date_add_sql( data_type: str, kind: str @@ -104,6 +107,33 @@ def _unqualify_unnest(expression: exp.Expression) -> exp.Expression: return expression +def _pushdown_cte_column_names(expression: exp.Expression) -> exp.Expression: + """BigQuery doesn't allow column names when defining a CTE, so we try to push them down.""" + if isinstance(expression, exp.CTE) and expression.alias_column_names: + cte_query = expression.this + + if cte_query.is_star: + logger.warning( + "Can't push down CTE column names for star queries. Run the query through" + " the optimizer or use 'qualify' to expand the star projections first." + ) + return expression + + column_names = expression.alias_column_names + expression.args["alias"].set("columns", None) + + for name, select in zip(column_names, cte_query.selects): + to_replace = select + + if isinstance(select, exp.Alias): + select = select.this + + # Inner aliases are shadowed by the CTE column names + to_replace.replace(exp.alias_(select, name)) + + return expression + + class BigQuery(Dialect): UNNEST_COLUMN_ONLY = True @@ -309,6 +339,7 @@ class Generator(generator.Generator): "TIMESTAMP", self.func("DATETIME", e.this, e.args.get("zone")) ), exp.Cast: transforms.preprocess([transforms.remove_precision_parameterized_types]), + exp.CTE: transforms.preprocess([_pushdown_cte_column_names]), exp.DateAdd: _date_add_sql("DATE", "ADD"), exp.DateSub: _date_add_sql("DATE", "SUB"), exp.DatetimeAdd: _date_add_sql("DATETIME", "ADD"), @@ -486,6 +517,11 @@ class Generator(generator.Generator): "within", } + def cte_sql(self, expression: exp.CTE) -> str: + if expression.alias_column_names: + self.unsupported("Column names in CTE definition are not supported.") + return super().cte_sql(expression) + def array_sql(self, expression: exp.Array) -> str: first_arg = seq_get(expression.expressions, 0) if isinstance(first_arg, exp.Subqueryable):

diff --git a/tests/dialects/test_bigquery.py b/tests/dialects/test_bigquery.py index e2b655dffc..c4f364e631 100644 --- a/tests/dialects/test_bigquery.py +++ b/tests/dialects/test_bigquery.py @@ -1,3 +1,5 @@ +from unittest import mock + from sqlglot import ErrorLevel, ParseError, UnsupportedError, transpile from tests.dialects.test_dialect import Validator @@ -571,3 +573,34 @@ def test_rename_table(self): "bigquery": "ALTER TABLE db.t1 RENAME TO t2", }, ) + + @mock.patch("sqlglot.dialects.bigquery.logger") + def test_pushdown_cte_column_names(self, mock_logger): + with self.assertRaises(UnsupportedError): + transpile( + "WITH cte(foo) AS (SELECT * FROM tbl) SELECT foo FROM cte", + read="spark", + write="bigquery", + unsupported_level=ErrorLevel.RAISE, + ) + + self.validate_all( + "WITH cte AS (SELECT 1 AS foo) SELECT foo FROM cte", + read={"spark": "WITH cte(foo) AS (SELECT 1) SELECT foo FROM cte"}, + ) + self.validate_all( + "WITH cte AS (SELECT 1 AS foo) SELECT foo FROM cte", + read={"spark": "WITH cte(foo) AS (SELECT 1 AS bar) SELECT foo FROM cte"}, + ) + self.validate_all( + "WITH cte AS (SELECT 1 AS bar) SELECT bar FROM cte", + read={"spark": "WITH cte AS (SELECT 1 AS bar) SELECT bar FROM cte"}, + ) + self.validate_all( + "WITH cte AS (SELECT 1 AS foo, 2) SELECT foo FROM cte", + read={"postgres": "WITH cte(foo) AS (SELECT 1, 2) SELECT foo FROM cte"}, + ) + self.validate_all( + "WITH cte AS (SELECT 1 AS foo UNION ALL SELECT 2) SELECT foo FROM cte", + read={"postgres": "WITH cte(foo) AS (SELECT 1 UNION ALL SELECT 2) SELECT foo FROM cte"}, + )

[]

[ "tests/dialects/test_bigquery.py::TestBigQuery::test_pushdown_cte_column_names" ]

[ "tests/dialects/test_bigquery.py::TestBigQuery::test_bigquery", "tests/dialects/test_bigquery.py::TestBigQuery::test_group_concat", "tests/dialects/test_bigquery.py::TestBigQuery::test_merge", "tests/dialects/test_bigquery.py::TestBigQuery::test_remove_precision_parameterized_types", "tests/dialects/test_bi...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feat(bigquery): pushdown CTE column names {} ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

ceb42fabad60312699e4b15936aeebac00e22e4d

pvlib__pvlib-python-1784

1,784

pvlib/pvlib-python

0.9

996361d56dce8d4f14b0a1f3484528b90eb50ace

2023-06-26T18:00:53Z

diff --git a/docs/sphinx/source/whatsnew/v0.10.2.rst b/docs/sphinx/source/whatsnew/v0.10.2.rst index 7259f6a566..dacfe27f53 100644 --- a/docs/sphinx/source/whatsnew/v0.10.2.rst +++ b/docs/sphinx/source/whatsnew/v0.10.2.rst @@ -15,6 +15,8 @@ Enhancements :py:func:`pvlib.iotools.get_pvgis_hourly`, :py:func:`pvlib.iotools.get_cams`, :py:func:`pvlib.iotools.get_bsrn`, and :py:func:`pvlib.iotools.read_midc_raw_data_from_nrel`. (:pull:`1800`) +* Added option to infer threshold values for + :py:func:`pvlib.clearsky.detect_clearsky` (:issue:`1808`, :pull:`1784`) Bug fixes @@ -39,4 +41,5 @@ Requirements Contributors ~~~~~~~~~~~~ * Adam R. Jensen (:ghuser:`AdamRJensen`) +* Abigail Jones (:ghuser:`ajonesr`) * Taos Transue (:ghuser:`reepoi`) diff --git a/pvlib/clearsky.py b/pvlib/clearsky.py index ffc7ac9b55..62318942da 100644 --- a/pvlib/clearsky.py +++ b/pvlib/clearsky.py @@ -644,8 +644,38 @@ def _clear_sample_index(clear_windows, samples_per_window, align, H): return clear_samples -def detect_clearsky(measured, clearsky, times=None, window_length=10, - mean_diff=75, max_diff=75, +def _clearsky_get_threshold(sample_interval): + """ + Returns threshold values for kwargs in detect_clearsky. See + Table 1 in [1]. + + References + ---------- + .. [1] Jordan, D.C. and C. Hansen, "Clear-sky detection for PV + degradation analysis using multiple regression", Renewable Energy, + v209, p. 393-400, 2023. + """ + + if (sample_interval < 1 or sample_interval > 30): + raise ValueError("`infer_limits=True` can only be used for inputs \ + with time step from 1 to 30 minutes") + + data_freq = np.array([1, 5, 15, 30]) + + window_length = np.interp(sample_interval, data_freq, [50, 60, 90, 120]) + mean_diff = np.interp(sample_interval, data_freq, [75, 75, 75, 75]) + max_diff = np.interp(sample_interval, data_freq, [60, 65, 75, 90]) + lower_line_length = np.interp(sample_interval, data_freq, [-45,-45,-45,-45]) + upper_line_length = np.interp(sample_interval, data_freq, [80, 80, 80, 80]) + var_diff = np.interp(sample_interval, data_freq, [0.005, 0.01, 0.032, 0.07]) + slope_dev = np.interp(sample_interval, data_freq, [50, 60, 75, 96]) + + return (window_length, mean_diff, max_diff, lower_line_length, + upper_line_length, var_diff, slope_dev) + + +def detect_clearsky(measured, clearsky, times=None, infer_limits=False, + window_length=10, mean_diff=75, max_diff=75, lower_line_length=-5, upper_line_length=10, var_diff=0.005, slope_dev=8, max_iterations=20, return_components=False): @@ -676,6 +706,9 @@ def detect_clearsky(measured, clearsky, times=None, window_length=10, times : DatetimeIndex or None, default None. Times of measured and clearsky values. If None the index of measured will be used. + infer_limits : bool, default False + If True, does not use passed in kwargs (or defaults), but instead + interpolates these values from Table 1 in [2]_. window_length : int, default 10 Length of sliding time window in minutes. Must be greater than 2 periods. @@ -731,6 +764,9 @@ def detect_clearsky(measured, clearsky, times=None, window_length=10, .. [1] Reno, M.J. and C.W. Hansen, "Identification of periods of clear sky irradiance in time series of GHI measurements" Renewable Energy, v90, p. 520-531, 2016. + .. [2] Jordan, D.C. and C. Hansen, "Clear-sky detection for PV + degradation analysis using multiple regression", Renewable Energy, + v209, p. 393-400, 2023. :doi:`10.1016/j.renene.2023.04.035` Notes ----- @@ -773,6 +809,21 @@ def detect_clearsky(measured, clearsky, times=None, window_length=10, sample_interval, samples_per_window = \ tools._get_sample_intervals(times, window_length) + # if infer_limits, find threshold values using the sample interval + if infer_limits: + window_length, mean_diff, max_diff, lower_line_length, \ + upper_line_length, var_diff, slope_dev = \ + _clearsky_get_threshold(sample_interval) + + # recalculate samples_per_window using returned window_length + _, samples_per_window = \ + tools._get_sample_intervals(times, window_length) + + # check that we have enough data to produce a nonempty hankel matrix + if len(times) < samples_per_window: + raise ValueError(f"times has only {len(times)} entries, but it must \ + have at least {samples_per_window} entries") + # generate matrix of integers for creating windows with indexing H = hankel(np.arange(samples_per_window), np.arange(samples_per_window-1, len(times))) @@ -826,7 +877,22 @@ def detect_clearsky(measured, clearsky, times=None, window_length=10, def rmse(alpha): return np.sqrt(np.mean((clear_meas - alpha*clear_clear)**2)) - alpha = minimize_scalar(rmse).x + optimize_result = minimize_scalar(rmse) + if not optimize_result.success: + try: + message = "Optimizer exited unsuccessfully: " \ + + optimize_result.message + except AttributeError: + message = "Optimizer exited unsuccessfully: \ + No message explaining the failure was returned. \ + If you would like to see this message, please \ + update your scipy version (try version 1.8.0 \ + or beyond)." + raise RuntimeError(message) + + else: + alpha = optimize_result.x + if round(alpha*10000) == round(previous_alpha*10000): break else: diff --git a/pvlib/data/detect_clearsky_threshold_data.csv b/pvlib/data/detect_clearsky_threshold_data.csv new file mode 100644 index 0000000000..a36736b1a3 --- /dev/null +++ b/pvlib/data/detect_clearsky_threshold_data.csv @@ -0,0 +1,126 @@ +# latitude:35.04 +# longitude:-106.62 +# elevation:1619 +# window_length:10 +Time (UTC),GHI,Clear or not +4/1/2012 17:30,862.0935267144818,1 +4/1/2012 17:31,863.9568654037691,1 +4/1/2012 17:32,865.802767695237,1 +4/1/2012 17:33,867.6311939211416,1 +4/1/2012 17:34,869.4421084958154,1 +4/1/2012 17:35,871.2354749580768,1 +4/1/2012 17:36,873.0112572200139,1 +4/1/2012 17:37,874.7694195555663,1 +4/1/2012 17:38,876.5099266138993,1 +4/1/2012 17:39,878.2327434081394,1 +4/1/2012 17:40,879.9378353205582,1 +4/1/2012 17:41,881.6251681074431,1 +4/1/2012 17:42,500.0,0 +4/1/2012 17:43,300.0,0 +4/1/2012 17:44,400.0,0 +4/1/2012 17:45,888.1962370575133,1 +4/1/2012 17:46,889.7942734332919,1 +4/1/2012 17:47,891.3743529660121,1 +4/1/2012 17:48,892.9364440027008,1 +4/1/2012 17:49,894.4805152569894,1 +4/1/2012 17:50,896.0065358138269,1 +4/1/2012 17:51,897.514475133874,1 +4/1/2012 17:52,899.0043030438522,1 +4/1/2012 17:53,900.4759897479845,1 +4/1/2012 17:54,901.9295058184756,1 +4/1/2012 17:55,903.3648231563722,1 +4/1/2012 17:56,950.0,0 +4/1/2012 17:57,906.1807424805852,1 +4/1/2012 17:58,907.5612891914101,1 +4/1/2012 17:59,908.9235237269177,1 +4/1/2012 18:00,910.2674188971979,1 +4/1/2012 18:01,911.592947889838,1 +4/1/2012 18:02,912.9000842614388,1 +4/1/2012 18:03,914.1888019477013,1 +4/1/2012 18:04,915.4590752551169,1 +4/1/2012 18:05,916.7108788648916,1 +4/1/2012 18:06,917.9441886574208,1 +4/1/2012 18:07,919.1589784086842,1 +4/1/2012 18:08,920.3552247618425,1 +4/1/2012 18:09,921.5329038989687,1 +4/1/2012 18:10,922.691992377965,1 +4/1/2012 18:11,923.8324671359268,1 +4/1/2012 18:12,924.9543054818693,1 +4/1/2012 18:13,926.057485105408,1 +4/1/2012 18:14,927.141984069634,1 +4/1/2012 18:15,928.2077808145282,1 +4/1/2012 18:16,929.254854160055,1 +4/1/2012 18:17,930.2831839827653,1 +4/1/2012 18:18,931.2927484780441,1 +4/1/2012 18:19,932.2835282910601,1 +4/1/2012 18:20,933.2555037490038,1 +4/1/2012 18:21,934.2086555597849,1 +4/1/2012 18:22,935.1429648059466,1 +4/1/2012 18:23,936.058412951919,1 +4/1/2012 18:24,936.9549818381174,1 +4/1/2012 18:25,937.8326536837798,1 +4/1/2012 18:26,938.6914110895166,1 +4/1/2012 18:27,939.5312370318452,1 +4/1/2012 18:28,940.3521148697101,1 +4/1/2012 18:29,941.1540288705581,1 +4/1/2012 18:30,941.9369620746523,1 +4/1/2012 18:31,942.7008995238247,1 +4/1/2012 18:32,943.4458260928685,1 +4/1/2012 18:33,944.1717270394992,1 +4/1/2012 18:34,944.8785879996012,1 +4/1/2012 18:35,945.5663949895419,1 +4/1/2012 18:36,946.2351344081491,1 +4/1/2012 18:37,946.8847930330305,1 +4/1/2012 18:38,947.5153580226918,1 +4/1/2012 18:39,948.126816918376,1 +4/1/2012 18:40,948.7191580309192,1 +4/1/2012 18:41,949.2923688693852,1 +4/1/2012 18:42,949.8464385206038,1 +4/1/2012 18:43,950.3813560493355,1 +4/1/2012 18:44,950.8971109033968,1 +4/1/2012 18:45,951.3936929103834,1 +4/1/2012 18:46,951.8710922815745,1 +4/1/2012 18:47,952.3292996087865,1 +4/1/2012 18:48,952.7683058659376,1 +4/1/2012 18:49,953.1881024102506,1 +4/1/2012 18:50,953.5886809795984,1 +4/1/2012 18:51,953.9700339452911,1 +4/1/2012 18:52,954.3321532981175,1 +4/1/2012 18:53,954.6750321861093,1 +4/1/2012 18:54,954.9986638782349,1 +4/1/2012 18:55,955.3030420248847,1 +4/1/2012 18:56,955.5881606602495,1 +4/1/2012 18:57,955.8540142004646,1 +4/1/2012 18:58,956.1005974445337,1 +4/1/2012 18:59,956.3279055749699,1 +4/1/2012 19:00,956.5359341563872,1 +4/1/2012 19:01,956.7246791371283,1 +4/1/2012 19:02,956.8941369551687,1 +4/1/2012 19:03,957.0443040971436,1 +4/1/2012 19:04,957.175177780536,1 +4/1/2012 19:05,957.2867554853715,1 +4/1/2012 19:06,957.3790350752402,1 +4/1/2012 19:07,957.4520147966049,1 +4/1/2012 19:08,957.5056932791584,1 +4/1/2012 19:09,957.5400695359402,1 +4/1/2012 19:10,957.5551429630466,1 +4/1/2012 19:11,957.5509133398784,1 +4/1/2012 19:12,957.527380828979,1 +4/1/2012 19:13,957.4845459762313,1 +4/1/2012 19:14,957.4224096624041,1 +4/1/2012 19:15,957.3409732831614,1 +4/1/2012 19:16,957.2402384985319,1 +4/1/2012 19:17,957.1202073871192,1 +4/1/2012 19:18,956.9808824107419,1 +4/1/2012 19:19,956.8222664139458,1 +4/1/2012 19:20,956.6443626248492,1 +4/1/2012 19:21,956.4471746540574,1 +4/1/2012 19:22,956.2307064955613,1 +4/1/2012 19:23,955.9949625264852,1 +4/1/2012 19:24,955.7399475061342,1 +4/1/2012 19:25,955.4656663871413,1 +4/1/2012 19:26,955.1721250622959,1 +4/1/2012 19:27,954.8593292624192,1 +4/1/2012 19:28,954.5272852786308,1 +4/1/2012 19:29,954.175999783701,1 +4/1/2012 19:30,953.8054798341012,1

diff --git a/pvlib/tests/test_clearsky.py b/pvlib/tests/test_clearsky.py index 37b95dcdf9..c2ef607f0f 100644 --- a/pvlib/tests/test_clearsky.py +++ b/pvlib/tests/test_clearsky.py @@ -533,6 +533,49 @@ def detect_clearsky_data(): return expected, cs +@pytest.fixture +def detect_clearsky_threshold_data(): + # this is (roughly) just a 2 hour period of the same data in + # detect_clearsky_data (which only spans 30 minutes) + data_file = DATA_DIR / 'detect_clearsky_threshold_data.csv' + expected = pd.read_csv( + data_file, index_col=0, parse_dates=True, comment='#') + expected = expected.tz_localize('UTC').tz_convert('Etc/GMT+7') + metadata = {} + with data_file.open() as f: + for line in f: + if line.startswith('#'): + key, value = line.strip('# \n').split(':') + metadata[key] = float(value) + else: + break + metadata['window_length'] = int(metadata['window_length']) + loc = Location(metadata['latitude'], metadata['longitude'], + altitude=metadata['elevation']) + # specify turbidity to guard against future lookup changes + cs = loc.get_clearsky(expected.index, linke_turbidity=2.658197) + return expected, cs + + +def test_clearsky_get_threshold(): + out = clearsky._clearsky_get_threshold(4.5) + expected = (58.75, 75, 64.375, -45, 80.0, 0.009375, 58.75) + assert np.allclose(out, expected) + + +def test_clearsky_get_threshold_raises_error(): + with pytest.raises(ValueError, match='can only be used for inputs'): + clearsky._clearsky_get_threshold(0.5) + + +def test_detect_clearsky_calls_threshold(mocker, detect_clearsky_threshold_data): + threshold_spy = mocker.spy(clearsky, '_clearsky_get_threshold') + expected, cs = detect_clearsky_threshold_data + threshold_actual = clearsky.detect_clearsky(expected['GHI'], cs['ghi'], + infer_limits=True) + assert threshold_spy.call_count == 1 + + def test_detect_clearsky(detect_clearsky_data): expected, cs = detect_clearsky_data clear_samples = clearsky.detect_clearsky( @@ -629,6 +672,18 @@ def test_detect_clearsky_missing_index(detect_clearsky_data): clearsky.detect_clearsky(expected['GHI'].values, cs['ghi'].values) +def test_detect_clearsky_not_enough_data(detect_clearsky_data): + expected, cs = detect_clearsky_data + with pytest.raises(ValueError, match='have at least'): + clearsky.detect_clearsky(expected['GHI'], cs['ghi'], window_length=60) + + +def test_detect_clearsky_optimizer_failed(detect_clearsky_data): + expected, cs = detect_clearsky_data + with pytest.raises(RuntimeError, match='Optimizer exited unsuccessfully'): + clearsky.detect_clearsky(expected['GHI'], cs['ghi'], window_length=15) + + @pytest.fixture def detect_clearsky_helper_data(): samples_per_window = 3

diff --git a/docs/sphinx/source/whatsnew/v0.10.2.rst b/docs/sphinx/source/whatsnew/v0.10.2.rst index 7259f6a566..dacfe27f53 100644 --- a/docs/sphinx/source/whatsnew/v0.10.2.rst +++ b/docs/sphinx/source/whatsnew/v0.10.2.rst @@ -15,6 +15,8 @@ Enhancements :py:func:`pvlib.iotools.get_pvgis_hourly`, :py:func:`pvlib.iotools.get_cams`, :py:func:`pvlib.iotools.get_bsrn`, and :py:func:`pvlib.iotools.read_midc_raw_data_from_nrel`. (:pull:`1800`) +* Added option to infer threshold values for + :py:func:`pvlib.clearsky.detect_clearsky` (:issue:`1808`, :pull:`1784`) Bug fixes @@ -39,4 +41,5 @@ Requirements Contributors ~~~~~~~~~~~~ * Adam R. Jensen (:ghuser:`AdamRJensen`) +* Abigail Jones (:ghuser:`ajonesr`) * Taos Transue (:ghuser:`reepoi`) diff --git a/pvlib/data/detect_clearsky_threshold_data.csv b/pvlib/data/detect_clearsky_threshold_data.csv new file mode 100644 index 0000000000..a36736b1a3 --- /dev/null +++ b/pvlib/data/detect_clearsky_threshold_data.csv @@ -0,0 +1,126 @@ +# latitude:35.04 +# longitude:-106.62 +# elevation:1619 +# window_length:10 +Time (UTC),GHI,Clear or not +4/1/2012 17:30,862.0935267144818,1 +4/1/2012 17:31,863.9568654037691,1 +4/1/2012 17:32,865.802767695237,1 +4/1/2012 17:33,867.6311939211416,1 +4/1/2012 17:34,869.4421084958154,1 +4/1/2012 17:35,871.2354749580768,1 +4/1/2012 17:36,873.0112572200139,1 +4/1/2012 17:37,874.7694195555663,1 +4/1/2012 17:38,876.5099266138993,1 +4/1/2012 17:39,878.2327434081394,1 +4/1/2012 17:40,879.9378353205582,1 +4/1/2012 17:41,881.6251681074431,1 +4/1/2012 17:42,500.0,0 +4/1/2012 17:43,300.0,0 +4/1/2012 17:44,400.0,0 +4/1/2012 17:45,888.1962370575133,1 +4/1/2012 17:46,889.7942734332919,1 +4/1/2012 17:47,891.3743529660121,1 +4/1/2012 17:48,892.9364440027008,1 +4/1/2012 17:49,894.4805152569894,1 +4/1/2012 17:50,896.0065358138269,1 +4/1/2012 17:51,897.514475133874,1 +4/1/2012 17:52,899.0043030438522,1 +4/1/2012 17:53,900.4759897479845,1 +4/1/2012 17:54,901.9295058184756,1 +4/1/2012 17:55,903.3648231563722,1 +4/1/2012 17:56,950.0,0 +4/1/2012 17:57,906.1807424805852,1 +4/1/2012 17:58,907.5612891914101,1 +4/1/2012 17:59,908.9235237269177,1 +4/1/2012 18:00,910.2674188971979,1 +4/1/2012 18:01,911.592947889838,1 +4/1/2012 18:02,912.9000842614388,1 +4/1/2012 18:03,914.1888019477013,1 +4/1/2012 18:04,915.4590752551169,1 +4/1/2012 18:05,916.7108788648916,1 +4/1/2012 18:06,917.9441886574208,1 +4/1/2012 18:07,919.1589784086842,1 +4/1/2012 18:08,920.3552247618425,1 +4/1/2012 18:09,921.5329038989687,1 +4/1/2012 18:10,922.691992377965,1 +4/1/2012 18:11,923.8324671359268,1 +4/1/2012 18:12,924.9543054818693,1 +4/1/2012 18:13,926.057485105408,1 +4/1/2012 18:14,927.141984069634,1 +4/1/2012 18:15,928.2077808145282,1 +4/1/2012 18:16,929.254854160055,1 +4/1/2012 18:17,930.2831839827653,1 +4/1/2012 18:18,931.2927484780441,1 +4/1/2012 18:19,932.2835282910601,1 +4/1/2012 18:20,933.2555037490038,1 +4/1/2012 18:21,934.2086555597849,1 +4/1/2012 18:22,935.1429648059466,1 +4/1/2012 18:23,936.058412951919,1 +4/1/2012 18:24,936.9549818381174,1 +4/1/2012 18:25,937.8326536837798,1 +4/1/2012 18:26,938.6914110895166,1 +4/1/2012 18:27,939.5312370318452,1 +4/1/2012 18:28,940.3521148697101,1 +4/1/2012 18:29,941.1540288705581,1 +4/1/2012 18:30,941.9369620746523,1 +4/1/2012 18:31,942.7008995238247,1 +4/1/2012 18:32,943.4458260928685,1 +4/1/2012 18:33,944.1717270394992,1 +4/1/2012 18:34,944.8785879996012,1 +4/1/2012 18:35,945.5663949895419,1 +4/1/2012 18:36,946.2351344081491,1 +4/1/2012 18:37,946.8847930330305,1 +4/1/2012 18:38,947.5153580226918,1 +4/1/2012 18:39,948.126816918376,1 +4/1/2012 18:40,948.7191580309192,1 +4/1/2012 18:41,949.2923688693852,1 +4/1/2012 18:42,949.8464385206038,1 +4/1/2012 18:43,950.3813560493355,1 +4/1/2012 18:44,950.8971109033968,1 +4/1/2012 18:45,951.3936929103834,1 +4/1/2012 18:46,951.8710922815745,1 +4/1/2012 18:47,952.3292996087865,1 +4/1/2012 18:48,952.7683058659376,1 +4/1/2012 18:49,953.1881024102506,1 +4/1/2012 18:50,953.5886809795984,1 +4/1/2012 18:51,953.9700339452911,1 +4/1/2012 18:52,954.3321532981175,1 +4/1/2012 18:53,954.6750321861093,1 +4/1/2012 18:54,954.9986638782349,1 +4/1/2012 18:55,955.3030420248847,1 +4/1/2012 18:56,955.5881606602495,1 +4/1/2012 18:57,955.8540142004646,1 +4/1/2012 18:58,956.1005974445337,1 +4/1/2012 18:59,956.3279055749699,1 +4/1/2012 19:00,956.5359341563872,1 +4/1/2012 19:01,956.7246791371283,1 +4/1/2012 19:02,956.8941369551687,1 +4/1/2012 19:03,957.0443040971436,1 +4/1/2012 19:04,957.175177780536,1 +4/1/2012 19:05,957.2867554853715,1 +4/1/2012 19:06,957.3790350752402,1 +4/1/2012 19:07,957.4520147966049,1 +4/1/2012 19:08,957.5056932791584,1 +4/1/2012 19:09,957.5400695359402,1 +4/1/2012 19:10,957.5551429630466,1 +4/1/2012 19:11,957.5509133398784,1 +4/1/2012 19:12,957.527380828979,1 +4/1/2012 19:13,957.4845459762313,1 +4/1/2012 19:14,957.4224096624041,1 +4/1/2012 19:15,957.3409732831614,1 +4/1/2012 19:16,957.2402384985319,1 +4/1/2012 19:17,957.1202073871192,1 +4/1/2012 19:18,956.9808824107419,1 +4/1/2012 19:19,956.8222664139458,1 +4/1/2012 19:20,956.6443626248492,1 +4/1/2012 19:21,956.4471746540574,1 +4/1/2012 19:22,956.2307064955613,1 +4/1/2012 19:23,955.9949625264852,1 +4/1/2012 19:24,955.7399475061342,1 +4/1/2012 19:25,955.4656663871413,1 +4/1/2012 19:26,955.1721250622959,1 +4/1/2012 19:27,954.8593292624192,1 +4/1/2012 19:28,954.5272852786308,1 +4/1/2012 19:29,954.175999783701,1 +4/1/2012 19:30,953.8054798341012,1

[ { "components": [ { "doc": "Returns threshold values for kwargs in detect_clearsky. See\nTable 1 in [1].\n\nReferences\n----------\n.. [1] Jordan, D.C. and C. Hansen, \"Clear-sky detection for PV\n degradation analysis using multiple regression\", Renewable Energy,\n v209, p. 393-400, 2023.", ...

[ "pvlib/tests/test_clearsky.py::test_clearsky_get_threshold", "pvlib/tests/test_clearsky.py::test_clearsky_get_threshold_raises_error", "pvlib/tests/test_clearsky.py::test_detect_clearsky_calls_threshold", "pvlib/tests/test_clearsky.py::test_detect_clearsky_not_enough_data", "pvlib/tests/test_clearsky.py::te...

[ "pvlib/tests/test_clearsky.py::test_ineichen_series", "pvlib/tests/test_clearsky.py::test_ineichen_series_perez_enhancement", "pvlib/tests/test_clearsky.py::test_ineichen_scalar_input", "pvlib/tests/test_clearsky.py::test_ineichen_nans", "pvlib/tests/test_clearsky.py::test_ineichen_arrays", "pvlib/tests/t...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Infer thresholds for detect_clearsky - [x] Closes #1808 - [x] I am familiar with the [contributing guidelines](https://pvlib-python.readthedocs.io/en/latest/contributing.html) - [x] Tests added - ~~[ ] Updates entries in [`docs/sphinx/source/reference`](https://github.com/pvlib/pvlib-python/blob/main/docs/sphinx/source/reference) for API changes.~~ - [x] Adds description and name entries in the appropriate "what's new" file in [`docs/sphinx/source/whatsnew`](https://github.com/pvlib/pvlib-python/tree/main/docs/sphinx/source/whatsnew) for all changes. Includes link to the GitHub Issue with `` :issue:`num` `` or this Pull Request with `` :pull:`num` ``. Includes contributor name and/or GitHub username (link with `` :ghuser:`user` ``). - [x] New code is fully documented. Includes [numpydoc](https://numpydoc.readthedocs.io/en/latest/format.html) compliant docstrings, examples, and comments where necessary. - [x] Pull request is nearly complete and ready for detailed review. - [x] Maintainer: Appropriate GitHub Labels (including `remote-data`) and Milestone are assigned to the Pull Request and linked Issue. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pvlib/clearsky.py] (definition of _clearsky_get_threshold:) def _clearsky_get_threshold(sample_interval): """Returns threshold values for kwargs in detect_clearsky. See Table 1 in [1]. References ---------- .. [1] Jordan, D.C. and C. Hansen, "Clear-sky detection for PV degradation analysis using multiple regression", Renewable Energy, v209, p. 393-400, 2023.""" [end of new definitions in pvlib/clearsky.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Extend detect_clearsky for different data periods The threshold parameters for `pvlib.clearsky.detect_clearsky` were calibrated using data at 1 minute intervals. Recently, Jordan and Hansen [1] showed how to extend the `detect_clearsky` function for time-averaged data out to 30 minute intervals. The extension requires different data window length and different values for the threshold parameters, but doesn't require any change to the parameter calculations. Interestingly, the threshold values are linear functions of the data interval. **Describe the solution you'd like** Implement a helper function for `detect_clearsky` that infers the parameter values from the input data interval. **Describe alternatives you've considered** Leaving as-is. **Additional context** [1] Jordan, D.C. and C. Hansen, "Clear-sky detection for PV degradation analysis using multiple regression", Renewable Energy, v209, p. 393-400, 2023. ---------- -------------------- </issues>

d53f97e984bfdd268aa92f8bf482ced0edda0110

conan-io__conan-14169

14,169

conan-io/conan

null

ccdd94f2941060bf69b47536b4ccbc22da1288ac

2023-06-26T17:15:08Z

diff --git a/conan/tools/files/__init__.py b/conan/tools/files/__init__.py index f47cd2beffd..a697136753c 100644 --- a/conan/tools/files/__init__.py +++ b/conan/tools/files/__init__.py @@ -7,4 +7,4 @@ from conan.tools.files.packager import AutoPackager from conan.tools.files.symlinks import symlinks from conan.tools.files.copy_pattern import copy -from conan.tools.files.conandata import update_conandata +from conan.tools.files.conandata import update_conandata, trim_conandata diff --git a/conan/tools/files/conandata.py b/conan/tools/files/conandata.py index 43bd7a12d44..9e62288266d 100644 --- a/conan/tools/files/conandata.py +++ b/conan/tools/files/conandata.py @@ -31,3 +31,31 @@ def recursive_dict_update(d, u): recursive_dict_update(conandata, data) new_content = yaml.safe_dump(conandata) save(path, new_content) + + +def trim_conandata(conanfile): + """ + Tool to modify the ``conandata.yml`` once it is exported, to limit it to the current version + only + """ + if not hasattr(conanfile, "export_folder") or conanfile.export_folder is None: + raise ConanException("The 'trim_conandata()' can only be used in the 'export()' method") + path = os.path.join(conanfile.export_folder, "conandata.yml") + if not os.path.exists(path): + raise ConanException("conandata.yml file doesn't exist") + + conandata = load(path) + conandata = yaml.safe_load(conandata) + + version = str(conanfile.version) + result = {} + for k, v in conandata.items(): + if not isinstance(v, dict): + result[k] = v + continue # to allow user extra conandata, common to all versions + version_data = v.get(version) + if version_data is not None: + result[k] = {version: version_data} + + new_conandata_yml = yaml.safe_dump(result, default_flow_style=False) + save(path, new_conandata_yml)

diff --git a/conans/test/integration/conanfile/conan_data_test.py b/conans/test/integration/conanfile/conan_data_test.py index ff154c15cb3..47d773a252e 100644 --- a/conans/test/integration/conanfile/conan_data_test.py +++ b/conans/test/integration/conanfile/conan_data_test.py @@ -331,3 +331,53 @@ def export(self): c.save({"conanfile.py": conanfile}) c.run("export .") # It doesn't fail assert "pkg/0.1: Calling export()" in c.out + + +def test_conandata_trim(): + """ test the explict trim_conandata() helper + """ + c = TestClient() + conanfile = textwrap.dedent(""" + from conan import ConanFile + from conan.tools.files import trim_conandata + + class Pkg(ConanFile): + name = "pkg" + def export(self): + trim_conandata(self) + """) + conandata_yml = textwrap.dedent("""\ + sources: + "1.0": + url: "url1" + sha256: "sha1" + patches: + "1.0": + - patch_file: "patches/some_patch" + base_path: "source_subfolder" + something: else + """) + c.save({"conanfile.py": conanfile, + "conandata.yml": conandata_yml}) + c.run("export . 1.0@") + assert "pkg/1.0: Exported revision: 70612e15e4fc9af1123fe11731ac214f" in c.out + conandata_yml2 = textwrap.dedent("""\ + sources: + "1.0": + url: "url1" + sha256: "sha1" + "1.1": + url: "url2" + sha256: "sha2" + patches: + "1.1": + - patch_file: "patches/some_patch2" + base_path: "source_subfolder" + "1.0": + - patch_file: "patches/some_patch" + base_path: "source_subfolder" + something: else + """) + c.save({"conandata.yml": conandata_yml2}) + c.run("export . 1.0@") + assert "pkg/1.0: Exported revision: 70612e15e4fc9af1123fe11731ac214f" in c.out

[ { "components": [ { "doc": "Tool to modify the ``conandata.yml`` once it is exported, to limit it to the current version\nonly", "lines": [ 36, 61 ], "name": "trim_conandata", "signature": "def trim_conandata(conanfile):", "type": "functi...

[ "conans/test/integration/conanfile/conan_data_test.py::test_conandata_trim" ]

[ "conans/test/integration/conanfile/conan_data_test.py::ConanDataTest::test_conan_data_as_source", "conans/test/integration/conanfile/conan_data_test.py::ConanDataTest::test_conan_data_as_source_newtools", "conans/test/integration/conanfile/conan_data_test.py::ConanDataTest::test_conan_data_development_flow", ...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> trim_conandata() Changelog: Feature: New ``trim_conandata()`` function to make things explicit, not depend on hook. Docs: https://github.com/conan-io/docs/pull/3373 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conan/tools/files/conandata.py] (definition of trim_conandata:) def trim_conandata(conanfile): """Tool to modify the ``conandata.yml`` once it is exported, to limit it to the current version only""" [end of new definitions in conan/tools/files/conandata.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

4a5b19a75db9225316c8cb022a2dfb9705a2af34

scikit-learn__scikit-learn-26689

26,689

scikit-learn/scikit-learn

1.6

f6280bf4fd30627eeef7eb344f17d4fc05d37502

2023-06-23T17:50:45Z

diff --git a/doc/whats_new/upcoming_changes/sklearn.neighbors/26689.enhancement.rst b/doc/whats_new/upcoming_changes/sklearn.neighbors/26689.enhancement.rst new file mode 100644 index 0000000000000..ebc50d1bc6aaa --- /dev/null +++ b/doc/whats_new/upcoming_changes/sklearn.neighbors/26689.enhancement.rst @@ -0,0 +1,7 @@ +- Add :meth:`neighbors.NearestCentroid.decision_function`, + :meth:`neighbors.NearestCentroid.predict_proba` and + :meth:`neighbors.NearestCentroid.predict_log_proba` + to the :class:`neighbors.NearestCentroid` estimator class. + Support the case when `X` is sparse and `shrinking_threshold` + is not `None` in :class:`neighbors.NearestCentroid`. + By :user:`Matthew Ning <NoPenguinsLand>` diff --git a/sklearn/discriminant_analysis.py b/sklearn/discriminant_analysis.py index 69339491d214d..6a851c07dc896 100644 --- a/sklearn/discriminant_analysis.py +++ b/sklearn/discriminant_analysis.py @@ -168,6 +168,84 @@ def _class_cov(X, y, priors, shrinkage=None, covariance_estimator=None): return cov +class DiscriminantAnalysisPredictionMixin: + """Mixin class for QuadraticDiscriminantAnalysis and NearestCentroid.""" + + def decision_function(self, X): + """Apply decision function to an array of samples. + + Parameters + ---------- + X : {array-like, sparse matrix} of shape (n_samples, n_features) + Array of samples (test vectors). + + Returns + ------- + y_scores : ndarray of shape (n_samples,) or (n_samples, n_classes) + Decision function values related to each class, per sample. + In the two-class case, the shape is `(n_samples,)`, giving the + log likelihood ratio of the positive class. + """ + y_scores = self._decision_function(X) + if len(self.classes_) == 2: + return y_scores[:, 1] - y_scores[:, 0] + return y_scores + + def predict(self, X): + """Perform classification on an array of vectors `X`. + + Returns the class label for each sample. + + Parameters + ---------- + X : {array-like, sparse matrix} of shape (n_samples, n_features) + Input vectors, where `n_samples` is the number of samples and + `n_features` is the number of features. + + Returns + ------- + y_pred : ndarray of shape (n_samples,) + Class label for each sample. + """ + scores = self._decision_function(X) + return self.classes_.take(scores.argmax(axis=1)) + + def predict_proba(self, X): + """Estimate class probabilities. + + Parameters + ---------- + X : {array-like, sparse matrix} of shape (n_samples, n_features) + Input data. + + Returns + ------- + y_proba : ndarray of shape (n_samples, n_classes) + Probability estimate of the sample for each class in the + model, where classes are ordered as they are in `self.classes_`. + """ + return np.exp(self.predict_log_proba(X)) + + def predict_log_proba(self, X): + """Estimate log class probabilities. + + Parameters + ---------- + X : {array-like, sparse matrix} of shape (n_samples, n_features) + Input data. + + Returns + ------- + y_log_proba : ndarray of shape (n_samples, n_classes) + Estimated log probabilities. + """ + scores = self._decision_function(X) + log_likelihood = scores - scores.max(axis=1)[:, np.newaxis] + return log_likelihood - np.log( + np.exp(log_likelihood).sum(axis=1)[:, np.newaxis] + ) + + class LinearDiscriminantAnalysis( ClassNamePrefixFeaturesOutMixin, LinearClassifierMixin, @@ -744,9 +822,9 @@ def decision_function(self, X): Returns ------- - C : ndarray of shape (n_samples,) or (n_samples, n_classes) + y_scores : ndarray of shape (n_samples,) or (n_samples, n_classes) Decision function values related to each class, per sample. - In the two-class case, the shape is (n_samples,), giving the + In the two-class case, the shape is `(n_samples,)`, giving the log likelihood ratio of the positive class. """ # Only override for the doc @@ -758,7 +836,9 @@ def __sklearn_tags__(self): return tags -class QuadraticDiscriminantAnalysis(ClassifierMixin, BaseEstimator): +class QuadraticDiscriminantAnalysis( + DiscriminantAnalysisPredictionMixin, ClassifierMixin, BaseEstimator +): """Quadratic Discriminant Analysis. A classifier with a quadratic decision boundary, generated @@ -992,14 +1072,10 @@ def decision_function(self, X): ------- C : ndarray of shape (n_samples,) or (n_samples, n_classes) Decision function values related to each class, per sample. - In the two-class case, the shape is (n_samples,), giving the + In the two-class case, the shape is `(n_samples,)`, giving the log likelihood ratio of the positive class. """ - dec_func = self._decision_function(X) - # handle special case of two classes - if len(self.classes_) == 2: - return dec_func[:, 1] - dec_func[:, 0] - return dec_func + return super().decision_function(X) def predict(self, X): """Perform classification on an array of test vectors X. @@ -1017,9 +1093,7 @@ def predict(self, X): C : ndarray of shape (n_samples,) Estimated probabilities. """ - d = self._decision_function(X) - y_pred = self.classes_.take(d.argmax(1)) - return y_pred + return super().predict(X) def predict_proba(self, X): """Return posterior probabilities of classification. @@ -1034,12 +1108,9 @@ def predict_proba(self, X): C : ndarray of shape (n_samples, n_classes) Posterior probabilities of classification per class. """ - values = self._decision_function(X) # compute the likelihood of the underlying gaussian models # up to a multiplicative constant. - likelihood = np.exp(values - values.max(axis=1)[:, np.newaxis]) - # compute posterior probabilities - return likelihood / likelihood.sum(axis=1)[:, np.newaxis] + return super().predict_proba(X) def predict_log_proba(self, X): """Return log of posterior probabilities of classification. @@ -1055,5 +1126,4 @@ def predict_log_proba(self, X): Posterior log-probabilities of classification per class. """ # XXX : can do better to avoid precision overflows - probas_ = self.predict_proba(X) - return np.log(probas_) + return super().predict_log_proba(X) diff --git a/sklearn/neighbors/_nearest_centroid.py b/sklearn/neighbors/_nearest_centroid.py index f92ae68973741..cb8d1dbf7107f 100644 --- a/sklearn/neighbors/_nearest_centroid.py +++ b/sklearn/neighbors/_nearest_centroid.py @@ -5,21 +5,29 @@ # Authors: The scikit-learn developers # SPDX-License-Identifier: BSD-3-Clause +import warnings from numbers import Real import numpy as np from scipy import sparse as sp from ..base import BaseEstimator, ClassifierMixin, _fit_context -from ..metrics.pairwise import pairwise_distances_argmin +from ..discriminant_analysis import DiscriminantAnalysisPredictionMixin +from ..metrics.pairwise import ( + pairwise_distances, + pairwise_distances_argmin, +) from ..preprocessing import LabelEncoder +from ..utils._available_if import available_if from ..utils._param_validation import Interval, StrOptions from ..utils.multiclass import check_classification_targets from ..utils.sparsefuncs import csc_median_axis_0 from ..utils.validation import check_is_fitted, validate_data -class NearestCentroid(ClassifierMixin, BaseEstimator): +class NearestCentroid( + DiscriminantAnalysisPredictionMixin, ClassifierMixin, BaseEstimator +): """Nearest centroid classifier. Each class is represented by its centroid, with test samples classified to @@ -47,6 +55,13 @@ class is the arithmetic mean, which minimizes the sum of squared L1 distances. shrink_threshold : float, default=None Threshold for shrinking centroids to remove features. + priors : {"uniform", "empirical"} or array-like of shape (n_classes,), \ + default="uniform" + The class prior probabilities. By default, the class proportions are + inferred from the training data. + + .. versionadded:: 1.6 + Attributes ---------- centroids_ : array-like of shape (n_classes, n_features) @@ -66,6 +81,24 @@ class is the arithmetic mean, which minimizes the sum of squared L1 distances. .. versionadded:: 1.0 + deviations_ : ndarray of shape (n_classes, n_features) + Deviations (or shrinkages) of the centroids of each class from the + overall centroid. Equal to eq. (18.4) if `shrink_threshold=None`, + else (18.5) p. 653 of [2]. Can be used to identify features used + for classification. + + .. versionadded:: 1.6 + + within_class_std_dev_ : ndarray of shape (n_features,) + Pooled or within-class standard deviation of input data. + + .. versionadded:: 1.6 + + class_prior_ : ndarray of shape (n_classes,) + The class prior probabilities. + + .. versionadded:: 1.6 + See Also -------- KNeighborsClassifier : Nearest neighbors classifier. @@ -77,11 +110,14 @@ class is the arithmetic mean, which minimizes the sum of squared L1 distances. References ---------- - Tibshirani, R., Hastie, T., Narasimhan, B., & Chu, G. (2002). Diagnosis of + [1] Tibshirani, R., Hastie, T., Narasimhan, B., & Chu, G. (2002). Diagnosis of multiple cancer types by shrunken centroids of gene expression. Proceedings of the National Academy of Sciences of the United States of America, 99(10), 6567-6572. The National Academy of Sciences. + [2] Hastie, T., Tibshirani, R., Friedman, J. (2009). The Elements of Statistical + Learning Data Mining, Inference, and Prediction. 2nd Edition. New York, Springer. + Examples -------- >>> from sklearn.neighbors import NearestCentroid @@ -93,19 +129,24 @@ class is the arithmetic mean, which minimizes the sum of squared L1 distances. NearestCentroid() >>> print(clf.predict([[-0.8, -1]])) [1] - - For a more detailed example see: - :ref:`sphx_glr_auto_examples_neighbors_plot_nearest_centroid.py` """ _parameter_constraints: dict = { "metric": [StrOptions({"manhattan", "euclidean"})], "shrink_threshold": [Interval(Real, 0, None, closed="neither"), None], + "priors": ["array-like", StrOptions({"empirical", "uniform"})], } - def __init__(self, metric="euclidean", *, shrink_threshold=None): + def __init__( + self, + metric="euclidean", + *, + shrink_threshold=None, + priors="uniform", + ): self.metric = metric self.shrink_threshold = shrink_threshold + self.priors = priors @_fit_context(prefer_skip_nested_validation=True) def fit(self, X, y): @@ -133,8 +174,6 @@ def fit(self, X, y): else: X, y = validate_data(self, X, y, accept_sparse=["csr", "csc"]) is_X_sparse = sp.issparse(X) - if is_X_sparse and self.shrink_threshold: - raise ValueError("threshold shrinking not supported for sparse input") check_classification_targets(y) n_samples, n_features = X.shape @@ -148,8 +187,26 @@ def fit(self, X, y): % (n_classes) ) + if self.priors == "empirical": # estimate priors from sample + _, class_counts = np.unique(y, return_inverse=True) # non-negative ints + self.class_prior_ = np.bincount(class_counts) / float(len(y)) + elif self.priors == "uniform": + self.class_prior_ = np.asarray([1 / n_classes] * n_classes) + else: + self.class_prior_ = np.asarray(self.priors) + + if (self.class_prior_ < 0).any(): + raise ValueError("priors must be non-negative") + if not np.isclose(self.class_prior_.sum(), 1.0): + warnings.warn( + "The priors do not sum to 1. Normalizing such that it sums to one.", + UserWarning, + ) + self.class_prior_ = self.class_prior_ / self.class_prior_.sum() + # Mask mapping each class to its members. self.centroids_ = np.empty((n_classes, n_features), dtype=np.float64) + # Number of clusters in each class. nk = np.zeros(n_classes) @@ -168,30 +225,44 @@ def fit(self, X, y): else: # metric == "euclidean" self.centroids_[cur_class] = X[center_mask].mean(axis=0) + # Compute within-class std_dev with unshrunked centroids + variance = np.array(X - self.centroids_[y_ind], copy=False) ** 2 + self.within_class_std_dev_ = np.array( + np.sqrt(variance.sum(axis=0) / (n_samples - n_classes)), copy=False + ) + if any(self.within_class_std_dev_ == 0): + warnings.warn( + "self.within_class_std_dev_ has at least 1 zero standard deviation." + "Inputs within the same classes for at least 1 feature are identical." + ) + + err_msg = "All features have zero variance. Division by zero." + if is_X_sparse and np.all((X.max(axis=0) - X.min(axis=0)).toarray() == 0): + raise ValueError(err_msg) + elif not is_X_sparse and np.all(np.ptp(X, axis=0) == 0): + raise ValueError(err_msg) + + dataset_centroid_ = X.mean(axis=0) + # m parameter for determining deviation + m = np.sqrt((1.0 / nk) - (1.0 / n_samples)) + # Calculate deviation using the standard deviation of centroids. + # To deter outliers from affecting the results. + s = self.within_class_std_dev_ + np.median(self.within_class_std_dev_) + mm = m.reshape(len(m), 1) # Reshape to allow broadcasting. + ms = mm * s + self.deviations_ = np.array( + (self.centroids_ - dataset_centroid_) / ms, copy=False + ) + # Soft thresholding: if the deviation crosses 0 during shrinking, + # it becomes zero. if self.shrink_threshold: - if np.all(np.ptp(X, axis=0) == 0): - raise ValueError("All features have zero variance. Division by zero.") - dataset_centroid_ = np.mean(X, axis=0) - - # m parameter for determining deviation - m = np.sqrt((1.0 / nk) - (1.0 / n_samples)) - # Calculate deviation using the standard deviation of centroids. - variance = (X - self.centroids_[y_ind]) ** 2 - variance = variance.sum(axis=0) - s = np.sqrt(variance / (n_samples - n_classes)) - s += np.median(s) # To deter outliers from affecting the results. - mm = m.reshape(len(m), 1) # Reshape to allow broadcasting. - ms = mm * s - deviation = (self.centroids_ - dataset_centroid_) / ms - # Soft thresholding: if the deviation crosses 0 during shrinking, - # it becomes zero. - signs = np.sign(deviation) - deviation = np.abs(deviation) - self.shrink_threshold - np.clip(deviation, 0, None, out=deviation) - deviation *= signs + signs = np.sign(self.deviations_) + self.deviations_ = np.abs(self.deviations_) - self.shrink_threshold + np.clip(self.deviations_, 0, None, out=self.deviations_) + self.deviations_ *= signs # Now adjust the centroids using the deviation - msd = ms * deviation - self.centroids_ = dataset_centroid_[np.newaxis, :] + msd + msd = ms * self.deviations_ + self.centroids_ = np.array(dataset_centroid_ + msd, copy=False) return self def predict(self, X): @@ -202,16 +273,62 @@ def predict(self, X): Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) - Test samples. + Input data. Returns ------- - C : ndarray of shape (n_samples,) + y_pred : ndarray of shape (n_samples,) The predicted classes. """ check_is_fitted(self) + if np.isclose(self.class_prior_, 1 / len(self.classes_)).all(): + # `validate_data` is called here since we are not calling `super()` + X = validate_data(self, X, accept_sparse="csr", reset=False) + return self.classes_[ + pairwise_distances_argmin(X, self.centroids_, metric=self.metric) + ] + else: + return super().predict(X) + + def _decision_function(self, X): + # return discriminant scores, see eq. (18.2) p. 652 of the ESL. + check_is_fitted(self, "centroids_") + + X_normalized = validate_data( + self, X, copy=True, reset=False, accept_sparse="csr", dtype=np.float64 + ) + + discriminant_score = np.empty( + (X_normalized.shape[0], self.classes_.size), dtype=np.float64 + ) + + mask = self.within_class_std_dev_ != 0 + X_normalized[:, mask] /= self.within_class_std_dev_[mask] + centroids_normalized = self.centroids_.copy() + centroids_normalized[:, mask] /= self.within_class_std_dev_[mask] + + for class_idx in range(self.classes_.size): + distances = pairwise_distances( + X_normalized, centroids_normalized[[class_idx]], metric=self.metric + ).ravel() + distances **= 2 + discriminant_score[:, class_idx] = np.squeeze( + -distances + 2.0 * np.log(self.class_prior_[class_idx]) + ) + + return discriminant_score + + def _check_euclidean_metric(self): + return self.metric == "euclidean" + + decision_function = available_if(_check_euclidean_metric)( + DiscriminantAnalysisPredictionMixin.decision_function + ) + + predict_proba = available_if(_check_euclidean_metric)( + DiscriminantAnalysisPredictionMixin.predict_proba + ) - X = validate_data(self, X, accept_sparse="csr", reset=False) - return self.classes_[ - pairwise_distances_argmin(X, self.centroids_, metric=self.metric) - ] + predict_log_proba = available_if(_check_euclidean_metric)( + DiscriminantAnalysisPredictionMixin.predict_log_proba + )

diff --git a/sklearn/neighbors/tests/test_nearest_centroid.py b/sklearn/neighbors/tests/test_nearest_centroid.py index 5ce792ac29d56..1aa9274cd28a8 100644 --- a/sklearn/neighbors/tests/test_nearest_centroid.py +++ b/sklearn/neighbors/tests/test_nearest_centroid.py @@ -4,10 +4,14 @@ import numpy as np import pytest -from numpy.testing import assert_array_equal from sklearn import datasets from sklearn.neighbors import NearestCentroid +from sklearn.utils._testing import ( + assert_allclose, + assert_array_almost_equal, + assert_array_equal, +) from sklearn.utils.fixes import CSR_CONTAINERS # toy sample @@ -15,6 +19,11 @@ y = [-1, -1, -1, 1, 1, 1] T = [[-1, -1], [2, 2], [3, 2]] true_result = [-1, 1, 1] +true_result_prior1 = [-1, 1, 1] + +true_discriminant_scores = [-32, 64, 80] +true_proba = [[1, 1.26642e-14], [1.60381e-28, 1], [1.80485e-35, 1]] + # also load the iris dataset # and randomly permute it @@ -31,9 +40,30 @@ def test_classification_toy(csr_container): X_csr = csr_container(X) T_csr = csr_container(T) + # Check classification on a toy dataset, including sparse versions. clf = NearestCentroid() clf.fit(X, y) assert_array_equal(clf.predict(T), true_result) + assert_array_almost_equal(clf.decision_function(T), true_discriminant_scores) + assert_array_almost_equal(clf.predict_proba(T), true_proba) + + # Test uniform priors + clf = NearestCentroid(priors="uniform") + clf.fit(X, y) + assert_array_equal(clf.predict(T), true_result) + assert_array_almost_equal(clf.decision_function(T), true_discriminant_scores) + assert_array_almost_equal(clf.predict_proba(T), true_proba) + + clf = NearestCentroid(priors="empirical") + clf.fit(X, y) + assert_array_equal(clf.predict(T), true_result) + assert_array_almost_equal(clf.decision_function(T), true_discriminant_scores) + assert_array_almost_equal(clf.predict_proba(T), true_proba) + + # Test custom priors + clf = NearestCentroid(priors=[0.25, 0.75]) + clf.fit(X, y) + assert_array_equal(clf.predict(T), true_result_prior1) # Same test, but with a sparse matrix to fit and test. clf = NearestCentroid() @@ -159,3 +189,49 @@ def test_features_zero_var(): clf = NearestCentroid(shrink_threshold=0.1) with pytest.raises(ValueError): clf.fit(X, y) + + +def test_negative_priors_error(): + """Check that we raise an error when the user-defined priors are negative.""" + clf = NearestCentroid(priors=[-2, 4]) + with pytest.raises(ValueError, match="priors must be non-negative"): + clf.fit(X, y) + + +def test_warn_non_normalized_priors(): + """Check that we raise a warning and normalize the user-defined priors when they + don't sum to 1. + """ + priors = [2, 4] + clf = NearestCentroid(priors=priors) + with pytest.warns( + UserWarning, + match="The priors do not sum to 1. Normalizing such that it sums to one.", + ): + clf.fit(X, y) + + assert_allclose(clf.class_prior_, np.asarray(priors) / np.asarray(priors).sum()) + + +@pytest.mark.parametrize( + "response_method", ["decision_function", "predict_proba", "predict_log_proba"] +) +def test_method_not_available_with_manhattan(response_method): + """Check that we raise an AttributeError with Manhattan metric when trying + to call a non-thresholded response method. + """ + clf = NearestCentroid(metric="manhattan").fit(X, y) + with pytest.raises(AttributeError): + getattr(clf, response_method)(T) + + +@pytest.mark.parametrize("array_constructor", [np.array] + CSR_CONTAINERS) +def test_error_zero_variances(array_constructor): + """Check that we raise an error when the variance for all features is zero.""" + X = np.ones((len(y), 2)) + X[:, 1] *= 2 + X = array_constructor(X) + + clf = NearestCentroid() + with pytest.raises(ValueError, match="All features have zero variance"): + clf.fit(X, y)

diff --git a/doc/whats_new/upcoming_changes/sklearn.neighbors/26689.enhancement.rst b/doc/whats_new/upcoming_changes/sklearn.neighbors/26689.enhancement.rst new file mode 100644 index 0000000000000..ebc50d1bc6aaa --- /dev/null +++ b/doc/whats_new/upcoming_changes/sklearn.neighbors/26689.enhancement.rst @@ -0,0 +1,7 @@ +- Add :meth:`neighbors.NearestCentroid.decision_function`, + :meth:`neighbors.NearestCentroid.predict_proba` and + :meth:`neighbors.NearestCentroid.predict_log_proba` + to the :class:`neighbors.NearestCentroid` estimator class. + Support the case when `X` is sparse and `shrinking_threshold` + is not `None` in :class:`neighbors.NearestCentroid`. + By :user:`Matthew Ning <NoPenguinsLand>`

[ { "components": [ { "doc": "Mixin class for QuadraticDiscriminantAnalysis and NearestCentroid.", "lines": [ 171, 245 ], "name": "DiscriminantAnalysisPredictionMixin", "signature": "class DiscriminantAnalysisPredictionMixin:", "type": "cla...

[ "sklearn/neighbors/tests/test_nearest_centroid.py::test_classification_toy[csr_matrix]", "sklearn/neighbors/tests/test_nearest_centroid.py::test_classification_toy[csr_array]", "sklearn/neighbors/tests/test_nearest_centroid.py::test_negative_priors_error", "sklearn/neighbors/tests/test_nearest_centroid.py::te...

[ "sklearn/neighbors/tests/test_nearest_centroid.py::test_iris", "sklearn/neighbors/tests/test_nearest_centroid.py::test_iris_shrinkage", "sklearn/neighbors/tests/test_nearest_centroid.py::test_pickle", "sklearn/neighbors/tests/test_nearest_centroid.py::test_shrinkage_correct", "sklearn/neighbors/tests/test_n...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> ENH Add decision_function, predict_proba and predict_log_proba for NearestCentroid estimator #### Reference Issues/PRs closes #17711 and #26659 supersede #17711 #### What does this implement/fix? Explain your changes. Add `decision_function`, `predict_proba` and `predict_log_proba` methods for **NearestCentroid** estimator class for usage with `roc_curve` function. The **NearestCentroid** class constructor now has an additional parameter called _priors_. By default, _priors_ is set to `None`. When _priors_ is set to `None`, class _priors_ will be estimated using the sample data _X_. Thus, it is not backward compatible with the old version of **NearestCentroid**. The old and new **NearestCentroid** estimators will yield different results because the old **NearestCentroid** estimator assumed equal class _priors_. #### Any other comments? I try to keep the design as consistent as possible with the **LinearDiscriminantAnalysis** estimator. So, the _priors_ parameter in both classes are the same. Open to feedback and advise. #### References Tibshirani, R., Hastie, T., Narasimhan, B., & Chu, G. (2002). Class Prediction by Nearest Shrunken Centroids, with Applications to DNA Microaarrays. Statistical Science 18(1), p. 104-117. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/discriminant_analysis.py] (definition of DiscriminantAnalysisPredictionMixin:) class DiscriminantAnalysisPredictionMixin: """Mixin class for QuadraticDiscriminantAnalysis and NearestCentroid.""" (definition of DiscriminantAnalysisPredictionMixin.decision_function:) def decision_function(self, X): """Apply decision function to an array of samples. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Array of samples (test vectors). Returns ------- y_scores : ndarray of shape (n_samples,) or (n_samples, n_classes) Decision function values related to each class, per sample. In the two-class case, the shape is `(n_samples,)`, giving the log likelihood ratio of the positive class.""" (definition of DiscriminantAnalysisPredictionMixin.predict:) def predict(self, X): """Perform classification on an array of vectors `X`. Returns the class label for each sample. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Input vectors, where `n_samples` is the number of samples and `n_features` is the number of features. Returns ------- y_pred : ndarray of shape (n_samples,) Class label for each sample.""" (definition of DiscriminantAnalysisPredictionMixin.predict_proba:) def predict_proba(self, X): """Estimate class probabilities. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Input data. Returns ------- y_proba : ndarray of shape (n_samples, n_classes) Probability estimate of the sample for each class in the model, where classes are ordered as they are in `self.classes_`.""" (definition of DiscriminantAnalysisPredictionMixin.predict_log_proba:) def predict_log_proba(self, X): """Estimate log class probabilities. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Input data. Returns ------- y_log_proba : ndarray of shape (n_samples, n_classes) Estimated log probabilities.""" [end of new definitions in sklearn/discriminant_analysis.py] [start of new definitions in sklearn/neighbors/_nearest_centroid.py] (definition of NearestCentroid._decision_function:) def _decision_function(self, X): (definition of NearestCentroid._check_euclidean_metric:) def _check_euclidean_metric(self): [end of new definitions in sklearn/neighbors/_nearest_centroid.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Implement probability estimates for NearestCentroid classifier #### Reference Issues/PRs There are no related issues or PRs. #### What does this implement/fix? Explain your changes. This contribution implements the .predict_proba() method for the NearestCentroid() classifier based on the contribution of _Tibshirani, R., Hastie, T., Narasimhan, B., & Chu, G. (2002). Class Prediction by Nearest Shrunken Centroids, with Applications to DNA Microaarrays. Statistical Science 18(1), p. 104-117._ #### Any other comments? Currently, the estimation of probabilities is optional and has to be enabled at the instantiation of the classifier. However, this is a design decision and any advise is welcome. ---------- @kempa-liehr Are you able to complete this PR. Otherwise, I would close it and open a new issue with the necessary information such that a new contributor can takeover. @adrnjalali. @glemaitre Thanks for catching up. I'll be able to continue working on the PR next week. Sorry, for the delay. @kempa-liehr would you like to finish this or leave it to a new contributor? -------------------- </issues>

18dc8630a7cbe1b591c12774949058b12157a39a

astropy__astropy-14979

14,979

astropy/astropy

5.2

9e3d8361e8b047a13d6279693f169476882e38f9

2023-06-22T19:53:15Z

diff --git a/astropy/cosmology/_io/yaml.py b/astropy/cosmology/_io/yaml.py index abdf8f73749e..71bf1a5bda1e 100644 --- a/astropy/cosmology/_io/yaml.py +++ b/astropy/cosmology/_io/yaml.py @@ -200,9 +200,6 @@ def to_yaml(cosmology, *args): # =================================================================== # Register -for cosmo_cls in _COSMOLOGY_CLASSES.values(): - register_cosmology_yaml(cosmo_cls) - convert_registry.register_reader("yaml", Cosmology, from_yaml) convert_registry.register_writer("yaml", Cosmology, to_yaml) # convert_registry.register_identifier("yaml", Cosmology, yaml_identify) diff --git a/astropy/cosmology/core.py b/astropy/cosmology/core.py index 3036dc40d2ea..98f635b80e3c 100644 --- a/astropy/cosmology/core.py +++ b/astropy/cosmology/core.py @@ -70,12 +70,16 @@ class Cosmology(metaclass=abc.ABCMeta): Notes ----- - Class instances are static -- you cannot (and should not) change the values - of the parameters. That is, all of the above attributes (except meta) are - read only. + Class instances are static -- you cannot (and should not) change the + values of the parameters. That is, all of the above attributes + (except meta) are read only. For details on how to create performant custom subclasses, see the documentation on :ref:`astropy-cosmology-fast-integrals`. + + Cosmology subclasses are automatically registered in a global registry + and with various I/O methods. To turn off or change this registration, + override the ``_register_cls`` classmethod in the subclass. """ meta = MetaData() @@ -125,8 +129,9 @@ def __init_subclass__(cls): cls.__all_parameters__ = cls.__parameters__ + tuple(derived_parameters) # ------------------- - # register as a Cosmology subclass - _COSMOLOGY_CLASSES[cls.__qualname__] = cls + # Registration + + cls._register_cls() @classproperty(lazy=True) def _init_signature(cls): @@ -136,6 +141,16 @@ def _init_signature(cls): sig = sig.replace(parameters=list(sig.parameters.values())[1:]) return sig + @classmethod + def _register_cls(cls): + # register class + _COSMOLOGY_CLASSES[cls.__qualname__] = cls + + # register to YAML + from astropy.cosmology._io.yaml import register_cosmology_yaml + + register_cosmology_yaml(cls) + # --------------------------------------------------------------- def __init__(self, name=None, meta=None):

diff --git a/astropy/cosmology/tests/test_core.py b/astropy/cosmology/tests/test_core.py index ba4c6ad19c8b..bd484a942248 100644 --- a/astropy/cosmology/tests/test_core.py +++ b/astropy/cosmology/tests/test_core.py @@ -141,6 +141,9 @@ def cosmo(self, cosmo_cls): def test_init_subclass(self, cosmo_cls): """Test creating subclasses registers classes and manages Parameters.""" + # ----------------------------------------------------------- + # Normal subclass creation + class InitSubclassTest(cosmo_cls): pass @@ -151,6 +154,18 @@ class InitSubclassTest(cosmo_cls): registrant = _COSMOLOGY_CLASSES.pop(InitSubclassTest.__qualname__) assert registrant is InitSubclassTest + # ----------------------------------------------------------- + # Skip + + class UnRegisteredSubclassTest(cosmo_cls): + @classmethod + def _register_cls(cls): + """Override to not register.""" + pass + + assert UnRegisteredSubclassTest.__parameters__ == cosmo_cls.__parameters__ + assert UnRegisteredSubclassTest.__qualname__ not in _COSMOLOGY_CLASSES + def test_init_signature(self, cosmo_cls, cosmo): """Test class-property ``_init_signature``.""" # test presence

[ { "components": [ { "doc": "", "lines": [ 145, 152 ], "name": "Cosmology._register_cls", "signature": "def _register_cls(cls):", "type": "function" } ], "file": "astropy/cosmology/core.py" } ]

[ "astropy/cosmology/tests/test_core.py::TestCosmology::test_to_yaml", "astropy/cosmology/tests/test_core.py::TestCosmology::test_from_yaml_default", "astropy/cosmology/tests/test_core.py::TestCosmology::test_from_yaml_autoidentify", "astropy/cosmology/tests/test_core.py::TestCosmology::test_is_equivalent_to_ya...

[ "astropy/cosmology/tests/test_core.py::TestCosmology::test_to_table_bad_index", "astropy/cosmology/tests/test_core.py::TestCosmology::test_to_table_failed_cls", "astropy/cosmology/tests/test_core.py::TestCosmology::test_to_table_cls[QTable]", "astropy/cosmology/tests/test_core.py::TestCosmology::test_to_table...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Register YAML on class creation Auto-registration of Cosmology classes with YAML. Optionally turn off the registration for e.g. temporary classes. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in astropy/cosmology/core.py] (definition of Cosmology._register_cls:) def _register_cls(cls): [end of new definitions in astropy/cosmology/core.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

32bd0ffb6898c6a57b9ec1a55c13c7a0efe8d273

softlayer__softlayer-python-1999

1,999

softlayer/softlayer-python

null

36d7c19ae40ca3bec8d7c07454a60ee3d8cd9a9e

2023-06-21T13:56:06Z

diff --git a/SoftLayer/CLI/loadbal/protocol_add.py b/SoftLayer/CLI/loadbal/protocol_add.py new file mode 100644 index 000000000..dd5a4f60f --- /dev/null +++ b/SoftLayer/CLI/loadbal/protocol_add.py @@ -0,0 +1,66 @@ +"""Add a new load balancer protocol.""" +import click + +import SoftLayer +from SoftLayer.CLI import environment +from SoftLayer.CLI import exceptions +from SoftLayer.CLI import formatting + + +# pylint: disable=unused-argument +def parse_proto(ctx, param, value): + """Parses the frontend and backend cli options""" + proto = {'protocol': 'HTTP', 'port': 80} + splitout = value.split(':') + if len(splitout) != 2: + raise exceptions.ArgumentError("{}={} is not properly formatted.".format(param, value)) + proto['protocol'] = splitout[0] + proto['port'] = int(splitout[1]) + return proto + + +@click.command(cls=SoftLayer.CLI.command.SLCommand, ) +@click.argument('identifier') +@click.option('--frontend', '-f', required=True, default='HTTP:80', show_default=True, callback=parse_proto, + help='PROTOCOL:PORT string for incoming internet connections.') +@click.option('--backend', '-b', required=True, default='HTTP:80', show_default=True, callback=parse_proto, + help='PROTOCOL:PORT string for connecting to backend servers.') +@click.option('--method', '-m', help="Balancing Method.", default='ROUNDROBIN', show_default=True, + type=click.Choice(['ROUNDROBIN', 'LEASTCONNECTION', 'WEIGHTED_RR'])) +@click.option('--session', '-s', required=True, + help="Session stickiness type. Valid values are SOURCE_IP or HTTP_COOKIE ") +@click.option('--max', help="Max Connections setting", type=int) +@environment.pass_env +def cli(env, identifier, **args): + """Add a new load balancer protocol.""" + + mgr = SoftLayer.LoadBalancerManager(env.client) + + uuid = mgr.get_lb_uuid(identifier) + + backend = args.get('backend') + frontend = args.get('frontend') + protocols = [ + { + "backendPort": backend.get('port'), + "backendProtocol": backend.get('protocol'), + "frontendPort": frontend.get('port'), + "frontendProtocol": frontend.get('protocol'), + "loadBalancingMethod": args.get('method'), + "sessionType": args.get('session'), + "maxConn": args.get('max') + } + ] + + protocol = mgr.add_protocols(uuid, protocols) + + table = formatting.KeyValueTable(['name', 'value']) + table.align['name'] = 'r' + table.align['value'] = 'l' + table.add_row(['Id', protocol.get('id')]) + table.add_row(['UUI', protocol.get('uuid')]) + table.add_row(['Address', protocol.get('address')]) + table.add_row(['Type', mgr.get_lb_type(protocol.get('type'))]) + table.add_row(['Description', protocol.get('description')]) + + env.fout(table) diff --git a/SoftLayer/CLI/loadbal/protocol_delete.py b/SoftLayer/CLI/loadbal/protocol_delete.py new file mode 100644 index 000000000..105b585bf --- /dev/null +++ b/SoftLayer/CLI/loadbal/protocol_delete.py @@ -0,0 +1,31 @@ +"""Delete load balancer protocol.""" +import click + +import SoftLayer +from SoftLayer.CLI import environment +from SoftLayer.CLI import formatting + + +@click.command(cls=SoftLayer.CLI.command.SLCommand, ) +@click.argument('identifier') +@click.option('--uuid', help="Load Balancer Uuid.") +@environment.pass_env +def cli(env, identifier, uuid): + """delete a load balancer protocol.""" + + mgr = SoftLayer.LoadBalancerManager(env.client) + + uuid_lb = mgr.get_lb(identifier)['uuid'] + + protocol = mgr.delete_protocol(uuid_lb, uuid) + + table = formatting.KeyValueTable(['name', 'value']) + table.align['name'] = 'r' + table.align['value'] = 'l' + table.add_row(['Id', protocol.get('id')]) + table.add_row(['UUI', protocol.get('uuid')]) + table.add_row(['Address', protocol.get('address')]) + table.add_row(['Type', SoftLayer.LoadBalancerManager.TYPE.get(protocol.get('type'))]) + table.add_row(['Description', protocol.get('description')]) + + env.fout(table) diff --git a/SoftLayer/CLI/loadbal/protocol_edit.py b/SoftLayer/CLI/loadbal/protocol_edit.py new file mode 100644 index 000000000..d0f1a685b --- /dev/null +++ b/SoftLayer/CLI/loadbal/protocol_edit.py @@ -0,0 +1,67 @@ +"""Add a new load balancer protocol.""" +import click + +import SoftLayer +from SoftLayer.CLI import environment +from SoftLayer.CLI import exceptions +from SoftLayer.CLI import formatting + + +# pylint: disable=unused-argument +def parse_proto(ctx, param, value): + """Parses the frontend and backend cli options""" + proto = {'protocol': 'HTTP', 'port': 80} + splitout = value.split(':') + if len(splitout) != 2: + raise exceptions.ArgumentError("{}={} is not properly formatted.".format(param, value)) + proto['protocol'] = splitout[0] + proto['port'] = int(splitout[1]) + return proto + + +@click.command(cls=SoftLayer.CLI.command.SLCommand, ) +@click.argument('identifier') +@click.option('--uuid', help="Load Balancer Uuid.") +@click.option('--frontend', '-f', required=True, default='HTTP:80', show_default=True, callback=parse_proto, + help='PROTOCOL:PORT string for incoming internet connections.') +@click.option('--backend', '-b', required=True, default='HTTP:80', show_default=True, callback=parse_proto, + help='PROTOCOL:PORT string for connecting to backend servers.') +@click.option('--method', '-m', help="Balancing Method.", default='ROUNDROBIN', show_default=True, + type=click.Choice(['ROUNDROBIN', 'LEASTCONNECTION', 'WEIGHTED_RR'])) +@click.option('--session', '-s', required=True, + help="Session stickiness type. Valid values are SOURCE_IP or HTTP_COOKIE ") +@click.option('--max', help="Max Connections setting", type=int) +@environment.pass_env +def cli(env, identifier, **args): + """Edit a load balancer protocol.""" + + mgr = SoftLayer.LoadBalancerManager(env.client) + + uuid = mgr.get_lb_uuid(identifier) + + backend = args.get('backend') + frontend = args.get('frontend') + protocol_configurations = [ + { + "backendPort": backend.get('port'), + "backendProtocol": backend.get('protocol'), + "frontendPort": frontend.get('port'), + "frontendProtocol": frontend.get('protocol'), + "loadBalancingMethod": args.get('method'), + "sessionType": args.get('session'), + "maxConn": args.get('max') + } + ] + protocol_configurations[0]['listenerUuid'] = args.get('uuid') + protocol = mgr.add_protocols(uuid, protocol_configurations) + + table = formatting.KeyValueTable(['name', 'value']) + table.align['name'] = 'r' + table.align['value'] = 'l' + table.add_row(['Id', protocol.get('id')]) + table.add_row(['UUI', protocol.get('uuid')]) + table.add_row(['Address', protocol.get('address')]) + table.add_row(['Type', mgr.get_lb_type(protocol.get('type'))]) + table.add_row(['Description', protocol.get('description')]) + + env.fout(table) diff --git a/SoftLayer/CLI/routes.py b/SoftLayer/CLI/routes.py index e0558b626..15d1e98ce 100644 --- a/SoftLayer/CLI/routes.py +++ b/SoftLayer/CLI/routes.py @@ -244,6 +244,9 @@ ('loadbal:order', 'SoftLayer.CLI.loadbal.order:order'), ('loadbal:order-options', 'SoftLayer.CLI.loadbal.order:order_options'), ('loadbal:cancel', 'SoftLayer.CLI.loadbal.order:cancel'), + ('loadbal:protocol-add', 'SoftLayer.CLI.loadbal.protocol_add:cli'), + ('loadbal:protocol-edit', 'SoftLayer.CLI.loadbal.protocol_edit:cli'), + ('loadbal:protocol-delete', 'SoftLayer.CLI.loadbal.protocol_delete:cli'), ('loadbal:ns-detail', 'SoftLayer.CLI.loadbal.ns_detail:cli'), ('loadbal:ns-list', 'SoftLayer.CLI.loadbal.ns_list:cli'), diff --git a/SoftLayer/managers/load_balancer.py b/SoftLayer/managers/load_balancer.py index ecd48dd59..2e7fc75a1 100644 --- a/SoftLayer/managers/load_balancer.py +++ b/SoftLayer/managers/load_balancer.py @@ -5,6 +5,7 @@ :license: MIT, see LICENSE for more details. """ +import SoftLayer from SoftLayer import exceptions from SoftLayer.managers import ordering from SoftLayer import utils @@ -70,7 +71,7 @@ def get_lb(self, identifier, mask=None): :returns: SoftLayer_Network_LBaaS_LoadBalancer """ if mask is None: - mask = "mask[healthMonitors, l7Pools, members, sslCiphers, " \ + mask = "mask[healthMonitors, l7Pools, uuid, members, sslCiphers, " \ "listeners[defaultPool[healthMonitor, members, sessionAffinity],l7Policies]]" this_lb = self.lbaas.getObject(id=identifier, mask=mask) @@ -275,3 +276,38 @@ def cancel_lbaas(self, uuid): """ return self.lbaas.cancelLoadBalancer(uuid) + + def add_protocols(self, uuid, protocols): + """This sample shows how to add protocols to the LBaaS. + + https://softlayer.github.io/reference/services/SoftLayer_Network_LBaaS_Listener/updateLoadBalancerProtocols/ + :param uuid string: UUID of the LBaaS instance to add a new protocol + :param protocols SoftLayer_Network_LBaaS_LoadBalancerProtocolConfiguration[]: protocol configurations + """ + return self.client.call('SoftLayer_Network_LBaaS_Listener', 'updateLoadBalancerProtocols', + uuid, protocols) + + def delete_protocol(self, uuid_lb, uuid): + """This sample shows how to delete protocols to the LBaaS. + + https://softlayer.github.io/reference/services/SoftLayer_Network_LBaaS_Listener/updateLoadBalancerProtocols/ + :param uuid string: UUID of the LBaaS instance to add a new protocol + :param protocols SoftLayer_Network_LBaaS_LoadBalancerProtocolConfiguration[]: protocol configurations + """ + return self.client.call('SoftLayer_Network_LBaaS_Listener', 'deleteLoadBalancerProtocols', + uuid_lb, [uuid]) + + def get_lb_uuid(self, identifier): + """this sample show the uuid from loadbalancer. + + :param identifier int: loadbalancer identifier. + """ + load_balancer = self.lbaas.getObject(id=identifier, mask="mask[id,uuid]") + return load_balancer.get('uuid') + + def get_lb_type(self, lb_type): + """return the loadbalancer type. + + :param lb_type: load balancer type + """ + return SoftLayer.LoadBalancerManager.TYPE.get(lb_type) diff --git a/docs/cli/loadbal.rst b/docs/cli/loadbal.rst index e019e2aa0..3ba20f9ee 100644 --- a/docs/cli/loadbal.rst +++ b/docs/cli/loadbal.rst @@ -52,6 +52,15 @@ LBaaS Commands .. click:: SoftLayer.CLI.loadbal.order:cancel :prog: loadbal cancel :show-nested: +.. click:: SoftLayer.CLI.loadbal.protocol_add:cli + :prog: loadbal protocol-add + :show-nested: +.. click:: SoftLayer.CLI.loadbal.protocol_edit:cli + :prog: loadbal protocol-edit + :show-nested: +.. click:: SoftLayer.CLI.loadbal.protocol_delete:cli + :prog: loadbal protocol-delete + :show-nested: NetScaler Commands

diff --git a/tests/CLI/modules/loadbal_tests.py b/tests/CLI/modules/loadbal_tests.py index cbba6266c..dabfa8891 100644 --- a/tests/CLI/modules/loadbal_tests.py +++ b/tests/CLI/modules/loadbal_tests.py @@ -315,3 +315,23 @@ def test_ns_detail(self): result = self.run_command(['loadbal', 'ns-detail', '11111']) self.assert_no_fail(result) + + def test_lb_protocol_add(self): + result = self.run_command(['lb', 'protocol-add', '1111111', '--backend', 'HTTP:216', + '--frontend', 'HTTP:217', '--method', 'ROUNDROBIN', '-s', 'SOURCE_IP', + '--max', '190']) + self.assert_no_fail(result) + + def test_lb_protocol_edit(self): + result = self.run_command(['lb', 'protocol-edit', '1111111', + '--uuid', '4d088a44-8c42-4f24-a437-9461ff4c9851', '--backend', 'HTTP:216', + '--frontend', 'HTTP:217', '--method', 'ROUNDROBIN', '-s', 'SOURCE_IP', + '--max', '190']) + + self.assert_no_fail(result) + + def test_lb_protocol_delete(self): + result = self.run_command(['lb', 'protocol-delete', '1111111', + '--uuid', '4d088a44-8c42-4f24-a437-9461ff4c9851']) + + self.assert_no_fail(result) diff --git a/tests/managers/loadbal_tests.py b/tests/managers/loadbal_tests.py index fd231be78..4dfbe1d29 100644 --- a/tests/managers/loadbal_tests.py +++ b/tests/managers/loadbal_tests.py @@ -9,6 +9,7 @@ """ import SoftLayer from SoftLayer import exceptions +from SoftLayer import fixtures from SoftLayer.fixtures import SoftLayer_Network_LBaaS_LoadBalancer from SoftLayer import testing @@ -209,3 +210,26 @@ def test_get_lbaas_by_name_fails(self): load_bal_mock.return_value = [] name = 'test' self.assertRaises(exceptions.SoftLayerError, self.lb_mgr.get_lbaas_by_name, name) + + def test_lbaas_update_protocol(self): + uuid = '1a1aa111-4474-4e16-9f02-4de959229b85' + protocol_configurations = [ + { + "backendPort": 52, + "backendProtocol": 'HTTP', + "frontendPort": 216, + "frontendProtocol": 'HTTP', + "loadBalancingMethod": 'ROUNDROBIN', + "sessionType": 'SOURCE_IP', + "maxConn": 50 + } + ] + result = self.lb_mgr.add_protocols(uuid, protocol_configurations) + self.assertEqual(fixtures.SoftLayer_Network_LBaaS_Listener.updateLoadBalancerProtocols, result) + + def test_lbaas_delete_protocol(self): + uuid = '1a1aa111-4474-4e16-9f02-4de959229b85' + uuid_delete = 'abba-aabb-cc' + + result = self.lb_mgr.delete_protocol(uuid, uuid_delete) + self.assertEqual(fixtures.SoftLayer_Network_LBaaS_Listener.deleteLoadBalancerProtocols, result)

diff --git a/docs/cli/loadbal.rst b/docs/cli/loadbal.rst index e019e2aa0..3ba20f9ee 100644 --- a/docs/cli/loadbal.rst +++ b/docs/cli/loadbal.rst @@ -52,6 +52,15 @@ LBaaS Commands .. click:: SoftLayer.CLI.loadbal.order:cancel :prog: loadbal cancel :show-nested: +.. click:: SoftLayer.CLI.loadbal.protocol_add:cli + :prog: loadbal protocol-add + :show-nested: +.. click:: SoftLayer.CLI.loadbal.protocol_edit:cli + :prog: loadbal protocol-edit + :show-nested: +.. click:: SoftLayer.CLI.loadbal.protocol_delete:cli + :prog: loadbal protocol-delete + :show-nested: NetScaler Commands

[ { "components": [ { "doc": "Parses the frontend and backend cli options", "lines": [ 11, 19 ], "name": "parse_proto", "signature": "def parse_proto(ctx, param, value):", "type": "function" }, { "doc": "Add a new load b...

[ "tests/CLI/modules/loadbal_tests.py::LoadBalancerTests::test_lb_protocol_add", "tests/CLI/modules/loadbal_tests.py::LoadBalancerTests::test_lb_protocol_delete", "tests/CLI/modules/loadbal_tests.py::LoadBalancerTests::test_lb_protocol_edit", "tests/managers/loadbal_tests.py::LoadBalancerTests::test_lbaas_delet...

[ "tests/CLI/modules/loadbal_tests.py::LoadBalancerTests::test_add_7p", "tests/CLI/modules/loadbal_tests.py::LoadBalancerTests::test_add_7p_fail", "tests/CLI/modules/loadbal_tests.py::LoadBalancerTests::test_add_7p_server", "tests/CLI/modules/loadbal_tests.py::LoadBalancerTests::test_add_7p_server_fail", "tes...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> LB protocol features [#issue1986](https://github.com/softlayer/softlayer-python/issues/1986) **protocol-add** ![image](https://github.com/softlayer/softlayer-python/assets/22535437/55115e08-c377-44e7-bf07-4dc14847ab50) **protocol-edit** ![image](https://github.com/softlayer/softlayer-python/assets/22535437/7690f563-a0e3-40b6-b2cb-d386e61be07d) **protocol-delete** ![image](https://github.com/softlayer/softlayer-python/assets/22535437/5e9d601a-b010-4a06-a344-5a48b8ff3f64) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in SoftLayer/CLI/loadbal/protocol_add.py] (definition of parse_proto:) def parse_proto(ctx, param, value): """Parses the frontend and backend cli options""" (definition of cli:) def cli(env, identifier, **args): """Add a new load balancer protocol.""" [end of new definitions in SoftLayer/CLI/loadbal/protocol_add.py] [start of new definitions in SoftLayer/CLI/loadbal/protocol_delete.py] (definition of cli:) def cli(env, identifier, uuid): """delete a load balancer protocol.""" [end of new definitions in SoftLayer/CLI/loadbal/protocol_delete.py] [start of new definitions in SoftLayer/CLI/loadbal/protocol_edit.py] (definition of parse_proto:) def parse_proto(ctx, param, value): """Parses the frontend and backend cli options""" (definition of cli:) def cli(env, identifier, **args): """Edit a load balancer protocol.""" [end of new definitions in SoftLayer/CLI/loadbal/protocol_edit.py] [start of new definitions in SoftLayer/managers/load_balancer.py] (definition of LoadBalancerManager.add_protocols:) def add_protocols(self, uuid, protocols): """This sample shows how to add protocols to the LBaaS. https://softlayer.github.io/reference/services/SoftLayer_Network_LBaaS_Listener/updateLoadBalancerProtocols/ :param uuid string: UUID of the LBaaS instance to add a new protocol :param protocols SoftLayer_Network_LBaaS_LoadBalancerProtocolConfiguration[]: protocol configurations""" (definition of LoadBalancerManager.delete_protocol:) def delete_protocol(self, uuid_lb, uuid): """This sample shows how to delete protocols to the LBaaS. https://softlayer.github.io/reference/services/SoftLayer_Network_LBaaS_Listener/updateLoadBalancerProtocols/ :param uuid string: UUID of the LBaaS instance to add a new protocol :param protocols SoftLayer_Network_LBaaS_LoadBalancerProtocolConfiguration[]: protocol configurations""" (definition of LoadBalancerManager.get_lb_uuid:) def get_lb_uuid(self, identifier): """this sample show the uuid from loadbalancer. :param identifier int: loadbalancer identifier.""" (definition of LoadBalancerManager.get_lb_type:) def get_lb_type(self, lb_type): """return the loadbalancer type. :param lb_type: load balancer type""" [end of new definitions in SoftLayer/managers/load_balancer.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

bd1ecce1ec4313b9ceefd3cfea52d1b9274fef9d