TypeDAL 2.1.5__py3-none-any.whl → 2.2.1__py3-none-any.whl

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__ = "2.1.5"
+__version__ = "2.2.1"

typedal/cli.py

@@ -0,0 +1,375 @@
+"""
+Typer CLI for TypeDAL.
+"""
+import sys
+import typing
+import warnings
+from pathlib import Path
+from typing import Optional
+
+import tomli
+from configuraptor import asdict
+from configuraptor.alias import is_alias
+from configuraptor.helpers import is_optional
+
+try:
+    import edwh_migrate
+    import pydal2sql  # noqa: F401
+    import questionary
+    import rich
+    import tomlkit
+    import typer
+except ImportError as e:  # pragma: no cover
+    # ImportWarning is hidden by default
+    warnings.warn(
+        "`migrations` extra not installed. Please run `pip install typedal[migrations]` to fix this.",
+        source=e,
+        category=RuntimeWarning,
+    )
+    exit(127)  # command not found
+
+from pydal2sql.typer_support import IS_DEBUG, with_exit_code
+from pydal2sql.types import (
+    DBType_Option,
+    OptionalArgument,
+    OutputFormat_Option,
+    Tables_Option,
+)
+from pydal2sql_core import core_alter, core_create
+from typing_extensions import Never
+
+from .__about__ import __version__
+from .config import TypeDALConfig, fill_defaults, load_config, transform
+
+app = typer.Typer(
+    no_args_is_help=True,
+)
+
+questionary_types: dict[typing.Hashable, Optional[dict[str, typing.Any]]] = {
+    str: {
+        "type": "text",
+        "validate": lambda text: True if len(text) > 0 else "Please enter a value",
+    },
+    Optional[str]: {
+        "type": "text",
+        # no validate because it's optional
+    },
+    bool: {
+        "type": "confirm",
+    },
+    int: {"type": "text", "validate": lambda text: True if text.isdigit() else "Please enter a number"},
+    # specific props:
+    "dialect": {
+        "type": "select",
+        "choices": ["sqlite", "postgres", "mysql"],
+    },
+    "folder": {
+        "type": "path",
+        "message": "Database directory:",
+        "only_directories": True,
+        "default": "",
+    },
+    "input": {
+        "type": "path",
+        "message": "Python file containing table definitions.",
+        "file_filter": lambda file: "." not in file or file.endswith(".py"),
+    },
+    "output": {
+        "type": "path",
+        "message": "Python file where migrations will be written to.",
+        "file_filter": lambda file: "." not in file or file.endswith(".py"),
+    },
+    # disabled props:
+    "pyproject": None,
+    "noop": None,
+    # bool: questionary.confirm,
+    # int: questionary.text,
+    # 'pyproject': None,
+    # 'input': questionary.text,
+    # 'output': questionary.text,
+    # 'tables': questionary.print,
+    # 'flag_location': questionary.path,  # directory
+}
+
+T = typing.TypeVar("T")
+
+notfound = object()
+
+
+def _get_question(prop: str, annotation: typing.Type[T]) -> Optional[dict[str, typing.Any]]:  # pragma: no cover
+    question = questionary_types.get(prop, notfound)
+    if question is notfound:
+        # None means skip the question, notfound means use the type default!
+        question = questionary_types.get(annotation)  # type: ignore
+
+    if not question:
+        return None
+    # make a copy so the original is not overwritten:
+    return question.copy()  # type: ignore
+
+
+def get_question(prop: str, annotation: typing.Type[T], default: T | None) -> Optional[T]:  # pragma: no cover
+    """
+    Generate a question based on a config property and prompt the user for it.
+    """
+    if not (question := _get_question(prop, annotation)):
+        return default
+
+    question["name"] = prop
+    question["message"] = question.get("message", f"{prop}? ")
+    default = typing.cast(T, default or question.get("default") or "")
+
+    if annotation == int:
+        default = typing.cast(T, str(default))
+
+    response = questionary.unsafe_prompt([question], default=default)[prop]
+    return typing.cast(T, response)
+
+
+@app.command()
+@with_exit_code(hide_tb=IS_DEBUG)
+def setup(
+    config_file: typing.Annotated[Optional[str], typer.Option("--config", "-c")] = None,
+    minimal: bool = False,
+) -> None:  # pragma: no cover
+    """
+    Setup a [tool.typedal] entry in the local pyproject.toml.
+    """
+    # 1. check if [tool.typedal] in pyproject.toml and ask missing questions (excl .env vars)
+    # 2. else if [tool.migrate] and/or [tool.pydal2sql] exist in the config, ask the user with copied defaults
+    # 3. else: ask the user every question or minimal questions based on cli arg
+
+    config = load_config(config_file)
+
+    toml_path = Path(config.pyproject)
+
+    if not (config.pyproject and toml_path.exists()):
+        # no pyproject.toml found!
+        toml_path = toml_path if config.pyproject else Path("pyproject.toml")
+        rich.print(f"[blue]Config toml doesn't exist yet, creating {toml_path}[/blue]", file=sys.stderr)
+        toml_path.touch()
+
+    toml_contents = toml_path.read_text()
+    # tomli has native Python types, tomlkit doesn't but preserves comments
+    toml_obj: dict[str, typing.Any] = tomli.loads(toml_contents)
+
+    if "[tool.typedal]" in toml_contents:
+        section = toml_obj["tool"]["typedal"]
+        config.update(**section, _overwrite=True)
+
+    if "[tool.pydal2sql]" in toml_contents:
+        mapping = {"": ""}  # <- placeholder
+
+        extra_config = toml_obj["tool"]["pydal2sql"]
+        extra_config = {mapping.get(k, k): v for k, v in extra_config.items()}
+        extra_config.pop("format", None)  # always edwh-migrate
+        config.update(**extra_config)
+
+    if "[tool.migrate]" in toml_contents:
+        mapping = {"migrate_uri": "database"}
+
+        extra_config = toml_obj["tool"]["migrate"]
+        extra_config = {mapping.get(k, k): v for k, v in extra_config.items()}
+
+        config.update(**extra_config)
+
+    data = asdict(config, with_top_level_key=False)
+    data["migrate"] = None  # determined based on existence of input/output file.
+    for prop, annotation in TypeDALConfig.__annotations__.items():
+        if is_alias(config.__class__, prop):
+            # don't store aliases!
+            data.pop(prop, None)
+            continue
+
+        if minimal and getattr(config, prop, None) not in (None, "") or is_optional(annotation):
+            # property already present or not required, SKIP!
+            data[prop] = getattr(config, prop, None)
+            continue
+
+        fill_defaults(data, prop)
+        # default_value = getattr(config, prop, None)
+        default_value = data.get(prop, None)
+        answer: typing.Any = get_question(prop, annotation, default_value)
+
+        if annotation == bool:
+            answer = bool(answer)
+        elif annotation == int:
+            answer = int(answer)
+
+        config.update(**{prop: answer})
+        data[prop] = answer
+
+    for prop in TypeDALConfig.__annotations__:
+        transform(data, prop)
+
+    with toml_path.open("r") as f:
+        old_contents: dict[str, typing.Any] = tomlkit.load(f)
+
+    if "tool" not in old_contents:
+        old_contents["tool"] = {}
+
+    data.pop("pyproject", None)
+
+    # ignore any None:
+    old_contents["tool"]["typedal"] = {k: v for k, v in data.items() if v is not None}
+
+    with toml_path.open("w") as f:
+        tomlkit.dump(old_contents, f)
+
+    rich.print(f"[green]Wrote updated config to {toml_path}![/green]")
+
+
+@app.command()
+@with_exit_code(hide_tb=IS_DEBUG)
+def generate_migrations(
+    filename_before: OptionalArgument[str] = None,
+    filename_after: OptionalArgument[str] = None,
+    dialect: DBType_Option = None,
+    tables: Tables_Option = None,
+    magic: Optional[bool] = None,
+    noop: Optional[bool] = None,
+    function: Optional[str] = None,
+    output_format: OutputFormat_Option = None,
+    output_file: Optional[str] = None,
+    dry_run: bool = False,
+) -> bool:
+    """
+    Run pydal2sql based on the typedal config.
+    """
+    # 1. choose CREATE or ALTER based on whether 'output' exists?
+    # 2. pass right args based on 'config' to function chosen in 1.
+    generic_config = load_config()
+    pydal2sql_config = generic_config.to_pydal2sql()
+    pydal2sql_config.update(
+        magic=magic,
+        noop=noop,
+        tables=tables,
+        db_type=dialect.value if dialect else None,
+        function=function,
+        format=output_format,
+        input=filename_before,
+        output=output_file,
+    )
+
+    if pydal2sql_config.output and Path(pydal2sql_config.output).exists():
+        if dry_run:
+            print("Would run `pyda2sql alter` with config", asdict(pydal2sql_config), file=sys.stderr)
+            sys.stderr.flush()
+
+            return True
+        else:  # pragma: no cover
+            return core_alter(
+                pydal2sql_config.input,
+                filename_after or pydal2sql_config.input,
+                db_type=pydal2sql_config.db_type,
+                tables=pydal2sql_config.tables,
+                noop=pydal2sql_config.noop,
+                magic=pydal2sql_config.magic,
+                function=pydal2sql_config.function,
+                output_format=pydal2sql_config.format,
+                output_file=pydal2sql_config.output,
+            )
+    else:
+        if dry_run:
+            print("Would run `pyda2sql create` with config", asdict(pydal2sql_config), file=sys.stderr)
+            sys.stderr.flush()
+
+            return True
+        else:  # pragma: no cover
+            return core_create(
+                filename=pydal2sql_config.input,
+                db_type=pydal2sql_config.db_type,
+                tables=pydal2sql_config.tables,
+                noop=pydal2sql_config.noop,
+                magic=pydal2sql_config.magic,
+                function=pydal2sql_config.function,
+                output_format=pydal2sql_config.format,
+                output_file=pydal2sql_config.output,
+            )
+
+
+@app.command()
+@with_exit_code(hide_tb=IS_DEBUG)
+def run_migrations(
+    migrations_file: OptionalArgument[str] = None,
+    db_uri: Optional[str] = None,
+    db_folder: Optional[str] = None,
+    schema_version: Optional[str] = None,
+    redis_host: Optional[str] = None,
+    migrate_cat_command: Optional[str] = None,
+    database_to_restore: Optional[str] = None,
+    migrate_table: Optional[str] = None,
+    flag_location: Optional[str] = None,
+    schema: Optional[str] = None,
+    create_flag_location: Optional[bool] = None,
+    dry_run: bool = False,
+) -> bool:
+    """
+    Run edwh-migrate based on the typedal config.
+    """
+    # 1. build migrate Config from TypeDAL config
+    # 2. import right file
+    # 3. `activate_migrations`
+    generic_config = load_config()
+    migrate_config = generic_config.to_migrate()
+
+    migrate_config.update(
+        migrate_uri=db_uri,
+        schema_version=schema_version,
+        redis_host=redis_host,
+        migrate_cat_command=migrate_cat_command,
+        database_to_restore=database_to_restore,
+        migrate_table=migrate_table,
+        flag_location=flag_location,
+        schema=schema,
+        create_flag_location=create_flag_location,
+        db_folder=db_folder,
+        migrations_file=migrations_file,
+    )
+
+    if dry_run:
+        print("Would run `migrate` with config", asdict(migrate_config), file=sys.stderr)
+    else:  # pragma: no cover
+        edwh_migrate.console_hook([], config=migrate_config)
+    return True
+
+
+def version_callback() -> Never:
+    """
+    --version requested!
+    """
+    print(f"pydal2sql Version: {__version__}")
+
+    raise typer.Exit(0)
+
+
+def config_callback() -> Never:
+    """
+    --show-config requested.
+    """
+    config = load_config()
+
+    print(repr(config))
+
+    raise typer.Exit(0)
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    _: typer.Context,
+    # stops the program:
+    show_config: bool = False,
+    version: bool = False,
+) -> None:
+    """
+    This script can be used to generate the create or alter sql from pydal or typedal.
+    """
+    if show_config:
+        config_callback()
+    elif version:
+        version_callback()
+    # else: just continue
+
+
+if __name__ == "__main__":  # pragma: no cover
+    app()

