diff --git a/README.md b/README.md index 29303fd4..8d2ebe39 100644 --- a/README.md +++ b/README.md @@ -43,9 +43,10 @@ requests, code review feedback, and also pull requests. ## Supported Python Versions -We currently support Python 3.9+. However, Python 3.9 support is deprecated, -and developers are strongly advised to use Python 3.10 or higher. Firebase -Admin Python SDK is also tested on PyPy and +We currently support Python 3.9+. However, Python 3.9 and 3.10 support is +deprecated and will be dropped in an upcoming minor release. Developers are +strongly advised to use Python 3.11 or higher. Firebase Admin Python SDK is +also tested on PyPy and [Google App Engine](https://cloud.google.com/appengine/) environments. diff --git a/firebase_admin/__init__.py b/firebase_admin/__init__.py index 8c9f628e..1b93f3c3 100644 --- a/firebase_admin/__init__.py +++ b/firebase_admin/__init__.py @@ -21,9 +21,14 @@ from google.auth.credentials import Credentials as GoogleAuthCredentials from google.auth.exceptions import DefaultCredentialsError from firebase_admin import credentials +from firebase_admin import _python_version_support from firebase_admin.__about__ import __version__ +# Perform Python version check and emit a support warning if needed. +_python_version_support.check_python_version() + + _apps = {} _apps_lock = threading.RLock() _clock = datetime.datetime.utcnow diff --git a/firebase_admin/_python_version_support.py b/firebase_admin/_python_version_support.py new file mode 100644 index 00000000..65ef30a3 --- /dev/null +++ b/firebase_admin/_python_version_support.py @@ -0,0 +1,201 @@ +# Copyright 2026 Google Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Code to check Python versions supported by the Firebase Admin Python SDK. + +Adapted from ``google.api_core._python_version_support``. +""" + +import datetime +import enum +import sys +import textwrap +from typing import Dict, List, NamedTuple, Optional, Tuple +import warnings + + +class PythonVersionStatus(enum.Enum): + """Support status of a Python version in this SDK release.""" + + PYTHON_VERSION_SUPPORTED = 'PYTHON_VERSION_SUPPORTED' + """This Python version is fully supported, so the SDK running on this + version will have all features and bug fixes.""" + + PYTHON_VERSION_DEPRECATED = 'PYTHON_VERSION_DEPRECATED' + """This Python version is still supported, but support will end within a + year. At that time, there will be no more releases for this SDK + running under this Python version.""" + + PYTHON_VERSION_EOL = 'PYTHON_VERSION_EOL' + """This Python version has reached its end of life in the Python community + (see https://devguide.python.org/versions/), and this SDK will cease + supporting this Python version within the next few releases.""" + + PYTHON_VERSION_UNSUPPORTED = 'PYTHON_VERSION_UNSUPPORTED' + """This release of the SDK may not be the latest, since current releases no + longer support this Python version.""" + + +class VersionInfo(NamedTuple): + """Hold release and support date information for a Python version.""" + + version: str + python_start: datetime.date + python_eol: datetime.date + deprecation_date: Optional[datetime.date] = None + end_of_support_date: Optional[datetime.date] = None + + +PYTHON_VERSIONS: List[VersionInfo] = [ + # Refer to https://devguide.python.org/versions/ and the PEPs linked therefrom. + VersionInfo( + version='3.9', + python_start=datetime.date(2020, 10, 5), + python_eol=datetime.date(2025, 10, 5), + ), + VersionInfo( + version='3.10', + python_start=datetime.date(2021, 10, 4), + python_eol=datetime.date(2026, 10, 4), + ), + VersionInfo( + version='3.11', + python_start=datetime.date(2022, 10, 24), + python_eol=datetime.date(2027, 10, 24), + ), + VersionInfo( + version='3.12', + python_start=datetime.date(2023, 10, 2), + python_eol=datetime.date(2028, 10, 2), + ), + VersionInfo( + version='3.13', + python_start=datetime.date(2024, 10, 7), + python_eol=datetime.date(2029, 10, 7), + ), + VersionInfo( + version='3.14', + python_start=datetime.date(2025, 10, 7), + python_eol=datetime.date(2030, 10, 7), + ), +] + +PYTHON_VERSION_INFO: Dict[Tuple[int, int], VersionInfo] = { + (int(info.version.split('.')[0]), int(info.version.split('.')[1])): info + for info in PYTHON_VERSIONS +} + +LOWEST_TRACKED_VERSION = min(PYTHON_VERSION_INFO.keys()) +_FAKE_PAST_DATE = datetime.date.min + datetime.timedelta(days=900) +_FAKE_PAST_VERSION = VersionInfo( + version='0.0', + python_start=_FAKE_PAST_DATE, + python_eol=_FAKE_PAST_DATE, +) +_FAKE_FUTURE_DATE = datetime.date.max - datetime.timedelta(days=900) +_FAKE_FUTURE_VERSION = VersionInfo( + version='999.0', + python_start=_FAKE_FUTURE_DATE, + python_eol=_FAKE_FUTURE_DATE, +) +DEPRECATION_WARNING_PERIOD = datetime.timedelta(days=365) +EOL_GRACE_PERIOD = datetime.timedelta(weeks=1) +_PACKAGE_LABEL = 'package firebase-admin (firebase_admin)' + + +def _flatten_message(text: str) -> str: + """Dedent a multi-line string and flatten it into a single line.""" + return ' '.join(textwrap.dedent(text).strip().split()) + + +def check_python_version( + today: Optional[datetime.date] = None) -> PythonVersionStatus: + """Check the running Python version and issue a support warning if needed. + + Args: + today: The date to check against. Defaults to the current date. + + Returns: + PythonVersionStatus: The support status of the current Python version. + """ + today = today or datetime.date.today() + + python_version = sys.version_info + version_tuple = (python_version.major, python_version.minor) + py_version_str = sys.version.split()[0] + + version_info = PYTHON_VERSION_INFO.get(version_tuple) + + if not version_info: + if version_tuple < LOWEST_TRACKED_VERSION: + version_info = _FAKE_PAST_VERSION + else: + version_info = _FAKE_FUTURE_VERSION + + deprecation_date = version_info.deprecation_date or ( + version_info.python_eol - DEPRECATION_WARNING_PERIOD + ) + end_of_support_date = version_info.end_of_support_date or ( + version_info.python_eol + EOL_GRACE_PERIOD + ) + + def min_python(date: datetime.date) -> str: + """Find the minimum supported Python version for a given date.""" + for version, info in sorted(PYTHON_VERSION_INFO.items()): + if info.python_start <= date < info.python_eol: + return f'Python {version[0]}.{version[1]}' + return 'a currently supported Python version [https://devguide.python.org/versions]' + + if end_of_support_date < today: + message = _flatten_message( + f""" + You are using a non-supported Python version ({py_version_str}). + Google will not post any further updates to {_PACKAGE_LABEL} + supporting this Python version. Please upgrade to the latest Python + version, or at least {min_python(today)}, and then update + {_PACKAGE_LABEL}. + """ + ) + warnings.warn(message, FutureWarning, stacklevel=2) + return PythonVersionStatus.PYTHON_VERSION_UNSUPPORTED + + if version_info.python_eol <= today <= end_of_support_date: + message = _flatten_message( + f""" + You are using a Python version ({py_version_str}) + past its end of life. Google will update {_PACKAGE_LABEL} + with critical bug fixes on a best-effort basis, but not + with any other fixes or features. Please upgrade + to the latest Python version, or at least + {min_python(today)}, and then update {_PACKAGE_LABEL}. + """ + ) + warnings.warn(message, FutureWarning, stacklevel=2) + return PythonVersionStatus.PYTHON_VERSION_EOL + + if deprecation_date <= today < version_info.python_eol: + message = _flatten_message( + f""" + You are using a Python version ({py_version_str}) which Google will + stop supporting in new releases of {_PACKAGE_LABEL} once it reaches + its end of life ({version_info.python_eol}). Please upgrade to the + latest Python version, or at least + {min_python(version_info.python_eol)}, to continue receiving updates + for {_PACKAGE_LABEL} past that date. + """ + ) + warnings.warn(message, FutureWarning, stacklevel=2) + return PythonVersionStatus.PYTHON_VERSION_DEPRECATED + + return PythonVersionStatus.PYTHON_VERSION_SUPPORTED diff --git a/tests/test_python_version_support.py b/tests/test_python_version_support.py new file mode 100644 index 00000000..42aafbb2 --- /dev/null +++ b/tests/test_python_version_support.py @@ -0,0 +1,264 @@ +# Copyright 2026 Google Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for firebase_admin._python_version_support.""" + +from collections import namedtuple +import datetime +import textwrap +from unittest.mock import patch +import warnings + +import pytest + +from firebase_admin._python_version_support import ( + PYTHON_VERSION_INFO, + PythonVersionStatus, + _flatten_message, + check_python_version, +) + +# Helper object for mocking sys.version_info +VersionInfoMock = namedtuple('VersionInfoMock', ['major', 'minor']) + + +def test_flatten_message(): + """Test that _flatten_message correctly dedents and flattens a string.""" + input_text = """ + This is a multi-line + string with some + indentation. + """ + expected_output = 'This is a multi-line string with some indentation.' + assert _flatten_message(input_text) == expected_output + + +def _create_failure_message( + expected, result, py_version, date, deprecation_date, py_eol, end_of_support_date): + """Create a detailed failure message for a test.""" + return textwrap.dedent( # pragma: NO COVER + f""" + --- Test Failed --- + Expected status: {expected.name} + Received status: {result.name} + --------------------- + Context: + - Mocked Python Version: {py_version} + - Mocked Today's Date: {date} + Calculated Dates: + - deprecation_date: {deprecation_date} + - python_eol: {py_eol} + - end_of_support_date: {end_of_support_date} + """ + ) + + +def get_tracked_version_test_cases(): + """Return a list of test parameters for all tracked versions and boundary conditions.""" + results = [] + + for version_tuple, version_info in PYTHON_VERSION_INFO.items(): + py_version_str = f'{version_tuple[0]}.{version_tuple[1]}' + deprecation_date = version_info.deprecation_date or ( + version_info.python_eol - datetime.timedelta(days=365) + ) + end_of_support_date = version_info.end_of_support_date or ( + version_info.python_eol + datetime.timedelta(weeks=1) + ) + + test_cases = { + 'supported_before_deprecation_date': { + 'date': deprecation_date - datetime.timedelta(days=1), + 'expected': PythonVersionStatus.PYTHON_VERSION_SUPPORTED, + }, + 'deprecated_on_deprecation_date': { + 'date': deprecation_date, + 'expected': PythonVersionStatus.PYTHON_VERSION_DEPRECATED, + }, + 'deprecated_before_eol_date': { + 'date': version_info.python_eol - datetime.timedelta(days=1), + 'expected': PythonVersionStatus.PYTHON_VERSION_DEPRECATED, + }, + 'eol_on_eol_date': { + 'date': version_info.python_eol, + 'expected': PythonVersionStatus.PYTHON_VERSION_EOL, + }, + 'eol_on_end_of_support_date': { + 'date': end_of_support_date, + 'expected': PythonVersionStatus.PYTHON_VERSION_EOL, + }, + 'unsupported_after_end_of_support_date': { + 'date': end_of_support_date + datetime.timedelta(days=1), + 'expected': PythonVersionStatus.PYTHON_VERSION_UNSUPPORTED, + }, + } + + for name, params in test_cases.items(): + results.append( + pytest.param( + version_tuple, + params['date'], + params['expected'], + deprecation_date, + end_of_support_date, + id=f'{py_version_str}-{name}', + ) + ) + return results + + +@pytest.mark.parametrize( + 'version_tuple, mock_date, expected_status, deprecation_date, end_of_support_date', + get_tracked_version_test_cases(), +) +def test_all_tracked_versions_and_date_scenarios( + version_tuple, mock_date, expected_status, deprecation_date, end_of_support_date): + """Test all outcomes for each tracked version using parametrization.""" + mock_py_v = VersionInfoMock(major=version_tuple[0], minor=version_tuple[1]) + + with patch('firebase_admin._python_version_support.sys.version_info', mock_py_v): + # Supported versions should not issue warnings + if expected_status == PythonVersionStatus.PYTHON_VERSION_SUPPORTED: + with warnings.catch_warnings(record=True) as recorded_warnings: + warnings.simplefilter('always') + result = check_python_version(today=mock_date) + assert len(recorded_warnings) == 0 + # All other statuses should issue a FutureWarning mentioning firebase-admin + else: + with pytest.warns(FutureWarning) as record: + result = check_python_version(today=mock_date) + assert len(record) == 1 + assert 'package firebase-admin (firebase_admin)' in str(record[0].message) + + if result != expected_status: # pragma: NO COVER + py_version_str = f'{version_tuple[0]}.{version_tuple[1]}' + version_info = PYTHON_VERSION_INFO[version_tuple] + + fail_msg = _create_failure_message( + expected_status, + result, + py_version_str, + mock_date, + deprecation_date, + version_info.python_eol, + end_of_support_date, + ) + pytest.fail(fail_msg, pytrace=False) + + +@pytest.mark.parametrize('version_tuple', [(3, 9), (3, 10)]) +def test_python_39_and_310_emit_unsupported_warning_past_eol(version_tuple): + """Verify 3.9 and 3.10 emit PYTHON_VERSION_UNSUPPORTED after EOL + 1-week grace.""" + mock_py_version = VersionInfoMock(major=version_tuple[0], minor=version_tuple[1]) + check_date = datetime.date(2026, 10, 20) + target = 'firebase_admin._python_version_support.sys.version_info' + + with patch(target, mock_py_version): + with pytest.warns(FutureWarning) as record: + result = check_python_version(today=check_date) + + assert result == PythonVersionStatus.PYTHON_VERSION_UNSUPPORTED + assert len(record) == 1 + message = str(record[0].message) + assert 'non-supported Python version' in message + assert 'package firebase-admin (firebase_admin)' in message + assert 'at least Python 3.11' in message + + +def test_override_end_of_support_date_only(): + """Test behavior when only end_of_support_date is manually overridden.""" + version_tuple = (3, 10) + original_info = PYTHON_VERSION_INFO[version_tuple] + mock_py_version = VersionInfoMock(major=version_tuple[0], minor=version_tuple[1]) + + custom_end = original_info.python_eol + datetime.timedelta(days=212) + overridden_info = original_info._replace(end_of_support_date=custom_end) + version_info_target = 'firebase_admin._python_version_support.sys.version_info' + info_dict_target = 'firebase_admin._python_version_support.PYTHON_VERSION_INFO' + + with patch(version_info_target, mock_py_version): + with patch.dict(info_dict_target, {version_tuple: overridden_info}): + with pytest.warns(FutureWarning, match='past its end of life'): + result_before_boundary = check_python_version( + today=custom_end + datetime.timedelta(days=-1) + ) + assert result_before_boundary == PythonVersionStatus.PYTHON_VERSION_EOL + + with pytest.warns(FutureWarning, match='past its end of life'): + result_at_boundary = check_python_version(today=custom_end) + assert result_at_boundary == PythonVersionStatus.PYTHON_VERSION_EOL + + with pytest.warns(FutureWarning, match='non-supported Python version'): + result_after_boundary = check_python_version( + today=custom_end + datetime.timedelta(days=1) + ) + assert ( + result_after_boundary == PythonVersionStatus.PYTHON_VERSION_UNSUPPORTED + ) + + +def test_override_deprecation_date_only(): + """Test behavior when only deprecation_date is manually overridden.""" + version_tuple = (3, 10) + original_info = PYTHON_VERSION_INFO[version_tuple] + mock_py_version = VersionInfoMock(major=version_tuple[0], minor=version_tuple[1]) + + custom_dep = original_info.python_eol - datetime.timedelta(days=120) + overridden_info = original_info._replace(deprecation_date=custom_dep) + version_info_target = 'firebase_admin._python_version_support.sys.version_info' + info_dict_target = 'firebase_admin._python_version_support.PYTHON_VERSION_INFO' + + with patch(version_info_target, mock_py_version): + with patch.dict(info_dict_target, {version_tuple: overridden_info}): + result_before_boundary = check_python_version( + today=custom_dep - datetime.timedelta(days=1) + ) + assert ( + result_before_boundary == PythonVersionStatus.PYTHON_VERSION_SUPPORTED + ) + + with pytest.warns(FutureWarning, match='Google will stop supporting'): + result_at_boundary = check_python_version(today=custom_dep) + assert result_at_boundary == PythonVersionStatus.PYTHON_VERSION_DEPRECATED + + +def test_untracked_older_version_is_unsupported(): + """Test that an old, untracked version is unsupported and logs.""" + mock_py_version = VersionInfoMock(major=3, minor=8) + target = 'firebase_admin._python_version_support.sys.version_info' + + with patch(target, mock_py_version): + with pytest.warns(FutureWarning) as record: + mock_date = datetime.date(2025, 1, 15) + result = check_python_version(today=mock_date) + + assert result == PythonVersionStatus.PYTHON_VERSION_UNSUPPORTED + assert len(record) == 1 + assert 'non-supported' in str(record[0].message) + + +def test_untracked_newer_version_is_supported(): + """Test that a new, untracked version is supported and does not log.""" + target = 'firebase_admin._python_version_support.sys.version_info' + for major_minor in [(3, 15), (40, 0)]: + mock_py_version = VersionInfoMock(major=major_minor[0], minor=major_minor[1]) + + with patch(target, mock_py_version): + with warnings.catch_warnings(record=True) as recorded_warnings: + warnings.simplefilter('always') + mock_date = datetime.date(2025, 1, 15) + result = check_python_version(today=mock_date) + + assert result == PythonVersionStatus.PYTHON_VERSION_SUPPORTED + assert len(recorded_warnings) == 0