ialdev-core 0.1.0__py3-none-any.whl

iad/core/pydantools/__init__.py

@@ -0,0 +1,5 @@
+"""Pydantic + YAML model utilities (moved from ``algutils.param``)."""
+
+from iad.core.pydantools.models import YamlModel, make_yml_model_format, model_arguments
+
+__all__ = ["YamlModel", "make_yml_model_format", "model_arguments"]

iad/core/pydantools/fixed_pydantic_yaml/__init__.py

@@ -0,0 +1,32 @@
+"""YAML-enabled Pydantic models."""
+
+from .version import __version__
+
+
+__all__ = [
+    "__version__",
+    "SemVer",
+    "yaml",
+    "VersionedYamlModel",
+    "YamlEnum",  # deprecated class
+    "YamlInt",
+    "YamlIntEnum",
+    "YamlModel",
+    "YamlModelMixin",
+    "YamlModelMixinConfig",
+    "YamlStr",
+    "YamlStrEnum",
+]
+from .main import (
+    SemVer,
+    VersionedYamlModel,
+    YamlEnum,
+    YamlInt,
+    YamlIntEnum,
+    YamlModel,
+    YamlModelMixin,
+    YamlModelMixinConfig,
+    YamlStr,
+    YamlStrEnum,
+    yaml,
+)

iad/core/pydantools/fixed_pydantic_yaml/compat/hacks.py

@@ -0,0 +1,76 @@
+"""Module for some hacks that are needed to work around the YAML library interfaces.
+
+Mainy, this defines "safe" representers for common types that Pydantic is able to parse.
+"""
+
+__all__ = ["inject_all"]
+
+from typing import List, Type
+
+from .representers import register_str_like, register_int_like
+
+
+def get_str_like_types() -> List[Type]:
+    """Returns many string-like types from stdlib and Pydantic."""
+
+    # flake8: noqa
+
+    from uuid import UUID
+    from pathlib import (
+        Path,
+        PosixPath,
+        PurePath,
+        PurePosixPath,
+        PureWindowsPath,
+        WindowsPath,
+    )
+
+    from pydantic.v1 import types, networks
+
+    def _chk(x) -> bool:
+        try:
+            return issubclass(x, (str, Path, PurePath, UUID))
+        except Exception:
+            return False
+
+    # Get most candidates
+    candidates = (
+        list(locals().values())
+        + [getattr(types, v) for v in types.__all__]
+        + [getattr(networks, v) for v in networks.__all__]
+    )
+    str_like = [v for v in candidates if _chk(v)]
+
+    # SecretStr, SecretBytes are stringified as "**********" by Pydantic
+    str_like += [types.SecretStr, types.SecretBytes]
+    return str_like
+
+
+def get_int_like_types() -> List[Type]:
+    """Returns many int-like types from stdlib and Pydantic."""
+
+    from pydantic.v1 import types
+
+    def _chk(x) -> bool:
+        try:
+            return issubclass(x, (int))
+        except Exception:
+            return False
+
+    candidates = list(locals().values()) + [getattr(types, v) for v in types.__all__]
+    int_like = [v for v in candidates if _chk(v)]
+    return int_like
+
+
+def inject_all():
+    """Injects all necessary "hacks" into the namespace.
+
+    What this currently does:
+    - Registers many str-like and int-like types (from Pydantic and the standard
+      library) to be representable in YAML.
+    """
+    # Add representers for string-like and int-like values.
+    for cls in get_str_like_types():
+        register_str_like(cls, method=str)
+    for cls in get_int_like_types():
+        register_int_like(cls, method=int)

iad/core/pydantools/fixed_pydantic_yaml/compat/old_enums.py