typedal/config.py

@@ -0,0 +1,271 @@
+"""
+TypeDAL can be configured by a combination of pyproject.toml (static), env (dynamic) and code (programmic).
+"""
+import os
+import typing
+import warnings
+from pathlib import Path
+from typing import Any, Optional
+
+import black.files
+import tomli
+from configuraptor import TypedConfig, alias
+from dotenv import dotenv_values, find_dotenv
+
+if typing.TYPE_CHECKING:  # pragma: no cover
+    from edwh_migrate import Config as MigrateConfig
+    from pydal2sql.typer_support import Config as P2SConfig
+
+
+class TypeDALConfig(TypedConfig):
+    """
+    Unified config for TypeDAL runtime behavior and migration utilities.
+    """
+
+    # typedal:
+    database: str
+    dialect: str
+    folder: str = "databases"
+    caching: bool = True
+    pool_size: int = 0
+    pyproject: str
+    connection: str = "default"
+
+    # pydal2sql:
+    input: str = ""  # noqa: A003
+    output: str = ""
+    noop: bool = False
+    magic: bool = True
+    tables: Optional[list[str]] = None
+    function: str = "define_tables"
+
+    # edwh-migrate:
+    # migrate uri = database
+    database_to_restore: Optional[str]
+    migrate_cat_command: Optional[str]
+    schema_version: Optional[str]
+    redis_host: Optional[str]
+    migrate_table: str = "typedal_implemented_features"
+    flag_location: str
+    create_flag_location: bool = True
+    schema: str = "public"
+
+    # typedal (depends on properties above)
+    migrate: bool = True
+    fake_migrate: bool = False
+
+    # aliases:
+    db_uri: str = alias("database")
+    db_type: str = alias("dialect")
+    db_folder: str = alias("folder")
+
+    def __repr__(self) -> str:
+        """
+        Dump the config to a (fancy) string.
+        """
+        return f"<TypeDAL {self.__dict__}>"
+
+    def to_pydal2sql(self) -> "P2SConfig":
+        """
+        Convert the config to the format required by pydal2sql.
+        """
+        from pydal2sql.typer_support import Config, get_pydal2sql_config
+
+        if self.pyproject:  # pragma: no cover
+            project = Path(self.pyproject).read_text()
+
+            if "[tool.typedal]" not in project and "[tool.pydal2sql]" in project:
+                # no typedal config, but existing p2s config:
+                return get_pydal2sql_config(self.pyproject)
+
+        return Config.load(
+            {
+                "db_type": self.dialect,
+                "format": "edwh-migrate",
+                "tables": self.tables,
+                "magic": self.magic,
+                "function": self.function,
+                "input": self.input,
+                "output": self.output,
+                "pyproject": self.pyproject,
+            }
+        )
+
+    def to_migrate(self) -> "MigrateConfig":
+        """
+        Convert the config to the format required by edwh-migrate.
+        """
+        from edwh_migrate import Config, get_config
+
+        if self.pyproject:  # pragma: no cover
+            project = Path(self.pyproject).read_text()
+
+            if "[tool.typedal]" not in project and "[tool.migrate]" in project:
+                # no typedal config, but existing p2s config:
+                return get_config()
+
+        return Config.load(
+            {
+                "migrate_uri": self.database,
+                "schema_version": self.schema_version,
+                "redis_host": self.redis_host,
+                "migrate_cat_command": self.migrate_cat_command,
+                "database_to_restore": self.database_to_restore,
+                "migrate_table": self.migrate_table,
+                "flag_location": self.flag_location,
+                "create_flag_location": self.create_flag_location,
+                "schema": self.schema,
+                "db_folder": self.folder,
+                "migrations_file": self.output,
+            }
+        )
+
+
+def find_pyproject_toml(directory: str | None = None) -> typing.Optional[str]:
+    """
+    Find the project's config toml, looks up until it finds the project root (black's logic).
+    """
+    return black.files.find_pyproject_toml((directory or os.getcwd(),))
+
+
+def _load_toml(path: str | bool | None = True) -> tuple[str, dict[str, Any]]:
+    """
+    Path can be a file, a directory, a bool or None.
+
+    If it is True or None, the default logic is used.
+    If it is False, no data is loaded.
+    if it is a directory, the pyproject.toml will be searched there.
+    If it is a path, that file will be used.
+    """
+    if path is False:
+        toml_path = None
+    elif path in (True, None):
+        toml_path = find_pyproject_toml()
+    elif Path(str(path)).is_file():
+        toml_path = str(path)
+    else:
+        toml_path = find_pyproject_toml(str(path))
+
+    if not toml_path:
+        # nothing to load
+        return "", {}
+
+    try:
+        with open(toml_path, "rb") as f:
+            data = tomli.load(f)
+
+        return toml_path or "", typing.cast(dict[str, Any], data["tool"]["typedal"])
+    except Exception as e:
+        warnings.warn(f"Could not load typedal config toml: {e}", source=e)
+        return toml_path or "", {}
+
+
+def _load_dotenv(path: str | bool | None = True) -> tuple[str, dict[str, Any]]:
+    if path is False:
+        dotenv_path = None
+    elif path in (True, None):
+        dotenv_path = find_dotenv(usecwd=True)
+    elif Path(str(path)).is_file():
+        dotenv_path = str(path)
+    else:
+        dotenv_path = str(Path(str(path)) / ".env")
+
+    if not dotenv_path:
+        return "", {}
+
+    # 1. find everything with TYPEDAL_ prefix
+    # 2. remove that prefix
+    # 3. format values if possible
+    data = dotenv_values(dotenv_path)
+    data |= os.environ  # higher prio than .env
+
+    typedal_data = {k.lower().removeprefix("typedal_"): v for k, v in data.items()}
+
+    return dotenv_path, typedal_data
+
+
+DB_ALIASES = {
+    "postgresql": "postgres",
+    "psql": "postgres",
+    "sqlite3": "sqlite",
+}
+
+
+def get_db_for_alias(db_name: str) -> str:
+    """
+    Convert a db dialect alias to the standard name.
+    """
+    return DB_ALIASES.get(db_name, db_name)
+
+
+DEFAULTS: dict[str, Any | typing.Callable[[dict[str, Any]], Any]] = {
+    "database": lambda data: data.get("db_uri") or "sqlite:memory",
+    "dialect": lambda data: get_db_for_alias(data["database"].split(":")[0])
+    if ":" in data["database"]
+    else data.get("db_type"),
+    "migrate": lambda data: not (data.get("input") or data.get("output")),
+    "folder": lambda data: data.get("db_folder"),
+    "flag_location": lambda data: f"{db_folder}/flags"
+    if (db_folder := (data.get("folder") or data.get("db_folder")))
+    else "/flags",
+    "pool_size": lambda data: 1 if data.get("dialect", "sqlite") == "sqlite" else 3,
+}
+
+
+def fill_defaults(data: dict[str, Any], prop: str) -> None:
+    """
+    Fill missing property defaults with (calculated) sane defaults.
+    """
+    if data.get(prop, None) is None:
+        default = DEFAULTS.get(prop)
+        if callable(default):
+            default = default(data)
+        data[prop] = default
+
+
+TRANSFORMS: dict[str, typing.Callable[[dict[str, Any]], Any]] = {
+    "database": lambda data: data["database"]
+    if (":" in data["database"] or not data.get("dialect"))
+    else (data["dialect"] + "://" + data["database"])
+}
+
+
+def transform(data: dict[str, Any], prop: str) -> bool:
+    """
+    After the user has chosen a value, possibly transform it.
+    """
+    if fn := TRANSFORMS.get(prop):
+        data[prop] = fn(data)
+        return True
+    return False
+
+
+def load_config(
+    _use_pyproject: bool | str | None = True, _use_env: bool | str | None = True, **fallback: Any
+) -> TypeDALConfig:
+    """
+    Combines multiple sources of config into one config instance.
+    """
+    # load toml data
+    # load .env data
+    # combine and fill with fallback values
+    # load typedal config or fail
+    toml_path, toml = _load_toml(_use_pyproject)
+    dotenv_path, dotenv = _load_dotenv(_use_env)
+
+    connection_name = dotenv.get("connection", "") or toml.get("default", "")
+    connection: dict[str, Any] = (toml.get(connection_name) if connection_name else toml) or {}
+
+    combined = connection | dotenv | fallback
+    combined = {k.replace("-", "_"): v for k, v in combined.items()}
+
+    combined["pyproject"] = toml_path
+    combined["connection"] = connection_name
+
+    for prop in TypeDALConfig.__annotations__:
+        fill_defaults(combined, prop)
+
+    for prop in TypeDALConfig.__annotations__:
+        transform(combined, prop)
+
+    return TypeDALConfig.load(combined, convert_types=True)

