Drop Python 3.8 for codegen

.github/workflows/tests.yml

@@ -26,7 +26,7 @@ jobs:
       fail-fast: false
       matrix:
         python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
-        edgedb-version: [5, nightly]
+        edgedb-version: [6, nightly]
         os: [ubuntu-latest, macos-latest, windows-2019]
         loop: [asyncio, uvloop]
         exclude:

README.rst

@@ -14,7 +14,7 @@ The Python driver for Gel
 **gel-python** is the official Gel driver for Python.
 It provides both blocking IO and asyncio implementations.
 
-The library requires Python 3.8 or later.
+The library requires Python 3.9 or later.
 
 
 Documentation

gel/codegen/generator.py

@@ -341,11 +341,7 @@ def _generate(
         name_hint = f"{self._snake_to_camel(name)}Result"
         out_type = self._generate_code(dr.output_type, name_hint)
         if dr.output_cardinality.is_multi():
-            if SYS_VERSION_INFO >= (3, 9):
-                out_type = f"list[{out_type}]"
-            else:
-                self._imports.add("typing")
-                out_type = f"typing.List[{out_type}]"
+            out_type = f"list[{out_type}]"
         elif dr.output_cardinality == gel.Cardinality.AT_MOST_ONE:
             if SYS_VERSION_INFO >= (3, 10):
                 out_type = f"{out_type} | None"
@@ -442,22 +438,14 @@ def _generate_code(
             el_type = self._generate_code(
                 type_.element_type, f"{name_hint}Item", is_input
             )
-            if SYS_VERSION_INFO >= (3, 9):
-                rv = f"list[{el_type}]"
-            else:
-                self._imports.add("typing")
-                rv = f"typing.List[{el_type}]"
+            rv = f"list[{el_type}]"
 
         elif isinstance(type_, describe.TupleType):
             elements = ", ".join(
                 self._generate_code(el_type, f"{name_hint}Item", is_input)
                 for el_type in type_.element_types
             )
-            if SYS_VERSION_INFO >= (3, 9):
-                rv = f"tuple[{elements}]"
-            else:
-                self._imports.add("typing")
-                rv = f"typing.Tuple[{elements}]"
+            rv = f"tuple[{elements}]"
 
         elif isinstance(type_, describe.ScalarType):
             rv = self._find_name(type_.name or name_hint)

tests/codegen/test-project1/select_optional_json_async_edgeql.py.assert

@@ -5,7 +5,6 @@
 from __future__ import annotations
 import dataclasses
 import gel
-import typing
 import uuid
 
 
@@ -28,7 +27,7 @@ class NoPydanticValidation:
 @dataclasses.dataclass
 class SelectOptionalJsonResultItem(NoPydanticValidation):
     id: uuid.UUID
-    snake_case: typing.Optional[SelectOptionalJsonResultItemSnakeCase]
+    snake_case: SelectOptionalJsonResultItemSnakeCase | None
 
 
 @dataclasses.dataclass
@@ -38,8 +37,8 @@ class SelectOptionalJsonResultItemSnakeCase(NoPydanticValidation):
 
 async def select_optional_json(
     executor: gel.AsyncIOExecutor,
-    arg0: typing.Optional[str],
-) -> typing.List[typing.Tuple[str, SelectOptionalJsonResultItem]]:
+    arg0: str | None,
+) -> list[tuple[str, SelectOptionalJsonResultItem]]:
     return await executor.query(
         """\
         create type TestCase {

tests/codegen/test-project2/object/link_prop_async_edgeql.py.assert

@@ -30,21 +30,21 @@ class NoPydanticValidation:
 class LinkPropResult(NoPydanticValidation):
     id: uuid.UUID
     name: str
-    friends: typing.List[LinkPropResultFriendsItem]
+    friends: list[LinkPropResultFriendsItem]
 
 
 @dataclasses.dataclass
 class LinkPropResultFriendsItem(NoPydanticValidation):
     id: uuid.UUID
     name: str
-    created_at: typing.Optional[datetime.datetime]
+    created_at: datetime.datetime | None
 
     @typing.overload
-    def __getitem__(self, key: typing.Literal["@created_at"]) -> typing.Optional[datetime.datetime]:
+    def __getitem__(self, key: typing.Literal["@created_at"]) -> datetime.datetime | None:
         ...
 
     @typing.overload
-    def __getitem__(self, key: typing.Literal["@strength"]) -> typing.Optional[float]:
+    def __getitem__(self, key: typing.Literal["@strength"]) -> float | None:
         ...
 
     def __getitem__(self, key: str) -> typing.Any:
@@ -53,7 +53,7 @@ class LinkPropResultFriendsItem(NoPydanticValidation):
 
 async def link_prop(
     executor: gel.AsyncIOExecutor,
-) -> typing.List[LinkPropResult]:
+) -> list[LinkPropResult]:
     return await executor.query(
         """\
         create type Person {

tests/codegen/test-project2/object/select_object_async_edgeql.py.assert

@@ -5,7 +5,6 @@
 from __future__ import annotations
 import dataclasses
 import gel
-import typing
 import uuid
 
 
@@ -30,19 +29,19 @@ class SelectObjectResult(NoPydanticValidation):
     id: uuid.UUID
     Name: str
     Language: str
-    Params: typing.List[SelectObjectResultParamsItem]
+    Params: list[SelectObjectResultParamsItem]
 
 
 @dataclasses.dataclass
 class SelectObjectResultParamsItem(NoPydanticValidation):
     id: uuid.UUID
     Name: str
-    Default: typing.Optional[str]
+    Default: str | None
 
 
 async def select_object(
     executor: gel.AsyncIOExecutor,
-) -> typing.Optional[SelectObjectResult]:
+) -> SelectObjectResult | None:
     return await executor.query_single(
         """\
         select schema::Function {

tests/codegen/test-project2/object/select_objects_async_edgeql.py.assert

@@ -5,7 +5,6 @@
 from __future__ import annotations
 import dataclasses
 import gel
-import typing
 import uuid
 
 
@@ -30,19 +29,19 @@ class SelectObjectsResult(NoPydanticValidation):
     id: uuid.UUID
     Name: str
     Language: str
-    Params: typing.List[SelectObjectsResultParamsItem]
+    Params: list[SelectObjectsResultParamsItem]
 
 
 @dataclasses.dataclass
 class SelectObjectsResultParamsItem(NoPydanticValidation):
     id: uuid.UUID
     Name: str
-    Default: typing.Optional[str]
+    Default: str | None
 
 
 async def select_objects(
     executor: gel.AsyncIOExecutor,
-) -> typing.List[SelectObjectsResult]:
+) -> list[SelectObjectsResult]:
     return await executor.query(
         """\
         select schema::Function {

tests/codegen/test-project2/parpkg/subpkg/my_query_async_edgeql.py.assert

@@ -42,118 +42,118 @@ class MyEnum(enum.Enum):
 @dataclasses.dataclass
 class MyQueryResult(NoPydanticValidation):
     a: uuid.UUID
-    b: typing.Optional[uuid.UUID]
+    b: uuid.UUID | None
     c: str
-    d: typing.Optional[str]
+    d: str | None
     e: bytes
-    f: typing.Optional[bytes]
+    f: bytes | None
     g: int
-    h: typing.Optional[int]
+    h: int | None
     i: int
-    j: typing.Optional[int]
+    j: int | None
     k: int
-    l: typing.Optional[int]
+    l: int | None
     m: float
-    n: typing.Optional[float]
+    n: float | None
     o: float
-    p: typing.Optional[float]
+    p: float | None
     q: bool
-    r: typing.Optional[bool]
+    r: bool | None
     s: datetime.datetime
-    t: typing.Optional[datetime.datetime]
+    t: datetime.datetime | None
     u: datetime.datetime
-    v: typing.Optional[datetime.datetime]
+    v: datetime.datetime | None
     w: datetime.date
-    x: typing.Optional[datetime.date]
+    x: datetime.date | None
     y: datetime.time
-    z: typing.Optional[datetime.time]
+    z: datetime.time | None
     aa: datetime.timedelta
-    ab: typing.Optional[datetime.timedelta]
+    ab: datetime.timedelta | None
     ac: int
-    ad: typing.Optional[int]
+    ad: int | None
     ae: gel.RelativeDuration
-    af: typing.Optional[gel.RelativeDuration]
+    af: gel.RelativeDuration | None
     ag: gel.DateDuration
-    ah: typing.Optional[gel.DateDuration]
+    ah: gel.DateDuration | None
     ai: gel.ConfigMemory
-    aj: typing.Optional[gel.ConfigMemory]
+    aj: gel.ConfigMemory | None
     ak: gel.Range[int]
-    al: typing.Optional[gel.Range[int]]
+    al: gel.Range[int] | None
     am: gel.Range[int]
-    an: typing.Optional[gel.Range[int]]
+    an: gel.Range[int] | None
     ao: gel.Range[float]
-    ap: typing.Optional[gel.Range[float]]
+    ap: gel.Range[float] | None
     aq: gel.Range[float]
-    ar: typing.Optional[gel.Range[float]]
+    ar: gel.Range[float] | None
     as_: gel.Range[datetime.datetime]
-    at: typing.Optional[gel.Range[datetime.datetime]]
+    at: gel.Range[datetime.datetime] | None
     au: gel.Range[datetime.datetime]
-    av: typing.Optional[gel.Range[datetime.datetime]]
+    av: gel.Range[datetime.datetime] | None
     aw: gel.Range[datetime.date]
-    ax: typing.Optional[gel.Range[datetime.date]]
+    ax: gel.Range[datetime.date] | None
     ay: MyScalar
-    az: typing.Optional[MyScalar]
+    az: MyScalar | None
     ba: MyEnum
-    bb: typing.Optional[MyEnum]
+    bb: MyEnum | None
     bc: array.array
-    bd: typing.Optional[array.array]
+    bd: array.array | None
 
 
 async def my_query(
     executor: gel.AsyncIOExecutor,
     *,
     a: uuid.UUID,
-    b: typing.Optional[uuid.UUID] = None,
+    b: uuid.UUID | None = None,
     c: str,
-    d: typing.Optional[str] = None,
+    d: str | None = None,
     e: bytes,
-    f: typing.Optional[bytes] = None,
+    f: bytes | None = None,
     g: int,
-    h: typing.Optional[int] = None,
+    h: int | None = None,
     i: int,
-    j: typing.Optional[int] = None,
+    j: int | None = None,
     k: int,
-    l: typing.Optional[int] = None,
+    l: int | None = None,
     m: float,
-    n: typing.Optional[float] = None,
+    n: float | None = None,
     o: float,
-    p: typing.Optional[float] = None,
+    p: float | None = None,
     q: bool,
-    r: typing.Optional[bool] = None,
+    r: bool | None = None,
     s: datetime.datetime,
-    t: typing.Optional[datetime.datetime] = None,
+    t: datetime.datetime | None = None,
     u: datetime.datetime,
-    v: typing.Optional[datetime.datetime] = None,
+    v: datetime.datetime | None = None,
     w: datetime.date,
-    x: typing.Optional[datetime.date] = None,
+    x: datetime.date | None = None,
     y: datetime.time,
-    z: typing.Optional[datetime.time] = None,
+    z: datetime.time | None = None,
     aa: datetime.timedelta,
-    ab: typing.Optional[datetime.timedelta] = None,
+    ab: datetime.timedelta | None = None,
     ac: int,
-    ad: typing.Optional[int] = None,
+    ad: int | None = None,
     ae: gel.RelativeDuration,
-    af: typing.Optional[gel.RelativeDuration] = None,
+    af: gel.RelativeDuration | None = None,
     ag: gel.DateDuration,
-    ah: typing.Optional[gel.DateDuration] = None,
+    ah: gel.DateDuration | None = None,
     ai: gel.ConfigMemory,
-    aj: typing.Optional[gel.ConfigMemory] = None,
+    aj: gel.ConfigMemory | None = None,
     ak: gel.Range[int],
-    al: typing.Optional[gel.Range[int]] = None,
+    al: gel.Range[int] | None = None,
     am: gel.Range[int],
-    an: typing.Optional[gel.Range[int]] = None,
+    an: gel.Range[int] | None = None,
     ao: gel.Range[float],
-    ap: typing.Optional[gel.Range[float]] = None,
+    ap: gel.Range[float] | None = None,
     aq: gel.Range[float],
-    ar: typing.Optional[gel.Range[float]] = None,
+    ar: gel.Range[float] | None = None,
     as_: gel.Range[datetime.datetime],
-    at: typing.Optional[gel.Range[datetime.datetime]] = None,
+    at: gel.Range[datetime.datetime] | None = None,
     au: gel.Range[datetime.datetime],
-    av: typing.Optional[gel.Range[datetime.datetime]] = None,
+    av: gel.Range[datetime.datetime] | None = None,
     aw: gel.Range[datetime.date],
-    ax: typing.Optional[gel.Range[datetime.date]] = None,
+    ax: gel.Range[datetime.date] | None = None,
     bc: typing.Sequence[float],
-    bd: typing.Optional[typing.Sequence[float]] = None,
+    bd: typing.Sequence[float] | None = None,
 ) -> MyQueryResult:
     return await executor.query_single(
         """\