@@ -0,0 +1,37 @@
+"""Old class for YamlEnum that is now deprecated (and marked as such)."""
+
+from enum import Enum
+from inspect import isabstract
+
+from deprecated import deprecated
+
+from .representers import register_str_like
+
+__all__ = ["YamlEnum"]
+
+
+@deprecated(version="0.5.0", reason="Use the `YamlStrEnum` class instead.")
+class YamlEnum(Enum):
+    """This class is DEPRECATED, please use `pydantic_yaml.YamlStrEnum` instead.
+
+    Enumeration that serializes as the proper underlying object type.
+
+    You can use this instead of `enum.Enum`, for example:
+        class MyEnum(str, YamlEnum):
+            val1 = "Value 1"
+            val2 = "Value 2"
+
+    Note
+    ----
+    This is actually a lie, it only supports `str` enums for now. Oops.
+    """
+
+    def __init_subclass__(cls):
+        if not isabstract(cls):
+            register_str_like(cls)
+
+    def __repr__(self) -> str:
+        return repr(self.value)
+
+    def __str__(self) -> str:
+        return str(self.value)

iad/core/pydantools/fixed_pydantic_yaml/compat/representers.py

@@ -0,0 +1,92 @@
+"""Representers for dumping common objects to YAML."""
+
+from functools import partial
+from typing import Any, Callable, TypeVar
+
+from .yaml_lib import yaml, dumper_classes, representer_classes
+
+CType = TypeVar("CType")
+
+__all__ = ["register_str_like", "register_int_like"]
+
+
+def dump_as_str(dumper: yaml.Dumper, data: Any, method: Callable[[Any], str] = str):
+    """Represents an object as a string in YAML.
+
+    Parameters
+    ----------
+    dumper : yaml.Dumper
+        The dumper instance, such as `yaml.SafeDumper()`.
+    data
+        The object to dump. Ideally this is string-like.
+    method : callable
+        A method that converts `data` to a string. Default is `str`.
+
+    Returns
+    -------
+    node
+        The YAML internal node representation.
+    """
+    return dumper.represent_str(method(data))
+
+
+def dump_as_int(dumper: yaml.Dumper, data: Any, method: Callable[[Any], int] = int):
+    """Represents an object as an integer in YAML.
+
+    Parameters
+    ----------
+    dumper : yaml.Dumper
+        The dumper instance, such as `yaml.SafeDumper()`.
+    data
+        The object to dump. Ideally this is int-like.
+    method : callable
+        A method that converts `data` to an integer. Default is `int`.
+
+    Returns
+    -------
+    node
+        The YAML internal node representation.
+    """
+    return dumper.represent_int(method(data))
+
+
+def register_str_like(cls: CType, method: Callable[[Any], str] = str) -> CType:
+    """Registers `cls` to be dumped to YAML as a string.
+
+    Parameters
+    ----------
+    cls : Type
+        The class to represent.
+    method : callable
+        A method that converts objects of type `cls` to a string.
+        Default is `str`.
+
+    Returns
+    -------
+    cls
+        This is the same as the input `cls`.
+    """
+    for x_cls in dumper_classes + representer_classes:
+        x_cls.add_representer(cls, partial(dump_as_str, method=method))
+    return cls
+
+
+def register_int_like(cls: CType, method: Callable[[Any], int] = int) -> CType:
+    """Registers `cls` to be dumped to YAML as an integer.
+
+    Parameters
+    ----------
+    cls : Type
+        The class to represent.
+    method : callable
+        A method that converts objects of type `cls` to an integer.
+        Default is `int`.
+
+    Returns
+    -------
+    cls
+        This is the same as the input `cls`.
+    """
+    for x_cls in dumper_classes + representer_classes:
+        x_cls.add_representer(cls, partial(dump_as_int, method=method))
+    return cls

iad/core/pydantools/fixed_pydantic_yaml/compat/types.py