typedal/core.py

@@ -19,10 +19,11 @@ import pydal
 from pydal._globals import DEFAULT
 from pydal.objects import Field as _Field
 from pydal.objects import Query as _Query
-from pydal.objects import Row, Rows
+from pydal.objects import Row
 from pydal.objects import Table as _Table
 from typing_extensions import Self
 
+from .config import load_config
 from .helpers import (
     DummyQuery,
     all_annotations,
@@ -52,6 +53,8 @@ from .types import (
     PaginateDict,
     Pagination,
     Query,
+    Rows,
+    Validator,
     _Types,
 )
 
@@ -336,13 +339,13 @@ class TypeDAL(pydal.DAL):  # type: ignore
 
     def __init__(
         self,
-        uri: str = "sqlite:memory",
-        pool_size: int = 0,
-        folder: Optional[str | Path] = None,
+        uri: Optional[str] = None,  # default from config or 'sqlite:memory'
+        pool_size: int = None,  # default 1 if sqlite else 3
+        folder: Optional[str | Path] = None,  # default 'databases' in config
         db_codec: str = "UTF-8",
         check_reserved: Optional[list[str]] = None,
-        migrate: bool = True,
-        fake_migrate: bool = False,
+        migrate: Optional[bool] = None,  # default True by config
+        fake_migrate: Optional[bool] = None,  # default False by config
         migrate_enabled: bool = True,
         fake_migrate_all: bool = False,
         decode_credentials: bool = False,
@@ -359,24 +362,37 @@ class TypeDAL(pydal.DAL):  # type: ignore
         ignore_field_case: bool = True,
         entity_quoting: bool = True,
         table_hash: Optional[str] = None,
-        enable_typedal_caching: bool = True,
+        enable_typedal_caching: bool = None,
+        use_pyproject: bool | str = True,
+        use_env: bool | str = True,
     ) -> None:
         """
         Adds some internal tables after calling pydal's default init.
 
         Set enable_typedal_caching to False to disable this behavior.
         """
-        if folder:
-            Path(folder).mkdir(exist_ok=True)
+        config = load_config(_use_pyproject=use_pyproject, _use_env=use_env)
+        config.update(
+            database=uri,
+            dialect=uri.split(":")[0] if uri and ":" in uri else None,
+            folder=folder,
+            migrate=migrate,
+            fake_migrate=fake_migrate,
+            caching=enable_typedal_caching,
+            pool_size=pool_size,
+        )
+
+        if config.folder:
+            Path(config.folder).mkdir(exist_ok=True)
 
         super().__init__(
-            uri,
-            pool_size,
-            str(folder),
+            config.database,
+            config.pool_size,
+            config.folder,
             db_codec,
             check_reserved,
-            migrate,
-            fake_migrate,
+            config.migrate,
+            config.fake_migrate,
             migrate_enabled,
             fake_migrate_all,
             decode_credentials,
@@ -395,7 +411,7 @@ class TypeDAL(pydal.DAL):  # type: ignore
             table_hash,
         )
 
-        if enable_typedal_caching:
+        if config.caching:
             self.try_define(_TypedalCache)
             self.try_define(_TypedalCacheDependency)
 
@@ -508,6 +524,7 @@ class TypeDAL(pydal.DAL):  # type: ignore
                 relationships=typing.cast(dict[str, Relationship[Any]], relationships),
             )
             self._class_map[str(table)] = cls
