From c254940f598a79e480e6e164b9d7a0b9678baf89 Mon Sep 17 00:00:00 2001 From: ohmayr Date: Mon, 3 Aug 2026 19:42:52 +0000 Subject: [PATCH 01/12] chore: add deprecation warnings for grpcio --- .../%name_%version/%sub/__init__.py.j2 | 98 ++++++++++++++++++- .../asset/google/cloud/asset_v1/__init__.py | 91 ++++++++++++++++- .../google/iam/credentials_v1/__init__.py | 91 ++++++++++++++++- .../google/cloud/logging_v2/__init__.py | 91 ++++++++++++++++- .../google/cloud/logging_v2/__init__.py | 91 ++++++++++++++++- .../redis/google/cloud/redis_v1/__init__.py | 91 ++++++++++++++++- .../google/cloud/redis_v1/__init__.py | 91 ++++++++++++++++- .../storagebatchoperations_v1/__init__.py | 91 ++++++++++++++++- .../api_core/_python_package_support.py | 30 +++++- .../tests/unit/test_python_package_support.py | 22 ++++- .../google-auth/google/auth/transport/grpc.py | 23 +++++ .../google/cloud/bigquery/__init__.py | 23 +++++ .../google/cloud/ndb/__init__.py | 24 +++++ 13 files changed, 836 insertions(+), 21 deletions(-) diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/__init__.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/__init__.py.j2 index 79ff49bf35c7..b10a50dd2b77 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/__init__.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/__init__.py.j2 @@ -6,9 +6,12 @@ from {{package_path}} import gapic_version as package_version import google.api_core as api_core +import sys __version__ = package_version.__version__ +from importlib import metadata + # PEP 0810: Explicit Lazy Imports # Python 3.15+ natively intercepts and defers these imports. # Developers can disable this behavior and force eager imports. @@ -60,8 +63,99 @@ from .types.{{ proto.module_name }} import {{ enum.name }} {% endfor %} {% endfor %} -api_core.check_python_version("{{package_path}}") -api_core.check_dependency_versions("{{package_path}}") +if hasattr(api_core, "check_python_version") and hasattr(api_core, "check_dependency_versions"): # pragma: NO COVER + {# TODO(api_core): remove `type:ignore` below when minimum version of api_core makes the else clause unnecessary. #} + api_core.check_python_version("{{package_path}}") # type: ignore + api_core.check_dependency_versions("{{package_path}}") # type: ignore +else: # pragma: NO COVER +{# TODO(api_core): Remove this try-catch when we require api-core at a version that + supports the changes in https://github.com/googleapis/python-api-core/pull/832 + + In the meantime, please ensure the functionality here mirrors the + equivalent functionality in api_core, in those two functions above. +#} + # An older version of api_core is installed which does not define the + # functions above. We do equivalent checks manually. + try: + import warnings + + _py_version_str = sys.version.split()[0] + _package_label = "{{package_path}}" + if sys.version_info < (3, 10): + warnings.warn("You are using a non-supported Python version " + + f"({_py_version_str}). Google will not post any further " + + f"updates to {_package_label} supporting this Python version. " + + "Please upgrade to the latest Python version, or at " + + f"least to Python 3.10, and then update {_package_label}.", + FutureWarning) + + def parse_version_to_tuple(version_string: str): + """Safely converts a semantic version string to a comparable tuple of integers. + Example: "6.33.5" -> (6, 33, 5) + Ignores non-numeric parts and handles common version formats. + Args: + version_string: Version string in the format "x.y.z" or "x.y.z" + Returns: + Tuple of integers for the parsed version string. + """ + parts = [] + for part in version_string.split("."): + try: + parts.append(int(part)) + except ValueError: + # If it's a non-numeric part (e.g., '1.0.0b1' -> 'b1'), stop here. + # This is a simplification compared to 'packaging.parse_version', but sufficient + # for comparing strictly numeric semantic versions. + break + return tuple(parts) + + def _get_version(dependency_name): + try: + version_string: str = metadata.version(dependency_name) + parsed_version = parse_version_to_tuple(version_string) + return (parsed_version, version_string) + except Exception: + # Catch exceptions from metadata.version() (e.g., PackageNotFoundError) + # or errors during parse_version_to_tuple + return (None, "--") + + _dependency_package = "google.protobuf" + _next_supported_version = "6.33.5" + _next_supported_version_tuple = (6, 33, 5) + _recommendation = " (we recommend 7.x)" + (_version_used, _version_used_string) = _get_version(_dependency_package) + if _version_used and _version_used < _next_supported_version_tuple: + warnings.warn(f"Package {_package_label} depends on " + + f"{_dependency_package}, currently installed at version " + + f"{_version_used_string}. Future updates to " + + f"{_package_label} will require {_dependency_package} at " + + f"version {_next_supported_version} or higher{_recommendation}." + + " Please ensure " + + "that either (a) your Python environment doesn't pin the " + + f"version of {_dependency_package}, so that updates to " + + f"{_package_label} can require the higher version, or " + + "(b) you manually update your Python environment to use at " + + f"least version {_next_supported_version} of " + + f"{_dependency_package}.", + FutureWarning) + _grpc_package = "grpcio" + _grpc_min_version = "1.83.0" + _grpc_min_version_tuple = (1, 83, 0) + (_grpc_version_used, _grpc_version_used_string) = _get_version(_grpc_package) + if _grpc_version_used and _grpc_version_used < _grpc_min_version_tuple: + warnings.warn(f"Package {_package_label} depends on {_grpc_package}, currently installed at version {_grpc_version_used_string}. " + + "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + + "Support for non-PQC environments is deprecated. In October 2026, " + + "Google Cloud Python client libraries will raise their minimum requirements " + + "(including google-api-core, grpcio, and grpcio-status) to enforce grpcio >= 1.83.0. For more details on Google Cloud's post-quantum " + + "security migration, visit: https://cloud.google.com/security/resources/post-quantum-cryptography", + FutureWarning) + except Exception: + warnings.warn("Could not determine the version of Python " + + "currently being used. To continue receiving " + + "updates for {_package_label}, ensure you are " + + "using a supported version of Python; see " + + "https://devguide.python.org/versions/") {# Define __all__. This requires the full set of imported names, so we iterate over diff --git a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/__init__.py b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/__init__.py index c4cff9be0634..8e5dd71750c2 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/__init__.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/__init__.py @@ -16,9 +16,12 @@ from google.cloud.asset_v1 import gapic_version as package_version import google.api_core as api_core +import sys __version__ = package_version.__version__ +from importlib import metadata + # PEP 0810: Explicit Lazy Imports # Python 3.15+ natively intercepts and defers these imports. # Developers can disable this behavior and force eager imports. @@ -118,8 +121,92 @@ from .types.assets import TimeWindow from .types.assets import VersionedResource -api_core.check_python_version("google.cloud.asset_v1") -api_core.check_dependency_versions("google.cloud.asset_v1") +if hasattr(api_core, "check_python_version") and hasattr(api_core, "check_dependency_versions"): # pragma: NO COVER + api_core.check_python_version("google.cloud.asset_v1") # type: ignore + api_core.check_dependency_versions("google.cloud.asset_v1") # type: ignore +else: # pragma: NO COVER + # An older version of api_core is installed which does not define the + # functions above. We do equivalent checks manually. + try: + import warnings + + _py_version_str = sys.version.split()[0] + _package_label = "google.cloud.asset_v1" + if sys.version_info < (3, 10): + warnings.warn("You are using a non-supported Python version " + + f"({_py_version_str}). Google will not post any further " + + f"updates to {_package_label} supporting this Python version. " + + "Please upgrade to the latest Python version, or at " + + f"least to Python 3.10, and then update {_package_label}.", + FutureWarning) + + def parse_version_to_tuple(version_string: str): + """Safely converts a semantic version string to a comparable tuple of integers. + Example: "6.33.5" -> (6, 33, 5) + Ignores non-numeric parts and handles common version formats. + Args: + version_string: Version string in the format "x.y.z" or "x.y.z" + Returns: + Tuple of integers for the parsed version string. + """ + parts = [] + for part in version_string.split("."): + try: + parts.append(int(part)) + except ValueError: + # If it's a non-numeric part (e.g., '1.0.0b1' -> 'b1'), stop here. + # This is a simplification compared to 'packaging.parse_version', but sufficient + # for comparing strictly numeric semantic versions. + break + return tuple(parts) + + def _get_version(dependency_name): + try: + version_string: str = metadata.version(dependency_name) + parsed_version = parse_version_to_tuple(version_string) + return (parsed_version, version_string) + except Exception: + # Catch exceptions from metadata.version() (e.g., PackageNotFoundError) + # or errors during parse_version_to_tuple + return (None, "--") + + _dependency_package = "google.protobuf" + _next_supported_version = "6.33.5" + _next_supported_version_tuple = (6, 33, 5) + _recommendation = " (we recommend 7.x)" + (_version_used, _version_used_string) = _get_version(_dependency_package) + if _version_used and _version_used < _next_supported_version_tuple: + warnings.warn(f"Package {_package_label} depends on " + + f"{_dependency_package}, currently installed at version " + + f"{_version_used_string}. Future updates to " + + f"{_package_label} will require {_dependency_package} at " + + f"version {_next_supported_version} or higher{_recommendation}." + + " Please ensure " + + "that either (a) your Python environment doesn't pin the " + + f"version of {_dependency_package}, so that updates to " + + f"{_package_label} can require the higher version, or " + + "(b) you manually update your Python environment to use at " + + f"least version {_next_supported_version} of " + + f"{_dependency_package}.", + FutureWarning) + _grpc_package = "grpcio" + _grpc_min_version = "1.83.0" + _grpc_min_version_tuple = (1, 83, 0) + (_grpc_version_used, _grpc_version_used_string) = _get_version(_grpc_package) + if _grpc_version_used and _grpc_version_used < _grpc_min_version_tuple: + warnings.warn(f"Package {_package_label} depends on {_grpc_package}, currently installed at version {_grpc_version_used_string}. " + + "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + + "Support for non-PQC environments is deprecated. In October 2026, " + + "Google Cloud Python client libraries will raise their minimum requirements " + + "(including google-api-core, grpcio, and grpcio-status) to enforce grpcio >= 1.83.0. For more details on Google Cloud's post-quantum " + + "security migration, visit: https://cloud.google.com/security/resources/post-quantum-cryptography", + FutureWarning) + except Exception: + warnings.warn("Could not determine the version of Python " + + "currently being used. To continue receiving " + + "updates for {_package_label}, ensure you are " + + "using a supported version of Python; see " + + "https://devguide.python.org/versions/") __all__ = ( 'AssetServiceAsyncClient', diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/__init__.py b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/__init__.py index 9c0c65db39c0..c747c2e53620 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/__init__.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/__init__.py @@ -16,9 +16,12 @@ from google.iam.credentials_v1 import gapic_version as package_version import google.api_core as api_core +import sys __version__ = package_version.__version__ +from importlib import metadata + # PEP 0810: Explicit Lazy Imports # Python 3.15+ natively intercepts and defers these imports. # Developers can disable this behavior and force eager imports. @@ -44,8 +47,92 @@ from .types.common import SignJwtRequest from .types.common import SignJwtResponse -api_core.check_python_version("google.iam.credentials_v1") -api_core.check_dependency_versions("google.iam.credentials_v1") +if hasattr(api_core, "check_python_version") and hasattr(api_core, "check_dependency_versions"): # pragma: NO COVER + api_core.check_python_version("google.iam.credentials_v1") # type: ignore + api_core.check_dependency_versions("google.iam.credentials_v1") # type: ignore +else: # pragma: NO COVER + # An older version of api_core is installed which does not define the + # functions above. We do equivalent checks manually. + try: + import warnings + + _py_version_str = sys.version.split()[0] + _package_label = "google.iam.credentials_v1" + if sys.version_info < (3, 10): + warnings.warn("You are using a non-supported Python version " + + f"({_py_version_str}). Google will not post any further " + + f"updates to {_package_label} supporting this Python version. " + + "Please upgrade to the latest Python version, or at " + + f"least to Python 3.10, and then update {_package_label}.", + FutureWarning) + + def parse_version_to_tuple(version_string: str): + """Safely converts a semantic version string to a comparable tuple of integers. + Example: "6.33.5" -> (6, 33, 5) + Ignores non-numeric parts and handles common version formats. + Args: + version_string: Version string in the format "x.y.z" or "x.y.z" + Returns: + Tuple of integers for the parsed version string. + """ + parts = [] + for part in version_string.split("."): + try: + parts.append(int(part)) + except ValueError: + # If it's a non-numeric part (e.g., '1.0.0b1' -> 'b1'), stop here. + # This is a simplification compared to 'packaging.parse_version', but sufficient + # for comparing strictly numeric semantic versions. + break + return tuple(parts) + + def _get_version(dependency_name): + try: + version_string: str = metadata.version(dependency_name) + parsed_version = parse_version_to_tuple(version_string) + return (parsed_version, version_string) + except Exception: + # Catch exceptions from metadata.version() (e.g., PackageNotFoundError) + # or errors during parse_version_to_tuple + return (None, "--") + + _dependency_package = "google.protobuf" + _next_supported_version = "6.33.5" + _next_supported_version_tuple = (6, 33, 5) + _recommendation = " (we recommend 7.x)" + (_version_used, _version_used_string) = _get_version(_dependency_package) + if _version_used and _version_used < _next_supported_version_tuple: + warnings.warn(f"Package {_package_label} depends on " + + f"{_dependency_package}, currently installed at version " + + f"{_version_used_string}. Future updates to " + + f"{_package_label} will require {_dependency_package} at " + + f"version {_next_supported_version} or higher{_recommendation}." + + " Please ensure " + + "that either (a) your Python environment doesn't pin the " + + f"version of {_dependency_package}, so that updates to " + + f"{_package_label} can require the higher version, or " + + "(b) you manually update your Python environment to use at " + + f"least version {_next_supported_version} of " + + f"{_dependency_package}.", + FutureWarning) + _grpc_package = "grpcio" + _grpc_min_version = "1.83.0" + _grpc_min_version_tuple = (1, 83, 0) + (_grpc_version_used, _grpc_version_used_string) = _get_version(_grpc_package) + if _grpc_version_used and _grpc_version_used < _grpc_min_version_tuple: + warnings.warn(f"Package {_package_label} depends on {_grpc_package}, currently installed at version {_grpc_version_used_string}. " + + "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + + "Support for non-PQC environments is deprecated. In October 2026, " + + "Google Cloud Python client libraries will raise their minimum requirements " + + "(including google-api-core, grpcio, and grpcio-status) to enforce grpcio >= 1.83.0. For more details on Google Cloud's post-quantum " + + "security migration, visit: https://cloud.google.com/security/resources/post-quantum-cryptography", + FutureWarning) + except Exception: + warnings.warn("Could not determine the version of Python " + + "currently being used. To continue receiving " + + "updates for {_package_label}, ensure you are " + + "using a supported version of Python; see " + + "https://devguide.python.org/versions/") __all__ = ( 'IAMCredentialsAsyncClient', diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/__init__.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/__init__.py index 5e2f12d53746..df909112e36d 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/__init__.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/__init__.py @@ -16,9 +16,12 @@ from google.cloud.logging_v2 import gapic_version as package_version import google.api_core as api_core +import sys __version__ = package_version.__version__ +from importlib import metadata + # PEP 0810: Explicit Lazy Imports # Python 3.15+ natively intercepts and defers these imports. # Developers can disable this behavior and force eager imports. @@ -120,8 +123,92 @@ from .types.logging_metrics import LogMetric from .types.logging_metrics import UpdateLogMetricRequest -api_core.check_python_version("google.cloud.logging_v2") -api_core.check_dependency_versions("google.cloud.logging_v2") +if hasattr(api_core, "check_python_version") and hasattr(api_core, "check_dependency_versions"): # pragma: NO COVER + api_core.check_python_version("google.cloud.logging_v2") # type: ignore + api_core.check_dependency_versions("google.cloud.logging_v2") # type: ignore +else: # pragma: NO COVER + # An older version of api_core is installed which does not define the + # functions above. We do equivalent checks manually. + try: + import warnings + + _py_version_str = sys.version.split()[0] + _package_label = "google.cloud.logging_v2" + if sys.version_info < (3, 10): + warnings.warn("You are using a non-supported Python version " + + f"({_py_version_str}). Google will not post any further " + + f"updates to {_package_label} supporting this Python version. " + + "Please upgrade to the latest Python version, or at " + + f"least to Python 3.10, and then update {_package_label}.", + FutureWarning) + + def parse_version_to_tuple(version_string: str): + """Safely converts a semantic version string to a comparable tuple of integers. + Example: "6.33.5" -> (6, 33, 5) + Ignores non-numeric parts and handles common version formats. + Args: + version_string: Version string in the format "x.y.z" or "x.y.z" + Returns: + Tuple of integers for the parsed version string. + """ + parts = [] + for part in version_string.split("."): + try: + parts.append(int(part)) + except ValueError: + # If it's a non-numeric part (e.g., '1.0.0b1' -> 'b1'), stop here. + # This is a simplification compared to 'packaging.parse_version', but sufficient + # for comparing strictly numeric semantic versions. + break + return tuple(parts) + + def _get_version(dependency_name): + try: + version_string: str = metadata.version(dependency_name) + parsed_version = parse_version_to_tuple(version_string) + return (parsed_version, version_string) + except Exception: + # Catch exceptions from metadata.version() (e.g., PackageNotFoundError) + # or errors during parse_version_to_tuple + return (None, "--") + + _dependency_package = "google.protobuf" + _next_supported_version = "6.33.5" + _next_supported_version_tuple = (6, 33, 5) + _recommendation = " (we recommend 7.x)" + (_version_used, _version_used_string) = _get_version(_dependency_package) + if _version_used and _version_used < _next_supported_version_tuple: + warnings.warn(f"Package {_package_label} depends on " + + f"{_dependency_package}, currently installed at version " + + f"{_version_used_string}. Future updates to " + + f"{_package_label} will require {_dependency_package} at " + + f"version {_next_supported_version} or higher{_recommendation}." + + " Please ensure " + + "that either (a) your Python environment doesn't pin the " + + f"version of {_dependency_package}, so that updates to " + + f"{_package_label} can require the higher version, or " + + "(b) you manually update your Python environment to use at " + + f"least version {_next_supported_version} of " + + f"{_dependency_package}.", + FutureWarning) + _grpc_package = "grpcio" + _grpc_min_version = "1.83.0" + _grpc_min_version_tuple = (1, 83, 0) + (_grpc_version_used, _grpc_version_used_string) = _get_version(_grpc_package) + if _grpc_version_used and _grpc_version_used < _grpc_min_version_tuple: + warnings.warn(f"Package {_package_label} depends on {_grpc_package}, currently installed at version {_grpc_version_used_string}. " + + "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + + "Support for non-PQC environments is deprecated. In October 2026, " + + "Google Cloud Python client libraries will raise their minimum requirements " + + "(including google-api-core, grpcio, and grpcio-status) to enforce grpcio >= 1.83.0. For more details on Google Cloud's post-quantum " + + "security migration, visit: https://cloud.google.com/security/resources/post-quantum-cryptography", + FutureWarning) + except Exception: + warnings.warn("Could not determine the version of Python " + + "currently being used. To continue receiving " + + "updates for {_package_label}, ensure you are " + + "using a supported version of Python; see " + + "https://devguide.python.org/versions/") __all__ = ( 'ConfigServiceV2AsyncClient', diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/__init__.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/__init__.py index b58fac5882bb..9268adf976a9 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/__init__.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/__init__.py @@ -16,9 +16,12 @@ from google.cloud.logging_v2 import gapic_version as package_version import google.api_core as api_core +import sys __version__ = package_version.__version__ +from importlib import metadata + # PEP 0810: Explicit Lazy Imports # Python 3.15+ natively intercepts and defers these imports. # Developers can disable this behavior and force eager imports. @@ -120,8 +123,92 @@ from .types.logging_metrics import LogMetric from .types.logging_metrics import UpdateLogMetricRequest -api_core.check_python_version("google.cloud.logging_v2") -api_core.check_dependency_versions("google.cloud.logging_v2") +if hasattr(api_core, "check_python_version") and hasattr(api_core, "check_dependency_versions"): # pragma: NO COVER + api_core.check_python_version("google.cloud.logging_v2") # type: ignore + api_core.check_dependency_versions("google.cloud.logging_v2") # type: ignore +else: # pragma: NO COVER + # An older version of api_core is installed which does not define the + # functions above. We do equivalent checks manually. + try: + import warnings + + _py_version_str = sys.version.split()[0] + _package_label = "google.cloud.logging_v2" + if sys.version_info < (3, 10): + warnings.warn("You are using a non-supported Python version " + + f"({_py_version_str}). Google will not post any further " + + f"updates to {_package_label} supporting this Python version. " + + "Please upgrade to the latest Python version, or at " + + f"least to Python 3.10, and then update {_package_label}.", + FutureWarning) + + def parse_version_to_tuple(version_string: str): + """Safely converts a semantic version string to a comparable tuple of integers. + Example: "6.33.5" -> (6, 33, 5) + Ignores non-numeric parts and handles common version formats. + Args: + version_string: Version string in the format "x.y.z" or "x.y.z" + Returns: + Tuple of integers for the parsed version string. + """ + parts = [] + for part in version_string.split("."): + try: + parts.append(int(part)) + except ValueError: + # If it's a non-numeric part (e.g., '1.0.0b1' -> 'b1'), stop here. + # This is a simplification compared to 'packaging.parse_version', but sufficient + # for comparing strictly numeric semantic versions. + break + return tuple(parts) + + def _get_version(dependency_name): + try: + version_string: str = metadata.version(dependency_name) + parsed_version = parse_version_to_tuple(version_string) + return (parsed_version, version_string) + except Exception: + # Catch exceptions from metadata.version() (e.g., PackageNotFoundError) + # or errors during parse_version_to_tuple + return (None, "--") + + _dependency_package = "google.protobuf" + _next_supported_version = "6.33.5" + _next_supported_version_tuple = (6, 33, 5) + _recommendation = " (we recommend 7.x)" + (_version_used, _version_used_string) = _get_version(_dependency_package) + if _version_used and _version_used < _next_supported_version_tuple: + warnings.warn(f"Package {_package_label} depends on " + + f"{_dependency_package}, currently installed at version " + + f"{_version_used_string}. Future updates to " + + f"{_package_label} will require {_dependency_package} at " + + f"version {_next_supported_version} or higher{_recommendation}." + + " Please ensure " + + "that either (a) your Python environment doesn't pin the " + + f"version of {_dependency_package}, so that updates to " + + f"{_package_label} can require the higher version, or " + + "(b) you manually update your Python environment to use at " + + f"least version {_next_supported_version} of " + + f"{_dependency_package}.", + FutureWarning) + _grpc_package = "grpcio" + _grpc_min_version = "1.83.0" + _grpc_min_version_tuple = (1, 83, 0) + (_grpc_version_used, _grpc_version_used_string) = _get_version(_grpc_package) + if _grpc_version_used and _grpc_version_used < _grpc_min_version_tuple: + warnings.warn(f"Package {_package_label} depends on {_grpc_package}, currently installed at version {_grpc_version_used_string}. " + + "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + + "Support for non-PQC environments is deprecated. In October 2026, " + + "Google Cloud Python client libraries will raise their minimum requirements " + + "(including google-api-core, grpcio, and grpcio-status) to enforce grpcio >= 1.83.0. For more details on Google Cloud's post-quantum " + + "security migration, visit: https://cloud.google.com/security/resources/post-quantum-cryptography", + FutureWarning) + except Exception: + warnings.warn("Could not determine the version of Python " + + "currently being used. To continue receiving " + + "updates for {_package_label}, ensure you are " + + "using a supported version of Python; see " + + "https://devguide.python.org/versions/") __all__ = ( 'BaseConfigServiceV2AsyncClient', diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/__init__.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/__init__.py index 365eb099e564..dc8efac12481 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/__init__.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/__init__.py @@ -16,9 +16,12 @@ from google.cloud.redis_v1 import gapic_version as package_version import google.api_core as api_core +import sys __version__ = package_version.__version__ +from importlib import metadata + # PEP 0810: Explicit Lazy Imports # Python 3.15+ natively intercepts and defers these imports. # Developers can disable this behavior and force eager imports. @@ -62,8 +65,92 @@ from .types.cloud_redis import WeeklyMaintenanceWindow from .types.cloud_redis import ZoneMetadata -api_core.check_python_version("google.cloud.redis_v1") -api_core.check_dependency_versions("google.cloud.redis_v1") +if hasattr(api_core, "check_python_version") and hasattr(api_core, "check_dependency_versions"): # pragma: NO COVER + api_core.check_python_version("google.cloud.redis_v1") # type: ignore + api_core.check_dependency_versions("google.cloud.redis_v1") # type: ignore +else: # pragma: NO COVER + # An older version of api_core is installed which does not define the + # functions above. We do equivalent checks manually. + try: + import warnings + + _py_version_str = sys.version.split()[0] + _package_label = "google.cloud.redis_v1" + if sys.version_info < (3, 10): + warnings.warn("You are using a non-supported Python version " + + f"({_py_version_str}). Google will not post any further " + + f"updates to {_package_label} supporting this Python version. " + + "Please upgrade to the latest Python version, or at " + + f"least to Python 3.10, and then update {_package_label}.", + FutureWarning) + + def parse_version_to_tuple(version_string: str): + """Safely converts a semantic version string to a comparable tuple of integers. + Example: "6.33.5" -> (6, 33, 5) + Ignores non-numeric parts and handles common version formats. + Args: + version_string: Version string in the format "x.y.z" or "x.y.z" + Returns: + Tuple of integers for the parsed version string. + """ + parts = [] + for part in version_string.split("."): + try: + parts.append(int(part)) + except ValueError: + # If it's a non-numeric part (e.g., '1.0.0b1' -> 'b1'), stop here. + # This is a simplification compared to 'packaging.parse_version', but sufficient + # for comparing strictly numeric semantic versions. + break + return tuple(parts) + + def _get_version(dependency_name): + try: + version_string: str = metadata.version(dependency_name) + parsed_version = parse_version_to_tuple(version_string) + return (parsed_version, version_string) + except Exception: + # Catch exceptions from metadata.version() (e.g., PackageNotFoundError) + # or errors during parse_version_to_tuple + return (None, "--") + + _dependency_package = "google.protobuf" + _next_supported_version = "6.33.5" + _next_supported_version_tuple = (6, 33, 5) + _recommendation = " (we recommend 7.x)" + (_version_used, _version_used_string) = _get_version(_dependency_package) + if _version_used and _version_used < _next_supported_version_tuple: + warnings.warn(f"Package {_package_label} depends on " + + f"{_dependency_package}, currently installed at version " + + f"{_version_used_string}. Future updates to " + + f"{_package_label} will require {_dependency_package} at " + + f"version {_next_supported_version} or higher{_recommendation}." + + " Please ensure " + + "that either (a) your Python environment doesn't pin the " + + f"version of {_dependency_package}, so that updates to " + + f"{_package_label} can require the higher version, or " + + "(b) you manually update your Python environment to use at " + + f"least version {_next_supported_version} of " + + f"{_dependency_package}.", + FutureWarning) + _grpc_package = "grpcio" + _grpc_min_version = "1.83.0" + _grpc_min_version_tuple = (1, 83, 0) + (_grpc_version_used, _grpc_version_used_string) = _get_version(_grpc_package) + if _grpc_version_used and _grpc_version_used < _grpc_min_version_tuple: + warnings.warn(f"Package {_package_label} depends on {_grpc_package}, currently installed at version {_grpc_version_used_string}. " + + "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + + "Support for non-PQC environments is deprecated. In October 2026, " + + "Google Cloud Python client libraries will raise their minimum requirements " + + "(including google-api-core, grpcio, and grpcio-status) to enforce grpcio >= 1.83.0. For more details on Google Cloud's post-quantum " + + "security migration, visit: https://cloud.google.com/security/resources/post-quantum-cryptography", + FutureWarning) + except Exception: + warnings.warn("Could not determine the version of Python " + + "currently being used. To continue receiving " + + "updates for {_package_label}, ensure you are " + + "using a supported version of Python; see " + + "https://devguide.python.org/versions/") __all__ = ( 'CloudRedisAsyncClient', diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/__init__.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/__init__.py index 1b8d17cc75ca..37d40d5cf946 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/__init__.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/__init__.py @@ -16,9 +16,12 @@ from google.cloud.redis_v1 import gapic_version as package_version import google.api_core as api_core +import sys __version__ = package_version.__version__ +from importlib import metadata + # PEP 0810: Explicit Lazy Imports # Python 3.15+ natively intercepts and defers these imports. # Developers can disable this behavior and force eager imports. @@ -55,8 +58,92 @@ from .types.cloud_redis import WeeklyMaintenanceWindow from .types.cloud_redis import ZoneMetadata -api_core.check_python_version("google.cloud.redis_v1") -api_core.check_dependency_versions("google.cloud.redis_v1") +if hasattr(api_core, "check_python_version") and hasattr(api_core, "check_dependency_versions"): # pragma: NO COVER + api_core.check_python_version("google.cloud.redis_v1") # type: ignore + api_core.check_dependency_versions("google.cloud.redis_v1") # type: ignore +else: # pragma: NO COVER + # An older version of api_core is installed which does not define the + # functions above. We do equivalent checks manually. + try: + import warnings + + _py_version_str = sys.version.split()[0] + _package_label = "google.cloud.redis_v1" + if sys.version_info < (3, 10): + warnings.warn("You are using a non-supported Python version " + + f"({_py_version_str}). Google will not post any further " + + f"updates to {_package_label} supporting this Python version. " + + "Please upgrade to the latest Python version, or at " + + f"least to Python 3.10, and then update {_package_label}.", + FutureWarning) + + def parse_version_to_tuple(version_string: str): + """Safely converts a semantic version string to a comparable tuple of integers. + Example: "6.33.5" -> (6, 33, 5) + Ignores non-numeric parts and handles common version formats. + Args: + version_string: Version string in the format "x.y.z" or "x.y.z" + Returns: + Tuple of integers for the parsed version string. + """ + parts = [] + for part in version_string.split("."): + try: + parts.append(int(part)) + except ValueError: + # If it's a non-numeric part (e.g., '1.0.0b1' -> 'b1'), stop here. + # This is a simplification compared to 'packaging.parse_version', but sufficient + # for comparing strictly numeric semantic versions. + break + return tuple(parts) + + def _get_version(dependency_name): + try: + version_string: str = metadata.version(dependency_name) + parsed_version = parse_version_to_tuple(version_string) + return (parsed_version, version_string) + except Exception: + # Catch exceptions from metadata.version() (e.g., PackageNotFoundError) + # or errors during parse_version_to_tuple + return (None, "--") + + _dependency_package = "google.protobuf" + _next_supported_version = "6.33.5" + _next_supported_version_tuple = (6, 33, 5) + _recommendation = " (we recommend 7.x)" + (_version_used, _version_used_string) = _get_version(_dependency_package) + if _version_used and _version_used < _next_supported_version_tuple: + warnings.warn(f"Package {_package_label} depends on " + + f"{_dependency_package}, currently installed at version " + + f"{_version_used_string}. Future updates to " + + f"{_package_label} will require {_dependency_package} at " + + f"version {_next_supported_version} or higher{_recommendation}." + + " Please ensure " + + "that either (a) your Python environment doesn't pin the " + + f"version of {_dependency_package}, so that updates to " + + f"{_package_label} can require the higher version, or " + + "(b) you manually update your Python environment to use at " + + f"least version {_next_supported_version} of " + + f"{_dependency_package}.", + FutureWarning) + _grpc_package = "grpcio" + _grpc_min_version = "1.83.0" + _grpc_min_version_tuple = (1, 83, 0) + (_grpc_version_used, _grpc_version_used_string) = _get_version(_grpc_package) + if _grpc_version_used and _grpc_version_used < _grpc_min_version_tuple: + warnings.warn(f"Package {_package_label} depends on {_grpc_package}, currently installed at version {_grpc_version_used_string}. " + + "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + + "Support for non-PQC environments is deprecated. In October 2026, " + + "Google Cloud Python client libraries will raise their minimum requirements " + + "(including google-api-core, grpcio, and grpcio-status) to enforce grpcio >= 1.83.0. For more details on Google Cloud's post-quantum " + + "security migration, visit: https://cloud.google.com/security/resources/post-quantum-cryptography", + FutureWarning) + except Exception: + warnings.warn("Could not determine the version of Python " + + "currently being used. To continue receiving " + + "updates for {_package_label}, ensure you are " + + "using a supported version of Python; see " + + "https://devguide.python.org/versions/") __all__ = ( 'CloudRedisAsyncClient', diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/__init__.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/__init__.py index 08bda73fa39f..fa8d8320cc34 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/__init__.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/__init__.py @@ -16,9 +16,12 @@ from google.cloud.storagebatchoperations_v1 import gapic_version as package_version import google.api_core as api_core +import sys __version__ = package_version.__version__ +from importlib import metadata + # PEP 0810: Explicit Lazy Imports # Python 3.15+ natively intercepts and defers these imports. # Developers can disable this behavior and force eager imports. @@ -64,8 +67,92 @@ from .types.storage_batch_operations_types import RewriteObject from .types.storage_batch_operations_types import UpdateObjectCustomContext -api_core.check_python_version("google.cloud.storagebatchoperations_v1") -api_core.check_dependency_versions("google.cloud.storagebatchoperations_v1") +if hasattr(api_core, "check_python_version") and hasattr(api_core, "check_dependency_versions"): # pragma: NO COVER + api_core.check_python_version("google.cloud.storagebatchoperations_v1") # type: ignore + api_core.check_dependency_versions("google.cloud.storagebatchoperations_v1") # type: ignore +else: # pragma: NO COVER + # An older version of api_core is installed which does not define the + # functions above. We do equivalent checks manually. + try: + import warnings + + _py_version_str = sys.version.split()[0] + _package_label = "google.cloud.storagebatchoperations_v1" + if sys.version_info < (3, 10): + warnings.warn("You are using a non-supported Python version " + + f"({_py_version_str}). Google will not post any further " + + f"updates to {_package_label} supporting this Python version. " + + "Please upgrade to the latest Python version, or at " + + f"least to Python 3.10, and then update {_package_label}.", + FutureWarning) + + def parse_version_to_tuple(version_string: str): + """Safely converts a semantic version string to a comparable tuple of integers. + Example: "6.33.5" -> (6, 33, 5) + Ignores non-numeric parts and handles common version formats. + Args: + version_string: Version string in the format "x.y.z" or "x.y.z" + Returns: + Tuple of integers for the parsed version string. + """ + parts = [] + for part in version_string.split("."): + try: + parts.append(int(part)) + except ValueError: + # If it's a non-numeric part (e.g., '1.0.0b1' -> 'b1'), stop here. + # This is a simplification compared to 'packaging.parse_version', but sufficient + # for comparing strictly numeric semantic versions. + break + return tuple(parts) + + def _get_version(dependency_name): + try: + version_string: str = metadata.version(dependency_name) + parsed_version = parse_version_to_tuple(version_string) + return (parsed_version, version_string) + except Exception: + # Catch exceptions from metadata.version() (e.g., PackageNotFoundError) + # or errors during parse_version_to_tuple + return (None, "--") + + _dependency_package = "google.protobuf" + _next_supported_version = "6.33.5" + _next_supported_version_tuple = (6, 33, 5) + _recommendation = " (we recommend 7.x)" + (_version_used, _version_used_string) = _get_version(_dependency_package) + if _version_used and _version_used < _next_supported_version_tuple: + warnings.warn(f"Package {_package_label} depends on " + + f"{_dependency_package}, currently installed at version " + + f"{_version_used_string}. Future updates to " + + f"{_package_label} will require {_dependency_package} at " + + f"version {_next_supported_version} or higher{_recommendation}." + + " Please ensure " + + "that either (a) your Python environment doesn't pin the " + + f"version of {_dependency_package}, so that updates to " + + f"{_package_label} can require the higher version, or " + + "(b) you manually update your Python environment to use at " + + f"least version {_next_supported_version} of " + + f"{_dependency_package}.", + FutureWarning) + _grpc_package = "grpcio" + _grpc_min_version = "1.83.0" + _grpc_min_version_tuple = (1, 83, 0) + (_grpc_version_used, _grpc_version_used_string) = _get_version(_grpc_package) + if _grpc_version_used and _grpc_version_used < _grpc_min_version_tuple: + warnings.warn(f"Package {_package_label} depends on {_grpc_package}, currently installed at version {_grpc_version_used_string}. " + + "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + + "Support for non-PQC environments is deprecated. In October 2026, " + + "Google Cloud Python client libraries will raise their minimum requirements " + + "(including google-api-core, grpcio, and grpcio-status) to enforce grpcio >= 1.83.0. For more details on Google Cloud's post-quantum " + + "security migration, visit: https://cloud.google.com/security/resources/post-quantum-cryptography", + FutureWarning) + except Exception: + warnings.warn("Could not determine the version of Python " + + "currently being used. To continue receiving " + + "updates for {_package_label}, ensure you are " + + "using a supported version of Python; see " + + "https://devguide.python.org/versions/") __all__ = ( 'StorageBatchOperationsAsyncClient', diff --git a/packages/google-api-core/google/api_core/_python_package_support.py b/packages/google-api-core/google/api_core/_python_package_support.py index a6c35d8c1804..39e67a806688 100644 --- a/packages/google-api-core/google/api_core/_python_package_support.py +++ b/packages/google-api-core/google/api_core/_python_package_support.py @@ -30,14 +30,37 @@ # about deprecated and unsupported versions. DependencyConstraint = namedtuple( "DependencyConstraint", - ["package_name", "minimum_fully_supported_version", "recommended_version"], + [ + "package_name", + "minimum_fully_supported_version", + "recommended_version", + "message_template", + ], + defaults=(None, None), ) + +PQC_GRPC_WARNING_TEMPLATE = ( + "Package {consumer_package} depends on {dependency_package}, currently installed at version {version_used_string}. " + "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + "Support for non-PQC environments is deprecated. In October 2026, " + "Google Cloud Python packages will raise their minimum requirements " + "(including google-api-core, grpcio, and grpcio-status) to enforce grpcio >= 1.83.0. " + "For more details on Google Cloud's post-quantum security migration, visit: " + "https://cloud.google.com/security/resources/post-quantum-cryptography" +) + _PACKAGE_DEPENDENCY_WARNINGS = [ DependencyConstraint( "google.protobuf", minimum_fully_supported_version="6.33.5", recommended_version="6.x", - ) + ), + DependencyConstraint( + "grpcio", + minimum_fully_supported_version="1.83.0", + recommended_version="1.83.x", + message_template=PQC_GRPC_WARNING_TEMPLATE, + ), ] @@ -162,7 +185,7 @@ def warn_deprecation_for_versions_less_than( ) = _get_distribution_and_import_packages(consumer_import_package) recommendation = ( - " (we recommend {recommended_version})" if recommended_version else "" + f" (we recommend {recommended_version})" if recommended_version else "" ) message_template = message_template or _flatten_message( """ @@ -222,4 +245,5 @@ def check_dependency_versions( package_info.package_name, package_info.minimum_fully_supported_version, recommended_version=package_info.recommended_version, + message_template=package_info.message_template, ) diff --git a/packages/google-api-core/tests/unit/test_python_package_support.py b/packages/google-api-core/tests/unit/test_python_package_support.py index 42e8de673dea..ba57aa202ec6 100644 --- a/packages/google-api-core/tests/unit/test_python_package_support.py +++ b/packages/google-api-core/tests/unit/test_python_package_support.py @@ -18,6 +18,7 @@ import pytest from google.api_core._python_package_support import ( + PQC_GRPC_WARNING_TEMPLATE, DependencyConstraint, DependencyVersion, check_dependency_versions, @@ -125,8 +126,25 @@ def test_check_dependency_versions_with_custom_warnings(mock_warn): assert mock_warn.call_count == 2 mock_warn.assert_any_call( - "my-consumer", "pkg1", "1.0.0", recommended_version="2.0.0" + "my-consumer", "pkg1", "1.0.0", recommended_version="2.0.0", message_template=None ) mock_warn.assert_any_call( - "my-consumer", "pkg2", "2.0.0", recommended_version="3.0.0" + "my-consumer", "pkg2", "2.0.0", recommended_version="3.0.0", message_template=None ) + + +@patch( + "google.api_core._python_package_support.warn_deprecation_for_versions_less_than" +) +def test_check_dependency_versions_default(mock_warn): + """Test check_dependency_versions with default package dependency warnings.""" + check_dependency_versions("my-consumer") + + assert mock_warn.call_count == 2 + mock_warn.assert_any_call( + "my-consumer", "google.protobuf", "6.33.5", recommended_version="6.x", message_template=None + ) + mock_warn.assert_any_call( + "my-consumer", "grpcio", "1.83.0", recommended_version="1.83.x", message_template=PQC_GRPC_WARNING_TEMPLATE + ) + diff --git a/packages/google-auth/google/auth/transport/grpc.py b/packages/google-auth/google/auth/transport/grpc.py index 5930a07f1d08..414e8755496c 100644 --- a/packages/google-auth/google/auth/transport/grpc.py +++ b/packages/google-auth/google/auth/transport/grpc.py @@ -25,6 +25,29 @@ try: import grpc # type: ignore + try: + import warnings + from importlib import metadata + + _grpc_ver_str = metadata.version("grpcio") + _grpc_parts = [] + for _p in _grpc_ver_str.split("."): + try: + _grpc_parts.append(int(_p)) + except ValueError: + break + if tuple(_grpc_parts) < (1, 83, 0): + warnings.warn( + "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + "Support for non-PQC environments is deprecated. In October 2026, " + "google-auth will raise its minimum requirements " + "to enforce grpcio >= 1.83.0. " + "For more details on Google Cloud's post-quantum security migration, visit: " + "https://cloud.google.com/security/resources/post-quantum-cryptography", + FutureWarning, + ) + except Exception: + pass except ImportError as caught_exc: # pragma: NO COVER raise ImportError( "gRPC is not installed from please install the grpcio package to use the gRPC transport." diff --git a/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py b/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py index fa03156e2e26..551aaf0ecf0c 100644 --- a/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py +++ b/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py @@ -246,3 +246,26 @@ def load_ipython_extension(ipython): ipython.register_magic_function( _cell_magic, magic_kind="cell", magic_name="bigquery" ) + +try: + from importlib import metadata + + _grpc_ver_str = metadata.version("grpcio") + _grpc_parts = [] + for _p in _grpc_ver_str.split("."): + try: + _grpc_parts.append(int(_p)) + except ValueError: + break + if tuple(_grpc_parts) < (1, 83, 0): + warnings.warn( + "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + "Support for non-PQC environments is deprecated. In October 2026, " + "Google Cloud Python client libraries will raise their minimum requirements " + "(including google-api-core and grpcio) to enforce grpcio >= 1.83.0. " + "For more details on Google Cloud's post-quantum security migration, visit: " + "https://cloud.google.com/security/resources/post-quantum-cryptography", + FutureWarning, + ) +except Exception: + pass diff --git a/packages/google-cloud-ndb/google/cloud/ndb/__init__.py b/packages/google-cloud-ndb/google/cloud/ndb/__init__.py index 153ff9d1db7c..7b0553407b64 100644 --- a/packages/google-cloud-ndb/google/cloud/ndb/__init__.py +++ b/packages/google-cloud-ndb/google/cloud/ndb/__init__.py @@ -242,3 +242,27 @@ "wait_all", "wait_any", ] + +try: + import warnings + from importlib import metadata + + _grpc_ver_str = metadata.version("grpcio") + _grpc_parts = [] + for _p in _grpc_ver_str.split("."): + try: + _grpc_parts.append(int(_p)) + except ValueError: + break + if tuple(_grpc_parts) < (1, 83, 0): + warnings.warn( + "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + "Support for non-PQC environments is deprecated. In October 2026, " + "Google Cloud Python client libraries will raise their minimum requirements " + "(including google-api-core) to enforce grpcio >= 1.83.0. " + "For more details on Google Cloud's post-quantum security migration, visit: " + "https://cloud.google.com/security/resources/post-quantum-cryptography", + FutureWarning, + ) +except Exception: + pass From 9890d8f52763766faf61642bfef1347b171aec7b Mon Sep 17 00:00:00 2001 From: ohmayr Date: Tue, 4 Aug 2026 15:46:44 +0000 Subject: [PATCH 02/12] fix namespace conflict --- packages/google-auth/google/auth/transport/grpc.py | 4 ++-- .../google-cloud-bigquery/google/cloud/bigquery/__init__.py | 4 ++-- packages/google-cloud-ndb/google/cloud/ndb/__init__.py | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/packages/google-auth/google/auth/transport/grpc.py b/packages/google-auth/google/auth/transport/grpc.py index 414e8755496c..72344210297e 100644 --- a/packages/google-auth/google/auth/transport/grpc.py +++ b/packages/google-auth/google/auth/transport/grpc.py @@ -27,9 +27,9 @@ import grpc # type: ignore try: import warnings - from importlib import metadata + import importlib.metadata - _grpc_ver_str = metadata.version("grpcio") + _grpc_ver_str = importlib.metadata.version("grpcio") _grpc_parts = [] for _p in _grpc_ver_str.split("."): try: diff --git a/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py b/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py index 551aaf0ecf0c..255db6bd7847 100644 --- a/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py +++ b/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py @@ -248,9 +248,9 @@ def load_ipython_extension(ipython): ) try: - from importlib import metadata + import importlib.metadata - _grpc_ver_str = metadata.version("grpcio") + _grpc_ver_str = importlib.metadata.version("grpcio") _grpc_parts = [] for _p in _grpc_ver_str.split("."): try: diff --git a/packages/google-cloud-ndb/google/cloud/ndb/__init__.py b/packages/google-cloud-ndb/google/cloud/ndb/__init__.py index 7b0553407b64..c6add98b3526 100644 --- a/packages/google-cloud-ndb/google/cloud/ndb/__init__.py +++ b/packages/google-cloud-ndb/google/cloud/ndb/__init__.py @@ -245,9 +245,9 @@ try: import warnings - from importlib import metadata + import importlib.metadata - _grpc_ver_str = metadata.version("grpcio") + _grpc_ver_str = importlib.metadata.version("grpcio") _grpc_parts = [] for _p in _grpc_ver_str.split("."): try: From 5549693a7a13dcef344000c40d07d1c9297ef0ae Mon Sep 17 00:00:00 2001 From: ohmayr Date: Tue, 4 Aug 2026 15:52:03 +0000 Subject: [PATCH 03/12] fix lint --- .../google-auth/google/auth/transport/grpc.py | 47 ++++++++++--------- 1 file changed, 24 insertions(+), 23 deletions(-) diff --git a/packages/google-auth/google/auth/transport/grpc.py b/packages/google-auth/google/auth/transport/grpc.py index 72344210297e..f138c3a610aa 100644 --- a/packages/google-auth/google/auth/transport/grpc.py +++ b/packages/google-auth/google/auth/transport/grpc.py @@ -25,34 +25,35 @@ try: import grpc # type: ignore - try: - import warnings - import importlib.metadata - - _grpc_ver_str = importlib.metadata.version("grpcio") - _grpc_parts = [] - for _p in _grpc_ver_str.split("."): - try: - _grpc_parts.append(int(_p)) - except ValueError: - break - if tuple(_grpc_parts) < (1, 83, 0): - warnings.warn( - "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " - "Support for non-PQC environments is deprecated. In October 2026, " - "google-auth will raise its minimum requirements " - "to enforce grpcio >= 1.83.0. " - "For more details on Google Cloud's post-quantum security migration, visit: " - "https://cloud.google.com/security/resources/post-quantum-cryptography", - FutureWarning, - ) - except Exception: - pass except ImportError as caught_exc: # pragma: NO COVER raise ImportError( "gRPC is not installed from please install the grpcio package to use the gRPC transport." ) from caught_exc +try: + import importlib.metadata + import warnings + + _grpc_ver_str = importlib.metadata.version("grpcio") + _grpc_parts = [] + for _p in _grpc_ver_str.split("."): + try: + _grpc_parts.append(int(_p)) + except ValueError: + break + if tuple(_grpc_parts) < (1, 83, 0): + warnings.warn( + "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + "Support for non-PQC environments is deprecated. In October 2026, " + "google-auth will raise its minimum requirements " + "to enforce grpcio >= 1.83.0. " + "For more details on Google Cloud's post-quantum security migration, visit: " + "https://cloud.google.com/security/resources/post-quantum-cryptography", + FutureWarning, + ) +except Exception: + pass + _LOGGER = logging.getLogger(__name__) From b7839345f97b060545eaec7bf89733736cb793e2 Mon Sep 17 00:00:00 2001 From: ohmayr Date: Tue, 4 Aug 2026 15:59:00 +0000 Subject: [PATCH 04/12] fix lint --- .../google/cloud/bigquery/__init__.py | 45 ++++++++--------- .../google/cloud/ndb/__init__.py | 48 +++++++++---------- 2 files changed, 47 insertions(+), 46 deletions(-) diff --git a/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py b/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py index 255db6bd7847..0c29368bec1c 100644 --- a/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py +++ b/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py @@ -30,6 +30,29 @@ import sys import warnings +try: + import importlib.metadata + + _grpc_ver_str = importlib.metadata.version("grpcio") + _grpc_parts = [] + for _p in _grpc_ver_str.split("."): + try: + _grpc_parts.append(int(_p)) + except ValueError: + break + if tuple(_grpc_parts) < (1, 83, 0): + warnings.warn( + "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + "Support for non-PQC environments is deprecated. In October 2026, " + "Google Cloud Python client libraries will raise their minimum requirements " + "(including google-api-core and grpcio) to enforce grpcio >= 1.83.0. " + "For more details on Google Cloud's post-quantum security migration, visit: " + "https://cloud.google.com/security/resources/post-quantum-cryptography", + FutureWarning, + ) +except Exception: + pass + from google.cloud.bigquery import version as bigquery_version __version__ = bigquery_version.__version__ @@ -247,25 +270,3 @@ def load_ipython_extension(ipython): _cell_magic, magic_kind="cell", magic_name="bigquery" ) -try: - import importlib.metadata - - _grpc_ver_str = importlib.metadata.version("grpcio") - _grpc_parts = [] - for _p in _grpc_ver_str.split("."): - try: - _grpc_parts.append(int(_p)) - except ValueError: - break - if tuple(_grpc_parts) < (1, 83, 0): - warnings.warn( - "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " - "Support for non-PQC environments is deprecated. In October 2026, " - "Google Cloud Python client libraries will raise their minimum requirements " - "(including google-api-core and grpcio) to enforce grpcio >= 1.83.0. " - "For more details on Google Cloud's post-quantum security migration, visit: " - "https://cloud.google.com/security/resources/post-quantum-cryptography", - FutureWarning, - ) -except Exception: - pass diff --git a/packages/google-cloud-ndb/google/cloud/ndb/__init__.py b/packages/google-cloud-ndb/google/cloud/ndb/__init__.py index c6add98b3526..c0875caa3648 100644 --- a/packages/google-cloud-ndb/google/cloud/ndb/__init__.py +++ b/packages/google-cloud-ndb/google/cloud/ndb/__init__.py @@ -23,6 +23,30 @@ from google.cloud.ndb import version +try: + import warnings + import importlib.metadata + + _grpc_ver_str = importlib.metadata.version("grpcio") + _grpc_parts = [] + for _p in _grpc_ver_str.split("."): + try: + _grpc_parts.append(int(_p)) + except ValueError: + break + if tuple(_grpc_parts) < (1, 83, 0): + warnings.warn( + "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + "Support for non-PQC environments is deprecated. In October 2026, " + "Google Cloud Python client libraries will raise their minimum requirements " + "(including google-api-core) to enforce grpcio >= 1.83.0. " + "For more details on Google Cloud's post-quantum security migration, visit: " + "https://cloud.google.com/security/resources/post-quantum-cryptography", + FutureWarning, + ) +except Exception: + pass + __version__: str = version.__version__ from google.cloud.ndb._datastore_api import EVENTUAL, EVENTUAL_CONSISTENCY, STRONG @@ -242,27 +266,3 @@ "wait_all", "wait_any", ] - -try: - import warnings - import importlib.metadata - - _grpc_ver_str = importlib.metadata.version("grpcio") - _grpc_parts = [] - for _p in _grpc_ver_str.split("."): - try: - _grpc_parts.append(int(_p)) - except ValueError: - break - if tuple(_grpc_parts) < (1, 83, 0): - warnings.warn( - "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " - "Support for non-PQC environments is deprecated. In October 2026, " - "Google Cloud Python client libraries will raise their minimum requirements " - "(including google-api-core) to enforce grpcio >= 1.83.0. " - "For more details on Google Cloud's post-quantum security migration, visit: " - "https://cloud.google.com/security/resources/post-quantum-cryptography", - FutureWarning, - ) -except Exception: - pass From 1154f9b13759975fe570efe64dd137beabed1664 Mon Sep 17 00:00:00 2001 From: ohmayr Date: Tue, 4 Aug 2026 16:57:03 +0000 Subject: [PATCH 05/12] refactor --- .../%name_%version/%sub/__init__.py.j2 | 22 +++++----- .../api_core/_python_package_support.py | 18 ++++---- .../tests/unit/test_python_package_support.py | 10 ++++- packages/google-auth/google/auth/_helpers.py | 17 +++++++ .../google-auth/google/auth/transport/grpc.py | 10 ++--- packages/google-auth/tests/test__helpers.py | 8 ++++ .../google/cloud/bigquery/__init__.py | 44 ++++++++----------- .../google/cloud/bigquery/_helpers.py | 17 +++++++ .../tests/unit/test__helpers.py | 10 +++++ .../google/cloud/ndb/__init__.py | 10 ++--- .../google/cloud/ndb/utils.py | 17 +++++++ .../google-cloud-ndb/tests/unit/test_utils.py | 8 ++++ 12 files changed, 129 insertions(+), 62 deletions(-) diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/__init__.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/__init__.py.j2 index b10a50dd2b77..2527860c40cb 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/__init__.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/__init__.py.j2 @@ -91,21 +91,19 @@ else: # pragma: NO COVER def parse_version_to_tuple(version_string: str): """Safely converts a semantic version string to a comparable tuple of integers. - Example: "6.33.5" -> (6, 33, 5) - Ignores non-numeric parts and handles common version formats. - Args: - version_string: Version string in the format "x.y.z" or "x.y.z" - Returns: - Tuple of integers for the parsed version string. + Example: "6.33.5" -> (6, 33, 5), "1.83.1rc1" -> (1, 83, 1) + Parses leading digits of each component to correctly handle pre-releases. """ parts = [] for part in version_string.split("."): - try: - parts.append(int(part)) - except ValueError: - # If it's a non-numeric part (e.g., '1.0.0b1' -> 'b1'), stop here. - # This is a simplification compared to 'packaging.parse_version', but sufficient - # for comparing strictly numeric semantic versions. + digits = "" + for c in part: + if not c.isdigit(): + break + digits += c + if digits: + parts.append(int(digits)) + else: break return tuple(parts) diff --git a/packages/google-api-core/google/api_core/_python_package_support.py b/packages/google-api-core/google/api_core/_python_package_support.py index 39e67a806688..25aa4cd322c8 100644 --- a/packages/google-api-core/google/api_core/_python_package_support.py +++ b/packages/google-api-core/google/api_core/_python_package_support.py @@ -73,8 +73,8 @@ def parse_version_to_tuple(version_string: str) -> ParsedVersion: """Safely converts a semantic version string to a comparable tuple of integers. - Example: "6.33.5" -> (6, 33, 5) - Ignores non-numeric parts and handles common version formats. + Example: "6.33.5" -> (6, 33, 5), "1.83.1rc1" -> (1, 83, 1) + Parses leading digits of each component to correctly handle pre-releases. Args: version_string: Version string in the format "x.y.z" or "x.y.z" @@ -84,12 +84,14 @@ def parse_version_to_tuple(version_string: str) -> ParsedVersion: """ parts = [] for part in version_string.split("."): - try: - parts.append(int(part)) - except ValueError: - # If it's a non-numeric part (e.g., '1.0.0b1' -> 'b1'), stop here. - # This is a simplification compared to 'packaging.parse_version', but sufficient - # for comparing strictly numeric semantic versions. + digits = "" + for c in part: + if not c.isdigit(): + break + digits += c + if digits: + parts.append(int(digits)) + else: break return tuple(parts) diff --git a/packages/google-api-core/tests/unit/test_python_package_support.py b/packages/google-api-core/tests/unit/test_python_package_support.py index ba57aa202ec6..2b2658aa11f0 100644 --- a/packages/google-api-core/tests/unit/test_python_package_support.py +++ b/packages/google-api-core/tests/unit/test_python_package_support.py @@ -38,14 +38,20 @@ def test_get_dependency_version(mocker, version_string_to_test): parse_version_to_tuple(version_string_to_test), version_string_to_test ) assert get_dependency_version("some-package") == expected - mock_importlib.assert_called_once_with("some-package") # Test package not found - mock_importlib.side_effect = ImportError + mock_importlib.side_effect = Exception assert get_dependency_version("not-a-package") == DependencyVersion(None, "--") +def test_parse_version_to_tuple_prerelease(): + """Test parse_version_to_tuple with pre-release versions.""" + assert parse_version_to_tuple("1.83.1rc1") == (1, 83, 1) + assert parse_version_to_tuple("1.83.0dev0") == (1, 83, 0) + assert parse_version_to_tuple("6.33.5b2") == (6, 33, 5) + + @patch("google.api_core._python_package_support._get_distribution_and_import_packages") @patch("google.api_core._python_package_support.get_dependency_version") def test_warn_deprecation_for_versions_less_than(mock_get_version, mock_get_packages): diff --git a/packages/google-auth/google/auth/_helpers.py b/packages/google-auth/google/auth/_helpers.py index 86c48c1e525c..aed929223c92 100644 --- a/packages/google-auth/google/auth/_helpers.py +++ b/packages/google-auth/google/auth/_helpers.py @@ -534,3 +534,20 @@ def response_log(logger: logging.Logger, response: Any) -> None: if is_logging_enabled(logger): json_response = _parse_response(response) _response_log_base(logger, json_response) + + +def _parse_version_to_tuple(version_string): + """Safely converts a semantic version string to a comparable tuple of integers.""" + parts = [] + for part in version_string.split("."): + digits = "" + for c in part: + if not c.isdigit(): + break + digits += c + if digits: + parts.append(int(digits)) + else: + break + return tuple(parts) + diff --git a/packages/google-auth/google/auth/transport/grpc.py b/packages/google-auth/google/auth/transport/grpc.py index f138c3a610aa..13e8077e724c 100644 --- a/packages/google-auth/google/auth/transport/grpc.py +++ b/packages/google-auth/google/auth/transport/grpc.py @@ -18,6 +18,7 @@ import logging +from google.auth import _helpers from google.auth import exceptions from google.auth.transport import _mtls_helper from google.auth.transport import mtls @@ -30,18 +31,13 @@ "gRPC is not installed from please install the grpcio package to use the gRPC transport." ) from caught_exc + try: import importlib.metadata import warnings _grpc_ver_str = importlib.metadata.version("grpcio") - _grpc_parts = [] - for _p in _grpc_ver_str.split("."): - try: - _grpc_parts.append(int(_p)) - except ValueError: - break - if tuple(_grpc_parts) < (1, 83, 0): + if _helpers._parse_version_to_tuple(_grpc_ver_str) < (1, 83, 0): warnings.warn( "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " "Support for non-PQC environments is deprecated. In October 2026, " diff --git a/packages/google-auth/tests/test__helpers.py b/packages/google-auth/tests/test__helpers.py index e2d8e7b20c03..092d6b4a8acc 100644 --- a/packages/google-auth/tests/test__helpers.py +++ b/packages/google-auth/tests/test__helpers.py @@ -697,3 +697,11 @@ def test_out_of_range(self): with pytest.raises((OverflowError, OSError, ValueError)): # Large enough to fail on most systems (Year 300,000+) _helpers.utcfromtimestamp(9999999999999) + + +def test_parse_version_to_tuple(): + assert _helpers._parse_version_to_tuple("1.83.0") == (1, 83, 0) + assert _helpers._parse_version_to_tuple("1.83.1rc1") == (1, 83, 1) + assert _helpers._parse_version_to_tuple("1.83.0dev0") == (1, 83, 0) + assert _helpers._parse_version_to_tuple("2.0") == (2, 0) + diff --git a/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py b/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py index 0c29368bec1c..a89ef0554713 100644 --- a/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py +++ b/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py @@ -30,33 +30,8 @@ import sys import warnings -try: - import importlib.metadata - - _grpc_ver_str = importlib.metadata.version("grpcio") - _grpc_parts = [] - for _p in _grpc_ver_str.split("."): - try: - _grpc_parts.append(int(_p)) - except ValueError: - break - if tuple(_grpc_parts) < (1, 83, 0): - warnings.warn( - "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " - "Support for non-PQC environments is deprecated. In October 2026, " - "Google Cloud Python client libraries will raise their minimum requirements " - "(including google-api-core and grpcio) to enforce grpcio >= 1.83.0. " - "For more details on Google Cloud's post-quantum security migration, visit: " - "https://cloud.google.com/security/resources/post-quantum-cryptography", - FutureWarning, - ) -except Exception: - pass - from google.cloud.bigquery import version as bigquery_version - -__version__ = bigquery_version.__version__ - +from google.cloud.bigquery._helpers import _parse_version_to_tuple from google.cloud.bigquery.client import Client from google.cloud.bigquery.dataset import AccessEntry from google.cloud.bigquery.dataset import Dataset @@ -155,6 +130,23 @@ FutureWarning, ) +try: + import importlib.metadata + + _grpc_ver_str = importlib.metadata.version("grpcio") + if _parse_version_to_tuple(_grpc_ver_str) < (1, 83, 0): + warnings.warn( + "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + "Support for non-PQC environments is deprecated. In October 2026, " + "Google Cloud Python client libraries will raise their minimum requirements " + "(including google-api-core and grpcio) to enforce grpcio >= 1.83.0. " + "For more details on Google Cloud's post-quantum security migration, visit: " + "https://cloud.google.com/security/resources/post-quantum-cryptography", + FutureWarning, + ) +except Exception: + pass + __all__ = [ "__version__", "Client", diff --git a/packages/google-cloud-bigquery/google/cloud/bigquery/_helpers.py b/packages/google-cloud-bigquery/google/cloud/bigquery/_helpers.py index 00a2ef25605c..9b11ca588f42 100644 --- a/packages/google-cloud-bigquery/google/cloud/bigquery/_helpers.py +++ b/packages/google-cloud-bigquery/google/cloud/bigquery/_helpers.py @@ -1106,3 +1106,20 @@ def _isinstance_or_raise( msg = f"Pass {value} as a '{dtype}'{or_none}. Got {type(value)}." raise TypeError(msg) + + +def _parse_version_to_tuple(version_string: str) -> Tuple[int, ...]: + """Safely converts a semantic version string to a comparable tuple of integers.""" + parts = [] + for part in version_string.split("."): + digits = "" + for c in part: + if not c.isdigit(): + break + digits += c + if digits: + parts.append(int(digits)) + else: + break + return tuple(parts) + diff --git a/packages/google-cloud-bigquery/tests/unit/test__helpers.py b/packages/google-cloud-bigquery/tests/unit/test__helpers.py index 4e53236e39e7..4fd4f28cede4 100644 --- a/packages/google-cloud-bigquery/tests/unit/test__helpers.py +++ b/packages/google-cloud-bigquery/tests/unit/test__helpers.py @@ -1214,3 +1214,13 @@ def test__valid_isinstance_or_raise(self, value, dtype, none_allowed, expected): def test__invalid_isinstance_or_raise(self, value, dtype, none_allowed, expected): with expected: _isinstance_or_raise(value, dtype, none_allowed=none_allowed) + + +def test__parse_version_to_tuple(): + from google.cloud.bigquery._helpers import _parse_version_to_tuple + + assert _parse_version_to_tuple("1.83.0") == (1, 83, 0) + assert _parse_version_to_tuple("1.83.1rc1") == (1, 83, 1) + assert _parse_version_to_tuple("1.83.0dev0") == (1, 83, 0) + assert _parse_version_to_tuple("2.0") == (2, 0) + diff --git a/packages/google-cloud-ndb/google/cloud/ndb/__init__.py b/packages/google-cloud-ndb/google/cloud/ndb/__init__.py index c0875caa3648..857d58438dcd 100644 --- a/packages/google-cloud-ndb/google/cloud/ndb/__init__.py +++ b/packages/google-cloud-ndb/google/cloud/ndb/__init__.py @@ -21,20 +21,16 @@ .. autodata:: __all__ """ +from google.cloud.ndb import utils from google.cloud.ndb import version + try: import warnings import importlib.metadata _grpc_ver_str = importlib.metadata.version("grpcio") - _grpc_parts = [] - for _p in _grpc_ver_str.split("."): - try: - _grpc_parts.append(int(_p)) - except ValueError: - break - if tuple(_grpc_parts) < (1, 83, 0): + if utils._parse_version_to_tuple(_grpc_ver_str) < (1, 83, 0): warnings.warn( "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " "Support for non-PQC environments is deprecated. In October 2026, " diff --git a/packages/google-cloud-ndb/google/cloud/ndb/utils.py b/packages/google-cloud-ndb/google/cloud/ndb/utils.py index aecf861cd52c..8d48b576e60c 100644 --- a/packages/google-cloud-ndb/google/cloud/ndb/utils.py +++ b/packages/google-cloud-ndb/google/cloud/ndb/utils.py @@ -163,3 +163,20 @@ def tweak_logging(*args, **kwargs): def wrapping(*args, **kwargs): """Use functools.wraps instead""" raise NotImplementedError + + +def _parse_version_to_tuple(version_string): + """Safely converts a semantic version string to a comparable tuple of integers.""" + parts = [] + for part in version_string.split("."): + digits = "" + for c in part: + if not c.isdigit(): + break + digits += c + if digits: + parts.append(int(digits)) + else: + break + return tuple(parts) + diff --git a/packages/google-cloud-ndb/tests/unit/test_utils.py b/packages/google-cloud-ndb/tests/unit/test_utils.py index 571aa5ada0ed..43bfaf1698f3 100644 --- a/packages/google-cloud-ndb/tests/unit/test_utils.py +++ b/packages/google-cloud-ndb/tests/unit/test_utils.py @@ -133,3 +133,11 @@ def test_tweak_logging(): def test_wrapping(): with pytest.raises(NotImplementedError): utils.wrapping() + + +def test__parse_version_to_tuple(): + assert utils._parse_version_to_tuple("1.83.0") == (1, 83, 0) + assert utils._parse_version_to_tuple("1.83.1rc1") == (1, 83, 1) + assert utils._parse_version_to_tuple("1.83.0dev0") == (1, 83, 0) + assert utils._parse_version_to_tuple("2.0") == (2, 0) + From a88cd8f26431777878ac377a934285d8247c3222 Mon Sep 17 00:00:00 2001 From: ohmayr Date: Tue, 4 Aug 2026 17:07:07 +0000 Subject: [PATCH 06/12] fix mypy --- .../google-cloud-bigquery/google/cloud/bigquery/__init__.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py b/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py index a89ef0554713..b62bb5f4dc68 100644 --- a/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py +++ b/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py @@ -31,6 +31,9 @@ import warnings from google.cloud.bigquery import version as bigquery_version + +__version__ = bigquery_version.__version__ + from google.cloud.bigquery._helpers import _parse_version_to_tuple from google.cloud.bigquery.client import Client from google.cloud.bigquery.dataset import AccessEntry From 96ecf70ad1dfb20863fb309f8f9274e92cdbd782 Mon Sep 17 00:00:00 2001 From: ohmayr Date: Tue, 4 Aug 2026 17:08:48 +0000 Subject: [PATCH 07/12] fix auth lint --- packages/google-auth/google/auth/_helpers.py | 1 - packages/google-auth/tests/test__helpers.py | 1 - 2 files changed, 2 deletions(-) diff --git a/packages/google-auth/google/auth/_helpers.py b/packages/google-auth/google/auth/_helpers.py index aed929223c92..3abc0b6cc9fd 100644 --- a/packages/google-auth/google/auth/_helpers.py +++ b/packages/google-auth/google/auth/_helpers.py @@ -550,4 +550,3 @@ def _parse_version_to_tuple(version_string): else: break return tuple(parts) - diff --git a/packages/google-auth/tests/test__helpers.py b/packages/google-auth/tests/test__helpers.py index 092d6b4a8acc..ad2de3eeca6e 100644 --- a/packages/google-auth/tests/test__helpers.py +++ b/packages/google-auth/tests/test__helpers.py @@ -704,4 +704,3 @@ def test_parse_version_to_tuple(): assert _helpers._parse_version_to_tuple("1.83.1rc1") == (1, 83, 1) assert _helpers._parse_version_to_tuple("1.83.0dev0") == (1, 83, 0) assert _helpers._parse_version_to_tuple("2.0") == (2, 0) - From a26ff47b8de342788de6e61c2d51be95ce888f82 Mon Sep 17 00:00:00 2001 From: ohmayr Date: Tue, 4 Aug 2026 17:11:40 +0000 Subject: [PATCH 08/12] fix lint --- .../tests/unit/test_python_package_support.py | 25 +++++++++++++++---- .../google/cloud/bigquery/__init__.py | 1 - .../google/cloud/bigquery/_helpers.py | 1 - .../tests/unit/test__helpers.py | 1 - .../google/cloud/ndb/utils.py | 1 - .../google-cloud-ndb/tests/unit/test_utils.py | 1 - 6 files changed, 20 insertions(+), 10 deletions(-) diff --git a/packages/google-api-core/tests/unit/test_python_package_support.py b/packages/google-api-core/tests/unit/test_python_package_support.py index 2b2658aa11f0..76ed6eed837b 100644 --- a/packages/google-api-core/tests/unit/test_python_package_support.py +++ b/packages/google-api-core/tests/unit/test_python_package_support.py @@ -132,10 +132,18 @@ def test_check_dependency_versions_with_custom_warnings(mock_warn): assert mock_warn.call_count == 2 mock_warn.assert_any_call( - "my-consumer", "pkg1", "1.0.0", recommended_version="2.0.0", message_template=None + "my-consumer", + "pkg1", + "1.0.0", + recommended_version="2.0.0", + message_template=None, ) mock_warn.assert_any_call( - "my-consumer", "pkg2", "2.0.0", recommended_version="3.0.0", message_template=None + "my-consumer", + "pkg2", + "2.0.0", + recommended_version="3.0.0", + message_template=None, ) @@ -148,9 +156,16 @@ def test_check_dependency_versions_default(mock_warn): assert mock_warn.call_count == 2 mock_warn.assert_any_call( - "my-consumer", "google.protobuf", "6.33.5", recommended_version="6.x", message_template=None + "my-consumer", + "google.protobuf", + "6.33.5", + recommended_version="6.x", + message_template=None, ) mock_warn.assert_any_call( - "my-consumer", "grpcio", "1.83.0", recommended_version="1.83.x", message_template=PQC_GRPC_WARNING_TEMPLATE + "my-consumer", + "grpcio", + "1.83.0", + recommended_version="1.83.x", + message_template=PQC_GRPC_WARNING_TEMPLATE, ) - diff --git a/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py b/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py index b62bb5f4dc68..38eea6d85ad5 100644 --- a/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py +++ b/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py @@ -264,4 +264,3 @@ def load_ipython_extension(ipython): ipython.register_magic_function( _cell_magic, magic_kind="cell", magic_name="bigquery" ) - diff --git a/packages/google-cloud-bigquery/google/cloud/bigquery/_helpers.py b/packages/google-cloud-bigquery/google/cloud/bigquery/_helpers.py index 9b11ca588f42..990fb526cfea 100644 --- a/packages/google-cloud-bigquery/google/cloud/bigquery/_helpers.py +++ b/packages/google-cloud-bigquery/google/cloud/bigquery/_helpers.py @@ -1122,4 +1122,3 @@ def _parse_version_to_tuple(version_string: str) -> Tuple[int, ...]: else: break return tuple(parts) - diff --git a/packages/google-cloud-bigquery/tests/unit/test__helpers.py b/packages/google-cloud-bigquery/tests/unit/test__helpers.py index 4fd4f28cede4..848afe1fafe8 100644 --- a/packages/google-cloud-bigquery/tests/unit/test__helpers.py +++ b/packages/google-cloud-bigquery/tests/unit/test__helpers.py @@ -1223,4 +1223,3 @@ def test__parse_version_to_tuple(): assert _parse_version_to_tuple("1.83.1rc1") == (1, 83, 1) assert _parse_version_to_tuple("1.83.0dev0") == (1, 83, 0) assert _parse_version_to_tuple("2.0") == (2, 0) - diff --git a/packages/google-cloud-ndb/google/cloud/ndb/utils.py b/packages/google-cloud-ndb/google/cloud/ndb/utils.py index 8d48b576e60c..72a784494bd4 100644 --- a/packages/google-cloud-ndb/google/cloud/ndb/utils.py +++ b/packages/google-cloud-ndb/google/cloud/ndb/utils.py @@ -179,4 +179,3 @@ def _parse_version_to_tuple(version_string): else: break return tuple(parts) - diff --git a/packages/google-cloud-ndb/tests/unit/test_utils.py b/packages/google-cloud-ndb/tests/unit/test_utils.py index 43bfaf1698f3..16ebe6ec7454 100644 --- a/packages/google-cloud-ndb/tests/unit/test_utils.py +++ b/packages/google-cloud-ndb/tests/unit/test_utils.py @@ -140,4 +140,3 @@ def test__parse_version_to_tuple(): assert utils._parse_version_to_tuple("1.83.1rc1") == (1, 83, 1) assert utils._parse_version_to_tuple("1.83.0dev0") == (1, 83, 0) assert utils._parse_version_to_tuple("2.0") == (2, 0) - From 3c4211e88afdc303e02fa564c0df63217ddaffcc Mon Sep 17 00:00:00 2001 From: ohmayr Date: Wed, 5 Aug 2026 18:18:28 +0000 Subject: [PATCH 09/12] update redis --- .../redis/google/cloud/redis_v1/__init__.py | 91 +------------------ 1 file changed, 2 insertions(+), 89 deletions(-) diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/__init__.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/__init__.py index dc8efac12481..365eb099e564 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/__init__.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/__init__.py @@ -16,12 +16,9 @@ from google.cloud.redis_v1 import gapic_version as package_version import google.api_core as api_core -import sys __version__ = package_version.__version__ -from importlib import metadata - # PEP 0810: Explicit Lazy Imports # Python 3.15+ natively intercepts and defers these imports. # Developers can disable this behavior and force eager imports. @@ -65,92 +62,8 @@ from .types.cloud_redis import WeeklyMaintenanceWindow from .types.cloud_redis import ZoneMetadata -if hasattr(api_core, "check_python_version") and hasattr(api_core, "check_dependency_versions"): # pragma: NO COVER - api_core.check_python_version("google.cloud.redis_v1") # type: ignore - api_core.check_dependency_versions("google.cloud.redis_v1") # type: ignore -else: # pragma: NO COVER - # An older version of api_core is installed which does not define the - # functions above. We do equivalent checks manually. - try: - import warnings - - _py_version_str = sys.version.split()[0] - _package_label = "google.cloud.redis_v1" - if sys.version_info < (3, 10): - warnings.warn("You are using a non-supported Python version " + - f"({_py_version_str}). Google will not post any further " + - f"updates to {_package_label} supporting this Python version. " + - "Please upgrade to the latest Python version, or at " + - f"least to Python 3.10, and then update {_package_label}.", - FutureWarning) - - def parse_version_to_tuple(version_string: str): - """Safely converts a semantic version string to a comparable tuple of integers. - Example: "6.33.5" -> (6, 33, 5) - Ignores non-numeric parts and handles common version formats. - Args: - version_string: Version string in the format "x.y.z" or "x.y.z" - Returns: - Tuple of integers for the parsed version string. - """ - parts = [] - for part in version_string.split("."): - try: - parts.append(int(part)) - except ValueError: - # If it's a non-numeric part (e.g., '1.0.0b1' -> 'b1'), stop here. - # This is a simplification compared to 'packaging.parse_version', but sufficient - # for comparing strictly numeric semantic versions. - break - return tuple(parts) - - def _get_version(dependency_name): - try: - version_string: str = metadata.version(dependency_name) - parsed_version = parse_version_to_tuple(version_string) - return (parsed_version, version_string) - except Exception: - # Catch exceptions from metadata.version() (e.g., PackageNotFoundError) - # or errors during parse_version_to_tuple - return (None, "--") - - _dependency_package = "google.protobuf" - _next_supported_version = "6.33.5" - _next_supported_version_tuple = (6, 33, 5) - _recommendation = " (we recommend 7.x)" - (_version_used, _version_used_string) = _get_version(_dependency_package) - if _version_used and _version_used < _next_supported_version_tuple: - warnings.warn(f"Package {_package_label} depends on " + - f"{_dependency_package}, currently installed at version " + - f"{_version_used_string}. Future updates to " + - f"{_package_label} will require {_dependency_package} at " + - f"version {_next_supported_version} or higher{_recommendation}." + - " Please ensure " + - "that either (a) your Python environment doesn't pin the " + - f"version of {_dependency_package}, so that updates to " + - f"{_package_label} can require the higher version, or " + - "(b) you manually update your Python environment to use at " + - f"least version {_next_supported_version} of " + - f"{_dependency_package}.", - FutureWarning) - _grpc_package = "grpcio" - _grpc_min_version = "1.83.0" - _grpc_min_version_tuple = (1, 83, 0) - (_grpc_version_used, _grpc_version_used_string) = _get_version(_grpc_package) - if _grpc_version_used and _grpc_version_used < _grpc_min_version_tuple: - warnings.warn(f"Package {_package_label} depends on {_grpc_package}, currently installed at version {_grpc_version_used_string}. " + - "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + - "Support for non-PQC environments is deprecated. In October 2026, " + - "Google Cloud Python client libraries will raise their minimum requirements " + - "(including google-api-core, grpcio, and grpcio-status) to enforce grpcio >= 1.83.0. For more details on Google Cloud's post-quantum " + - "security migration, visit: https://cloud.google.com/security/resources/post-quantum-cryptography", - FutureWarning) - except Exception: - warnings.warn("Could not determine the version of Python " + - "currently being used. To continue receiving " + - "updates for {_package_label}, ensure you are " + - "using a supported version of Python; see " + - "https://devguide.python.org/versions/") +api_core.check_python_version("google.cloud.redis_v1") +api_core.check_dependency_versions("google.cloud.redis_v1") __all__ = ( 'CloudRedisAsyncClient', From e7bc24bdb96eb7166cf025cdf4d323f85c14201b Mon Sep 17 00:00:00 2001 From: ohmayr Date: Wed, 5 Aug 2026 20:30:33 +0000 Subject: [PATCH 10/12] chore: retrigger CI From 547b4c1106762a7b8b27a5a5973afb16fbaf5e1f Mon Sep 17 00:00:00 2001 From: ohmayr Date: Wed, 5 Aug 2026 21:14:28 +0000 Subject: [PATCH 11/12] refactor: use api_core for dependency checks in bigquery and ndb --- .../google/cloud/bigquery/__init__.py | 30 +++---------------- .../google/cloud/bigquery/_helpers.py | 16 ---------- .../tests/unit/test__helpers.py | 8 ----- .../google/cloud/ndb/__init__.py | 19 ++---------- .../google/cloud/ndb/utils.py | 15 ---------- .../google-cloud-ndb/tests/unit/test_utils.py | 6 ---- 6 files changed, 7 insertions(+), 87 deletions(-) diff --git a/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py b/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py index 38eea6d85ad5..fd0a81c9bf9a 100644 --- a/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py +++ b/packages/google-cloud-bigquery/google/cloud/bigquery/__init__.py @@ -34,7 +34,10 @@ __version__ = bigquery_version.__version__ -from google.cloud.bigquery._helpers import _parse_version_to_tuple +import google.api_core as api_core + +api_core.check_python_version("google.cloud.bigquery") +api_core.check_dependency_versions("google.cloud.bigquery") from google.cloud.bigquery.client import Client from google.cloud.bigquery.dataset import AccessEntry from google.cloud.bigquery.dataset import Dataset @@ -124,31 +127,6 @@ except ImportError: bigquery_magics = None -if sys.version_info < (3, 10): # pragma: NO COVER - warnings.warn( - "The python-bigquery library no longer supports Python <= 3.9. " - f"Your Python version is {sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}. We " - "recommend that you update soon to ensure ongoing support. For " - "more details, see: [Google Cloud Client Libraries Supported Python Versions policy](https://cloud.google.com/python/docs/supported-python-versions)", - FutureWarning, - ) - -try: - import importlib.metadata - - _grpc_ver_str = importlib.metadata.version("grpcio") - if _parse_version_to_tuple(_grpc_ver_str) < (1, 83, 0): - warnings.warn( - "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " - "Support for non-PQC environments is deprecated. In October 2026, " - "Google Cloud Python client libraries will raise their minimum requirements " - "(including google-api-core and grpcio) to enforce grpcio >= 1.83.0. " - "For more details on Google Cloud's post-quantum security migration, visit: " - "https://cloud.google.com/security/resources/post-quantum-cryptography", - FutureWarning, - ) -except Exception: - pass __all__ = [ "__version__", diff --git a/packages/google-cloud-bigquery/google/cloud/bigquery/_helpers.py b/packages/google-cloud-bigquery/google/cloud/bigquery/_helpers.py index 990fb526cfea..00a2ef25605c 100644 --- a/packages/google-cloud-bigquery/google/cloud/bigquery/_helpers.py +++ b/packages/google-cloud-bigquery/google/cloud/bigquery/_helpers.py @@ -1106,19 +1106,3 @@ def _isinstance_or_raise( msg = f"Pass {value} as a '{dtype}'{or_none}. Got {type(value)}." raise TypeError(msg) - - -def _parse_version_to_tuple(version_string: str) -> Tuple[int, ...]: - """Safely converts a semantic version string to a comparable tuple of integers.""" - parts = [] - for part in version_string.split("."): - digits = "" - for c in part: - if not c.isdigit(): - break - digits += c - if digits: - parts.append(int(digits)) - else: - break - return tuple(parts) diff --git a/packages/google-cloud-bigquery/tests/unit/test__helpers.py b/packages/google-cloud-bigquery/tests/unit/test__helpers.py index 848afe1fafe8..861954fd6269 100644 --- a/packages/google-cloud-bigquery/tests/unit/test__helpers.py +++ b/packages/google-cloud-bigquery/tests/unit/test__helpers.py @@ -1215,11 +1215,3 @@ def test__invalid_isinstance_or_raise(self, value, dtype, none_allowed, expected with expected: _isinstance_or_raise(value, dtype, none_allowed=none_allowed) - -def test__parse_version_to_tuple(): - from google.cloud.bigquery._helpers import _parse_version_to_tuple - - assert _parse_version_to_tuple("1.83.0") == (1, 83, 0) - assert _parse_version_to_tuple("1.83.1rc1") == (1, 83, 1) - assert _parse_version_to_tuple("1.83.0dev0") == (1, 83, 0) - assert _parse_version_to_tuple("2.0") == (2, 0) diff --git a/packages/google-cloud-ndb/google/cloud/ndb/__init__.py b/packages/google-cloud-ndb/google/cloud/ndb/__init__.py index 857d58438dcd..291d2a6aa074 100644 --- a/packages/google-cloud-ndb/google/cloud/ndb/__init__.py +++ b/packages/google-cloud-ndb/google/cloud/ndb/__init__.py @@ -25,23 +25,10 @@ from google.cloud.ndb import version -try: - import warnings - import importlib.metadata +import google.api_core as api_core - _grpc_ver_str = importlib.metadata.version("grpcio") - if utils._parse_version_to_tuple(_grpc_ver_str) < (1, 83, 0): - warnings.warn( - "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " - "Support for non-PQC environments is deprecated. In October 2026, " - "Google Cloud Python client libraries will raise their minimum requirements " - "(including google-api-core) to enforce grpcio >= 1.83.0. " - "For more details on Google Cloud's post-quantum security migration, visit: " - "https://cloud.google.com/security/resources/post-quantum-cryptography", - FutureWarning, - ) -except Exception: - pass +api_core.check_python_version("google.cloud.ndb") +api_core.check_dependency_versions("google.cloud.ndb") __version__: str = version.__version__ diff --git a/packages/google-cloud-ndb/google/cloud/ndb/utils.py b/packages/google-cloud-ndb/google/cloud/ndb/utils.py index 72a784494bd4..833c4c31c6e3 100644 --- a/packages/google-cloud-ndb/google/cloud/ndb/utils.py +++ b/packages/google-cloud-ndb/google/cloud/ndb/utils.py @@ -164,18 +164,3 @@ def wrapping(*args, **kwargs): """Use functools.wraps instead""" raise NotImplementedError - -def _parse_version_to_tuple(version_string): - """Safely converts a semantic version string to a comparable tuple of integers.""" - parts = [] - for part in version_string.split("."): - digits = "" - for c in part: - if not c.isdigit(): - break - digits += c - if digits: - parts.append(int(digits)) - else: - break - return tuple(parts) diff --git a/packages/google-cloud-ndb/tests/unit/test_utils.py b/packages/google-cloud-ndb/tests/unit/test_utils.py index 16ebe6ec7454..3041414a90d6 100644 --- a/packages/google-cloud-ndb/tests/unit/test_utils.py +++ b/packages/google-cloud-ndb/tests/unit/test_utils.py @@ -134,9 +134,3 @@ def test_wrapping(): with pytest.raises(NotImplementedError): utils.wrapping() - -def test__parse_version_to_tuple(): - assert utils._parse_version_to_tuple("1.83.0") == (1, 83, 0) - assert utils._parse_version_to_tuple("1.83.1rc1") == (1, 83, 1) - assert utils._parse_version_to_tuple("1.83.0dev0") == (1, 83, 0) - assert utils._parse_version_to_tuple("2.0") == (2, 0) From aed94d052804a890478a1c1836e87b1a144ac921 Mon Sep 17 00:00:00 2001 From: ohmayr Date: Wed, 5 Aug 2026 21:25:49 +0000 Subject: [PATCH 12/12] update templates --- .../%name_%version/%sub/__init__.py.j2 | 96 +------------------ .../asset/google/cloud/asset_v1/__init__.py | 91 +----------------- .../google/iam/credentials_v1/__init__.py | 91 +----------------- .../google/cloud/logging_v2/__init__.py | 91 +----------------- .../google/cloud/logging_v2/__init__.py | 91 +----------------- .../google/cloud/redis_v1/__init__.py | 91 +----------------- .../storagebatchoperations_v1/__init__.py | 91 +----------------- 7 files changed, 14 insertions(+), 628 deletions(-) diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/__init__.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/__init__.py.j2 index 2527860c40cb..79ff49bf35c7 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/__init__.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/__init__.py.j2 @@ -6,12 +6,9 @@ from {{package_path}} import gapic_version as package_version import google.api_core as api_core -import sys __version__ = package_version.__version__ -from importlib import metadata - # PEP 0810: Explicit Lazy Imports # Python 3.15+ natively intercepts and defers these imports. # Developers can disable this behavior and force eager imports. @@ -63,97 +60,8 @@ from .types.{{ proto.module_name }} import {{ enum.name }} {% endfor %} {% endfor %} -if hasattr(api_core, "check_python_version") and hasattr(api_core, "check_dependency_versions"): # pragma: NO COVER - {# TODO(api_core): remove `type:ignore` below when minimum version of api_core makes the else clause unnecessary. #} - api_core.check_python_version("{{package_path}}") # type: ignore - api_core.check_dependency_versions("{{package_path}}") # type: ignore -else: # pragma: NO COVER -{# TODO(api_core): Remove this try-catch when we require api-core at a version that - supports the changes in https://github.com/googleapis/python-api-core/pull/832 - - In the meantime, please ensure the functionality here mirrors the - equivalent functionality in api_core, in those two functions above. -#} - # An older version of api_core is installed which does not define the - # functions above. We do equivalent checks manually. - try: - import warnings - - _py_version_str = sys.version.split()[0] - _package_label = "{{package_path}}" - if sys.version_info < (3, 10): - warnings.warn("You are using a non-supported Python version " + - f"({_py_version_str}). Google will not post any further " + - f"updates to {_package_label} supporting this Python version. " + - "Please upgrade to the latest Python version, or at " + - f"least to Python 3.10, and then update {_package_label}.", - FutureWarning) - - def parse_version_to_tuple(version_string: str): - """Safely converts a semantic version string to a comparable tuple of integers. - Example: "6.33.5" -> (6, 33, 5), "1.83.1rc1" -> (1, 83, 1) - Parses leading digits of each component to correctly handle pre-releases. - """ - parts = [] - for part in version_string.split("."): - digits = "" - for c in part: - if not c.isdigit(): - break - digits += c - if digits: - parts.append(int(digits)) - else: - break - return tuple(parts) - - def _get_version(dependency_name): - try: - version_string: str = metadata.version(dependency_name) - parsed_version = parse_version_to_tuple(version_string) - return (parsed_version, version_string) - except Exception: - # Catch exceptions from metadata.version() (e.g., PackageNotFoundError) - # or errors during parse_version_to_tuple - return (None, "--") - - _dependency_package = "google.protobuf" - _next_supported_version = "6.33.5" - _next_supported_version_tuple = (6, 33, 5) - _recommendation = " (we recommend 7.x)" - (_version_used, _version_used_string) = _get_version(_dependency_package) - if _version_used and _version_used < _next_supported_version_tuple: - warnings.warn(f"Package {_package_label} depends on " + - f"{_dependency_package}, currently installed at version " + - f"{_version_used_string}. Future updates to " + - f"{_package_label} will require {_dependency_package} at " + - f"version {_next_supported_version} or higher{_recommendation}." + - " Please ensure " + - "that either (a) your Python environment doesn't pin the " + - f"version of {_dependency_package}, so that updates to " + - f"{_package_label} can require the higher version, or " + - "(b) you manually update your Python environment to use at " + - f"least version {_next_supported_version} of " + - f"{_dependency_package}.", - FutureWarning) - _grpc_package = "grpcio" - _grpc_min_version = "1.83.0" - _grpc_min_version_tuple = (1, 83, 0) - (_grpc_version_used, _grpc_version_used_string) = _get_version(_grpc_package) - if _grpc_version_used and _grpc_version_used < _grpc_min_version_tuple: - warnings.warn(f"Package {_package_label} depends on {_grpc_package}, currently installed at version {_grpc_version_used_string}. " + - "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + - "Support for non-PQC environments is deprecated. In October 2026, " + - "Google Cloud Python client libraries will raise their minimum requirements " + - "(including google-api-core, grpcio, and grpcio-status) to enforce grpcio >= 1.83.0. For more details on Google Cloud's post-quantum " + - "security migration, visit: https://cloud.google.com/security/resources/post-quantum-cryptography", - FutureWarning) - except Exception: - warnings.warn("Could not determine the version of Python " + - "currently being used. To continue receiving " + - "updates for {_package_label}, ensure you are " + - "using a supported version of Python; see " + - "https://devguide.python.org/versions/") +api_core.check_python_version("{{package_path}}") +api_core.check_dependency_versions("{{package_path}}") {# Define __all__. This requires the full set of imported names, so we iterate over diff --git a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/__init__.py b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/__init__.py index 8e5dd71750c2..589ca0f7adb9 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/__init__.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/__init__.py @@ -16,12 +16,9 @@ from google.cloud.asset_v1 import gapic_version as package_version import google.api_core as api_core -import sys __version__ = package_version.__version__ -from importlib import metadata - # PEP 0810: Explicit Lazy Imports # Python 3.15+ natively intercepts and defers these imports. # Developers can disable this behavior and force eager imports. @@ -121,92 +118,8 @@ from .types.assets import TimeWindow from .types.assets import VersionedResource -if hasattr(api_core, "check_python_version") and hasattr(api_core, "check_dependency_versions"): # pragma: NO COVER - api_core.check_python_version("google.cloud.asset_v1") # type: ignore - api_core.check_dependency_versions("google.cloud.asset_v1") # type: ignore -else: # pragma: NO COVER - # An older version of api_core is installed which does not define the - # functions above. We do equivalent checks manually. - try: - import warnings - - _py_version_str = sys.version.split()[0] - _package_label = "google.cloud.asset_v1" - if sys.version_info < (3, 10): - warnings.warn("You are using a non-supported Python version " + - f"({_py_version_str}). Google will not post any further " + - f"updates to {_package_label} supporting this Python version. " + - "Please upgrade to the latest Python version, or at " + - f"least to Python 3.10, and then update {_package_label}.", - FutureWarning) - - def parse_version_to_tuple(version_string: str): - """Safely converts a semantic version string to a comparable tuple of integers. - Example: "6.33.5" -> (6, 33, 5) - Ignores non-numeric parts and handles common version formats. - Args: - version_string: Version string in the format "x.y.z" or "x.y.z" - Returns: - Tuple of integers for the parsed version string. - """ - parts = [] - for part in version_string.split("."): - try: - parts.append(int(part)) - except ValueError: - # If it's a non-numeric part (e.g., '1.0.0b1' -> 'b1'), stop here. - # This is a simplification compared to 'packaging.parse_version', but sufficient - # for comparing strictly numeric semantic versions. - break - return tuple(parts) - - def _get_version(dependency_name): - try: - version_string: str = metadata.version(dependency_name) - parsed_version = parse_version_to_tuple(version_string) - return (parsed_version, version_string) - except Exception: - # Catch exceptions from metadata.version() (e.g., PackageNotFoundError) - # or errors during parse_version_to_tuple - return (None, "--") - - _dependency_package = "google.protobuf" - _next_supported_version = "6.33.5" - _next_supported_version_tuple = (6, 33, 5) - _recommendation = " (we recommend 7.x)" - (_version_used, _version_used_string) = _get_version(_dependency_package) - if _version_used and _version_used < _next_supported_version_tuple: - warnings.warn(f"Package {_package_label} depends on " + - f"{_dependency_package}, currently installed at version " + - f"{_version_used_string}. Future updates to " + - f"{_package_label} will require {_dependency_package} at " + - f"version {_next_supported_version} or higher{_recommendation}." + - " Please ensure " + - "that either (a) your Python environment doesn't pin the " + - f"version of {_dependency_package}, so that updates to " + - f"{_package_label} can require the higher version, or " + - "(b) you manually update your Python environment to use at " + - f"least version {_next_supported_version} of " + - f"{_dependency_package}.", - FutureWarning) - _grpc_package = "grpcio" - _grpc_min_version = "1.83.0" - _grpc_min_version_tuple = (1, 83, 0) - (_grpc_version_used, _grpc_version_used_string) = _get_version(_grpc_package) - if _grpc_version_used and _grpc_version_used < _grpc_min_version_tuple: - warnings.warn(f"Package {_package_label} depends on {_grpc_package}, currently installed at version {_grpc_version_used_string}. " + - "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + - "Support for non-PQC environments is deprecated. In October 2026, " + - "Google Cloud Python client libraries will raise their minimum requirements " + - "(including google-api-core, grpcio, and grpcio-status) to enforce grpcio >= 1.83.0. For more details on Google Cloud's post-quantum " + - "security migration, visit: https://cloud.google.com/security/resources/post-quantum-cryptography", - FutureWarning) - except Exception: - warnings.warn("Could not determine the version of Python " + - "currently being used. To continue receiving " + - "updates for {_package_label}, ensure you are " + - "using a supported version of Python; see " + - "https://devguide.python.org/versions/") +api_core.check_python_version("") +api_core.check_dependency_versions("") __all__ = ( 'AssetServiceAsyncClient', diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/__init__.py b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/__init__.py index c747c2e53620..f677d1815122 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/__init__.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/__init__.py @@ -16,12 +16,9 @@ from google.iam.credentials_v1 import gapic_version as package_version import google.api_core as api_core -import sys __version__ = package_version.__version__ -from importlib import metadata - # PEP 0810: Explicit Lazy Imports # Python 3.15+ natively intercepts and defers these imports. # Developers can disable this behavior and force eager imports. @@ -47,92 +44,8 @@ from .types.common import SignJwtRequest from .types.common import SignJwtResponse -if hasattr(api_core, "check_python_version") and hasattr(api_core, "check_dependency_versions"): # pragma: NO COVER - api_core.check_python_version("google.iam.credentials_v1") # type: ignore - api_core.check_dependency_versions("google.iam.credentials_v1") # type: ignore -else: # pragma: NO COVER - # An older version of api_core is installed which does not define the - # functions above. We do equivalent checks manually. - try: - import warnings - - _py_version_str = sys.version.split()[0] - _package_label = "google.iam.credentials_v1" - if sys.version_info < (3, 10): - warnings.warn("You are using a non-supported Python version " + - f"({_py_version_str}). Google will not post any further " + - f"updates to {_package_label} supporting this Python version. " + - "Please upgrade to the latest Python version, or at " + - f"least to Python 3.10, and then update {_package_label}.", - FutureWarning) - - def parse_version_to_tuple(version_string: str): - """Safely converts a semantic version string to a comparable tuple of integers. - Example: "6.33.5" -> (6, 33, 5) - Ignores non-numeric parts and handles common version formats. - Args: - version_string: Version string in the format "x.y.z" or "x.y.z" - Returns: - Tuple of integers for the parsed version string. - """ - parts = [] - for part in version_string.split("."): - try: - parts.append(int(part)) - except ValueError: - # If it's a non-numeric part (e.g., '1.0.0b1' -> 'b1'), stop here. - # This is a simplification compared to 'packaging.parse_version', but sufficient - # for comparing strictly numeric semantic versions. - break - return tuple(parts) - - def _get_version(dependency_name): - try: - version_string: str = metadata.version(dependency_name) - parsed_version = parse_version_to_tuple(version_string) - return (parsed_version, version_string) - except Exception: - # Catch exceptions from metadata.version() (e.g., PackageNotFoundError) - # or errors during parse_version_to_tuple - return (None, "--") - - _dependency_package = "google.protobuf" - _next_supported_version = "6.33.5" - _next_supported_version_tuple = (6, 33, 5) - _recommendation = " (we recommend 7.x)" - (_version_used, _version_used_string) = _get_version(_dependency_package) - if _version_used and _version_used < _next_supported_version_tuple: - warnings.warn(f"Package {_package_label} depends on " + - f"{_dependency_package}, currently installed at version " + - f"{_version_used_string}. Future updates to " + - f"{_package_label} will require {_dependency_package} at " + - f"version {_next_supported_version} or higher{_recommendation}." + - " Please ensure " + - "that either (a) your Python environment doesn't pin the " + - f"version of {_dependency_package}, so that updates to " + - f"{_package_label} can require the higher version, or " + - "(b) you manually update your Python environment to use at " + - f"least version {_next_supported_version} of " + - f"{_dependency_package}.", - FutureWarning) - _grpc_package = "grpcio" - _grpc_min_version = "1.83.0" - _grpc_min_version_tuple = (1, 83, 0) - (_grpc_version_used, _grpc_version_used_string) = _get_version(_grpc_package) - if _grpc_version_used and _grpc_version_used < _grpc_min_version_tuple: - warnings.warn(f"Package {_package_label} depends on {_grpc_package}, currently installed at version {_grpc_version_used_string}. " + - "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + - "Support for non-PQC environments is deprecated. In October 2026, " + - "Google Cloud Python client libraries will raise their minimum requirements " + - "(including google-api-core, grpcio, and grpcio-status) to enforce grpcio >= 1.83.0. For more details on Google Cloud's post-quantum " + - "security migration, visit: https://cloud.google.com/security/resources/post-quantum-cryptography", - FutureWarning) - except Exception: - warnings.warn("Could not determine the version of Python " + - "currently being used. To continue receiving " + - "updates for {_package_label}, ensure you are " + - "using a supported version of Python; see " + - "https://devguide.python.org/versions/") +api_core.check_python_version("") +api_core.check_dependency_versions("") __all__ = ( 'IAMCredentialsAsyncClient', diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/__init__.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/__init__.py index df909112e36d..62609e4635cd 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/__init__.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/__init__.py @@ -16,12 +16,9 @@ from google.cloud.logging_v2 import gapic_version as package_version import google.api_core as api_core -import sys __version__ = package_version.__version__ -from importlib import metadata - # PEP 0810: Explicit Lazy Imports # Python 3.15+ natively intercepts and defers these imports. # Developers can disable this behavior and force eager imports. @@ -123,92 +120,8 @@ from .types.logging_metrics import LogMetric from .types.logging_metrics import UpdateLogMetricRequest -if hasattr(api_core, "check_python_version") and hasattr(api_core, "check_dependency_versions"): # pragma: NO COVER - api_core.check_python_version("google.cloud.logging_v2") # type: ignore - api_core.check_dependency_versions("google.cloud.logging_v2") # type: ignore -else: # pragma: NO COVER - # An older version of api_core is installed which does not define the - # functions above. We do equivalent checks manually. - try: - import warnings - - _py_version_str = sys.version.split()[0] - _package_label = "google.cloud.logging_v2" - if sys.version_info < (3, 10): - warnings.warn("You are using a non-supported Python version " + - f"({_py_version_str}). Google will not post any further " + - f"updates to {_package_label} supporting this Python version. " + - "Please upgrade to the latest Python version, or at " + - f"least to Python 3.10, and then update {_package_label}.", - FutureWarning) - - def parse_version_to_tuple(version_string: str): - """Safely converts a semantic version string to a comparable tuple of integers. - Example: "6.33.5" -> (6, 33, 5) - Ignores non-numeric parts and handles common version formats. - Args: - version_string: Version string in the format "x.y.z" or "x.y.z" - Returns: - Tuple of integers for the parsed version string. - """ - parts = [] - for part in version_string.split("."): - try: - parts.append(int(part)) - except ValueError: - # If it's a non-numeric part (e.g., '1.0.0b1' -> 'b1'), stop here. - # This is a simplification compared to 'packaging.parse_version', but sufficient - # for comparing strictly numeric semantic versions. - break - return tuple(parts) - - def _get_version(dependency_name): - try: - version_string: str = metadata.version(dependency_name) - parsed_version = parse_version_to_tuple(version_string) - return (parsed_version, version_string) - except Exception: - # Catch exceptions from metadata.version() (e.g., PackageNotFoundError) - # or errors during parse_version_to_tuple - return (None, "--") - - _dependency_package = "google.protobuf" - _next_supported_version = "6.33.5" - _next_supported_version_tuple = (6, 33, 5) - _recommendation = " (we recommend 7.x)" - (_version_used, _version_used_string) = _get_version(_dependency_package) - if _version_used and _version_used < _next_supported_version_tuple: - warnings.warn(f"Package {_package_label} depends on " + - f"{_dependency_package}, currently installed at version " + - f"{_version_used_string}. Future updates to " + - f"{_package_label} will require {_dependency_package} at " + - f"version {_next_supported_version} or higher{_recommendation}." + - " Please ensure " + - "that either (a) your Python environment doesn't pin the " + - f"version of {_dependency_package}, so that updates to " + - f"{_package_label} can require the higher version, or " + - "(b) you manually update your Python environment to use at " + - f"least version {_next_supported_version} of " + - f"{_dependency_package}.", - FutureWarning) - _grpc_package = "grpcio" - _grpc_min_version = "1.83.0" - _grpc_min_version_tuple = (1, 83, 0) - (_grpc_version_used, _grpc_version_used_string) = _get_version(_grpc_package) - if _grpc_version_used and _grpc_version_used < _grpc_min_version_tuple: - warnings.warn(f"Package {_package_label} depends on {_grpc_package}, currently installed at version {_grpc_version_used_string}. " + - "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + - "Support for non-PQC environments is deprecated. In October 2026, " + - "Google Cloud Python client libraries will raise their minimum requirements " + - "(including google-api-core, grpcio, and grpcio-status) to enforce grpcio >= 1.83.0. For more details on Google Cloud's post-quantum " + - "security migration, visit: https://cloud.google.com/security/resources/post-quantum-cryptography", - FutureWarning) - except Exception: - warnings.warn("Could not determine the version of Python " + - "currently being used. To continue receiving " + - "updates for {_package_label}, ensure you are " + - "using a supported version of Python; see " + - "https://devguide.python.org/versions/") +api_core.check_python_version("") +api_core.check_dependency_versions("") __all__ = ( 'ConfigServiceV2AsyncClient', diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/__init__.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/__init__.py index 9268adf976a9..e138052ae3de 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/__init__.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/__init__.py @@ -16,12 +16,9 @@ from google.cloud.logging_v2 import gapic_version as package_version import google.api_core as api_core -import sys __version__ = package_version.__version__ -from importlib import metadata - # PEP 0810: Explicit Lazy Imports # Python 3.15+ natively intercepts and defers these imports. # Developers can disable this behavior and force eager imports. @@ -123,92 +120,8 @@ from .types.logging_metrics import LogMetric from .types.logging_metrics import UpdateLogMetricRequest -if hasattr(api_core, "check_python_version") and hasattr(api_core, "check_dependency_versions"): # pragma: NO COVER - api_core.check_python_version("google.cloud.logging_v2") # type: ignore - api_core.check_dependency_versions("google.cloud.logging_v2") # type: ignore -else: # pragma: NO COVER - # An older version of api_core is installed which does not define the - # functions above. We do equivalent checks manually. - try: - import warnings - - _py_version_str = sys.version.split()[0] - _package_label = "google.cloud.logging_v2" - if sys.version_info < (3, 10): - warnings.warn("You are using a non-supported Python version " + - f"({_py_version_str}). Google will not post any further " + - f"updates to {_package_label} supporting this Python version. " + - "Please upgrade to the latest Python version, or at " + - f"least to Python 3.10, and then update {_package_label}.", - FutureWarning) - - def parse_version_to_tuple(version_string: str): - """Safely converts a semantic version string to a comparable tuple of integers. - Example: "6.33.5" -> (6, 33, 5) - Ignores non-numeric parts and handles common version formats. - Args: - version_string: Version string in the format "x.y.z" or "x.y.z" - Returns: - Tuple of integers for the parsed version string. - """ - parts = [] - for part in version_string.split("."): - try: - parts.append(int(part)) - except ValueError: - # If it's a non-numeric part (e.g., '1.0.0b1' -> 'b1'), stop here. - # This is a simplification compared to 'packaging.parse_version', but sufficient - # for comparing strictly numeric semantic versions. - break - return tuple(parts) - - def _get_version(dependency_name): - try: - version_string: str = metadata.version(dependency_name) - parsed_version = parse_version_to_tuple(version_string) - return (parsed_version, version_string) - except Exception: - # Catch exceptions from metadata.version() (e.g., PackageNotFoundError) - # or errors during parse_version_to_tuple - return (None, "--") - - _dependency_package = "google.protobuf" - _next_supported_version = "6.33.5" - _next_supported_version_tuple = (6, 33, 5) - _recommendation = " (we recommend 7.x)" - (_version_used, _version_used_string) = _get_version(_dependency_package) - if _version_used and _version_used < _next_supported_version_tuple: - warnings.warn(f"Package {_package_label} depends on " + - f"{_dependency_package}, currently installed at version " + - f"{_version_used_string}. Future updates to " + - f"{_package_label} will require {_dependency_package} at " + - f"version {_next_supported_version} or higher{_recommendation}." + - " Please ensure " + - "that either (a) your Python environment doesn't pin the " + - f"version of {_dependency_package}, so that updates to " + - f"{_package_label} can require the higher version, or " + - "(b) you manually update your Python environment to use at " + - f"least version {_next_supported_version} of " + - f"{_dependency_package}.", - FutureWarning) - _grpc_package = "grpcio" - _grpc_min_version = "1.83.0" - _grpc_min_version_tuple = (1, 83, 0) - (_grpc_version_used, _grpc_version_used_string) = _get_version(_grpc_package) - if _grpc_version_used and _grpc_version_used < _grpc_min_version_tuple: - warnings.warn(f"Package {_package_label} depends on {_grpc_package}, currently installed at version {_grpc_version_used_string}. " + - "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + - "Support for non-PQC environments is deprecated. In October 2026, " + - "Google Cloud Python client libraries will raise their minimum requirements " + - "(including google-api-core, grpcio, and grpcio-status) to enforce grpcio >= 1.83.0. For more details on Google Cloud's post-quantum " + - "security migration, visit: https://cloud.google.com/security/resources/post-quantum-cryptography", - FutureWarning) - except Exception: - warnings.warn("Could not determine the version of Python " + - "currently being used. To continue receiving " + - "updates for {_package_label}, ensure you are " + - "using a supported version of Python; see " + - "https://devguide.python.org/versions/") +api_core.check_python_version("") +api_core.check_dependency_versions("") __all__ = ( 'BaseConfigServiceV2AsyncClient', diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/__init__.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/__init__.py index 37d40d5cf946..7b84c8338fd3 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/__init__.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/__init__.py @@ -16,12 +16,9 @@ from google.cloud.redis_v1 import gapic_version as package_version import google.api_core as api_core -import sys __version__ = package_version.__version__ -from importlib import metadata - # PEP 0810: Explicit Lazy Imports # Python 3.15+ natively intercepts and defers these imports. # Developers can disable this behavior and force eager imports. @@ -58,92 +55,8 @@ from .types.cloud_redis import WeeklyMaintenanceWindow from .types.cloud_redis import ZoneMetadata -if hasattr(api_core, "check_python_version") and hasattr(api_core, "check_dependency_versions"): # pragma: NO COVER - api_core.check_python_version("google.cloud.redis_v1") # type: ignore - api_core.check_dependency_versions("google.cloud.redis_v1") # type: ignore -else: # pragma: NO COVER - # An older version of api_core is installed which does not define the - # functions above. We do equivalent checks manually. - try: - import warnings - - _py_version_str = sys.version.split()[0] - _package_label = "google.cloud.redis_v1" - if sys.version_info < (3, 10): - warnings.warn("You are using a non-supported Python version " + - f"({_py_version_str}). Google will not post any further " + - f"updates to {_package_label} supporting this Python version. " + - "Please upgrade to the latest Python version, or at " + - f"least to Python 3.10, and then update {_package_label}.", - FutureWarning) - - def parse_version_to_tuple(version_string: str): - """Safely converts a semantic version string to a comparable tuple of integers. - Example: "6.33.5" -> (6, 33, 5) - Ignores non-numeric parts and handles common version formats. - Args: - version_string: Version string in the format "x.y.z" or "x.y.z" - Returns: - Tuple of integers for the parsed version string. - """ - parts = [] - for part in version_string.split("."): - try: - parts.append(int(part)) - except ValueError: - # If it's a non-numeric part (e.g., '1.0.0b1' -> 'b1'), stop here. - # This is a simplification compared to 'packaging.parse_version', but sufficient - # for comparing strictly numeric semantic versions. - break - return tuple(parts) - - def _get_version(dependency_name): - try: - version_string: str = metadata.version(dependency_name) - parsed_version = parse_version_to_tuple(version_string) - return (parsed_version, version_string) - except Exception: - # Catch exceptions from metadata.version() (e.g., PackageNotFoundError) - # or errors during parse_version_to_tuple - return (None, "--") - - _dependency_package = "google.protobuf" - _next_supported_version = "6.33.5" - _next_supported_version_tuple = (6, 33, 5) - _recommendation = " (we recommend 7.x)" - (_version_used, _version_used_string) = _get_version(_dependency_package) - if _version_used and _version_used < _next_supported_version_tuple: - warnings.warn(f"Package {_package_label} depends on " + - f"{_dependency_package}, currently installed at version " + - f"{_version_used_string}. Future updates to " + - f"{_package_label} will require {_dependency_package} at " + - f"version {_next_supported_version} or higher{_recommendation}." + - " Please ensure " + - "that either (a) your Python environment doesn't pin the " + - f"version of {_dependency_package}, so that updates to " + - f"{_package_label} can require the higher version, or " + - "(b) you manually update your Python environment to use at " + - f"least version {_next_supported_version} of " + - f"{_dependency_package}.", - FutureWarning) - _grpc_package = "grpcio" - _grpc_min_version = "1.83.0" - _grpc_min_version_tuple = (1, 83, 0) - (_grpc_version_used, _grpc_version_used_string) = _get_version(_grpc_package) - if _grpc_version_used and _grpc_version_used < _grpc_min_version_tuple: - warnings.warn(f"Package {_package_label} depends on {_grpc_package}, currently installed at version {_grpc_version_used_string}. " + - "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + - "Support for non-PQC environments is deprecated. In October 2026, " + - "Google Cloud Python client libraries will raise their minimum requirements " + - "(including google-api-core, grpcio, and grpcio-status) to enforce grpcio >= 1.83.0. For more details on Google Cloud's post-quantum " + - "security migration, visit: https://cloud.google.com/security/resources/post-quantum-cryptography", - FutureWarning) - except Exception: - warnings.warn("Could not determine the version of Python " + - "currently being used. To continue receiving " + - "updates for {_package_label}, ensure you are " + - "using a supported version of Python; see " + - "https://devguide.python.org/versions/") +api_core.check_python_version("") +api_core.check_dependency_versions("") __all__ = ( 'CloudRedisAsyncClient', diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/__init__.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/__init__.py index fa8d8320cc34..7c5150513e9b 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/__init__.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/__init__.py @@ -16,12 +16,9 @@ from google.cloud.storagebatchoperations_v1 import gapic_version as package_version import google.api_core as api_core -import sys __version__ = package_version.__version__ -from importlib import metadata - # PEP 0810: Explicit Lazy Imports # Python 3.15+ natively intercepts and defers these imports. # Developers can disable this behavior and force eager imports. @@ -67,92 +64,8 @@ from .types.storage_batch_operations_types import RewriteObject from .types.storage_batch_operations_types import UpdateObjectCustomContext -if hasattr(api_core, "check_python_version") and hasattr(api_core, "check_dependency_versions"): # pragma: NO COVER - api_core.check_python_version("google.cloud.storagebatchoperations_v1") # type: ignore - api_core.check_dependency_versions("google.cloud.storagebatchoperations_v1") # type: ignore -else: # pragma: NO COVER - # An older version of api_core is installed which does not define the - # functions above. We do equivalent checks manually. - try: - import warnings - - _py_version_str = sys.version.split()[0] - _package_label = "google.cloud.storagebatchoperations_v1" - if sys.version_info < (3, 10): - warnings.warn("You are using a non-supported Python version " + - f"({_py_version_str}). Google will not post any further " + - f"updates to {_package_label} supporting this Python version. " + - "Please upgrade to the latest Python version, or at " + - f"least to Python 3.10, and then update {_package_label}.", - FutureWarning) - - def parse_version_to_tuple(version_string: str): - """Safely converts a semantic version string to a comparable tuple of integers. - Example: "6.33.5" -> (6, 33, 5) - Ignores non-numeric parts and handles common version formats. - Args: - version_string: Version string in the format "x.y.z" or "x.y.z" - Returns: - Tuple of integers for the parsed version string. - """ - parts = [] - for part in version_string.split("."): - try: - parts.append(int(part)) - except ValueError: - # If it's a non-numeric part (e.g., '1.0.0b1' -> 'b1'), stop here. - # This is a simplification compared to 'packaging.parse_version', but sufficient - # for comparing strictly numeric semantic versions. - break - return tuple(parts) - - def _get_version(dependency_name): - try: - version_string: str = metadata.version(dependency_name) - parsed_version = parse_version_to_tuple(version_string) - return (parsed_version, version_string) - except Exception: - # Catch exceptions from metadata.version() (e.g., PackageNotFoundError) - # or errors during parse_version_to_tuple - return (None, "--") - - _dependency_package = "google.protobuf" - _next_supported_version = "6.33.5" - _next_supported_version_tuple = (6, 33, 5) - _recommendation = " (we recommend 7.x)" - (_version_used, _version_used_string) = _get_version(_dependency_package) - if _version_used and _version_used < _next_supported_version_tuple: - warnings.warn(f"Package {_package_label} depends on " + - f"{_dependency_package}, currently installed at version " + - f"{_version_used_string}. Future updates to " + - f"{_package_label} will require {_dependency_package} at " + - f"version {_next_supported_version} or higher{_recommendation}." + - " Please ensure " + - "that either (a) your Python environment doesn't pin the " + - f"version of {_dependency_package}, so that updates to " + - f"{_package_label} can require the higher version, or " + - "(b) you manually update your Python environment to use at " + - f"least version {_next_supported_version} of " + - f"{_dependency_package}.", - FutureWarning) - _grpc_package = "grpcio" - _grpc_min_version = "1.83.0" - _grpc_min_version_tuple = (1, 83, 0) - (_grpc_version_used, _grpc_version_used_string) = _get_version(_grpc_package) - if _grpc_version_used and _grpc_version_used < _grpc_min_version_tuple: - warnings.warn(f"Package {_package_label} depends on {_grpc_package}, currently installed at version {_grpc_version_used_string}. " + - "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). " + - "Support for non-PQC environments is deprecated. In October 2026, " + - "Google Cloud Python client libraries will raise their minimum requirements " + - "(including google-api-core, grpcio, and grpcio-status) to enforce grpcio >= 1.83.0. For more details on Google Cloud's post-quantum " + - "security migration, visit: https://cloud.google.com/security/resources/post-quantum-cryptography", - FutureWarning) - except Exception: - warnings.warn("Could not determine the version of Python " + - "currently being used. To continue receiving " + - "updates for {_package_label}, ensure you are " + - "using a supported version of Python; see " + - "https://devguide.python.org/versions/") +api_core.check_python_version("") +api_core.check_dependency_versions("") __all__ = ( 'StorageBatchOperationsAsyncClient',