@@ -0,0 +1,122 @@
+"""Defines useful types for building your own YAML-compatible types."""
+
+from enum import Enum
+from inspect import isabstract
+from typing import Dict, Tuple, Union
+
+from .representers import register_int_like, register_str_like
+from .yaml_lib import yaml_safe_dump
+
+__all__ = ["YamlInt", "YamlIntEnum", "YamlStr", "YamlStrEnum"]
+
+
+class YamlStr(str):
+    """A `str` subclass that serializes to YAML as an integer."""
+
+    def __init_subclass__(cls):
+        """Adds a representer when defining a subclass."""
+        res = super().__init_subclass__()
+        if not isabstract(cls):
+            register_str_like(cls, method=cls._to_yaml_str)
+        return res
+
+    @classmethod
+    def _to_yaml_str(cls, v) -> str:
+        """Represent a value of this type as a string."""
+        return str(v)
+
+    def __str__(self) -> str:
+        """This just returns the wrapped string."""
+        return super().__str__()
+
+    def __repr__(self) -> str:
+        """Repr string that keeps the class type. You may redefine this."""
+        return type(self).__qualname__ + "(" + super().__repr__() + ")"
+
+    def __getnewargs__(self) -> Tuple[str]:
+        """Implementation to prevent Enum from sabotaging us.
+
+        I'm not joking! See `_make_class_unpicklable()` from `enum.py`
+        """
+        return super().__getnewargs__()
+
+
+class YamlInt(int):
+    """An `int` subclass that serializes to YAML as an integer."""
+
+    def __init_subclass__(cls):
+        """Adds a representer when defining a subclass."""
+        res = super().__init_subclass__()
+        if not isabstract(cls):
+            register_int_like(cls, method=cls._to_yaml_int)
+        return res
+
+    @classmethod
+    def _to_yaml_int(cls, v) -> int:
+        """Represent a value of this type as an integer."""
+        return int(v)
+
+    def __int__(self) -> int:
+        return super().__int__()
+
+    def __str__(self) -> str:
+        """This returns the wrapped int."""
+        return super().__str__()
+
+    def __repr__(self) -> str:
+        """Repr string that keeps the class type. You may redefine this."""
+        return type(self).__qualname__ + "(" + super().__repr__() + ")"
+
+    def __getnewargs__(self) -> Tuple[int]:
+        """Implementation to prevent Enum from sabotaging us.
+
+        I'm not joking! See `_make_class_unpicklable()` from `enum.py`
+        """
+        return super().__getnewargs__()
+
+
+class YamlStrEnum(YamlStr, Enum):
+    """String-valued enum that serializes to YAML directly as a string.
+
+    This also checks that your enum can properly be serialized.
+    """
+
+    def __init_subclass__(cls):
+        res = super().__init_subclass__()
+        if not isabstract(cls):
+            vals: Dict[str, cls] = dict(cls.__members__)
+            yaml_safe_dump(vals)
+        return res
+
+    def __str__(self) -> str:
+        """This returns the wrapped string."""
+        return str.__str__(self)
+
+    def __repr__(self) -> str:
+        """Repr string that keeps the class type. You may redefine this."""
+        return type(self).__qualname__ + "(" + str.__repr__(self) + ")"
+
+
+class YamlIntEnum(YamlInt, Enum):
+    """Integer-valued enum that serializes to YAML directly as an integer.
+
+    This also checks that your enum can properly be serialized.
+    """
+
+    def __init_subclass__(cls):
+        res = super().__init_subclass__()
+        if not isabstract(cls):
+            vals: Dict[str, cls] = dict(cls.__members__)
+            yaml_safe_dump(vals)
+        return res
+
+
+if __name__ == "__main__":
+
+    class A(YamlStrEnum):
+        a = "a"
+        b = "b"
+
+    class X(YamlIntEnum):
+        x1 = 1
+        x2 = 2

iad/core/pydantools/fixed_pydantic_yaml/compat/yaml_lib.py

