Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package python-annotated-types for
openSUSE:Factory checked in at 2026-08-01 18:28:23
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-annotated-types (Old)
and /work/SRC/openSUSE:Factory/.python-annotated-types.new.16738 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-annotated-types"
Sat Aug 1 18:28:23 2026 rev:4 rq:1368879 version:0.8.0
Changes:
--------
---
/work/SRC/openSUSE:Factory/python-annotated-types/python-annotated-types.changes
2024-06-17 19:28:17.123600004 +0200
+++
/work/SRC/openSUSE:Factory/.python-annotated-types.new.16738/python-annotated-types.changes
2026-08-01 18:29:00.399110480 +0200
@@ -1,0 +2,17 @@
+Fri Jul 31 16:50:55 UTC 2026 - Dirk Müller <[email protected]>
+
+- update to 0.8.0:
+ * Rename DocInfo to Doc
+ * Add support for Python 3.13
+ * Fix docstring of `Timezone`
+ * Update license-files to be PEP-639 compliant
+ * fix: typo in README.md
+ * add CI for PyPy3.11 and fix test (issue 71)
+ * Fix string predicate names in doc
+ * Add SPDX license expression
+ * Added Python 3.14 to the test matrix
+ * Add support for Python 3.14 and drop EOL 3.8-3.9
+ * Fix typo in `Len` docstring
+ * Prepare for 0.8.0 release
+
+-------------------------------------------------------------------
Old:
----
annotated_types-0.7.0.tar.gz
New:
----
annotated_types-0.8.0.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ python-annotated-types.spec ++++++
--- /var/tmp/diff_new_pack.Aeabzu/_old 2026-08-01 18:29:01.071133375 +0200
+++ /var/tmp/diff_new_pack.Aeabzu/_new 2026-08-01 18:29:01.071133375 +0200
@@ -1,7 +1,7 @@
#
# spec file for package python-annotated-types
#
-# Copyright (c) 2024 SUSE LLC
+# Copyright (c) 2026 SUSE LLC and contributors
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -18,7 +18,7 @@
%{?sle15_python_module_pythons}
Name: python-annotated-types
-Version: 0.7.0
+Version: 0.8.0
Release: 0
Summary: Reusable constraint types to use with typing.Annotated
License: MIT
++++++ annotated_types-0.7.0.tar.gz -> annotated_types-0.8.0.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/annotated_types-0.7.0/.github/workflows/ci.yml
new/annotated_types-0.8.0/.github/workflows/ci.yml
--- old/annotated_types-0.7.0/.github/workflows/ci.yml 2020-02-02
01:00:00.000000000 +0100
+++ new/annotated_types-0.8.0/.github/workflows/ci.yml 2020-02-02
01:00:00.000000000 +0100
@@ -15,7 +15,7 @@
strategy:
fail-fast: false
matrix:
- python-version: ['3.8', '3.9', '3.10', '3.11', '3.12']
+ python-version: ['3.10', '3.11', 'pypy3.11', '3.12', '3.13', '3.14']
runs-on: ubuntu-latest
@@ -23,12 +23,13 @@
PYTHON: ${{ matrix.python-version }}
steps:
- - uses: actions/checkout@v3
+ - uses: actions/checkout@v5
- name: set up python
- uses: actions/setup-python@v4
+ uses: actions/setup-python@v6
with:
python-version: ${{ matrix.python-version }}
+ allow-prereleases: true
- run: pip install -r requirements/all.txt
@@ -38,7 +39,7 @@
- run: coverage xml
- - uses: codecov/codecov-action@v3
+ - uses: codecov/codecov-action@v5
with:
file: ./coverage.xml
env_vars: PYTHON
@@ -47,15 +48,15 @@
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@v3
+ - uses: actions/checkout@v5
- - uses: actions/setup-python@v4
+ - uses: actions/setup-python@v6
with:
python-version: '3.10'
- run: pip install -r requirements/all.txt
- - uses: pre-commit/[email protected]
+ - uses: pre-commit/[email protected]
with:
extra_args: --all-files --verbose
@@ -67,17 +68,17 @@
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@v3
+ - uses: actions/checkout@v5
- name: set up python
- uses: actions/setup-python@v4
+ uses: actions/setup-python@v6
with:
python-version: '3.10'
- run: pip install -U twine build
- name: check GITHUB_REF matches package version
- uses: samuelcolvin/check-python-version@v3
+ uses: samuelcolvin/check-python-version@v5
with:
version_file_path: annotated_types/__init__.py
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/annotated_types-0.7.0/.gitignore
new/annotated_types-0.8.0/.gitignore
--- old/annotated_types-0.7.0/.gitignore 2020-02-02 01:00:00.000000000
+0100
+++ new/annotated_types-0.8.0/.gitignore 2020-02-02 01:00:00.000000000
+0100
@@ -1,9 +1,6 @@
*.py[cod]
.idea/
env/
-env37/
-env38/
-env39/
env310/
.coverage
.cache/
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/annotated_types-0.7.0/PKG-INFO
new/annotated_types-0.8.0/PKG-INFO
--- old/annotated_types-0.7.0/PKG-INFO 2020-02-02 01:00:00.000000000 +0100
+++ new/annotated_types-0.8.0/PKG-INFO 2020-02-02 01:00:00.000000000 +0100
@@ -1,11 +1,12 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
Name: annotated-types
-Version: 0.7.0
+Version: 0.8.0
Summary: Reusable constraint types to use with typing.Annotated
Project-URL: Homepage, https://github.com/annotated-types/annotated-types
Project-URL: Source, https://github.com/annotated-types/annotated-types
Project-URL: Changelog,
https://github.com/annotated-types/annotated-types/releases
Author-email: Adrian Garcia Badaracco
<[email protected]>, Samuel Colvin
<[email protected]>, Zac Hatfield-Dodds <[email protected]>
+License-Expression: MIT
License-File: LICENSE
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Console
@@ -16,15 +17,14 @@
Classifier: Operating System :: POSIX :: Linux
Classifier: Operating System :: Unix
Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Typing :: Typed
-Requires-Python: >=3.8
-Requires-Dist: typing-extensions>=4.0.0; python_version < '3.9'
+Requires-Python: >=3.10
Description-Content-Type: text/markdown
# annotated-types
@@ -125,9 +125,9 @@
Examples of usage:
-* `Annotated[list, MaxLen(10)]` (or `Annotated[list, Len(max_length=10))`) -
list must have a length of 10 or less
+* `Annotated[list, MaxLen(10)]` (or `Annotated[list, Len(max_length=10)]`) -
list must have a length of 10 or less
* `Annotated[str, MaxLen(10)]` - string must have a length of 10 or less
-* `Annotated[list, MinLen(3))` (or `Annotated[list, Len(min_length=3))`) -
list must have a length of 3 or more
+* `Annotated[list, MinLen(3)]` (or `Annotated[list, Len(min_length=3)]`) -
list must have a length of 3 or more
* `Annotated[list, Len(4, 6)]` - list must have a length of 4, 5, or 6
* `Annotated[list, Len(8, 8)]` - list must have a length of exactly 8
@@ -205,8 +205,8 @@
For some common constraints, we provide generic types:
-* `IsLower = Annotated[T, Predicate(str.islower)]`
-* `IsUpper = Annotated[T, Predicate(str.isupper)]`
+* `LowerCase = Annotated[T, Predicate(str.islower)]`
+* `UpperCase = Annotated[T, Predicate(str.isupper)]`
* `IsDigit = Annotated[T, Predicate(str.isdigit)]`
* `IsFinite = Annotated[T, Predicate(math.isfinite)]`
* `IsNotFinite = Annotated[T, Predicate(Not(math.isfinite))]`
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/annotated_types-0.7.0/README.md
new/annotated_types-0.8.0/README.md
--- old/annotated_types-0.7.0/README.md 2020-02-02 01:00:00.000000000 +0100
+++ new/annotated_types-0.8.0/README.md 2020-02-02 01:00:00.000000000 +0100
@@ -96,9 +96,9 @@
Examples of usage:
-* `Annotated[list, MaxLen(10)]` (or `Annotated[list, Len(max_length=10))`) -
list must have a length of 10 or less
+* `Annotated[list, MaxLen(10)]` (or `Annotated[list, Len(max_length=10)]`) -
list must have a length of 10 or less
* `Annotated[str, MaxLen(10)]` - string must have a length of 10 or less
-* `Annotated[list, MinLen(3))` (or `Annotated[list, Len(min_length=3))`) -
list must have a length of 3 or more
+* `Annotated[list, MinLen(3)]` (or `Annotated[list, Len(min_length=3)]`) -
list must have a length of 3 or more
* `Annotated[list, Len(4, 6)]` - list must have a length of 4, 5, or 6
* `Annotated[list, Len(8, 8)]` - list must have a length of exactly 8
@@ -176,8 +176,8 @@
For some common constraints, we provide generic types:
-* `IsLower = Annotated[T, Predicate(str.islower)]`
-* `IsUpper = Annotated[T, Predicate(str.isupper)]`
+* `LowerCase = Annotated[T, Predicate(str.islower)]`
+* `UpperCase = Annotated[T, Predicate(str.isupper)]`
* `IsDigit = Annotated[T, Predicate(str.isdigit)]`
* `IsFinite = Annotated[T, Predicate(math.isfinite)]`
* `IsNotFinite = Annotated[T, Predicate(Not(math.isfinite))]`
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/annotated_types-0.7.0/annotated_types/__init__.py
new/annotated_types-0.8.0/annotated_types/__init__.py
--- old/annotated_types-0.7.0/annotated_types/__init__.py 2020-02-02
01:00:00.000000000 +0100
+++ new/annotated_types-0.8.0/annotated_types/__init__.py 2020-02-02
01:00:00.000000000 +0100
@@ -1,30 +1,21 @@
import math
-import sys
import types
+from collections.abc import Callable, Iterator
from dataclasses import dataclass
from datetime import tzinfo
-from typing import TYPE_CHECKING, Any, Callable, Iterator, Optional,
SupportsFloat, SupportsIndex, TypeVar, Union
-
-if sys.version_info < (3, 8):
- from typing_extensions import Protocol, runtime_checkable
-else:
- from typing import Protocol, runtime_checkable
-
-if sys.version_info < (3, 9):
- from typing_extensions import Annotated, Literal
-else:
- from typing import Annotated, Literal
-
-if sys.version_info < (3, 10):
- EllipsisType = type(Ellipsis)
- KW_ONLY = {}
- SLOTS = {}
-else:
- from types import EllipsisType
-
- KW_ONLY = {"kw_only": True}
- SLOTS = {"slots": True}
-
+from types import EllipsisType
+from typing import (
+ TYPE_CHECKING,
+ Annotated,
+ Any,
+ Literal,
+ Protocol,
+ SupportsFloat,
+ SupportsIndex,
+ TypeVar,
+ Union,
+ runtime_checkable,
+)
__all__ = (
'BaseMetadata',
@@ -54,7 +45,7 @@
'__version__',
)
-__version__ = '0.7.0'
+__version__ = '0.8.0'
T = TypeVar('T')
@@ -105,7 +96,7 @@
__slots__ = ()
-@dataclass(frozen=True, **SLOTS)
+@dataclass(frozen=True, slots=True)
class Gt(BaseMetadata):
"""Gt(gt=x) implies that the value must be greater than x.
@@ -116,7 +107,7 @@
gt: SupportsGt
-@dataclass(frozen=True, **SLOTS)
+@dataclass(frozen=True, slots=True)
class Ge(BaseMetadata):
"""Ge(ge=x) implies that the value must be greater than or equal to x.
@@ -127,7 +118,7 @@
ge: SupportsGe
-@dataclass(frozen=True, **SLOTS)
+@dataclass(frozen=True, slots=True)
class Lt(BaseMetadata):
"""Lt(lt=x) implies that the value must be less than x.
@@ -138,7 +129,7 @@
lt: SupportsLt
-@dataclass(frozen=True, **SLOTS)
+@dataclass(frozen=True, slots=True)
class Le(BaseMetadata):
"""Le(le=x) implies that the value must be less than or equal to x.
@@ -201,7 +192,7 @@
raise NotImplementedError # more helpful than "None has no
attribute..." type errors
-@dataclass(frozen=True, **KW_ONLY, **SLOTS)
+@dataclass(frozen=True, kw_only=True, slots=True)
class Interval(GroupedMetadata):
"""Interval can express inclusive or exclusive bounds with a single object.
@@ -209,10 +200,10 @@
are interpreted the same way as the single-bound constraints.
"""
- gt: Union[SupportsGt, None] = None
- ge: Union[SupportsGe, None] = None
- lt: Union[SupportsLt, None] = None
- le: Union[SupportsLe, None] = None
+ gt: SupportsGt | None = None
+ ge: SupportsGe | None = None
+ lt: SupportsLt | None = None
+ le: SupportsLe | None = None
def __iter__(self) -> Iterator[BaseMetadata]:
"""Unpack an Interval into zero or more single-bounds."""
@@ -226,7 +217,7 @@
yield Le(self.le)
-@dataclass(frozen=True, **SLOTS)
+@dataclass(frozen=True, slots=True)
class MultipleOf(BaseMetadata):
"""MultipleOf(multiple_of=x) might be interpreted in two ways:
@@ -237,10 +228,10 @@
and libraries to carefully document which they implement.
"""
- multiple_of: Union[SupportsDiv, SupportsMod]
+ multiple_of: SupportsDiv | SupportsMod
-@dataclass(frozen=True, **SLOTS)
+@dataclass(frozen=True, slots=True)
class MinLen(BaseMetadata):
"""
MinLen() implies minimum inclusive length,
@@ -250,7 +241,7 @@
min_length: Annotated[int, Ge(0)]
-@dataclass(frozen=True, **SLOTS)
+@dataclass(frozen=True, slots=True)
class MaxLen(BaseMetadata):
"""
MaxLen() implies maximum inclusive length,
@@ -260,7 +251,7 @@
max_length: Annotated[int, Ge(0)]
-@dataclass(frozen=True, **SLOTS)
+@dataclass(frozen=True, slots=True)
class Len(GroupedMetadata):
"""
Len() implies that ``min_length <= len(value) <= max_length``.
@@ -269,22 +260,22 @@
"""
min_length: Annotated[int, Ge(0)] = 0
- max_length: Optional[Annotated[int, Ge(0)]] = None
+ max_length: Annotated[int, Ge(0)] | None = None
def __iter__(self) -> Iterator[BaseMetadata]:
- """Unpack a Len into zone or more single-bounds."""
+ """Unpack a Len into zero or more single-bounds."""
if self.min_length > 0:
yield MinLen(self.min_length)
if self.max_length is not None:
yield MaxLen(self.max_length)
-@dataclass(frozen=True, **SLOTS)
+@dataclass(frozen=True, slots=True)
class Timezone(BaseMetadata):
"""Timezone(tz=...) requires a datetime to be aware (or ``tz=None``,
naive).
``Annotated[datetime, Timezone(None)]`` must be a naive datetime.
- ``Timezone[...]`` (the ellipsis literal) expresses that the datetime must
be
+ ``Timezone(...)`` (the ellipsis literal) expresses that the datetime must
be
tz-aware but any timezone is allowed.
You may also pass a specific timezone string or tzinfo object such as
@@ -293,10 +284,10 @@
a symptom of poor design.
"""
- tz: Union[str, tzinfo, EllipsisType, None]
+ tz: str | tzinfo | EllipsisType | None
-@dataclass(frozen=True, **SLOTS)
+@dataclass(frozen=True, slots=True)
class Unit(BaseMetadata):
"""Indicates that the value is a physical quantity with the specified unit.
@@ -319,7 +310,7 @@
unit: str
-@dataclass(frozen=True, **SLOTS)
+@dataclass(frozen=True, slots=True)
class Predicate(BaseMetadata):
"""``Predicate(func: Callable)`` implies `func(value)` is truthy for valid
values.
@@ -327,7 +318,7 @@
power and flexibility of arbitrary runtime predicates... here it is.
We provide a few predefined predicates for common string constraints:
- ``IsLower = Predicate(str.islower)``, ``IsUpper =
Predicate(str.isupper)``, and
+ ``LowerCase = Predicate(str.islower)``, ``UpperCase =
Predicate(str.isupper)``, and
``IsDigits = Predicate(str.isdigit)``. Users are encouraged to use methods
which
can be given special handling, and avoid indirection like ``lambda s:
s.lower()``.
@@ -406,11 +397,12 @@
"""Return True if x is neither a positive or negative infinity, and False
otherwise."""
try:
- from typing_extensions import DocInfo, doc # type: ignore [attr-defined]
+ # PEP 727 – Documentation in Annotated Metadata
+ from typing_extensions import Doc # type: ignore[attr-defined]
except ImportError:
- @dataclass(frozen=True, **SLOTS)
- class DocInfo: # type: ignore [no-redef]
+ @dataclass(frozen=True, slots=True)
+ class Doc: # type: ignore [no-redef]
""" "
The return value of doc(), mainly to be used by tools that want to
extract the
Annotated documentation at runtime.
@@ -419,14 +411,6 @@
documentation: str
"""The documentation string passed to doc()."""
- def doc(
- documentation: str,
- ) -> DocInfo:
- """
- Add documentation to a type annotation inside of Annotated.
-
- For example:
- >>> def hi(name: Annotated[int, doc("The name of the user")]) -> None:
...
- """
- return DocInfo(documentation)
+DocInfo = Doc # backwards compatibility
+doc = Doc
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/annotated_types-0.7.0/annotated_types/test_cases.py
new/annotated_types-0.8.0/annotated_types/test_cases.py
--- old/annotated_types-0.7.0/annotated_types/test_cases.py 2020-02-02
01:00:00.000000000 +0100
+++ new/annotated_types-0.8.0/annotated_types/test_cases.py 2020-02-02
01:00:00.000000000 +0100
@@ -1,13 +1,8 @@
import math
-import sys
+from collections.abc import Iterable, Iterator
from datetime import date, datetime, timedelta, timezone
from decimal import Decimal
-from typing import Any, Dict, Iterable, Iterator, List, NamedTuple, Set, Tuple
-
-if sys.version_info < (3, 9):
- from typing_extensions import Annotated
-else:
- from typing import Annotated
+from typing import Annotated, Any, NamedTuple
import annotated_types as at
@@ -83,20 +78,20 @@
yield Case(Annotated[str, at.MinLen(3)], ('123', '1234', 'x' * 10), ('',
'1', '12'))
yield Case(Annotated[str, at.Len(3)], ('123', '1234', 'x' * 10), ('', '1',
'12'))
- yield Case(Annotated[List[int], at.MinLen(3)], ([1, 2, 3], [1, 2, 3, 4],
[1] * 10), ([], [1], [1, 2]))
- yield Case(Annotated[List[int], at.Len(3)], ([1, 2, 3], [1, 2, 3, 4], [1]
* 10), ([], [1], [1, 2]))
+ yield Case(Annotated[list[int], at.MinLen(3)], ([1, 2, 3], [1, 2, 3, 4],
[1] * 10), ([], [1], [1, 2]))
+ yield Case(Annotated[list[int], at.Len(3)], ([1, 2, 3], [1, 2, 3, 4], [1]
* 10), ([], [1], [1, 2]))
yield Case(Annotated[str, at.MaxLen(4)], ('', '1234'), ('12345', 'x' * 10))
yield Case(Annotated[str, at.Len(0, 4)], ('', '1234'), ('12345', 'x' * 10))
- yield Case(Annotated[List[str], at.MaxLen(4)], ([], ['a', 'bcdef'], ['a',
'b', 'c']), (['a'] * 5, ['b'] * 10))
- yield Case(Annotated[List[str], at.Len(0, 4)], ([], ['a', 'bcdef'], ['a',
'b', 'c']), (['a'] * 5, ['b'] * 10))
+ yield Case(Annotated[list[str], at.MaxLen(4)], ([], ['a', 'bcdef'], ['a',
'b', 'c']), (['a'] * 5, ['b'] * 10))
+ yield Case(Annotated[list[str], at.Len(0, 4)], ([], ['a', 'bcdef'], ['a',
'b', 'c']), (['a'] * 5, ['b'] * 10))
yield Case(Annotated[str, at.Len(3, 5)], ('123', '12345'), ('', '1', '12',
'123456', 'x' * 10))
yield Case(Annotated[str, at.Len(3, 3)], ('123',), ('12', '1234'))
- yield Case(Annotated[Dict[int, int], at.Len(2, 3)], [{1: 1, 2: 2}], [{},
{1: 1}, {1: 1, 2: 2, 3: 3, 4: 4}])
- yield Case(Annotated[Set[int], at.Len(2, 3)], ({1, 2}, {1, 2, 3}), (set(),
{1}, {1, 2, 3, 4}))
- yield Case(Annotated[Tuple[int, ...], at.Len(2, 3)], ((1, 2), (1, 2, 3)),
((), (1,), (1, 2, 3, 4)))
+ yield Case(Annotated[dict[int, int], at.Len(2, 3)], [{1: 1, 2: 2}], [{},
{1: 1}, {1: 1, 2: 2, 3: 3, 4: 4}])
+ yield Case(Annotated[set[int], at.Len(2, 3)], ({1, 2}, {1, 2, 3}), (set(),
{1}, {1, 2, 3, 4}))
+ yield Case(Annotated[tuple[int, ...], at.Len(2, 3)], ((1, 2), (1, 2, 3)),
((), (1,), (1, 2, 3, 4)))
# Timezone
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/annotated_types-0.7.0/pyproject.toml
new/annotated_types-0.8.0/pyproject.toml
--- old/annotated_types-0.7.0/pyproject.toml 2020-02-02 01:00:00.000000000
+0100
+++ new/annotated_types-0.8.0/pyproject.toml 2020-02-02 01:00:00.000000000
+0100
@@ -8,7 +8,8 @@
]
readme = "README.md"
repository = "https://github.com/annotated-types/annotated-types";
-license-files = { paths = ['LICENSE'] }
+license = "MIT"
+license-files = ["LICENSE"]
classifiers = [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
@@ -19,17 +20,16 @@
"Environment :: MacOS X",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3 :: Only",
- "Programming Language :: Python :: 3.8",
- "Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
+ "Programming Language :: Python :: 3.13",
+ "Programming Language :: Python :: 3.14",
"Topic :: Software Development :: Libraries :: Python Modules",
"Typing :: Typed",
]
-requires-python = ">=3.8"
-dependencies = ["typing-extensions>=4.0.0; python_version<'3.9'"]
+requires-python = ">=3.10"
dynamic = ["version"]
[project.urls]
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/annotated_types-0.7.0/tests/test_grouped_metadata.py
new/annotated_types-0.8.0/tests/test_grouped_metadata.py
--- old/annotated_types-0.7.0/tests/test_grouped_metadata.py 2020-02-02
01:00:00.000000000 +0100
+++ new/annotated_types-0.8.0/tests/test_grouped_metadata.py 2020-02-02
01:00:00.000000000 +0100
@@ -1,13 +1,8 @@
-import sys
-from typing import Iterator
+from collections.abc import Iterator
+from typing import Literal
import pytest
-if sys.version_info < (3, 9):
- from typing_extensions import Literal
-else:
- from typing import Literal
-
from annotated_types import BaseMetadata, GroupedMetadata, Gt
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/annotated_types-0.7.0/tests/test_main.py
new/annotated_types-0.8.0/tests/test_main.py
--- old/annotated_types-0.7.0/tests/test_main.py 2020-02-02
01:00:00.000000000 +0100
+++ new/annotated_types-0.8.0/tests/test_main.py 2020-02-02
01:00:00.000000000 +0100
@@ -1,12 +1,7 @@
import math
-import sys
+from collections.abc import Callable, Iterable, Iterator
from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Any, Callable, Dict, Iterable, Iterator,
Type, Union
-
-if sys.version_info < (3, 9):
- from typing_extensions import Annotated, get_args, get_origin
-else:
- from typing import Annotated, get_args, get_origin
+from typing import TYPE_CHECKING, Annotated, Any, Union, get_args, get_origin
import pytest
@@ -85,7 +80,7 @@
Validator = Callable[[Constraint, Any], bool]
-VALIDATORS: Dict[Type[Constraint], Validator] = {
+VALIDATORS: dict[type[Constraint], Validator] = {
annotated_types.Gt: check_gt,
annotated_types.Lt: check_lt,
annotated_types.Ge: check_ge,
@@ -151,12 +146,12 @@
@pytest.mark.parametrize(
"pred, repr_",
[
- (annotated_types.Predicate(func=a_predicate_fn),
"Predicate(a_predicate_fn)"),
- (annotated_types.Predicate(func=str.isascii),
"Predicate(str.isascii)"),
- (annotated_types.Predicate(func=math.isfinite),
"Predicate(math.isfinite)"),
- (annotated_types.Predicate(func=bool), "Predicate(bool)"),
- (annotated_types.Predicate(func := lambda _: True),
f"Predicate({func!r})"),
+ (annotated_types.Predicate(func=a_predicate_fn),
["Predicate(a_predicate_fn)"]),
+ (annotated_types.Predicate(func=str.isascii),
["Predicate(str.isascii)"]),
+ (annotated_types.Predicate(func=math.isfinite),
["Predicate(math.isfinite)", "Predicate(isfinite)"]),
+ (annotated_types.Predicate(func=bool), ["Predicate(bool)"]),
+ (annotated_types.Predicate(func := lambda _: True),
[f"Predicate({func!r})"]),
],
)
def test_predicate_repr(pred: annotated_types.Predicate, repr_: str) -> None:
- assert repr(pred) == repr_
+ assert repr(pred) in repr_