+            cls.__on_define__(self)
         else:
             warnings.warn("db.define used without inheriting TypedTable. This could lead to strange problems!")
 
@@ -1042,6 +1059,13 @@ class TableMeta(type):
 
     # other table methods:
 
+    def truncate(self, mode: str = "") -> None:
+        """
+        Remove all data and reset index.
+        """
+        table = self._ensure_table_defined()
+        table.truncate(mode)
+
     def drop(self, mode: str = "") -> None:
         """
         Remove the underlying table.
@@ -1143,6 +1167,8 @@ class TypedField(typing.Generic[T_Value]):  # pragma: no cover
     _type: T_annotation
     kwargs: Any
 
+    requires: Validator | typing.Iterable[Validator]
+
     def __init__(self, _type: typing.Type[T_Value] | types.UnionType = str, /, **settings: Any) -> None:  # type: ignore
         """
         A TypedFieldType should not be inited manually, but TypedField (from `fields.py`) should be used!
@@ -1359,6 +1385,15 @@ class TypedTable(metaclass=TableMeta):
         inst._setup_instance_methods()
         return inst
 
+    @classmethod
+    def __on_define__(cls, db: TypeDAL) -> None:
+        """
+        Method that can be implemented by tables to do an action after db.define is completed.
+
+        This can be useful if you need to add something like requires=IS_NOT_IN_DB(db, "table.field"),
+        where you need a reference to the current database, which may not exist yet when defining the model.
+        """
+
     def __iter__(self) -> typing.Generator[Any, None, None]:
         """
         Allows looping through the columns.

typedal/for_py4web.py

@@ -1,14 +1,25 @@
 """
 ONLY USE IN COMBINATION WITH PY4WEB!
 """
+import typing
 from datetime import datetime
 from typing import Any, Optional
 
 import json_fix  # noqa: F401
 import threadsafevariable
-from py4web.core import ICECUBE, Fixture
+from py4web.core import ICECUBE
+from py4web.core import Fixture as _Fixture
+from pydal.validators import CRYPT, IS_EMAIL, IS_NOT_EMPTY, IS_NOT_IN_DB, IS_STRONG
 
-from .core import TypeDAL, TypedTable
+from .core import TypeDAL, TypedField, TypedTable
+from .fields import PasswordField
+from .types import Validator
+
+
+class Fixture(_Fixture):  # type: ignore
+    """
+    Make mypy happy.
+    """
 
 
 class DAL(TypeDAL, Fixture):  # pragma: no cover
@@ -46,13 +57,23 @@ class AuthUser(TypedTable):
 
     # call db.define on this when ready
 
-    email: str
-    password: str
-    first_name: Optional[str]
-    last_name: Optional[str]
-    sso_id: Optional[str]
-    action_token: Optional[str]
-    last_password_change: Optional[datetime]
+    email: TypedField[str]
+    password = PasswordField(requires=[IS_STRONG(entropy=45), CRYPT()])
+    first_name: TypedField[Optional[str]]
+    last_name: TypedField[Optional[str]]
+    sso_id: TypedField[Optional[str]]
+    action_token: TypedField[Optional[str]]
+    last_password_change: TypedField[Optional[datetime]]
+
     # past_passwords_hash: Optional[str]
     # username: Optional[str]
     # phone_number: Optional[str]
+
+    @classmethod
+    def __on_define__(cls, db: TypeDAL) -> None:
+        """
+        Add some requires= to the auth_user fields.
+        """
+        cls.email.requires = typing.cast(tuple[Validator, ...], (IS_EMAIL(), IS_NOT_IN_DB(db, "auth_user.email")))
+        cls.first_name.requires = IS_NOT_EMPTY()
+        cls.last_name.requires = IS_NOT_EMPTY()

typedal/types.py

@@ -10,7 +10,9 @@ from pydal.helpers.classes import Reference as _Reference
 from pydal.objects import Expression as _Expression
 from pydal.objects import Field as _Field
 from pydal.objects import Query as _Query
+from pydal.objects import Rows as _Rows
 from pydal.objects import Set as _Set
+from pydal.validators import Validator as _Validator
 from typing_extensions import NotRequired
 
 
@@ -30,7 +32,7 @@ class Expression(_Expression):  # type: ignore
     """
 
 
