dash-pydantic-utils 0.14.1__tar.gz

dash_pydantic_utils-0.14.1/.gitignore

@@ -0,0 +1,168 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Terraform - .terraform* matches the local .lock.hcl files and modules that we do not want to export to git
+.terraform*
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+*.ipynb
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+.vscode/settings.json
+
+.bbai/*
+.pixi/*

dash_pydantic_utils-0.14.1/LICENSE

@@ -0,0 +1,19 @@
+The MIT License (MIT)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

dash_pydantic_utils-0.14.1/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: dash-pydantic-utils
+Version: 0.14.1
+Summary: Utils for dash-pydantic-form, allows to use the utils in other places without requiring Dash.
+Project-URL: Source, https://github.com/RenaudLN/dash-pydantic-form
+Author-email: Renaud Lainé <renaudlaine31@gmail.com>
+License: The MIT License (MIT)
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in
+        all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+        THE SOFTWARE.
+License-File: LICENSE
+Requires-Python: <3.13,>=3.10
+Requires-Dist: pydantic==2.*
+Provides-Extra: dev
+Requires-Dist: dash[testing]; extra == 'dev'
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Provides-Extra: pandas
+Requires-Dist: numpy; extra == 'pandas'
+Requires-Dist: pandas; extra == 'pandas'

dash_pydantic_utils-0.14.1/dash_pydantic_utils/__init__.py

@@ -0,0 +1,42 @@
+from .common import (
+    deep_diff,
+    deep_merge,
+    get_all_subclasses,
+    get_model_cls,
+    get_non_null_annotation,
+    is_subclass,
+)
+from .path import (
+    SEP,
+    from_form_data,
+    get_fullpath,
+    get_model_value,
+    get_subitem,
+    get_subitem_cls,
+    handle_discriminated,
+    model_construct_recursive,
+    set_at_path,
+)
+from .quantity import Quantity, QuantityDtype
+from .types import Type
+
+__all__ = [
+    "deep_diff",
+    "deep_merge",
+    "from_form_data",
+    "get_all_subclasses",
+    "get_fullpath",
+    "get_model_cls",
+    "get_model_value",
+    "get_non_null_annotation",
+    "get_subitem",
+    "get_subitem_cls",
+    "handle_discriminated",
+    "is_subclass",
+    "model_construct_recursive",
+    "Quantity",
+    "QuantityDtype",
+    "SEP",
+    "set_at_path",
+    "Type",
+]

dash_pydantic_utils-0.14.1/dash_pydantic_utils/common.py

@@ -0,0 +1,66 @@
+from copy import deepcopy
+from types import UnionType
+from typing import Any, Union, get_args, get_origin
+
+from pydantic import BaseModel
+
+
+def deep_merge(dict1: dict, dict2: dict) -> dict:
+    """Deep merge two dictionaries, the second input is given priority."""
+    dict_final = deepcopy(dict1)
+    for key, val in dict2.items():
+        if isinstance(val, dict):
+            dict_final[key] = deep_merge(dict_final.get(key, {}), val)
+        else:
+            dict_final[key] = val
+    return dict_final
+
+
+def deep_diff(dict1: dict, dict2: dict) -> dict[str, dict | tuple[Any, Any]]:
+    """Compute the deep difference between two dictionaries."""
+    diff = {}
+    for key in dict1.keys() | dict2.keys():
+        if isinstance(dict1.get(key), dict) and isinstance(dict2.get(key), dict):
+            sub_diff = deep_diff(dict1[key], dict2[key])
+            if sub_diff:
+                diff[key] = sub_diff
+        elif dict1.get(key) != dict2.get(key):
+            diff[key] = (dict1.get(key), dict2.get(key))
+    return diff
+
+
+def get_non_null_annotation(annotation: type[Any]) -> type[Any]:
+    """Get a non-null annotation.
+
+    e.g., get_non_null_annotation(Optional[str]) = str
+    """
+    if get_origin(annotation) in [Union, UnionType]:
+        args = tuple(x for x in get_args(annotation) if x is not type(None))
+        if len(args) == 1:
+            return args[0]
+        return Union[args]  # noqa: UP007
+    return annotation
+
+
+def get_all_subclasses(cls: type):
+    """Get all subclasses of a class."""
+    all_subclasses = []
+
+    for subclass in cls.__subclasses__():
+        all_subclasses.append(subclass)
+        all_subclasses.extend(get_all_subclasses(subclass))
+
+    return all_subclasses
+
+
+def get_model_cls(str_repr: str) -> type[BaseModel]:
+    """Get the model class from a string representation."""
+    return next(cls for cls in get_all_subclasses(BaseModel) if str(cls) == str_repr)
+
+
+def is_subclass(cls: type, base_cls: type) -> bool:
+    """Check if a class is a subclass of another class, handling issubclass errors."""
+    try:
+        return issubclass(cls, base_cls)
+    except TypeError:
+        return False

dash_pydantic_utils-0.14.1/dash_pydantic_utils/path.py

@@ -0,0 +1,289 @@
+import logging
+import re
+from copy import deepcopy
+from typing import Annotated, Any, Literal, get_args, get_origin
+
+from pydantic import BaseModel, ValidationError, create_model
+from pydantic.fields import FieldInfo
+from pydantic_core import PydanticUndefined
+
+from dash_pydantic_utils.common import get_non_null_annotation, is_subclass
+from dash_pydantic_utils.types import Type
+
+SEP = ":"
+
+
+def get_model_value(item: BaseModel, field: str, parent: str, allow_default: bool = True):  # noqa: PLR0911
+    """Get the value of a model (parent, field) pair.
+
+    Parameters
+    ----------
+    item: BaseModel
+        The object to get the value from
+    field: str
+        The field name
+    parent: str
+        The parent of the field (for nested fields), in dot notation
+    allow_default: bool
+        Allow to return the default value, when the object has been created with model_construct.
+    """
+    try:
+        subitem = get_subitem(item, parent)
+        if isinstance(subitem, BaseModel):
+            return subitem[field]
+        if isinstance(subitem, dict) and isinstance(field, int):
+            return list(subitem.values())[field]
+        if isinstance(subitem, list) and isinstance(field, int):
+            return subitem[field]
+        return subitem[field]
+    except:
+        if allow_default:
+            subitem_cls = get_subitem_cls(item.__class__, parent, item=item)
+            if not is_subclass(subitem_cls, BaseModel):
+                return None
+            field_info = subitem_cls.model_fields[field]
+            if field_info.default is not PydanticUndefined:
+                return field_info.default
+            if field_info.default_factory:
+                return field_info.default_factory()
+            return None
+        raise
+
+
+def get_subitem(item: BaseModel | list | dict, parent: str) -> BaseModel:
+    """Get the subitem of a model at a given parent.
+
+    e.g., get_subitem(person, "au_metadata") = AUMetadata(param1=True, param2=False)
+    """
+    if parent == "":
+        return item
+
+    path = parent.split(SEP)
+
+    first_part = path[0]
+    if isinstance(first_part, str) and first_part.isdigit():
+        first_part = int(first_part)
+
+    if isinstance(item, BaseModel):
+        next_item = getattr(item, first_part)
+    elif isinstance(item, dict) and isinstance(first_part, int):
+        next_item = list(item.values())[first_part]
+    elif isinstance(item, list) and isinstance(first_part, int):
+        next_item = item[first_part]
+    elif is_idx_template(first_part):
+        next_item = None
+    else:
+        next_item = item.get(first_part)
+
+    if len(path) == 1 or next_item is None:
+        return next_item
+
+    return get_subitem(next_item, SEP.join(path[1:]))
+
+
+def is_idx_template(val: str):
+    """Check if a string is an index template."""
+    return bool(re.findall(r"^\{\{[\w|\{\}]+\}\}$", val))
+
+
+def get_subitem_cls(model: type[BaseModel], parent: str, item: BaseModel | None = None) -> type[BaseModel]:
+    """Get the subitem class of a model at a given parent.
+
+    e.g., get_subitem_cls(Person, "au_metadata") = AUMetadata
+    """
+    if parent == "":
+        return model
+
+    path = parent.split(SEP)
+
+    first_part = path[0]
+    second_part = None
+
+    if len(path) == 1:
+        ann = get_non_null_annotation(model.model_fields[first_part].annotation)
+        return ann
+
+    second_part = path[1]
+    if isinstance(second_part, str) and second_part.isdigit():
+        second_part = int(second_part)
+
+    field_info = model.model_fields[first_part] if is_subclass(model, BaseModel) else (item.model_fields[first_part])
+    first_annotation = get_non_null_annotation(field_info.annotation)
+    try:
+        subitem = get_subitem(item, first_part) if item is not None else None
+    except:  # noqa: E722
+        subitem = None
+    if Type.classify(first_annotation, field_info.discriminator) == Type.DISCRIMINATED_MODEL:
+        if not item:
+            raise TypeError("Discriminated models with nesting need passing item data to be displayed")
+        discriminator_value = None if subitem is None else getattr(subitem, field_info.discriminator, None)
+        subitem_cls, _ = handle_discriminated(
+            item.__class__, parent, first_annotation, field_info.discriminator, discriminator_value
+        )
+        return get_subitem_cls(subitem_cls, SEP.join(path[1:]), item=subitem)
+    if (
+        get_origin(first_annotation) is list
+        and (isinstance(second_part, int) or is_idx_template(second_part))
+        and get_args(first_annotation)
+    ):
+        try:
+            subitem = subitem[second_part] if subitem is not None else None
+        except:  # noqa: E722
+            subitem = None
+        return get_subitem_cls(
+            get_non_null_annotation(get_args(first_annotation)[0]),
+            SEP.join(path[2:]),
+            item=subitem,
+        )
+    if get_origin(first_annotation) is dict and (isinstance(second_part, int | str)) and get_args(first_annotation):
+        return get_subitem_cls(
+            get_non_null_annotation(get_args(first_annotation)[1]),
+            SEP.join(path[2:]),
+            item=subitem,
+        )
+    return get_subitem_cls(first_annotation, SEP.join(path[1:]), item=subitem)
+
+
+def handle_discriminated(model: type[BaseModel], parent: str, annotation: type, disc_field: str, disc_val: Any):
+    """Handle a discriminated model."""
+    all_vals = set()
+    out = None
+    if get_origin(annotation) is Annotated:
+        if disc_field is None:
+            disc_field = next(
+                (f.discriminator for f in get_args(annotation)[1:] if isinstance(f, FieldInfo)),
+                None,
+            )
+        annotation = get_args(annotation)[0]
+    for possible in get_args(annotation):
+        if not get_origin(possible.model_fields[disc_field].annotation) == Literal:
+            raise ValueError("Discriminator must be a Literal")
+
+        vals = get_args(possible.model_fields[disc_field].annotation)
+        all_vals = all_vals.union(vals)
+        if disc_val is not None and disc_val in vals:
+            out = possible
+
+    all_vals = tuple(all_vals)
+
+    if disc_val is None:
+        return create_model(
+            f"{model.__name__}{parent.replace(SEP, ' ').title().replace(' ', '')}Discriminator",
+            **{disc_field: (Literal[tuple(all_vals)], ...)},
+        ), all_vals
+
+    if out is None:
+        raise ValueError(f"Invalid discriminator value: {disc_val}")
+
+    return out, all_vals
+
+
+def get_fullpath(*parts, sep: str = SEP):
+    """Creates the full path of a field from its name and parent."""
+    return sep.join([str(p) for p in parts]).strip(sep)
+
+
+def model_construct_recursive(data: dict, data_model: type[BaseModel]):
+    """Construct a model recursively."""
+    updated = deepcopy(data)
+    for key, val in data.items():
+        if key not in data_model.model_fields:
+            continue
+        if val is None:
+            updated[key] = None
+            continue
+
+        field_info = data_model.model_fields[key]
+        ann = get_non_null_annotation(field_info.annotation)
+        type_ = Type.classify(ann, field_info.discriminator)
+        if type_ == Type.MODEL:
+            updated[key] = model_construct_recursive(val, ann)
+        elif type_ == Type.DISCRIMINATED_MODEL:
+            updated[key] = _construct_handle_discriminated(val, field_info.discriminator, ann)
+        elif type_ == Type.MODEL_LIST and isinstance(val, list):
+            updated[key] = [model_construct_recursive(vv, get_args(ann)[0]) for vv in val]
+        elif type_ == Type.DISCRIMINATED_MODEL_LIST and isinstance(val, list):
+            new_val = []
+            sub_ann = get_args(ann)[0]
+            # Note: since we have a DISCRIMINATED_MODEL_LIST, sub_ann will be an Annotated union with discriminator
+            sub_ann2 = get_args(sub_ann)[0]
+            discriminator = next((f.discriminator for f in get_args(sub_ann)[1:] if isinstance(f, FieldInfo)), None)
+            for vv in val:
+                new_val.append(_construct_handle_discriminated(vv, discriminator, sub_ann2))
+            updated[key] = new_val
+        elif type_ == Type.DISCRIMINATED_MODEL_DICT and isinstance(val, dict):
+            new_val = {}
+            sub_ann = get_args(ann)[1]
+            # Note: since we have a DISCRIMINATED_MODEL_LIST, sub_ann will be an Annotated union with discriminator
+            sub_ann2 = get_args(sub_ann)[0]
+            discriminator = next((f.discriminator for f in get_args(sub_ann)[1:] if isinstance(f, FieldInfo)), None)
+            for kk, vv in val.items():
+                new_val[kk] = _construct_handle_discriminated(vv, discriminator, sub_ann2)
+            updated[key] = new_val
+
+    return data_model.model_construct(**updated)
+
+
+def _construct_handle_discriminated(val: dict, discriminator: str | None, ann: type):
+    if discriminator is None or discriminator not in val:
+        return val
+
+    disc_val = val[discriminator]
+    out = None
+    for possible in get_args(ann):
+        if not get_origin(possible.model_fields[discriminator].annotation) == Literal:
+            raise ValueError("Discriminator must be a Literal")
+
+        if disc_val in get_args(possible.model_fields[discriminator].annotation):
+            out = possible
+            break
+
+    if out is not None:
+        return model_construct_recursive(val, out)
+    return val
+
+
+def from_form_data(data: dict, data_model: type[BaseModel]):
+    """Construct a model from form data, allowing to use default values when validation of a field fails."""
+    try:
+        return data_model.model_validate(data)
+    except ValidationError as exc:
+        data_with_defaults = deepcopy(data)
+        defaulted_fields = []
+        for error in exc.errors():
+            path_parts = [str(x) for x in error["loc"]]
+            for i in range(len(path_parts), 0, -1):
+                parts_extract = path_parts[:i]
+                path = SEP.join(parts_extract)
+                try:
+                    failing_model = get_subitem_cls(data_model, SEP.join(parts_extract[:-1]))
+                except AttributeError:
+                    continue
+                if not is_subclass(failing_model, BaseModel):
+                    continue
+                field = failing_model.model_fields[parts_extract[-1]]
+                if field.default != PydanticUndefined:
+                    set_at_path(data_with_defaults, path, field.default)
+                    defaulted_fields.append(path)
+                    break
+                if field.default_factory is not None:
+                    set_at_path(data_with_defaults, path, field.default_factory())
+                    defaulted_fields.append(path)
+                    break
+
+        if defaulted_fields:
+            logging.info(
+                "Could not validate the following fields: %s for %s, using default values instead.",
+                defaulted_fields,
+                data_model.__name__,
+            )
+        return data_model.model_validate(data_with_defaults)
+
+
+def set_at_path(data: dict, path: str, value: Any):
+    """Set a value at a path in a dictionary."""
+    parts = path.split(SEP)
+    pointer = data
+    for part in parts[:-1]:
+        pointer = pointer.get(part, pointer[int(part)])
+    pointer[parts[-1]] = value

dash_pydantic_utils-0.14.1/dash_pydantic_utils/quantity/__init__.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel
+
+try:
+    from .pandas import Quantity, QuantityDtype
+except ModuleNotFoundError:
+    from .quantity import Quantity
+
+    QuantityDtype = None
+
+BaseModel.__getitem__ = lambda self, key: self.__dict__.get(key)
+
+__all__ = ["Quantity", "QuantityDtype"]