diff --git a/gapic/templates/%namespace/%name_%version/%sub/__init__.py.j2 b/gapic/templates/%namespace/%name_%version/%sub/__init__.py.j2 index 8ee1670431..5492cc9e2d 100644 --- a/gapic/templates/%namespace/%name_%version/%sub/__init__.py.j2 +++ b/gapic/templates/%namespace/%name_%version/%sub/__init__.py.j2 @@ -7,6 +7,79 @@ from {{package_path}} import gapic_version as package_version __version__ = package_version.__version__ + +import google.api_core as api_core + +try: + api_core.check_python_version("{{package_path}}") + api_core.check_dependency_versions("{{package_path}}") +except AttributeError: +{# TODO: 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. + + import logging + import sys + + _py_version_str = sys.version.split()[0] + _package_label = "{{package_path}}" + if sys.version_info < (3, 9): + logging.warning("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.9, and then update {_package_label}.") + if sys.version_info[:2] == (3, 9): + logging.warning(f"You are using a Python version ({_py_version_str}) " + + f"which Google will stop supporting in {_package_label} when " + + "it reaches its end of life (October 2025). Please " + + "upgrade to the latest Python version, or at " + + "least Python 3.10, before then, and " + + f"then update {_package_label}.") + + from packaging.version import parse as parse_version + + if sys.version_info < (3, 8): + import pkg_resources + def _get_version(dependency_name): + try: + version_string = pkg_resources.get_distribution(dependency_name).version + return parse_version(version_string) + except pkg_resources.DistributionNotFound: + return None + else: + from importlib import metadata + + def _get_version(dependency_name): + try: + version_string = metadata.version("requests") + parsed_version = parse_version(version_string) + return parsed_version.release + except metadata.PackageNotFoundError: + return None + + _dependency_package = "google.protobuf" + _next_supported_version = "4.25.8" + _next_supported_version_tuple = (4, 25, 8) + _version_used = _get_version(_dependency_package) + if _version_used and _version_used < _next_supported_version_tuple: + logging.warning(f"DEPRECATION: Package {_package_label} depends on " + + f"{_dependency_package}, currently installed at version " + + f"{_version_used.__str__}. Future updates to " + + f"{_package_label} will require {_dependency_package} at " + + f"version {_next_supported_version} or higher. 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}.") + {# Import subpackages. -#} {% for subpackage, _ in api.subpackages|dictsort %} from . import {{ subpackage }} diff --git a/noxfile.py b/noxfile.py index 7b686cb7db..868d647a5b 100644 --- a/noxfile.py +++ b/noxfile.py @@ -60,6 +60,8 @@ def unit(session): "pyfakefs", "grpcio-status", "proto-plus", + "setuptools", # TODO: Remove when not needed in __init__.py.j2 + "packaging", # TODO: Remove when not needed in __init__.py.j2 ) session.install("-e", ".") session.run( @@ -481,6 +483,8 @@ def run_showcase_unit_tests(session, fail_under=100, rest_async_io_enabled=False "pytest-xdist", "asyncmock; python_version < '3.8'", "pytest-asyncio", + "setuptools", # TODO: Remove when not needed in __init__.py.j2 + "packaging", # TODO: Remove when not needed in __init__.py.j2 ) # Run the tests. # NOTE: async rest is not supported against the minimum supported version of google-api-core. @@ -594,6 +598,8 @@ def showcase_mypy( "types-protobuf", "types-requests", "types-dataclasses", + "setuptools", # TODO: Remove when not needed in __init__.py.j2 + "packaging", # TODO: Remove when not needed in __init__.py.j2 ) with showcase_library(session, templates=templates, other_opts=other_opts) as lib: @@ -724,6 +730,8 @@ def mypy(session): "types-PyYAML", "types-dataclasses", "click==8.1.3", + "setuptools", # TODO: Remove when not needed in __init__.py.j2 + "packaging", # TODO: Remove when not needed in __init__.py.j2 ) session.install(".") session.run("mypy", "-p", "gapic") diff --git a/tests/integration/goldens/asset/google/cloud/asset_v1/__init__.py b/tests/integration/goldens/asset/google/cloud/asset_v1/__init__.py index 03ee9ec521..cf6b765ee9 100755 --- a/tests/integration/goldens/asset/google/cloud/asset_v1/__init__.py +++ b/tests/integration/goldens/asset/google/cloud/asset_v1/__init__.py @@ -18,6 +18,73 @@ __version__ = package_version.__version__ +import google.api_core as api_core + +try: + api_core.check_python_version("google.cloud.asset_v1") + api_core.check_dependency_versions("google.cloud.asset_v1") +except AttributeError: + # An older version of api_core is installed, which does not define the + # functions above. We do equivalent checks manually. + + import logging + import sys + + _py_version_str = sys.version.split()[0] + _package_label = "google.cloud.asset_v1" + if sys.version_info < (3, 9): + logging.warning("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.9, and then update {_package_label}.") + if sys.version_info[:2] == (3, 9): + logging.warning(f"You are using a Python version ({_py_version_str}) " + + f"which Google will stop supporting in {_package_label} when " + + "it reaches its end of life (October 2025). Please " + + "upgrade to the latest Python version, or at " + + "least Python 3.10, before then, and " + + f"then update {_package_label}.") + + from packaging.version import parse as parse_version + + if sys.version_info < (3, 8): + import pkg_resources + def _get_version(dependency_name): + try: + version_string = pkg_resources.get_distribution(dependency_name).version + return parse_version(version_string) + except pkg_resources.DistributionNotFound: + return None + else: + from importlib import metadata + + def _get_version(dependency_name): + try: + version_string = metadata.version("requests") + parsed_version = parse_version(version_string) + return parsed_version.release + except metadata.PackageNotFoundError: + return None + + _dependency_package = "google.protobuf" + _next_supported_version = "4.25.8" + _next_supported_version_tuple = (4, 25, 8) + _version_used = _get_version(_dependency_package) + if _version_used and _version_used < _next_supported_version_tuple: + logging.warning(f"DEPRECATION: Package {_package_label} depends on " + + f"{_dependency_package}, currently installed at version " + + f"{_version_used.__str__}. Future updates to " + + f"{_package_label} will require {_dependency_package} at " + + f"version {_next_supported_version} or higher. 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}.") + + from .services.asset_service import AssetServiceClient from .services.asset_service import AssetServiceAsyncClient diff --git a/tests/integration/goldens/credentials/google/iam/credentials_v1/__init__.py b/tests/integration/goldens/credentials/google/iam/credentials_v1/__init__.py index 2be4471eb8..98349907a0 100755 --- a/tests/integration/goldens/credentials/google/iam/credentials_v1/__init__.py +++ b/tests/integration/goldens/credentials/google/iam/credentials_v1/__init__.py @@ -18,6 +18,73 @@ __version__ = package_version.__version__ +import google.api_core as api_core + +try: + api_core.check_python_version("google.iam.credentials_v1") + api_core.check_dependency_versions("google.iam.credentials_v1") +except AttributeError: + # An older version of api_core is installed, which does not define the + # functions above. We do equivalent checks manually. + + import logging + import sys + + _py_version_str = sys.version.split()[0] + _package_label = "google.iam.credentials_v1" + if sys.version_info < (3, 9): + logging.warning("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.9, and then update {_package_label}.") + if sys.version_info[:2] == (3, 9): + logging.warning(f"You are using a Python version ({_py_version_str}) " + + f"which Google will stop supporting in {_package_label} when " + + "it reaches its end of life (October 2025). Please " + + "upgrade to the latest Python version, or at " + + "least Python 3.10, before then, and " + + f"then update {_package_label}.") + + from packaging.version import parse as parse_version + + if sys.version_info < (3, 8): + import pkg_resources + def _get_version(dependency_name): + try: + version_string = pkg_resources.get_distribution(dependency_name).version + return parse_version(version_string) + except pkg_resources.DistributionNotFound: + return None + else: + from importlib import metadata + + def _get_version(dependency_name): + try: + version_string = metadata.version("requests") + parsed_version = parse_version(version_string) + return parsed_version.release + except metadata.PackageNotFoundError: + return None + + _dependency_package = "google.protobuf" + _next_supported_version = "4.25.8" + _next_supported_version_tuple = (4, 25, 8) + _version_used = _get_version(_dependency_package) + if _version_used and _version_used < _next_supported_version_tuple: + logging.warning(f"DEPRECATION: Package {_package_label} depends on " + + f"{_dependency_package}, currently installed at version " + + f"{_version_used.__str__}. Future updates to " + + f"{_package_label} will require {_dependency_package} at " + + f"version {_next_supported_version} or higher. 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}.") + + from .services.iam_credentials import IAMCredentialsClient from .services.iam_credentials import IAMCredentialsAsyncClient diff --git a/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/__init__.py b/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/__init__.py index a343867284..6deb432abe 100755 --- a/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/__init__.py +++ b/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/__init__.py @@ -18,6 +18,73 @@ __version__ = package_version.__version__ +import google.api_core as api_core + +try: + api_core.check_python_version("google.cloud.eventarc_v1") + api_core.check_dependency_versions("google.cloud.eventarc_v1") +except AttributeError: + # An older version of api_core is installed, which does not define the + # functions above. We do equivalent checks manually. + + import logging + import sys + + _py_version_str = sys.version.split()[0] + _package_label = "google.cloud.eventarc_v1" + if sys.version_info < (3, 9): + logging.warning("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.9, and then update {_package_label}.") + if sys.version_info[:2] == (3, 9): + logging.warning(f"You are using a Python version ({_py_version_str}) " + + f"which Google will stop supporting in {_package_label} when " + + "it reaches its end of life (October 2025). Please " + + "upgrade to the latest Python version, or at " + + "least Python 3.10, before then, and " + + f"then update {_package_label}.") + + from packaging.version import parse as parse_version + + if sys.version_info < (3, 8): + import pkg_resources + def _get_version(dependency_name): + try: + version_string = pkg_resources.get_distribution(dependency_name).version + return parse_version(version_string) + except pkg_resources.DistributionNotFound: + return None + else: + from importlib import metadata + + def _get_version(dependency_name): + try: + version_string = metadata.version("requests") + parsed_version = parse_version(version_string) + return parsed_version.release + except metadata.PackageNotFoundError: + return None + + _dependency_package = "google.protobuf" + _next_supported_version = "4.25.8" + _next_supported_version_tuple = (4, 25, 8) + _version_used = _get_version(_dependency_package) + if _version_used and _version_used < _next_supported_version_tuple: + logging.warning(f"DEPRECATION: Package {_package_label} depends on " + + f"{_dependency_package}, currently installed at version " + + f"{_version_used.__str__}. Future updates to " + + f"{_package_label} will require {_dependency_package} at " + + f"version {_next_supported_version} or higher. 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}.") + + from .services.eventarc import EventarcClient from .services.eventarc import EventarcAsyncClient diff --git a/tests/integration/goldens/logging/google/cloud/logging_v2/__init__.py b/tests/integration/goldens/logging/google/cloud/logging_v2/__init__.py index e8b59e0bb5..c286dff4cf 100755 --- a/tests/integration/goldens/logging/google/cloud/logging_v2/__init__.py +++ b/tests/integration/goldens/logging/google/cloud/logging_v2/__init__.py @@ -18,6 +18,73 @@ __version__ = package_version.__version__ +import google.api_core as api_core + +try: + api_core.check_python_version("google.cloud.logging_v2") + api_core.check_dependency_versions("google.cloud.logging_v2") +except AttributeError: + # An older version of api_core is installed, which does not define the + # functions above. We do equivalent checks manually. + + import logging + import sys + + _py_version_str = sys.version.split()[0] + _package_label = "google.cloud.logging_v2" + if sys.version_info < (3, 9): + logging.warning("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.9, and then update {_package_label}.") + if sys.version_info[:2] == (3, 9): + logging.warning(f"You are using a Python version ({_py_version_str}) " + + f"which Google will stop supporting in {_package_label} when " + + "it reaches its end of life (October 2025). Please " + + "upgrade to the latest Python version, or at " + + "least Python 3.10, before then, and " + + f"then update {_package_label}.") + + from packaging.version import parse as parse_version + + if sys.version_info < (3, 8): + import pkg_resources + def _get_version(dependency_name): + try: + version_string = pkg_resources.get_distribution(dependency_name).version + return parse_version(version_string) + except pkg_resources.DistributionNotFound: + return None + else: + from importlib import metadata + + def _get_version(dependency_name): + try: + version_string = metadata.version("requests") + parsed_version = parse_version(version_string) + return parsed_version.release + except metadata.PackageNotFoundError: + return None + + _dependency_package = "google.protobuf" + _next_supported_version = "4.25.8" + _next_supported_version_tuple = (4, 25, 8) + _version_used = _get_version(_dependency_package) + if _version_used and _version_used < _next_supported_version_tuple: + logging.warning(f"DEPRECATION: Package {_package_label} depends on " + + f"{_dependency_package}, currently installed at version " + + f"{_version_used.__str__}. Future updates to " + + f"{_package_label} will require {_dependency_package} at " + + f"version {_next_supported_version} or higher. 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}.") + + from .services.config_service_v2 import ConfigServiceV2Client from .services.config_service_v2 import ConfigServiceV2AsyncClient from .services.logging_service_v2 import LoggingServiceV2Client diff --git a/tests/integration/goldens/logging_internal/google/cloud/logging_v2/__init__.py b/tests/integration/goldens/logging_internal/google/cloud/logging_v2/__init__.py index 3e0f9c2155..f32009e695 100755 --- a/tests/integration/goldens/logging_internal/google/cloud/logging_v2/__init__.py +++ b/tests/integration/goldens/logging_internal/google/cloud/logging_v2/__init__.py @@ -18,6 +18,73 @@ __version__ = package_version.__version__ +import google.api_core as api_core + +try: + api_core.check_python_version("google.cloud.logging_v2") + api_core.check_dependency_versions("google.cloud.logging_v2") +except AttributeError: + # An older version of api_core is installed, which does not define the + # functions above. We do equivalent checks manually. + + import logging + import sys + + _py_version_str = sys.version.split()[0] + _package_label = "google.cloud.logging_v2" + if sys.version_info < (3, 9): + logging.warning("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.9, and then update {_package_label}.") + if sys.version_info[:2] == (3, 9): + logging.warning(f"You are using a Python version ({_py_version_str}) " + + f"which Google will stop supporting in {_package_label} when " + + "it reaches its end of life (October 2025). Please " + + "upgrade to the latest Python version, or at " + + "least Python 3.10, before then, and " + + f"then update {_package_label}.") + + from packaging.version import parse as parse_version + + if sys.version_info < (3, 8): + import pkg_resources + def _get_version(dependency_name): + try: + version_string = pkg_resources.get_distribution(dependency_name).version + return parse_version(version_string) + except pkg_resources.DistributionNotFound: + return None + else: + from importlib import metadata + + def _get_version(dependency_name): + try: + version_string = metadata.version("requests") + parsed_version = parse_version(version_string) + return parsed_version.release + except metadata.PackageNotFoundError: + return None + + _dependency_package = "google.protobuf" + _next_supported_version = "4.25.8" + _next_supported_version_tuple = (4, 25, 8) + _version_used = _get_version(_dependency_package) + if _version_used and _version_used < _next_supported_version_tuple: + logging.warning(f"DEPRECATION: Package {_package_label} depends on " + + f"{_dependency_package}, currently installed at version " + + f"{_version_used.__str__}. Future updates to " + + f"{_package_label} will require {_dependency_package} at " + + f"version {_next_supported_version} or higher. 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}.") + + from .services.config_service_v2 import BaseConfigServiceV2Client from .services.config_service_v2 import BaseConfigServiceV2AsyncClient from .services.logging_service_v2 import LoggingServiceV2Client diff --git a/tests/integration/goldens/redis/google/cloud/redis_v1/__init__.py b/tests/integration/goldens/redis/google/cloud/redis_v1/__init__.py index af3d250ccd..c57d143587 100755 --- a/tests/integration/goldens/redis/google/cloud/redis_v1/__init__.py +++ b/tests/integration/goldens/redis/google/cloud/redis_v1/__init__.py @@ -18,6 +18,73 @@ __version__ = package_version.__version__ +import google.api_core as api_core + +try: + api_core.check_python_version("google.cloud.redis_v1") + api_core.check_dependency_versions("google.cloud.redis_v1") +except AttributeError: + # An older version of api_core is installed, which does not define the + # functions above. We do equivalent checks manually. + + import logging + import sys + + _py_version_str = sys.version.split()[0] + _package_label = "google.cloud.redis_v1" + if sys.version_info < (3, 9): + logging.warning("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.9, and then update {_package_label}.") + if sys.version_info[:2] == (3, 9): + logging.warning(f"You are using a Python version ({_py_version_str}) " + + f"which Google will stop supporting in {_package_label} when " + + "it reaches its end of life (October 2025). Please " + + "upgrade to the latest Python version, or at " + + "least Python 3.10, before then, and " + + f"then update {_package_label}.") + + from packaging.version import parse as parse_version + + if sys.version_info < (3, 8): + import pkg_resources + def _get_version(dependency_name): + try: + version_string = pkg_resources.get_distribution(dependency_name).version + return parse_version(version_string) + except pkg_resources.DistributionNotFound: + return None + else: + from importlib import metadata + + def _get_version(dependency_name): + try: + version_string = metadata.version("requests") + parsed_version = parse_version(version_string) + return parsed_version.release + except metadata.PackageNotFoundError: + return None + + _dependency_package = "google.protobuf" + _next_supported_version = "4.25.8" + _next_supported_version_tuple = (4, 25, 8) + _version_used = _get_version(_dependency_package) + if _version_used and _version_used < _next_supported_version_tuple: + logging.warning(f"DEPRECATION: Package {_package_label} depends on " + + f"{_dependency_package}, currently installed at version " + + f"{_version_used.__str__}. Future updates to " + + f"{_package_label} will require {_dependency_package} at " + + f"version {_next_supported_version} or higher. 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}.") + + from .services.cloud_redis import CloudRedisClient from .services.cloud_redis import CloudRedisAsyncClient diff --git a/tests/integration/goldens/redis_selective/google/cloud/redis_v1/__init__.py b/tests/integration/goldens/redis_selective/google/cloud/redis_v1/__init__.py index 760fe80f6c..68fab62221 100755 --- a/tests/integration/goldens/redis_selective/google/cloud/redis_v1/__init__.py +++ b/tests/integration/goldens/redis_selective/google/cloud/redis_v1/__init__.py @@ -18,6 +18,73 @@ __version__ = package_version.__version__ +import google.api_core as api_core + +try: + api_core.check_python_version("google.cloud.redis_v1") + api_core.check_dependency_versions("google.cloud.redis_v1") +except AttributeError: + # An older version of api_core is installed, which does not define the + # functions above. We do equivalent checks manually. + + import logging + import sys + + _py_version_str = sys.version.split()[0] + _package_label = "google.cloud.redis_v1" + if sys.version_info < (3, 9): + logging.warning("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.9, and then update {_package_label}.") + if sys.version_info[:2] == (3, 9): + logging.warning(f"You are using a Python version ({_py_version_str}) " + + f"which Google will stop supporting in {_package_label} when " + + "it reaches its end of life (October 2025). Please " + + "upgrade to the latest Python version, or at " + + "least Python 3.10, before then, and " + + f"then update {_package_label}.") + + from packaging.version import parse as parse_version + + if sys.version_info < (3, 8): + import pkg_resources + def _get_version(dependency_name): + try: + version_string = pkg_resources.get_distribution(dependency_name).version + return parse_version(version_string) + except pkg_resources.DistributionNotFound: + return None + else: + from importlib import metadata + + def _get_version(dependency_name): + try: + version_string = metadata.version("requests") + parsed_version = parse_version(version_string) + return parsed_version.release + except metadata.PackageNotFoundError: + return None + + _dependency_package = "google.protobuf" + _next_supported_version = "4.25.8" + _next_supported_version_tuple = (4, 25, 8) + _version_used = _get_version(_dependency_package) + if _version_used and _version_used < _next_supported_version_tuple: + logging.warning(f"DEPRECATION: Package {_package_label} depends on " + + f"{_dependency_package}, currently installed at version " + + f"{_version_used.__str__}. Future updates to " + + f"{_package_label} will require {_dependency_package} at " + + f"version {_next_supported_version} or higher. 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}.") + + from .services.cloud_redis import CloudRedisClient from .services.cloud_redis import CloudRedisAsyncClient