-class Set(_Set):
+class Set(_Set):  # type: ignore
     """
     Pydal Set object.
 
@@ -38,7 +40,7 @@ class Set(_Set):
     """
 
 
-class OpRow(_OpRow):
+class OpRow(_OpRow):  # type: ignore
     """
     Pydal OpRow object.
 
@@ -46,7 +48,7 @@ class OpRow(_OpRow):
     """
 
 
-class Reference(_Reference):
+class Reference(_Reference):  # type: ignore
     """
     Pydal Reference object.
 
@@ -54,7 +56,7 @@ class Reference(_Reference):
     """
 
 
-class Field(_Field):
+class Field(_Field):  # type: ignore
     """
     Pydal Field object.
 
@@ -62,6 +64,22 @@ class Field(_Field):
     """
 
 
+class Rows(_Rows):  # type: ignore
+    """
+    Pydal Rows object.
+
+    Make mypy happy.
+    """
+
+
+class Validator(_Validator):  # type: ignore
+    """
+    Pydal Validator object.
+
+    Make mypy happy.
+    """
+
+
 class _Types:
     """
     Internal type storage for stuff that mypy otherwise won't understand.

{typedal-2.1.5.dist-info → typedal-2.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TypeDAL
-Version: 2.1.5
+Version: 2.2.1
 Summary: Typing support for PyDAL
 Project-URL: Documentation, https://typedal.readthedocs.io/
 Project-URL: Issues, https://github.com/trialandsuccess/TypeDAL/issues
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
+Requires-Dist: configuraptor>=1.24.0
 Requires-Dist: dill
 Requires-Dist: pydal
 Provides-Extra: all
@@ -22,6 +23,9 @@ Requires-Dist: edwh-migrate; extra == 'all'
 Requires-Dist: json-fix; extra == 'all'
 Requires-Dist: py4web; extra == 'all'
 Requires-Dist: pydal2sql[all]; extra == 'all'
+Requires-Dist: questionary; extra == 'all'
+Requires-Dist: tomlkit; extra == 'all'
+Requires-Dist: typer; extra == 'all'
 Provides-Extra: dev
 Requires-Dist: hatch; extra == 'dev'
 Requires-Dist: mkdocs; extra == 'dev'
@@ -32,6 +36,9 @@ Requires-Dist: su6[all]; extra == 'dev'
 Provides-Extra: migrations
 Requires-Dist: edwh-migrate; extra == 'migrations'
 Requires-Dist: pydal2sql; extra == 'migrations'
+Requires-Dist: questionary; extra == 'migrations'
+Requires-Dist: tomlkit; extra == 'migrations'
+Requires-Dist: typer; extra == 'migrations'
 Provides-Extra: py4web
 Requires-Dist: json-fix; extra == 'py4web'
 Requires-Dist: py4web; extra == 'py4web'
@@ -55,10 +62,13 @@ the underlying `db.define_table` pydal Tables.
 - `TypeDAL` is the replacement class for DAL that manages the code on top of DAL.
 - `TypedTable` must be the parent class of any custom Tables you define (e.g. `class SomeTable(TypedTable)`)
 - `TypedField` can be used instead of Python native types when extra settings (such as `default`) are required (
-  e.g. `name = TypedField(str, default="John Doe")`). It can also be used in an annotation (`name: TypedField[str]`) to improve
+  e.g. `name = TypedField(str, default="John Doe")`). It can also be used in an annotation (`name: TypedField[str]`) to
+  improve
   editor support over only annotating with `str`.
-- `TypedRows`: can be used as the return type annotation of pydal's `.select()` and subscribed with the actual table class, so
-  e.g. `rows: TypedRows[SomeTable] = db(...).select()`. When using the QueryBuilder, a `TypedRows` instance is returned by `.collect()`.
+- `TypedRows`: can be used as the return type annotation of pydal's `.select()` and subscribed with the actual table
+  class, so
+  e.g. `rows: TypedRows[SomeTable] = db(...).select()`. When using the QueryBuilder, a `TypedRows` instance is returned
+  by `.collect()`.
 
 Version 2.0 also introduces more ORM-like funcionality.
 Most notably, a Typed Query Builder that sees your table classes as models with relationships to each other.
@@ -68,7 +78,7 @@ details.
 ## Quick Overview
 
 Below you'll find a quick overview of translation from pydal to TypeDAL. For more info,
-see [the docs](https://github.com/trialandsuccess/TypeDAL/tree/master/docs).
+see [the docs](https://typedal.readthedocs.io/en/latest/).
 
 ### Translations from pydal to typedal
 
@@ -247,16 +257,6 @@ row: TableName = db.table_name(id=1)
 
 See [2. Defining Tables](docs/2_defining_tables.md)
 
-## Roadmap
-
-This section contains a non-exhaustive list of planned features for future feature releases:
-
-- 2.2
-    - Migrations: currently, you can use pydal's automatic migrations or disable those and manage them yourself, but
-      adding something like [`edwh-migrate`](https://github.com/educationwarehouse/migrate#readme)
-      with [`pydal2sql`](https://github.com/robinvandernoord/pydal2sql-core) as an option could make this project more
-      production-friendly.
-
 ## Caveats
 
 - This package depends heavily on the current implementation of annotations (which are computed when the class is

typedal-2.2.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+typedal/__about__.py,sha256=h_6wVhT5zBpkimIzSHhAe8DZCR_Nn-sqaS8GZXghPko,206
+typedal/__init__.py,sha256=QQpLiVl9w9hm2LBxey49Y_tCF_VB2bScVaS_mCjYy54,366
+typedal/caching.py,sha256=53WU5J_yRLygkKoDfD0rV_dkh5oqqT--64R9Mvz050Y,7457
+typedal/cli.py,sha256=MF2bGwL4SOaIqGzr1JRSvGD6CSujy88hKGgVIehlFNk,11789
+typedal/config.py,sha256=9ORQqJJ_3tDmFiL2Py_9PiceXLihpMR69t6OKZ_qpe8,8387
+typedal/core.py,sha256=LV0Fszbmh0pojAiARD1GKj5ooxakJmmj_4ebpvZZkcs,93644
+typedal/fields.py,sha256=z2PD9vLWqBR_zXtiY0DthqTG4AeF3yxKoeuVfGXnSdg,5197
+typedal/for_py4web.py,sha256=kw44_55-dBWlYmepB7YEev5sj7tbYcgzvp-Ecc7K9_I,2230
+typedal/helpers.py,sha256=ZpHdwBMSANw-P9I5gs56Vf6GUbxGzFsIwbBvASKXX8s,6487
+typedal/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+typedal/types.py,sha256=5qm3PgS8DXGCu9ZTUWQiIi2XXD8gz4_4Csg_vZlu_yo,3379
+typedal-2.2.1.dist-info/METADATA,sha256=-4kp0PN1msDhP9C07HqMh_4VCigOu0AhkN6yNrRPDkM,7623
+typedal-2.2.1.dist-info/WHEEL,sha256=KGYbc1zXlYddvwxnNty23BeaKzh7YuoSIvIMO4jEhvw,87
+typedal-2.2.1.dist-info/entry_points.txt,sha256=m1wqcc_10rHWPdlQ71zEkmJDADUAnZtn7Jac_6mbyUc,44
+typedal-2.2.1.dist-info/RECORD,,

typedal-2.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+typedal = typedal.cli:app

typedal-2.1.5.dist-info/RECORD

@@ -1,12 +0,0 @@
-typedal/__about__.py,sha256=z5coRWunglB2VeEfC8bQlGvTzl_8V8VDJJvYOu95z3A,206
-typedal/__init__.py,sha256=QQpLiVl9w9hm2LBxey49Y_tCF_VB2bScVaS_mCjYy54,366
-typedal/caching.py,sha256=53WU5J_yRLygkKoDfD0rV_dkh5oqqT--64R9Mvz050Y,7457
-typedal/core.py,sha256=OVLs-1xb3i-FsHEcVXeSgyCNhzcHu-WCAlX7YX95ulg,92238
-typedal/fields.py,sha256=z2PD9vLWqBR_zXtiY0DthqTG4AeF3yxKoeuVfGXnSdg,5197
-typedal/for_py4web.py,sha256=NN6GxZpp971HFxqiI5QZaNQYydsEvJh1TctxKuZE5pw,1460
-typedal/helpers.py,sha256=ZpHdwBMSANw-P9I5gs56Vf6GUbxGzFsIwbBvASKXX8s,6487
-typedal/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-typedal/types.py,sha256=AADKhLbBotpDm5FM__fhvaRNGoHPjG-LcxflnjvhOz0,3011
-typedal-2.1.5.dist-info/METADATA,sha256=x9hqsQdodHt8tcU5v2W-6J78Kx2YJDI0azqicUNHE1w,7814
-typedal-2.1.5.dist-info/WHEEL,sha256=KGYbc1zXlYddvwxnNty23BeaKzh7YuoSIvIMO4jEhvw,87
-typedal-2.1.5.dist-info/RECORD,,