@@ -0,0 +1,104 @@
+"""Imports an installed YAML library."""
+
+# flake8: noqa
+
+from typing import Any, Optional
+from io import BytesIO, StringIO, IOBase
+
+
+try:
+    import ruamel.yaml as yaml  # type: ignore
+
+    # ruamel.yaml doesn't have type annotations
+
+    if yaml.__version__ < "0.15.0":
+        __yaml_lib__ = "ruamel-old"
+    else:
+        __yaml_lib__ = "ruamel-new"
+except ImportError:
+    try:
+        import yaml  # type: ignore
+
+        __yaml_lib__ = "pyyaml"
+    except ImportError:
+        raise ImportError(
+            "Could not import ruamel.yaml or pyyaml, "
+            "please install at least one of them."
+        )
+
+dumper_classes = []
+for _fld in dir(yaml):
+    try:
+        if "Dumper" in _fld:
+            _obj = getattr(yaml, _fld)
+            dumper_classes.append(_obj)
+    except Exception:
+        pass
+
+representer_classes = []
+for _fld in dir(yaml):
+    try:
+        if "Representer" in _fld:
+            _obj = getattr(yaml, _fld)
+            representer_classes.append(_obj)
+    except Exception:
+        pass
+
+
+def yaml_safe_load(stream) -> Any:
+    """Wrapper around YAML library loader."""
+    if __yaml_lib__ in ["ruamel-old", "pyyaml"]:
+        return yaml.safe_load(stream)
+    # Fixing deprecation warning in new ruamel.yaml versions
+    assert __yaml_lib__ == "ruamel-new"
+    ruamel_obj = yaml.YAML(typ="safe", pure=True)
+    if isinstance(stream, str):
+        return ruamel_obj.load(StringIO(stream))
+    elif isinstance(stream, bytes):
+        return ruamel_obj.load(BytesIO(stream))
+    # we hope it's a stream, but don't enforce it
+    return ruamel_obj.load(stream)
+
+
+def yaml_safe_dump(
+    data: Any, stream=None, *, sort_keys: bool = False, **kwds
+) -> Optional[Any]:
+    """Wrapper around YAML library dumper.
+
+    Parameters
+    ----------
+    data
+        The data you want to dump, typically a mapping (dict).
+    stream
+        The stream to dump to. By default (if no stream is given, i.e. None),
+        this will instead dump to a text stream.
+    sort_keys : bool
+        Whether to sort the keys of mappings before dumping.
+        Default value is False, rather than True, which is the YAML default.
+        This is because Pydantic configs are easier to read if dumped in the
+        same order as they are defined.
+    kwds
+        Other keyword arguments to set on the YAML dumper instance.
+    """
+    if __yaml_lib__ in ["ruamel-old", "pyyaml"]:
+        return yaml.safe_dump(data, stream=stream, sort_keys=sort_keys, **kwds)
+    # Fixing deprecation warning in new ruamel.yaml versions
+    assert __yaml_lib__ == "ruamel-new"
+    ruamel_obj = yaml.YAML(typ="safe", pure=True)
+    ruamel_obj.sort_base_mapping_type_on_output = sort_keys  # type: ignore
+    # Hacking some options that aren't available
+    for kw in ["encoding", "default_flow_style", "default_style", "indent"]:
+        if kw in kwds:
+            setattr(ruamel_obj, kw, kwds[kw])
+
+    if stream is None:
+        text_stream = StringIO()
+        ruamel_obj.dump(data, stream=text_stream)
+        text_stream.seek(0)  # otherwise we always get ''
+        return text_stream.read()
+    else:
+        ruamel_obj.dump(data, stream=stream)
+        return None
+
+
+__all__ = ["yaml_safe_dump", "yaml_safe_load", "yaml", "__yaml_lib__"]

iad/core/pydantools/fixed_pydantic_yaml/ext/__init__.py

@@ -0,0 +1 @@
+"""Additional extension types that may be useful specifically for YAML files."""

iad/core/pydantools/fixed_pydantic_yaml/ext/semver.py

