ddsql 0.0.3__tar.gz → 0.1.0__tar.gz

ddsql-0.0.3/README.md → ddsql-0.1.0/PKG-INFO

@@ -1,3 +1,17 @@
+Metadata-Version: 2.4
+Name: ddsql
+Version: 0.1.0
+Summary: SQL Query Library
+Keywords: python,ddsql
+Author: davyddd
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: ddutils>=0.2.0,<0.3.0
+Requires-Dist: jinja2>=3.0.0,<4.0.0
+Requires-Python: >=3.11, <3.15
+Project-URL: Repository, https://github.com/davyddd/ddsql
+Description-Content-Type: text/markdown
+
 # DDSQL
 
 [![pypi](https://img.shields.io/pypi/v/ddsql.svg)](https://pypi.python.org/pypi/ddsql)
@@ -16,6 +30,21 @@ Install the library using pip:
 pip install ddsql
 ```
 
+## Development
+
+The project runs entirely in Docker. Requires Docker and [Fabric](https://www.fabfile.org/) on the host:
+
+```bash
+fab build      # build the dev image
+fab tests      # run pytest
+fab linters    # run ruff (with --fix), ty and complexipy
+fab shell      # IPython inside the container
+fab bash       # bash inside the container
+```
+
+This project was generated from [dd-lib-stub](https://github.com/davyddd/dd-lib-stub);
+run `copier update` to pull in template updates.
+
 ## Serializer
 
 The serializer converts Python types to their SQL representations. 
@@ -24,17 +53,17 @@ or create your own by inheriting from `BaseSerializer`.
 
 **Serialization Table**
 
-| Python Type          | Base                     | PostgreSQL                          | ClickHouse                                        |
-|----------------------|--------------------------|-------------------------------------|---------------------------------------------------|
-| `None`               | `NULL`                   | `NULL`                              | `NULL`                                            |
-| `bool`               | `true`/`false`           | `true`/`false`                      | `true`/`false`                                    |
-| `int`                | `123`                    | `123`                               | `123`                                             |
-| `float`/`Decimal`    | `45.67`                  | `45.67`                             | `45.67`                                           |
-| `str`                | `'value'`                | `'value'`                           | `'value'`                                         |
-| `UUID`               | `'550e8400-...'`         | `'550e8400-...'::uuid`              | `toUUID('550e8400-...')`                          |
-| `datetime`           | `'2025-01-01T12:00:00'`  | `'2025-01-01T12:00:00'::timestamp`  | `parseDateTimeBestEffort('2025-01-01T12:00:00')`  |
-| `date`               | `'2025-01-01'`           | `'2025-01-01'::date`                | `toDate('2025-01-01')`                            |
-| `list`/`tuple`/`set` | `(item1, item2, ...)`    | `(item1, item2, ...)`               | `(item1, item2, ...)`                             |
+| Python Type          | Base                    | PostgreSQL                         | ClickHouse                                            |
+|----------------------|-------------------------|------------------------------------|-------------------------------------------------------|
+| `None`               | `NULL`                  | `NULL`                             | `NULL`                                                |
+| `bool`               | `true`/`false`          | `true`/`false`                     | `true`/`false`                                        |
+| `int`                | `123`                   | `123`                              | `123`                                                 |
+| `float`/`Decimal`    | `45.67`                 | `45.67`                            | `45.67`                                               |
+| `str`                | `'value'`               | `'value'`                          | `'value'`                                             |
+| `UUID`               | `'550e8400-...'`        | `'550e8400-...'::uuid`             | `toUUID('550e8400-...')`                              |
+| `datetime`           | `'2025-01-01T12:00:00'` | `'2025-01-01T12:00:00'::timestamp` | `parseDateTime64BestEffort('2025-01-01T12:00:00', 6)` |
+| `date`               | `'2025-01-01'`          | `'2025-01-01'::date`               | `toDate('2025-01-01')`                                |
+| `list`/`tuple`/`set` | `(item1, item2, ...)`   | `(item1, item2, ...)`              | `(item1, item2, ...)`                                 |
 
 String values are escaped according to the dialect rules, so quotes, backslashes 
 and control characters cannot break the query:
@@ -48,6 +77,16 @@ and control characters cannot break the query:
   A NUL (`0x00`) character raises `ValueError`, since PostgreSQL cannot store it in text values.
 
 The serialized literal is always a single printable line. 
+
+`datetime` values keep their microseconds and UTC offset:
+
+- `ClickhouseSerializer` renders `parseDateTime64BestEffort('...', 6)`, which yields a `DateTime64(6)` 
+  literal; a timezone-aware value is converted according to its offset, a naive value is interpreted 
+  in the server time zone. Inserting such a literal into a `DateTime` column silently truncates it 
+  to seconds, and comparisons with `DateTime` columns work as expected.
+- `PostgresSerializer` renders a timezone-aware value as `'...+03:00'::timestamptz`, so its offset 
+  is honoured; a naive value is rendered as `'...'::timestamp`, as before.
+
 To customize escaping in your own serializer, override the `escape_string` method.
 
 If you need to serialize a type not listed in the table, override the `serialize_other_object` method in your serializer:
@@ -145,7 +184,7 @@ which wraps raw database rows into the specified model (called internally by `Ad
 
 Required parameters:
 - **model** – a declarative class (e.g., dataclass) describing the output result structure;
-- **text** or **path** – the SQL template source.
+- **text** or **path** – the SQL template source (inline string or path to a file).
 
 ### Inline Template (text)
 
@@ -161,25 +200,24 @@ query = Query(
 
 ### File Template (path)
 
-For file-based templates, set the `SQL_TEMPLATES_DIR` environment variable to the directory containing your SQL files:
-
-```bash
-export SQL_TEMPLATES_DIR=/app/src/templates/sql/
-```
-
-Then use a relative path:
+Pass the path to the SQL file as `Path`. The file is checked at construction time, so a wrong path fails
+on import rather than on the first query:
 
 ```python
+from pathlib import Path
+
 from ddsql.query import Query
 
+SQL_TEMPLATES_DIR = Path(__file__).parent / 'templates' / 'sql'
 
-# Loads template from /app/src/templates/sql/users/get_by_id.sql
 query = Query(
-    model=User, 
-    path='users/get_by_id.sql'
+    model=User,
+    path=SQL_TEMPLATES_DIR / 'users' / 'get_by_id.sql',
 )
 ```
 
+`{% include %}` and `{% import %}` inside the template resolve relative to the template's directory.
+
 ### Result
 
 The result of query execution is a `Result` object that wraps the data into the specified model:

ddsql-0.0.3/PKG-INFO → ddsql-0.1.0/README.md

@@ -1,25 +1,3 @@
-Metadata-Version: 2.4
-Name: ddsql
-Version: 0.0.3
-Summary: SQL Query Library
-License: MIT
-License-File: LICENSE
-Keywords: python,ddsql
-Author: davyddd
-Requires-Python: >=3.9,<3.15
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-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
-Requires-Dist: ddutils (<0.2.0)
-Requires-Dist: jinja2 (>=3.0.0,<4.0.0)
-Project-URL: Repository, https://github.com/davyddd/ddsql
-Description-Content-Type: text/markdown
-
 # DDSQL
 
 [![pypi](https://img.shields.io/pypi/v/ddsql.svg)](https://pypi.python.org/pypi/ddsql)
@@ -38,6 +16,21 @@ Install the library using pip:
 pip install ddsql
 ```
 
+## Development
+
+The project runs entirely in Docker. Requires Docker and [Fabric](https://www.fabfile.org/) on the host:
+
+```bash
+fab build      # build the dev image
+fab tests      # run pytest
+fab linters    # run ruff (with --fix), ty and complexipy
+fab shell      # IPython inside the container
+fab bash       # bash inside the container
+```
+
+This project was generated from [dd-lib-stub](https://github.com/davyddd/dd-lib-stub);
+run `copier update` to pull in template updates.
+
 ## Serializer
 
 The serializer converts Python types to their SQL representations. 
@@ -46,17 +39,17 @@ or create your own by inheriting from `BaseSerializer`.
 
 **Serialization Table**
 
-| Python Type          | Base                     | PostgreSQL                          | ClickHouse                                        |
-|----------------------|--------------------------|-------------------------------------|---------------------------------------------------|
-| `None`               | `NULL`                   | `NULL`                              | `NULL`                                            |
-| `bool`               | `true`/`false`           | `true`/`false`                      | `true`/`false`                                    |
-| `int`                | `123`                    | `123`                               | `123`                                             |
-| `float`/`Decimal`    | `45.67`                  | `45.67`                             | `45.67`                                           |
-| `str`                | `'value'`                | `'value'`                           | `'value'`                                         |
-| `UUID`               | `'550e8400-...'`         | `'550e8400-...'::uuid`              | `toUUID('550e8400-...')`                          |
-| `datetime`           | `'2025-01-01T12:00:00'`  | `'2025-01-01T12:00:00'::timestamp`  | `parseDateTimeBestEffort('2025-01-01T12:00:00')`  |
-| `date`               | `'2025-01-01'`           | `'2025-01-01'::date`                | `toDate('2025-01-01')`                            |
-| `list`/`tuple`/`set` | `(item1, item2, ...)`    | `(item1, item2, ...)`               | `(item1, item2, ...)`                             |
+| Python Type          | Base                    | PostgreSQL                         | ClickHouse                                            |
+|----------------------|-------------------------|------------------------------------|-------------------------------------------------------|
+| `None`               | `NULL`                  | `NULL`                             | `NULL`                                                |
+| `bool`               | `true`/`false`          | `true`/`false`                     | `true`/`false`                                        |
+| `int`                | `123`                   | `123`                              | `123`                                                 |
+| `float`/`Decimal`    | `45.67`                 | `45.67`                            | `45.67`                                               |
+| `str`                | `'value'`               | `'value'`                          | `'value'`                                             |
+| `UUID`               | `'550e8400-...'`        | `'550e8400-...'::uuid`             | `toUUID('550e8400-...')`                              |
+| `datetime`           | `'2025-01-01T12:00:00'` | `'2025-01-01T12:00:00'::timestamp` | `parseDateTime64BestEffort('2025-01-01T12:00:00', 6)` |
+| `date`               | `'2025-01-01'`          | `'2025-01-01'::date`               | `toDate('2025-01-01')`                                |
+| `list`/`tuple`/`set` | `(item1, item2, ...)`   | `(item1, item2, ...)`              | `(item1, item2, ...)`                                 |
 
 String values are escaped according to the dialect rules, so quotes, backslashes 
 and control characters cannot break the query:
@@ -70,6 +63,16 @@ and control characters cannot break the query:
   A NUL (`0x00`) character raises `ValueError`, since PostgreSQL cannot store it in text values.
 
 The serialized literal is always a single printable line. 
+
+`datetime` values keep their microseconds and UTC offset:
+
+- `ClickhouseSerializer` renders `parseDateTime64BestEffort('...', 6)`, which yields a `DateTime64(6)` 
+  literal; a timezone-aware value is converted according to its offset, a naive value is interpreted 
+  in the server time zone. Inserting such a literal into a `DateTime` column silently truncates it 
+  to seconds, and comparisons with `DateTime` columns work as expected.
+- `PostgresSerializer` renders a timezone-aware value as `'...+03:00'::timestamptz`, so its offset 
+  is honoured; a naive value is rendered as `'...'::timestamp`, as before.
+
 To customize escaping in your own serializer, override the `escape_string` method.
 
 If you need to serialize a type not listed in the table, override the `serialize_other_object` method in your serializer:
@@ -167,7 +170,7 @@ which wraps raw database rows into the specified model (called internally by `Ad
 
 Required parameters:
 - **model** – a declarative class (e.g., dataclass) describing the output result structure;
-- **text** or **path** – the SQL template source.
+- **text** or **path** – the SQL template source (inline string or path to a file).
 
 ### Inline Template (text)
 
@@ -183,25 +186,24 @@ query = Query(
 
 ### File Template (path)
 
-For file-based templates, set the `SQL_TEMPLATES_DIR` environment variable to the directory containing your SQL files:
-
-```bash
-export SQL_TEMPLATES_DIR=/app/src/templates/sql/
-```
-
-Then use a relative path:
+Pass the path to the SQL file as `Path`. The file is checked at construction time, so a wrong path fails
+on import rather than on the first query:
 
 ```python
+from pathlib import Path
+
 from ddsql.query import Query
 
+SQL_TEMPLATES_DIR = Path(__file__).parent / 'templates' / 'sql'
 
-# Loads template from /app/src/templates/sql/users/get_by_id.sql
 query = Query(
-    model=User, 
-    path='users/get_by_id.sql'
+    model=User,
+    path=SQL_TEMPLATES_DIR / 'users' / 'get_by_id.sql',
 )
 ```
 
+`{% include %}` and `{% import %}` inside the template resolve relative to the template's directory.
+
 ### Result
 
 The result of query execution is a `Result` object that wraps the data into the specified model:
@@ -263,4 +265,4 @@ async def get_users():
         .execute()
     )
     return result.get_list()
-```
+```

{ddsql-0.0.3 → ddsql-0.1.0}/ddsql/adapter.py

@@ -1,13 +1,15 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any, Dict, Generic, Optional, Sequence, Type, TypeVar
+from typing import TYPE_CHECKING, Any, Generic, TypeVar, overload
 
 from ddutils.annotation_helpers import is_subclass
 
 from ddsql.serializers import BaseSerializer
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from ddsql.query import Result
     from ddsql.sqlbase import SQLBase
 
@@ -15,7 +17,6 @@ if TYPE_CHECKING:
 class Adapter(ABC):
     serializer: BaseSerializer
 
-    @classmethod
     def __init_subclass__(cls, **kwargs):
         serializer = getattr(cls, 'serializer', None)
         serializer_class = getattr(serializer, '__class__', None)
@@ -36,20 +37,28 @@ class Adapter(ABC):
         return self.sql.query.build_result(await self._execute())
 
     @abstractmethod
-    async def _execute(self) -> Sequence[Dict[str, Any]]:  # noqa: UP006
-        ...
+    async def _execute(self) -> Sequence[dict[str, Any]]: ...
 
 
 AdapterT = TypeVar('AdapterT', bound=Adapter)
 
 
 class AdapterDescriptor(Generic[AdapterT]):
-    adapter_class: Type[AdapterT]  # noqa: UP006
+    adapter_class: type[AdapterT]
 
-    def __init__(self, adapter_class: Type[AdapterT]):  # noqa: UP006
+    def __init__(self, adapter_class: type[AdapterT]):
         self.adapter_class = adapter_class
 
-    def __get__(self, sql: SQLBase, sql_class: Optional[Type[SQLBase]] = None) -> AdapterT:  # noqa: UP006, UP007
+    @overload
+    def __get__(self, sql: None, sql_class: type[SQLBase]) -> AdapterDescriptor[AdapterT]: ...
+
+    @overload
+    def __get__(self, sql: SQLBase, sql_class: type[SQLBase] | None = None) -> AdapterT: ...
+
+    def __get__(self, sql: SQLBase | None, sql_class: type[SQLBase] | None = None) -> AdapterT | AdapterDescriptor[AdapterT]:
+        # accessed on the class, like `SQL.postgres`: return the descriptor itself, as `property` does
+        if sql is None:
+            return self
         return self.adapter_class(sql)
 
 

{ddsql-0.0.3 → ddsql-0.1.0}/ddsql/query.py

@@ -1,55 +1,51 @@
-import os
+from collections.abc import Sequence
 from pathlib import Path
-from typing import Any, Dict, Generic, Optional, Sequence, Tuple, Type, TypeVar
+from typing import Any, Generic, TypeVar
 
 from jinja2 import Environment, FileSystemLoader, Template
 
-SQL_TEMPLATES_DIR = os.getenv('SQL_TEMPLATES_DIR')
-
-
 DataT = TypeVar('DataT')
 
 
 class Result(Generic[DataT]):
     rows: Sequence[dict[str, Any]]
-    model: Type[DataT]
+    model: type[DataT]
 
-    def __init__(self, rows: Sequence[dict[str, Any]], model: Type[DataT]):
+    def __init__(self, rows: Sequence[dict[str, Any]], model: type[DataT]):
         self.rows = rows
         self.model = model
 
-    def get(self) -> Optional[DataT]:
+    def get(self) -> DataT | None:
         if not self.rows:
             return None
         return self.model(**self.rows[0])
 
-    def get_list(self) -> Tuple[DataT, ...]:
+    def get_list(self) -> tuple[DataT, ...]:
         return tuple(self.model(**row) for row in self.rows)
 
 
 class Query(Generic[DataT]):
-    model: Type[DataT]
+    model: type[DataT]
     template: Template
 
-    def __init__(self, model: Type[DataT], text: Optional[str] = None, path: Optional[str] = None):
+    def __init__(self, model: type[DataT], text: str | None = None, path: Path | None = None):
         self.model = model
 
         self.template = self.get_template(text, path)
 
     @staticmethod
-    def get_template(text: Optional[str] = None, path: Optional[str] = None) -> Template:
+    def get_template(text: str | None = None, path: Path | None = None) -> Template:
         if text:
-            file_system_loader = FileSystemLoader(Path('.'))
+            file_system_loader = None
             method = 'from_string'
             query = text
         elif path:
-            if SQL_TEMPLATES_DIR is None:
-                raise ValueError(
-                    'SQL Templates dir is not defined. Make sure the SQL_TEMPLATES_DIR environment variable is set correctly.'
-                )
-            file_system_loader = FileSystemLoader(Path(SQL_TEMPLATES_DIR))
+            if not path.is_file():
+                raise FileNotFoundError(f'SQL template not found: {path.resolve()}')
+            # the loader is rooted at the template directory, so `{% include %}` resolves relative to the file
+            file_system_loader = FileSystemLoader(path.parent)
             method = 'get_template'
-            query = path
+            query = path.name
         else:
             raise ValueError('One of `text` or `path` must be specified')
 
@@ -59,7 +55,7 @@ class Query(Generic[DataT]):
 
         return getattr(environment, method)(query)
 
-    def update_globals(self, envs: Optional[Dict[str, Any]] = None):
+    def update_globals(self, envs: dict[str, Any] | None = None):
         if envs:
             self.template.environment.globals.update(envs)
 
@@ -68,7 +64,7 @@ class Query(Generic[DataT]):
         strings = sql.split('\n')
         return '\n'.join([string.strip() for string in strings])
 
-    async def render_template(self, params: Dict[str, Any], template_functions: Optional[Dict[str, Any]] = None) -> str:
+    async def render_template(self, params: dict[str, Any], template_functions: dict[str, Any] | None = None) -> str:
         self.update_globals(template_functions)
 
         rendered_template = await self.template.render_async(**params)

{ddsql-0.0.3 → ddsql-0.1.0}/ddsql/serializers/base.py

@@ -1,13 +1,13 @@
 from collections.abc import Callable, Collection, Mapping
 from datetime import date, datetime
 from decimal import Decimal
-from typing import Any, Dict, Union
+from typing import Any
 from uuid import UUID
 
 
 class BaseSerializer:
     @property
-    def template_functions(self) -> Dict[str, Callable[[Any], str]]:
+    def template_functions(self) -> dict[str, Callable[[Any], str]]:
         return {'serialize_value': self.serialize_value}
 
     def serialize_value(self, value: Any) -> str:
@@ -41,7 +41,7 @@ class BaseSerializer:
         return f'{value}'.lower()
 
     @staticmethod
-    def serialize_number(value: Union[int, float, Decimal]) -> str:
+    def serialize_number(value: int | float | Decimal) -> str:
         return f'{value}'
 
     @staticmethod

{ddsql-0.0.3 → ddsql-0.1.0}/ddsql/serializers/clickhouse.py

@@ -1,11 +1,10 @@
 from datetime import date, datetime
-from typing import Dict
 from uuid import UUID
 
 from ddsql.serializers import BaseSerializer
 
 
-def _build_escape_translation() -> Dict[int, str]:
+def _build_escape_translation() -> dict[int, str]:
     # https://clickhouse.com/docs/en/sql-reference/syntax#string
     translation = {
         ord('\\'): '\\\\',
@@ -40,7 +39,9 @@ class ClickhouseSerializer(BaseSerializer):
 
     @classmethod
     def serialize_datetime(cls, value: datetime) -> str:
-        return f"parseDateTimeBestEffort('{cls.escape_string(value.isoformat())}')"
+        # parseDateTimeBestEffort returns DateTime (second precision) and silently drops
+        # microseconds; the DateTime64 variant keeps them and honours the UTC offset
+        return f"parseDateTime64BestEffort('{cls.escape_string(value.isoformat())}', 6)"
 
     @classmethod
     def serialize_date(cls, value: date) -> str:

{ddsql-0.0.3 → ddsql-0.1.0}/ddsql/serializers/postgres.py

@@ -1,6 +1,5 @@
 import re
 from datetime import date, datetime
-from typing import Dict
 from uuid import UUID
 
 from ddsql.serializers import BaseSerializer
@@ -11,7 +10,7 @@ from ddsql.serializers import BaseSerializer
 _ESCAPE_SYNTAX_REQUIRED = re.compile(r'[\\\x00-\x1F\x7F]')
 
 
-def _build_escape_translation() -> Dict[int, str]:
+def _build_escape_translation() -> dict[int, str]:
     # https://www.postgresql.org/docs/current/sql-syntax-lexical.html#SQL-SYNTAX-STRINGS-ESCAPE
     translation = {
         ord('\\'): '\\\\',
@@ -52,7 +51,10 @@ class PostgresSerializer(BaseSerializer):
 
     @classmethod
     def serialize_datetime(cls, value: datetime) -> str:
-        return f"'{cls.escape_string(value.isoformat())}'::timestamp"
+        # `timestamp` ignores the UTC offset of the literal, so a timezone-aware value
+        # is rendered as `timestamptz` to keep its offset; naive values are left as-is
+        cast = 'timestamptz' if value.tzinfo is not None else 'timestamp'
+        return f"'{cls.escape_string(value.isoformat())}'::{cast}"
 
     @classmethod
     def serialize_date(cls, value: date) -> str:

{ddsql-0.0.3 → ddsql-0.1.0}/ddsql/sqlbase.py

@@ -1,12 +1,11 @@
 from __future__ import annotations
 
 from abc import ABC
-from typing import TYPE_CHECKING, Any, Dict, TypeVar
+from typing import TYPE_CHECKING, Any, TypeVar
 
-from ddutils.annotation_helpers import is_subclass
 from ddutils.class_helpers import classproperty
 
-from ddsql.adapter import Adapter
+from ddsql.adapter import AdapterDescriptor
 
 if TYPE_CHECKING:
     from ddsql.query import Query
@@ -29,22 +28,17 @@ class SQLBase(ABC):
     """
 
     query: Query
-    params: Dict[str, Any]
+    params: dict[str, Any]
 
-    @classmethod
     def __init_subclass__(cls, **kwargs):
         if not cls.has_adapters:
             raise NotImplementedError('Subclasses must define at least one adapter')
 
     @classproperty
-    def has_adapters(cls) -> bool:
-        for field in cls.__annotations__:
-            adapter = getattr(cls, field, None)
-            adapter_class = getattr(adapter, '__class__', None)
-            if adapter_class and is_subclass(adapter_class, Adapter):
-                return True
-
-        return False
+    def has_adapters(cls: type[SQLBase]) -> bool:
+        # Descriptors are looked up in the class dictionaries along the MRO, so inherited adapters count
+        # and no adapter gets instantiated just for the check
+        return any(isinstance(value, AdapterDescriptor) for klass in cls.__mro__ for value in vars(klass).values())
 
     def __init__(self, query: Query) -> None:
         self.query = query

ddsql-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "ddsql"
+description = "SQL Query Library"
+version = "0.1.0"
+license = "MIT"
+license-files = ["LICENSE"]
+readme = "README.md"
+requires-python = ">=3.11,<3.15"
+keywords = [
+    "python",
+    "ddsql",
+]
+dependencies = [
+    "ddutils>=0.2.0,<0.3.0",
+    "jinja2>=3.0.0,<4.0.0",
+]
+
+[[project.authors]]
+name = "davyddd"
+
+[project.urls]
+Repository = "https://github.com/davyddd/ddsql"
+
+[dependency-groups]
+dev = [
+    "ipdb==0.13.13",
+    "ipython==9.16.1",
+]
+test = [
+    "pytest==9.0.3",
+    "pytest-cov==5.0.0",
+    "parameterized==0.9.0",
+]
+linter = [
+    "ruff==0.15.10",
+    "ty==0.0.15",
+    "complexipy==8.0.1",
+]
+
+[tool.uv.build-backend]
+module-root = ""
+
+[build-system]
+requires = ["uv_build>=0.12.0,<0.13.0"]
+build-backend = "uv_build"

ddsql-0.1.0/pyproject.toml.orig

@@ -0,0 +1,40 @@
+[project]
+name = "ddsql"
+description = "SQL Query Library"
+version = "0.1.0"
+authors = [{ name = "davyddd" }]
+license = "MIT"
+license-files = ["LICENSE"]
+readme = "README.md"
+requires-python = ">=3.11,<3.15"
+keywords = ["python", "ddsql"]
+dependencies = [
+    "ddutils>=0.2.0,<0.3.0",
+    "jinja2>=3.0.0,<4.0.0",
+]
+
+[project.urls]
+Repository = "https://github.com/davyddd/ddsql"
+
+[dependency-groups]
+dev = [
+    "ipdb==0.13.13",
+    "ipython==9.16.1",
+]
+test = [
+    "pytest==9.0.3",
+    "pytest-cov==5.0.0",
+    "parameterized==0.9.0",
+]
+linter = [
+    "ruff==0.15.10",
+    "ty==0.0.15",
+    "complexipy==8.0.1",
+]
+
+[tool.uv.build-backend]
+module-root = ""
+
+[build-system]
+requires = ["uv_build>=0.12.0,<0.13.0"]
+build-backend = "uv_build"

ddsql-0.0.3/pyproject.toml

@@ -1,33 +0,0 @@
-[tool.poetry]
-name = "ddsql"
-description = "SQL Query Library"
-version = "0.0.3"
-authors = ["davyddd"]
-license = "MIT"
-repository = "https://github.com/davyddd/ddsql"
-readme = "README.md"
-keywords = ["python", "ddsql"]
-packages = [{include = "ddsql"}]
-
-[tool.poetry.dependencies]
-python = ">=3.9,<3.15"
-ddutils = "<0.2.0"
-jinja2 = ">=3.0.0,<4.0.0"
-
-[tool.poetry.group.dev.dependencies]
-ipdb = "0.13.9"
-ipython = "8.12.3"
-
-[tool.poetry.group.test.dependencies]
-pytest = "8.1.1"
-pytest-cov = "5.0.0"
-parameterized = "0.9.0"
-typing-extensions = "^4.12.2"
-
-[tool.poetry.group.linter.dependencies]
-mypy = "1.18.2"
-ruff = "0.14.4"
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"