TypeDAL 3.7.0__tar.gz → 3.8.0__tar.gz

{typedal-3.7.0 → typedal-3.8.0}/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 <!--next-version-placeholder-->
 
+## v3.8.0 (2024-10-11)
+
+### Feature
+
+* Add `_sql()` function to TypedTable to generate SQL Schema code. (only if 'migration' extra/pydal2sql is installed) ([`31f86de`](https://github.com/trialandsuccess/TypeDAL/commit/31f86de30cc53cf320f6231c27dd545103b50d10))
+* Add FieldSettings typed dict for better hinting for options when creating a TypedField() or any of the fields using it ([`97a7c7a`](https://github.com/trialandsuccess/TypeDAL/commit/97a7c7ad6112a6098088c44bbc6ae438bbfc0040))
+* Add custom TypedFields for timestamp, point and uuid (valid types in postgres and sqlite is okay with anything) ([`a7bc9d1`](https://github.com/trialandsuccess/TypeDAL/commit/a7bc9d1b7ab0c88d4937956a68305b4d61a0851f))
+* Started on custom types (timestamp) ([`981da83`](https://github.com/trialandsuccess/TypeDAL/commit/981da83cc8f4fec442b2cf74e0b555ce0633f96a))
+
+## v3.7.1 (2024-10-09)
+
+### Fix
+
+* Prepare for python 3.13 (-> cgi dependency, changes in forward reference evaluation); except psycopg2 ([`bbcca8f`](https://github.com/trialandsuccess/TypeDAL/commit/bbcca8f7a5d2f8a6ddc8caf3a1b05fde3ed2fdd2))
+* Require legacy-cgi for python 3.13+ ([`7ba9489`](https://github.com/trialandsuccess/TypeDAL/commit/7ba94898cde600008a350e718783a4d0dbc05e45))
+
+### Documentation
+
+* **readme:** Include `from typedal.helpers import get_db` in example ([`8853052`](https://github.com/trialandsuccess/TypeDAL/commit/8853052575b4576945901eb87da94bf709e99526))
+
 ## v3.7.0 (2024-08-17)
 
 ### Feature

{typedal-3.7.0 → typedal-3.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: TypeDAL
-Version: 3.7.0
+Version: 3.8.0
 Summary: Typing support for PyDAL
 Project-URL: Documentation, https://typedal.readthedocs.io/
 Project-URL: Issues, https://github.com/trialandsuccess/TypeDAL/issues
@@ -12,16 +12,18 @@ Classifier: Programming Language :: Python
 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 :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
 Requires-Dist: configurable-json
 Requires-Dist: configuraptor>=1.26.2
 Requires-Dist: dill
+Requires-Dist: legacy-cgi; python_version >= '3.13'
 Requires-Dist: pydal
 Requires-Dist: python-slugify
 Provides-Extra: all
-Requires-Dist: edwh-migrate>=0.8.0; extra == 'all'
+Requires-Dist: edwh-migrate[full]>=0.8.0; extra == 'all'
 Requires-Dist: py4web; extra == 'all'
 Requires-Dist: pydal2sql[all]>=1.2.0; extra == 'all'
 Requires-Dist: questionary; extra == 'all'
@@ -318,6 +320,8 @@ These helpers are useful for scenarios where direct access to the PyDAL objects
 An example of this is when you need to do a `db.commit()` but you can't import `db` directly:
 
 ```python
+from typedal.helpers import get_db #, get_table, get_field
+
 MyTable.insert(...)
 db = get_db(MyTable)
 db.commit() # this is usually done automatically but sometimes you want to manually commit.

{typedal-3.7.0 → typedal-3.8.0}/README.md

@@ -264,6 +264,8 @@ These helpers are useful for scenarios where direct access to the PyDAL objects
 An example of this is when you need to do a `db.commit()` but you can't import `db` directly:
 
 ```python
+from typedal.helpers import get_db #, get_table, get_field
+
 MyTable.insert(...)
 db = get_db(MyTable)
 db.commit() # this is usually done automatically but sometimes you want to manually commit.

{typedal-3.7.0 → typedal-3.8.0}/example_new.py

@@ -19,6 +19,8 @@ class Person(TypedTable):
     age = TypedField(int, default=18)
     nicknames: list[str]
 
+    ts = TypedField(dt.datetime, type="timestamp")
+
 
 assert db.person._format == "%(name)s"
 

{typedal-3.7.0 → typedal-3.8.0}/pyproject.toml

@@ -19,6 +19,7 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: Implementation :: PyPy",
 ]
@@ -28,6 +29,7 @@ dependencies = [
     "configuraptor >= 1.26.2", # config
     "Configurable-JSON", # json dumping
     "python-slugify",
+    "legacy-cgi; python_version >= '3.13'"
 ]
 
 [project.optional-dependencies]
@@ -49,7 +51,7 @@ all = [
     "typer",
     "tabulate",
     "pydal2sql[all]>=1.2.0",
-    "edwh-migrate>=0.8.0",
+    "edwh-migrate[full]>=0.8.0",
     "questionary",
     "tomlkit",
 ]

{typedal-3.7.0 → typedal-3.8.0}/src/typedal/__about__.py

@@ -5,4 +5,4 @@ This file contains the Version info for this package.
 # SPDX-FileCopyrightText: 2023-present Robin van der Noord <robinvandernoord@gmail.com>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "3.7.0"
+__version__ = "3.8.0"

{typedal-3.7.0 → typedal-3.8.0}/src/typedal/core.py

@@ -8,6 +8,7 @@ import datetime as dt
 import inspect
 import json
 import math
+import sys
 import types
 import typing
 import warnings
@@ -47,6 +48,7 @@ from .types import (
     CacheMetadata,
     Expression,
     Field,
+    FieldSettings,
     Metadata,
     OpRow,
     PaginateDict,
@@ -339,6 +341,22 @@ def to_relationship(
     return Relationship(typing.cast(type[TypedTable], field), condition, typing.cast(JOIN_OPTIONS, join))
 
 
+def evaluate_forward_reference(fw_ref: typing.ForwardRef) -> type:
+    """
+    Extract the original type from a forward reference string.
+    """
+    kwargs = dict(
+        localns=locals(),
+        globalns=globals(),
+        recursive_guard=frozenset(),
+    )
+    if sys.version_info >= (3, 13):  # pragma: no cover
+        # suggested since 3.13 (warning) and not supported before. Mandatory after 1.15!
+        kwargs["type_params"] = ()
+
+    return fw_ref._evaluate(**kwargs)  # type: ignore
+
+
 class TypeDAL(pydal.DAL):  # type: ignore
     """
     Drop-in replacement for pyDAL with layer to convert class-based table definitions to classical pydal define_tables.
@@ -465,6 +483,7 @@ class TypeDAL(pydal.DAL):  # type: ignore
         # when __future__.annotations is implemented, cls.__annotations__ will not work anymore as below.
         # proper way to handle this would be (but gives error right now due to Table implementing magic methods):
         # typing.get_type_hints(cls, globalns=None, localns=None)
+        # -> ERR e.g. `pytest -svxk cli` -> name 'BestFriend' is not defined
 
         # dirty way (with evil eval):
         # [eval(v) for k, v in cls.__annotations__.items()]
@@ -519,7 +538,9 @@ class TypeDAL(pydal.DAL):  # type: ignore
         # }
 
         # keys of implicit references (also relationships):
-        reference_field_keys = [k for k, v in fields.items() if v.type.split(" ")[0] in ("list:reference", "reference")]
+        reference_field_keys = [
+            k for k, v in fields.items() if str(v.type).split(" ")[0] in ("list:reference", "reference")
+        ]
 
         # add implicit relationships:
         # User; list[User]; TypedField[User]; TypedField[list[User]]
@@ -663,7 +684,9 @@ class TypeDAL(pydal.DAL):  # type: ignore
 
     @classmethod
     def _build_field(cls, name: str, _type: str, **kw: Any) -> Field:
-        return Field(name, _type, **{**cls.default_kwargs, **kw})
+        # return Field(name, _type, **{**cls.default_kwargs, **kw})
+        kw_combined = cls.default_kwargs | kw
+        return Field(name, _type, **kw_combined)
 
     @classmethod
     def _annotation_to_pydal_fieldtype(
@@ -674,9 +697,8 @@ class TypeDAL(pydal.DAL):  # type: ignore
 
         if isinstance(ftype, str):
             # extract type from string
-            ftype = typing.get_args(Type[ftype])[0]._evaluate(
-                localns=locals(), globalns=globals(), recursive_guard=frozenset()
-            )
+            fw_ref: typing.ForwardRef = typing.get_args(Type[ftype])[0]
+            ftype = evaluate_forward_reference(fw_ref)
 
         if mapping := BASIC_MAPPINGS.get(ftype):
             # basi types
@@ -741,6 +763,7 @@ class TypeDAL(pydal.DAL):  # type: ignore
         """
         fname = cls.to_snake(fname)
 
+        # note: 'kw' is updated in `_annotation_to_pydal_fieldtype` by the kwargs provided to the TypedField(...)
         if converted_type := cls._annotation_to_pydal_fieldtype(ftype, kw):
             return cls._build_field(fname, converted_type, **kw)
         else:
@@ -1144,7 +1167,7 @@ class TableMeta(type):
         """
         Add a before insert hook.
         """
-        cls._before_insert.append(fn)  # type: ignore
+        cls._before_insert.append(fn)
         return cls
 
     def after_insert(
@@ -1157,7 +1180,7 @@ class TableMeta(type):
         """
         Add an after insert hook.
         """
-        cls._after_insert.append(fn)  # type: ignore
+        cls._after_insert.append(fn)
         return cls
 
     def before_update(
@@ -1167,7 +1190,7 @@ class TableMeta(type):
         """
         Add a before update hook.
         """
-        cls._before_update.append(fn)  # type: ignore
+        cls._before_update.append(fn)
         return cls
 
     def after_update(
@@ -1177,7 +1200,7 @@ class TableMeta(type):
         """
         Add an after update hook.
         """
-        cls._after_update.append(fn)  # type: ignore
+        cls._after_update.append(fn)
         return cls
 
     def before_delete(cls: Type[T_MetaInstance], fn: typing.Callable[[Set], Optional[bool]]) -> Type[T_MetaInstance]:
@@ -1212,9 +1235,16 @@ class TypedField(Expression, typing.Generic[T_Value]):  # pragma: no cover
 
     requires: Validator | typing.Iterable[Validator]
 
-    def __init__(self, _type: Type[T_Value] | types.UnionType = str, /, **settings: Any) -> None:  # type: ignore
+    # NOTE: for the logic of converting a TypedField into a pydal Field, see TypeDAL._to_field
+
+    def __init__(
+        self, _type: Type[T_Value] | types.UnionType = str, /, **settings: Unpack[FieldSettings]  # type: ignore
+    ) -> None:
         """
-        A TypedFieldType should not be inited manually, but TypedField (from `fields.py`) should be used!
+        Typed version of pydal.Field, which will be converted to a normal Field in the background.
+
+        Provide the Python type for this field as the first positional argument
+        and any other settings to Field() as keyword parameters.
         """
         self._type = _type
         self.kwargs = settings
@@ -1289,9 +1319,11 @@ class TypedField(Expression, typing.Generic[T_Value]):  # pragma: no cover
     def _to_field(self, extra_kwargs: typing.MutableMapping[str, Any]) -> Optional[str]:
         """
         Convert a Typed Field instance to a pydal.Field.
+
+        Actual logic in TypeDAL._to_field but this function creates the pydal type name and updates the kwarg settings.
         """
         other_kwargs = self.kwargs.copy()
-        extra_kwargs.update(other_kwargs)
+        extra_kwargs.update(other_kwargs)  # <- modifies and overwrites the default kwargs with user-specified ones
         return extra_kwargs.pop("type", False) or TypeDAL._annotation_to_pydal_fieldtype(self._type, extra_kwargs)
 
     def bind(self, field: pydal.objects.Field, table: pydal.objects.Table) -> None:
@@ -1738,6 +1770,18 @@ class TypedTable(_TypedTable, metaclass=TableMeta):
         state["_row"] = Row(json.loads(state["_row"]))
         self.__dict__ |= state
 
+    @classmethod
+    def _sql(cls) -> str:
+        """
+        Generate SQL Schema for this table via pydal2sql (if 'migrations' extra is installed).
+        """
+        try:
+            import pydal2sql
+        except ImportError as e:  # pragma: no cover
+            raise RuntimeError("Can not generate SQL without the 'migration' extra or `pydal2sql` installed!") from e
+
+        return pydal2sql.generate_sql(cls)
+
 
 # backwards compat:
 TypedRow = TypedTable

{typedal-3.7.0 → typedal-3.8.0}/src/typedal/fields.py

@@ -2,13 +2,18 @@
 This file contains available Field types.
 """
 
+import ast
 import datetime as dt
 import decimal
 import typing
+import uuid
 
+from pydal.helpers.classes import SQLCustomType
 from pydal.objects import Table
+from typing_extensions import Unpack
 
 from .core import TypeDAL, TypedField, TypedTable
+from .types import FieldSettings
 
 T = typing.TypeVar("T", bound=typing.Any)
 
@@ -16,23 +21,8 @@ T = typing.TypeVar("T", bound=typing.Any)
 ## general
 
 
-# def TypedField(
-#     _type: typing.Type[T] | types.UnionType,
-#     **kwargs: typing.Any,
-# ) -> T:
-#     """
-#     sneaky: its a function and not a class, because there's a return type.
-#
-#     and the return type (T) is the input type in _type
-#
-#     Example:
-#         age: TypedField(int, default=18)
-#     """
-#     return typing.cast(T, TypedFieldType(_type, **kwargs))
-
-
 ## specific
-def StringField(**kw: typing.Any) -> TypedField[str]:
+def StringField(**kw: Unpack[FieldSettings]) -> TypedField[str]:
     """
     Pydal type is string, Python type is str.
     """
@@ -43,7 +33,7 @@ def StringField(**kw: typing.Any) -> TypedField[str]:
 String = StringField
 
 
-def TextField(**kw: typing.Any) -> TypedField[str]:
+def TextField(**kw: Unpack[FieldSettings]) -> TypedField[str]:
     """
     Pydal type is text, Python type is str.
     """
@@ -54,7 +44,7 @@ def TextField(**kw: typing.Any) -> TypedField[str]:
 Text = TextField
 
 
-def BlobField(**kw: typing.Any) -> TypedField[bytes]:
+def BlobField(**kw: Unpack[FieldSettings]) -> TypedField[bytes]:
     """
     Pydal type is blob, Python type is bytes.
     """
@@ -65,7 +55,7 @@ def BlobField(**kw: typing.Any) -> TypedField[bytes]:
 Blob = BlobField
 
 
-def BooleanField(**kw: typing.Any) -> TypedField[bool]:
+def BooleanField(**kw: Unpack[FieldSettings]) -> TypedField[bool]:
     """
     Pydal type is boolean, Python type is bool.
     """
@@ -76,7 +66,7 @@ def BooleanField(**kw: typing.Any) -> TypedField[bool]:
 Boolean = BooleanField
 
 
-def IntegerField(**kw: typing.Any) -> TypedField[int]:
+def IntegerField(**kw: Unpack[FieldSettings]) -> TypedField[int]:
     """
     Pydal type is integer, Python type is int.
     """
@@ -87,7 +77,7 @@ def IntegerField(**kw: typing.Any) -> TypedField[int]:
 Integer = IntegerField
 
 
-def DoubleField(**kw: typing.Any) -> TypedField[float]:
+def DoubleField(**kw: Unpack[FieldSettings]) -> TypedField[float]:
     """
     Pydal type is double, Python type is float.
     """
@@ -98,7 +88,7 @@ def DoubleField(**kw: typing.Any) -> TypedField[float]:
 Double = DoubleField
 
 
-def DecimalField(n: int, m: int, **kw: typing.Any) -> TypedField[decimal.Decimal]:
+def DecimalField(n: int, m: int, **kw: Unpack[FieldSettings]) -> TypedField[decimal.Decimal]:
     """
     Pydal type is decimal, Python type is Decimal.
     """
@@ -109,7 +99,7 @@ def DecimalField(n: int, m: int, **kw: typing.Any) -> TypedField[decimal.Decimal
 Decimal = DecimalField
 
 
-def DateField(**kw: typing.Any) -> TypedField[dt.date]:
+def DateField(**kw: Unpack[FieldSettings]) -> TypedField[dt.date]:
     """
     Pydal type is date, Python type is datetime.date.
     """
@@ -120,7 +110,7 @@ def DateField(**kw: typing.Any) -> TypedField[dt.date]:
 Date = DateField
 
 
-def TimeField(**kw: typing.Any) -> TypedField[dt.time]:
+def TimeField(**kw: Unpack[FieldSettings]) -> TypedField[dt.time]:
     """
     Pydal type is time, Python type is datetime.time.
     """
@@ -131,7 +121,7 @@ def TimeField(**kw: typing.Any) -> TypedField[dt.time]:
 Time = TimeField
 
 
-def DatetimeField(**kw: typing.Any) -> TypedField[dt.datetime]:
+def DatetimeField(**kw: Unpack[FieldSettings]) -> TypedField[dt.datetime]:
     """
     Pydal type is datetime, Python type is datetime.datetime.
     """
@@ -142,7 +132,7 @@ def DatetimeField(**kw: typing.Any) -> TypedField[dt.datetime]:
 Datetime = DatetimeField
 
 
-def PasswordField(**kw: typing.Any) -> TypedField[str]:
+def PasswordField(**kw: Unpack[FieldSettings]) -> TypedField[str]:
     """
     Pydal type is password, Python type is str.
     """
@@ -153,7 +143,7 @@ def PasswordField(**kw: typing.Any) -> TypedField[str]:
 Password = PasswordField
 
 
-def UploadField(**kw: typing.Any) -> TypedField[str]:
+def UploadField(**kw: Unpack[FieldSettings]) -> TypedField[str]:
     """
     Pydal type is upload, Python type is str.
     """
@@ -167,7 +157,7 @@ T_subclass = typing.TypeVar("T_subclass", TypedTable, Table)
 
 
 def ReferenceField(
-    other_table: str | typing.Type[TypedTable] | TypedTable | Table | T_subclass, **kw: typing.Any
+    other_table: str | typing.Type[TypedTable] | TypedTable | Table | T_subclass, **kw: Unpack[FieldSettings]
 ) -> TypedField[int]:
     """
     Pydal type is reference, Python type is int (id).
@@ -190,7 +180,7 @@ def ReferenceField(
 Reference = ReferenceField
 
 
-def ListStringField(**kw: typing.Any) -> TypedField[list[str]]:
+def ListStringField(**kw: Unpack[FieldSettings]) -> TypedField[list[str]]:
     """
     Pydal type is list:string, Python type is list of str.
     """
@@ -201,7 +191,7 @@ def ListStringField(**kw: typing.Any) -> TypedField[list[str]]:
 ListString = ListStringField
 
 
-def ListIntegerField(**kw: typing.Any) -> TypedField[list[int]]:
+def ListIntegerField(**kw: Unpack[FieldSettings]) -> TypedField[list[int]]:
     """
     Pydal type is list:integer, Python type is list of int.
     """
@@ -212,7 +202,7 @@ def ListIntegerField(**kw: typing.Any) -> TypedField[list[int]]:
 ListInteger = ListIntegerField
 
 
-def ListReferenceField(other_table: str, **kw: typing.Any) -> TypedField[list[int]]:
+def ListReferenceField(other_table: str, **kw: Unpack[FieldSettings]) -> TypedField[list[int]]:
     """
     Pydal type is list:reference, Python type is list of int (id).
     """
@@ -223,7 +213,7 @@ def ListReferenceField(other_table: str, **kw: typing.Any) -> TypedField[list[in
 ListReference = ListReferenceField
 
 
-def JSONField(**kw: typing.Any) -> TypedField[object]:
+def JSONField(**kw: Unpack[FieldSettings]) -> TypedField[object]:
     """
     Pydal type is json, Python type is object (can be anything JSON-encodable).
     """
@@ -231,7 +221,7 @@ def JSONField(**kw: typing.Any) -> TypedField[object]:
     return TypedField(object, **kw)
 
 
-def BigintField(**kw: typing.Any) -> TypedField[int]:
+def BigintField(**kw: Unpack[FieldSettings]) -> TypedField[int]:
     """
     Pydal type is bigint, Python type is int.
     """
@@ -240,3 +230,59 @@ def BigintField(**kw: typing.Any) -> TypedField[int]:
 
 
 Bigint = BigintField
+
+## Custom:
+
+NativeTimestampField = SQLCustomType(
+    type="datetime",
+    native="timestamp",
+    encoder=lambda x: f"'{x}'",  # extra quotes
+    # decoder=lambda x: x, # already parsed into datetime
+)
+
+
+def TimestampField(**kw: Unpack[FieldSettings]) -> TypedField[dt.datetime]:
+    """
+    Database type is timestamp, Python type is datetime.
+
+    Advantage over the regular datetime type is that
+    a timestamp has millisecond precision (2024-10-11 20:18:24.505194)
+    whereas a regular datetime only has precision up to the second (2024-10-11 20:18:24)
+    """
+    kw["type"] = NativeTimestampField
+    return TypedField(
+        dt.datetime,
+        **kw,
+    )
+
+
+NativePointField = SQLCustomType(
+    type="string",
+    native="point",
+    encoder=str,
+    decoder=ast.literal_eval,
+)
+
+
+def PointField(**kw: Unpack[FieldSettings]) -> TypedField[tuple[float, float]]:
+    """
+    Database type is point, Python type is tuple[float, float].
+    """
+    kw["type"] = NativePointField
+    return TypedField(tuple[float, float], **kw)
+
+
+NativeUUIDField = SQLCustomType(
+    type="string",
+    native="uuid",
+    encoder=str,
+    decoder=uuid.UUID,
+)
+
+
+def UUIDField(**kw: Unpack[FieldSettings]) -> TypedField[uuid.UUID]:
+    """
+    Database type is uuid, Python type is UUID.
+    """
+    kw["type"] = NativeUUIDField
+    return TypedField(uuid.UUID, **kw)

{typedal-3.7.0 → typedal-3.8.0}/src/typedal/types.py

@@ -4,11 +4,12 @@ Stuff to make mypy happy.
 
 import typing
 from datetime import datetime
-from typing import Any, Optional, TypedDict
+from typing import Any, Callable, Optional, TypedDict
 
 from pydal.adapters.base import BaseAdapter
 from pydal.helpers.classes import OpRow as _OpRow
 from pydal.helpers.classes import Reference as _Reference
+from pydal.helpers.classes import SQLCustomType
 from pydal.objects import Expression as _Expression
 from pydal.objects import Field as _Field
 from pydal.objects import Query as _Query
@@ -218,7 +219,7 @@ CacheModel = typing.Callable[[str, CacheFn, int], Rows]
 CacheTuple = tuple[CacheModel, int]
 
 
-class SelectKwargs(typing.TypedDict, total=False):
+class SelectKwargs(TypedDict, total=False):
     """
     Possible keyword arguments for .select().
     """
@@ -250,3 +251,65 @@ class Metadata(TypedDict):
     relationships: NotRequired[set[str]]
 
     sql: NotRequired[str]
+
+
+class FileSystemLike(typing.Protocol):  # pragma: no cover
+    """
+    Protocol for any class that has an 'open' function.
+
+    An example of this is OSFS from PyFilesystem2.
+    """
+
+    def open(self, file: str, mode: str = "r") -> typing.IO[typing.Any]:
+        """
+        Opens a file for reading, writing or other modes.
+        """
+        ...
+
+
+AnyCallable: typing.TypeAlias = Callable[..., Any]
+
+
+class FieldSettings(TypedDict, total=False):
+    """
+    The supported keyword arguments for `pydal.Field()`.
+
+    Other arguments can be passed.
+    """
+
+    type: str | type | SQLCustomType
+    length: int
+    default: Any
+    required: bool
+    requires: list[AnyCallable | Any]
+    ondelete: str
+    onupdate: str
+    notnull: bool
+    unique: bool
+    uploadfield: bool | str
+    widget: AnyCallable
+    label: str
+    comment: str
+    writable: bool
+    readable: bool
+    searchable: bool
+    listable: bool
+    regex: str
+    options: list[Any] | AnyCallable
+    update: Any
+    authorize: AnyCallable
+    autodelete: bool
+    represent: AnyCallable
+    uploadfolder: str
+    uploadseparate: bool
+    uploadfs: FileSystemLike
+    compute: AnyCallable
+    custom_store: AnyCallable
+    custom_retrieve: AnyCallable
+    custom_retrieve_file_properties: AnyCallable
+    custom_delete: AnyCallable
+    filter_in: AnyCallable
+    filter_out: AnyCallable
+    custom_qualifier: Any
+    map_none: Any
+    rname: str

typedal-3.8.0/tests/test_config.py

@@ -0,0 +1,315 @@
+import os
+import shutil
+import tempfile
+from pathlib import Path
+import datetime as dt
+import uuid
+
+from pydal2sql import generate_sql
+import pytest
+# from contextlib import chdir
+from contextlib_chdir import chdir
+from testcontainers.postgres import PostgresContainer
+
+from src.typedal import TypeDAL, TypedTable, TypedField
+from src.typedal.config import (
+    _load_dotenv,
+    _load_toml,
+    expand_env_vars_into_toml_values,
+    load_config,
+)
+from src.typedal.fields import TimestampField, PointField, UUIDField
+
+postgres = PostgresContainer(
+    dbname="postgres",
+    username="someuser",
+    password="somepass",
+)
+
+
+@pytest.fixture(scope="module", autouse=True)
+def psql(request):
+    postgres.ports = {
+        5432: 9631,  # as set in valid.env
+    }
+
+    request.addfinalizer(postgres.stop)
+    postgres.start()
+
+
+@pytest.fixture
+def at_temp_dir():
+    with tempfile.TemporaryDirectory() as d:
+        with chdir(d):
+            yield d
+
+
+def _load_db_after_setup(dialect: str):
+    config = load_config()
+    db = TypeDAL(attempts=1)
+    assert db._uri == config.database
+
+    assert f"'dialect': '{dialect}'" in repr(config)
+
+    return True
+
+
+def test_load_toml(at_temp_dir):
+    base = Path("pyproject.toml")
+    base.write_text("# empty")
+
+    assert _load_toml(False) == ("", {})
+    assert _load_toml(None) == (str(base.resolve().absolute()), {})
+    assert _load_toml(str(base)) == ("pyproject.toml", {})
+    assert _load_toml(".") == (str(base.resolve().absolute()), {})
+
+
+def test_load_dotenv(at_temp_dir):
+    base = Path(".env")
+    base.write_text("# empty")
+
+    assert _load_dotenv(False)[0] == ""
+    assert _load_dotenv(None)[0] == str(base.resolve().absolute())
+    assert _load_dotenv(str(base))[0] == ".env"
+    assert _load_dotenv(".")[0] == ".env"
+
+
+def test_load_empty_config(at_temp_dir):
+    assert _load_db_after_setup("sqlite")
+
+
+def test_load_toml_config(at_temp_dir):
+    examples = Path(__file__).parent / "configs"
+    shutil.copy(examples / "valid.toml", "./pyproject.toml")
+
+    assert _load_db_after_setup("sqlite")
+
+
+def test_load_env_config(at_temp_dir):
+    examples = Path(__file__).parent / "configs"
+    shutil.copy(examples / "valid.env", "./.env")
+
+    assert _load_db_after_setup("postgres")
+
+
+def test_load_simple_config(at_temp_dir):
+    examples = Path(__file__).parent / "configs"
+    shutil.copy(examples / "valid.env", "./.env")
+    shutil.copy(examples / "simple.toml", "./pyproject.toml")
+
+    assert _load_db_after_setup("postgres")
+
+
+def test_load_both_config(at_temp_dir):
+    examples = Path(__file__).parent / "configs"
+    shutil.copy(examples / "valid.env", "./.env")
+    shutil.copy(examples / "valid.toml", "./pyproject.toml")
+
+    assert _load_db_after_setup("postgres")
+
+
+def test_converting(at_temp_dir):
+    from edwh_migrate import Config as MigrateConfig
+    from pydal2sql.typer_support import Config as P2SConfig
+
+    config = load_config()
+
+    assert isinstance(config.to_migrate(), MigrateConfig)
+    assert isinstance(config.to_pydal2sql(), P2SConfig)
+
+
+def test_environ(at_temp_dir):
+    os.environ["DB_URI"] = "sqlite:///tmp/db.sqlite"
+    config = load_config(False, True)
+
+    assert config.database == "sqlite:///tmp/db.sqlite"
+
+
+def test_expand_env_vars():
+    # str
+    input_str = "${MYVALUE:default}"
+    data = {"myvar": input_str}
+    expand_env_vars_into_toml_values(data, {})
+    assert data["myvar"] == input_str
+
+    expand_env_vars_into_toml_values(data, {"unrelated": "data"})
+    assert data["myvar"] == "default"
+
+    data = {"myvar": input_str}
+    expand_env_vars_into_toml_values(data, {"myvalue": "123"})
+
+    assert data["myvar"] == "123"
+
+    # list
+    data = {"myvar": [input_str, input_str]}
+    expand_env_vars_into_toml_values(data, {"myvalue": "456"})
+
+    assert data["myvar"] == ["456", "456"]
+
+    # dict
+    data = {"myvar": {"value": input_str}}
+    expand_env_vars_into_toml_values(data, {"myvalue": "789"})
+    assert data["myvar"]["value"] == "789"
+
+    # other - non-str
+    data = {"myvar": None, "mynumber": 123}
+    expand_env_vars_into_toml_values(data, {"myvalue": "789"})
+    assert data["myvar"] is None
+    assert data["mynumber"] == 123
+
+
+# note: these are not really 'config' specific but we already have access to postgres here so good enough:
+
+def test_timestamp_fields_sqlite(at_temp_dir):
+    db = TypeDAL("sqlite:memory")
+
+    class Timestamp(TypedTable):
+        ts = TimestampField(default=dt.datetime.now)
+        dt = TypedField(dt.datetime, default=dt.datetime.now)
+
+    db.define(Timestamp)
+
+    row = Timestamp.insert()
+
+    # old:
+    assert isinstance(row.dt, dt.datetime), "not a datetime"
+    assert "." not in str(row.dt)  # no ms precision
+
+    # new:
+    assert isinstance(row.ts, dt.datetime), "not a datetime"
+    assert "." in str(row.ts)  # ms precision
+
+    assert '"ts" timestamp NOT NULL' in Timestamp._sql()
+
+
+def test_timestamp_fields_psql(at_temp_dir):
+    examples = Path(__file__).parent / "configs"
+    shutil.copy(examples / "valid.env", "./.env")
+    shutil.copy(examples / "simple.toml", "./pyproject.toml")
+
+    assert _load_db_after_setup("postgres")
+    db = TypeDAL(attempts=1)
+
+    class Timestamp(TypedTable):
+        ts = TimestampField(default=dt.datetime.now)
+        dt = TypedField(dt.datetime, default=dt.datetime.now)
+
+    db.define(Timestamp)
+
+    row = Timestamp.insert()
+
+    # old:
+    assert isinstance(row.dt, dt.datetime), "not a datetime"
+    assert "." not in str(row.dt)  # no ms precision
+
+    # new:
+    assert isinstance(row.ts, dt.datetime), "not a datetime"
+    assert "." in str(row.ts)  # ms precision
+
+    assert '"ts" timestamp NOT NULL' in Timestamp._sql()
+
+
+def test_point_fields_sqlite(at_temp_dir):
+    db = TypeDAL("sqlite:memory")
+
+    class Point(TypedTable):
+        pt = PointField()
+
+    db.define(Point)
+
+    row1 = Point.insert(pt=(1, 0))
+    row2 = Point.insert(pt="(1, 0)")
+
+    assert row1.pt == row2.pt
+
+    x, y = row1.pt
+    assert x == 1
+    assert y == 0
+
+    with pytest.raises(Exception):
+        Point.insert(pt=123)
+
+    with pytest.raises(Exception):
+        Point.insert(pt="123")
+
+    # note: psql will check this whereas sqlite won't:
+    Point.insert(pt=())
+
+    assert '"pt" point NOT NULL' in Point._sql()
+
+
+def test_point_fields_psql(at_temp_dir):
+    examples = Path(__file__).parent / "configs"
+    shutil.copy(examples / "valid.env", "./.env")
+    shutil.copy(examples / "simple.toml", "./pyproject.toml")
+
+    assert _load_db_after_setup("postgres")
+    db = TypeDAL(attempts=1)
+
+    class Point(TypedTable):
+        pt = PointField()
+
+    db.define(Point)
+
+    row1 = Point.insert(pt=(1, 0))
+    row2 = Point.insert(pt="(1, 0)")
+
+    assert row1.pt == row2.pt
+
+    x, y = row1.pt
+    assert x == 1
+    assert y == 0
+
+    with pytest.raises(Exception):
+        Point.insert(pt=123)
+
+    with pytest.raises(Exception):
+        Point.insert(pt="123")
+
+    # note: psql will check this whereas sqlite won't:
+
+    with pytest.raises(Exception):
+        Point.insert(pt=())
+
+    assert '"pt" point NOT NULL' in Point._sql()
+
+
+def test_uuid_fields_psql(at_temp_dir):
+    examples = Path(__file__).parent / "configs"
+    shutil.copy(examples / "valid.env", "./.env")
+    shutil.copy(examples / "simple.toml", "./pyproject.toml")
+
+    assert _load_db_after_setup("postgres")
+    db = TypeDAL(attempts=1)
+
+    class UUIDTable(TypedTable):
+        gid = UUIDField(default=uuid.uuid4)
+
+    db.define(UUIDTable)
+
+    row = UUIDTable.insert()
+
+    assert isinstance(row.gid, uuid.UUID)
+
+    with pytest.raises(Exception):
+        UUIDTable.insert(gid="not-a-uuid")
+
+    assert '"gid" uuid NOT NULL' in UUIDTable._sql()
+
+
+def test_uuid_fields_sqlite(at_temp_dir):
+    db = TypeDAL("sqlite:memory")
+
+    class UUIDTable(TypedTable):
+        gid = UUIDField(default=uuid.uuid4)
+
+    db.define(UUIDTable)
+
+    row = UUIDTable.insert()
+
+    assert isinstance(row.gid, uuid.UUID)
+
+    with pytest.raises(Exception):
+        UUIDTable.insert(gid="not-a-uuid")
+
+    assert '"gid" uuid NOT NULL' in UUIDTable._sql()

typedal-3.7.0/tests/test_config.py

@@ -1,155 +0,0 @@
-import os
-import shutil
-import tempfile
-from pathlib import Path
-
-import pytest
-
-# from contextlib import chdir
-from contextlib_chdir import chdir
-from testcontainers.postgres import PostgresContainer
-
-from src.typedal import TypeDAL
-from src.typedal.config import (
-    _load_dotenv,
-    _load_toml,
-    expand_env_vars_into_toml_values,
-    load_config,
-)
-
-postgres = PostgresContainer(
-    dbname="postgres",
-    username="someuser",
-    password="somepass",
-)
-
-
-@pytest.fixture(scope="module", autouse=True)
-def psql(request):
-    postgres.ports = {
-        5432: 9631,  # as set in valid.env
-    }
-
-    request.addfinalizer(postgres.stop)
-    postgres.start()
-
-
-@pytest.fixture
-def at_temp_dir():
-    with tempfile.TemporaryDirectory() as d:
-        with chdir(d):
-            yield d
-
-
-def _load_db_after_setup(dialect: str):
-    config = load_config()
-    db = TypeDAL(attempts=1)
-    assert db._uri == config.database
-
-    assert f"'dialect': '{dialect}'" in repr(config)
-
-    return True
-
-
-def test_load_toml(at_temp_dir):
-    base = Path("pyproject.toml")
-    base.write_text("# empty")
-
-    assert _load_toml(False) == ("", {})
-    assert _load_toml(None) == (str(base.resolve().absolute()), {})
-    assert _load_toml(str(base)) == ("pyproject.toml", {})
-    assert _load_toml(".") == (str(base.resolve().absolute()), {})
-
-
-def test_load_dotenv(at_temp_dir):
-    base = Path(".env")
-    base.write_text("# empty")
-
-    assert _load_dotenv(False)[0] == ""
-    assert _load_dotenv(None)[0] == str(base.resolve().absolute())
-    assert _load_dotenv(str(base))[0] == ".env"
-    assert _load_dotenv(".")[0] == ".env"
-
-
-def test_load_empty_config(at_temp_dir):
-    assert _load_db_after_setup("sqlite")
-
-
-def test_load_toml_config(at_temp_dir):
-    examples = Path(__file__).parent / "configs"
-    shutil.copy(examples / "valid.toml", "./pyproject.toml")
-
-    assert _load_db_after_setup("sqlite")
-
-
-def test_load_env_config(at_temp_dir):
-    examples = Path(__file__).parent / "configs"
-    shutil.copy(examples / "valid.env", "./.env")
-
-    assert _load_db_after_setup("postgres")
-
-
-def test_load_simple_config(at_temp_dir):
-    examples = Path(__file__).parent / "configs"
-    shutil.copy(examples / "valid.env", "./.env")
-    shutil.copy(examples / "simple.toml", "./pyproject.toml")
-
-    assert _load_db_after_setup("postgres")
-
-
-def test_load_both_config(at_temp_dir):
-    examples = Path(__file__).parent / "configs"
-    shutil.copy(examples / "valid.env", "./.env")
-    shutil.copy(examples / "valid.toml", "./pyproject.toml")
-
-    assert _load_db_after_setup("postgres")
-
-
-def test_converting(at_temp_dir):
-    from edwh_migrate import Config as MigrateConfig
-    from pydal2sql.typer_support import Config as P2SConfig
-
-    config = load_config()
-
-    assert isinstance(config.to_migrate(), MigrateConfig)
-    assert isinstance(config.to_pydal2sql(), P2SConfig)
-
-
-def test_environ(at_temp_dir):
-    os.environ["DB_URI"] = "sqlite:///tmp/db.sqlite"
-    config = load_config(False, True)
-
-    assert config.database == "sqlite:///tmp/db.sqlite"
-
-
-def test_expand_env_vars():
-    # str
-    input_str = "${MYVALUE:default}"
-    data = {"myvar": input_str}
-    expand_env_vars_into_toml_values(data, {})
-    assert data["myvar"] == input_str
-
-    expand_env_vars_into_toml_values(data, {"unrelated": "data"})
-    assert data["myvar"] == "default"
-
-    data = {"myvar": input_str}
-    expand_env_vars_into_toml_values(data, {"myvalue": "123"})
-
-    assert data["myvar"] == "123"
-
-    # list
-    data = {"myvar": [input_str, input_str]}
-    expand_env_vars_into_toml_values(data, {"myvalue": "456"})
-
-    assert data["myvar"] == ["456", "456"]
-
-    # dict
-    data = {"myvar": {"value": input_str}}
-    expand_env_vars_into_toml_values(data, {"myvalue": "789"})
-    assert data["myvar"]["value"] == "789"
-
-    # other - non-str
-    data = {"myvar": None, "mynumber": 123}
-    expand_env_vars_into_toml_values(data, {"myvalue": "789"})
-    assert data["myvar"] is None
-    assert data["mynumber"] == 123