@@ -0,0 +1,152 @@
+from functools import wraps
+from typing import Any, Callable, Optional, Union, no_type_check
+
+from pydantic.v1 import errors
+from semver import VersionInfo
+
+from ..compat.types import YamlStr
+
+__all__ = ["SemVer"]
+
+
+Comparator = Callable[["SemVer", Any], bool]
+
+
+def _comparator(operator: Comparator) -> Comparator:
+    """Wrap a Version binary op method in a type-check."""
+
+    @wraps(operator)
+    def wrapper(self: "SemVer", other: Any) -> bool:
+        if not isinstance(other, SemVer):
+            try:
+                other = SemVer(other)
+            except Exception:
+                return NotImplemented
+        return operator(self, other)
+
+    return wrapper
+
+
+class SemVer(YamlStr):  # want to inherit from VersionInfo, but metaclass conflict
+    """Semantic Version string for Pydantic.
+
+    Depends on `semver` versions 2 or 3. Look here for how to fix the version:
+    https://python-semver.readthedocs.io/en/3.0.0-dev.2/install.html#release-policy
+    """
+
+    allow_build: bool = True
+    allow_prerelease: bool = True
+
+    __slots__ = ["_info"]
+
+    @no_type_check
+    def __new__(cls, version: Optional[str], **kwargs) -> object:
+        return YamlStr.__new__(cls, cls.parse(**kwargs) if version is None else version)
+
+    def __init__(self, version: str):
+        str.__init__(version)
+        self._info = VersionInfo.parse(version)
+
+    @classmethod
+    def parse(
+        self,
+        major: int,
+        minor: int = 0,
+        patch: int = 0,
+        prerelease: Optional[str] = None,
+        build: Optional[str] = None,
+    ) -> str:
+        return str(VersionInfo(major, minor, patch, prerelease, build))
+
+    @classmethod
+    def __get_validators__(cls):
+        yield cls.validate
+
+    @classmethod
+    def validate(cls, value: Union[str, "SemVer"]) -> "SemVer":
+        vi = VersionInfo.parse(value)
+        if not cls.allow_build and (vi.build is None):
+            raise errors.NotNoneError()
+        if not cls.allow_prerelease and (vi.prerelease is None):
+            raise errors.NotNoneError()
+        return cls(value)
+
+    @property
+    def info(self) -> VersionInfo:
+        return self._info
+
+    @info.setter
+    def info(self, value):
+        raise AttributeError("attribute 'info' is readonly")
+
+    @property
+    def major(self) -> int:
+        """The major part of a version (read-only)."""
+        return self._info.major
+
+    @major.setter
+    def major(self, value):
+        raise AttributeError("attribute 'major' is readonly")
+
+    @property
+    def minor(self) -> int:
+        """The minor part of a version (read-only)."""
+        return self._info.minor
+
+    @minor.setter
+    def minor(self, value):
+        raise AttributeError("attribute 'minor' is readonly")
+
+    @property
+    def patch(self) -> int:
+        """The patch part of a version (read-only)."""
+        return self._info.patch
+
+    @patch.setter
+    def patch(self, value):
+        raise AttributeError("attribute 'patch' is readonly")
+
+    @property
+    def prerelease(self) -> Optional[str]:
+        """The prerelease part of a version (read-only)."""
+        return self._info.prerelease
+
+    @prerelease.setter
+    def prerelease(self, value):
+        raise AttributeError("attribute 'prerelease' is readonly")
+
+    @property
+    def build(self) -> Optional[str]:
+        """The build part of a version (read-only)."""
+        return self._info.build
+
+    @build.setter
+    def build(self, value):
+        raise AttributeError("attribute 'build' is readonly")
+
+    def __hash__(self) -> int:
+        return super.__hash__(self)  # use string hashing
+
+    @_comparator
+    def __eq__(self, other: "SemVer"):
+        return self._info == other._info
+
+    @_comparator
+    def __ne__(self, other: "SemVer"):
+        return self._info != other._info
+
+    @_comparator
+    def __lt__(self, other: "SemVer"):
+        return self._info < other._info
+
+    @_comparator
+    def __le__(self, other: "SemVer"):
+        return self._info <= other._info
+
+    @_comparator
+    def __gt__(self, other: "SemVer"):
+        return self._info > other._info
+
+    @_comparator
+    def __ge__(self, other: "SemVer"):
+        return self._info >= other._info