ddutils 0.2.4__tar.gz → 0.3.1__tar.gz

{ddutils-0.2.4 → ddutils-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddutils
-Version: 0.2.4
+Version: 0.3.1
 Summary: Domain Driven Utils Library
 Keywords: python,ddutils
 Author: davyddd
@@ -337,28 +337,34 @@ delta = timedelta(seconds=5, milliseconds=500)
 convert_timedelta_to_milliseconds(delta)  # 5500
 ```
 
-### convert_to_builtin
+### convert_to_base_value
 
-Casts a value to its builtin base type (see [get_builtin_base_type](#get_builtin_base_type)):
-a `str` subclass becomes a plain `str`, an `Enum` member becomes its `.value` cast the same way.
-Raises `TypeError` for a value without a builtin base.
+Casts a value to its base value type (see [get_base_value_type](#get_base_value_type)):
+a `str` subclass becomes a plain `str`, a `UUID` subclass a plain `UUID`, a `datetime` subclass a plain `datetime`
+with the same `tzinfo` and `fold`, an `Enum` member becomes its `.value` cast the same way, `None` stays `None`.
+Raises `TypeError` for a value without a base type.
+
+Normalize a value once, then dispatch on the result with plain `isinstance` checks: subclasses, `Enum` members
+and third-party types such as a `pendulum.DateTime` all land on the stdlib type.
 
 ```python
 from enum import Enum
-from ddutils.convertors import convert_to_builtin
+from uuid import UUID
+from ddutils.convertors import convert_to_base_value
 
 
 class Kind(str, Enum):
     A = 'a'
 
 
-class UserId(int):
+class ProfileId(UUID):
     pass
 
 
-convert_to_builtin(Kind.A)  # 'a' (not 'Kind.A', which `str(Kind.A)` would give)
-convert_to_builtin(UserId(2))  # 2
-convert_to_builtin(object())  # TypeError
+convert_to_base_value(None)  # None
+convert_to_base_value(Kind.A)  # 'a' (not 'Kind.A', which `str(Kind.A)` would give)
+convert_to_base_value(ProfileId('12345678-1234-5678-1234-567812345678'))  # UUID('1234...'), exact type UUID
+convert_to_base_value(object())  # TypeError
 ```
 
 ## Datetime Helpers
@@ -513,6 +519,58 @@ that planted a key would be inherited by every request task, making all requests
 same reason the key is not reset when the block ends, so `scope()` must be entered in a task that does not
 outlive the block (a request handler, an actor run).
 
+## Connections
+
+`ddutils.connections` sits between a `ScopedRegistry` and the code that uses a connection: a query, a cache
+lookup, a Kafka send. A registry holds one connection per scope: a pooled client per process, a session
+per task. The connections module adds two things on top:
+
+- `ConnectionManagerFactory(registries, default, connection_manager_class=ConnectionManager)` resolves a
+  connection alias to its registry, like Django's `using`. Calling it opens a connection manager on the
+  chosen registry; `registry(alias)` returns the registry itself; `close()` clears every registry for the
+  current scope, calling the connection's destructor, which is the shutdown hook of process-scoped clients.
+- `ConnectionManager(registry)` is the default connection manager: an async context manager that hands out
+  the connection of the registry's current scope and releases nothing on exit. Enough for clients that are
+  pools themselves, such as ClickHouse, Redis or a Kafka producer.
+
+Databases with transactions pass their own `connection_manager_class`: a unit of work that begins, commits
+or rolls back and closes the session on exit. It depends on the driver, so it lives in the project.
+
+```python
+import os
+from enum import Enum
+
+from ddutils.connections import ConnectionManagerFactory
+from ddutils.scoped_registry import ScopedRegistry
+
+
+class ClickhouseDB(str, Enum):
+    PRIMARY = 'primary'
+
+
+client_registries = {
+    db: ScopedRegistry(create_func=make_client_for(db), scope_func=os.getpid, destructor_method_name='close')
+    for db in ClickhouseDB
+}
+clickhouse = ConnectionManagerFactory(client_registries, default=ClickhouseDB.PRIMARY)
+
+
+async with clickhouse() as client:
+    result = await client.query(sql)
+
+
+# a transactional database: `Atomic` is your unit of work over `registry.scope()`
+atomic = ConnectionManagerFactory(session_registries, default=PostgresDB.PRIMARY, connection_manager_class=Atomic)
+
+
+async with atomic(alias=PostgresDB.REPLICA) as session:
+    ...
+
+
+# on shutdown: closes the clients of every alias that was used in this process
+await clickhouse.close()
+```
+
 ## Function Exception Extraction
 
 AST-based introspection for extracting exceptions from function source code.
@@ -526,29 +584,53 @@ Returns an iterator of `ExceptionInfo` objects describing each raised exception.
 
 Runtime counterparts of the annotation helpers: they inspect values, not type hints.
 
-### get_builtin_base_type
+### get_base_value_type
 
-Returns the builtin type a value should be treated as, looking past subclasses: `bool`, `int`, `float`, `str` or `bytes`
-(`bool` is checked before `int`). An `Enum` member is looked at through its `.value`.
-Raises `TypeError` for any other value. Useful for APIs that dispatch on the exact type (serializers, query builders).
+Returns the base value type a value should be treated as, looking past subclasses. The candidates, in order,
+are `BASE_VALUE_TYPES`: `NoneType`, `bool`, `int`, `float`, `str`, `bytes`, `bytearray`, `datetime`, `date`, `time`,
+`timedelta`, `UUID`, `Decimal` (`bool` is checked before `int`, `datetime` before `date`). An `Enum` member is looked at
+through its `.value`. Raises `TypeError` for any other value, a collection or a mapping included. Useful for APIs that dispatch on the exact type
+(serializers, query builders).
 
 ```python
+from datetime import datetime
 from enum import Enum
-from ddutils.value_helpers import get_builtin_base_type
+from uuid import UUID
+from ddutils.value_helpers import get_base_value_type
 
 
 class Kind(str, Enum):
     A = 'a'
 
 
-class UserId(int):
+class ProfileId(UUID):
     pass
 
 
-get_builtin_base_type(UserId(2))  # <class 'int'>
-get_builtin_base_type(True)  # <class 'bool'>
-get_builtin_base_type(Kind.A)  # <class 'str'>
-get_builtin_base_type(object())  # TypeError
+get_base_value_type(None)  # <class 'NoneType'>
+get_base_value_type(True)  # <class 'bool'>
+get_base_value_type(Kind.A)  # <class 'str'>
+get_base_value_type(ProfileId('12345678-1234-5678-1234-567812345678'))  # <class 'uuid.UUID'>
+get_base_value_type(datetime.now())  # <class 'datetime.datetime'>
+get_base_value_type(object())  # TypeError
+```
+
+### unwrap_enum
+
+Returns the `.value` of an `Enum` member and any other value as is. `str(Kind.A)` of a `class Kind(str, Enum)`
+is `'Kind.A'`, so a member has to be unwrapped before it is formatted or cast.
+
+```python
+from enum import Enum
+from ddutils.value_helpers import unwrap_enum
+
+
+class Kind(str, Enum):
+    A = 'a'
+
+
+unwrap_enum(Kind.A)  # 'a'
+unwrap_enum('a')  # 'a'
 ```
 
 ### is_complex_sequence_value

{ddutils-0.2.4 → ddutils-0.3.1}/README.md

@@ -319,28 +319,34 @@ delta = timedelta(seconds=5, milliseconds=500)
 convert_timedelta_to_milliseconds(delta)  # 5500
 ```
 
-### convert_to_builtin
+### convert_to_base_value
 
-Casts a value to its builtin base type (see [get_builtin_base_type](#get_builtin_base_type)):
-a `str` subclass becomes a plain `str`, an `Enum` member becomes its `.value` cast the same way.
-Raises `TypeError` for a value without a builtin base.
+Casts a value to its base value type (see [get_base_value_type](#get_base_value_type)):
+a `str` subclass becomes a plain `str`, a `UUID` subclass a plain `UUID`, a `datetime` subclass a plain `datetime`
+with the same `tzinfo` and `fold`, an `Enum` member becomes its `.value` cast the same way, `None` stays `None`.
+Raises `TypeError` for a value without a base type.
+
+Normalize a value once, then dispatch on the result with plain `isinstance` checks: subclasses, `Enum` members
+and third-party types such as a `pendulum.DateTime` all land on the stdlib type.
 
 ```python
 from enum import Enum
-from ddutils.convertors import convert_to_builtin
+from uuid import UUID
+from ddutils.convertors import convert_to_base_value
 
 
 class Kind(str, Enum):
     A = 'a'
 
 
-class UserId(int):
+class ProfileId(UUID):
     pass
 
 
-convert_to_builtin(Kind.A)  # 'a' (not 'Kind.A', which `str(Kind.A)` would give)
-convert_to_builtin(UserId(2))  # 2
-convert_to_builtin(object())  # TypeError
+convert_to_base_value(None)  # None
+convert_to_base_value(Kind.A)  # 'a' (not 'Kind.A', which `str(Kind.A)` would give)
+convert_to_base_value(ProfileId('12345678-1234-5678-1234-567812345678'))  # UUID('1234...'), exact type UUID
+convert_to_base_value(object())  # TypeError
 ```
 
 ## Datetime Helpers
@@ -495,6 +501,58 @@ that planted a key would be inherited by every request task, making all requests
 same reason the key is not reset when the block ends, so `scope()` must be entered in a task that does not
 outlive the block (a request handler, an actor run).
 
+## Connections
+
+`ddutils.connections` sits between a `ScopedRegistry` and the code that uses a connection: a query, a cache
+lookup, a Kafka send. A registry holds one connection per scope: a pooled client per process, a session
+per task. The connections module adds two things on top:
+
+- `ConnectionManagerFactory(registries, default, connection_manager_class=ConnectionManager)` resolves a
+  connection alias to its registry, like Django's `using`. Calling it opens a connection manager on the
+  chosen registry; `registry(alias)` returns the registry itself; `close()` clears every registry for the
+  current scope, calling the connection's destructor, which is the shutdown hook of process-scoped clients.
+- `ConnectionManager(registry)` is the default connection manager: an async context manager that hands out
+  the connection of the registry's current scope and releases nothing on exit. Enough for clients that are
+  pools themselves, such as ClickHouse, Redis or a Kafka producer.
+
+Databases with transactions pass their own `connection_manager_class`: a unit of work that begins, commits
+or rolls back and closes the session on exit. It depends on the driver, so it lives in the project.
+
+```python
+import os
+from enum import Enum
+
+from ddutils.connections import ConnectionManagerFactory
+from ddutils.scoped_registry import ScopedRegistry
+
+
+class ClickhouseDB(str, Enum):
+    PRIMARY = 'primary'
+
+
+client_registries = {
+    db: ScopedRegistry(create_func=make_client_for(db), scope_func=os.getpid, destructor_method_name='close')
+    for db in ClickhouseDB
+}
+clickhouse = ConnectionManagerFactory(client_registries, default=ClickhouseDB.PRIMARY)
+
+
+async with clickhouse() as client:
+    result = await client.query(sql)
+
+
+# a transactional database: `Atomic` is your unit of work over `registry.scope()`
+atomic = ConnectionManagerFactory(session_registries, default=PostgresDB.PRIMARY, connection_manager_class=Atomic)
+
+
+async with atomic(alias=PostgresDB.REPLICA) as session:
+    ...
+
+
+# on shutdown: closes the clients of every alias that was used in this process
+await clickhouse.close()
+```
+
 ## Function Exception Extraction
 
 AST-based introspection for extracting exceptions from function source code.
@@ -508,29 +566,53 @@ Returns an iterator of `ExceptionInfo` objects describing each raised exception.
 
 Runtime counterparts of the annotation helpers: they inspect values, not type hints.
 
-### get_builtin_base_type
+### get_base_value_type
 
-Returns the builtin type a value should be treated as, looking past subclasses: `bool`, `int`, `float`, `str` or `bytes`
-(`bool` is checked before `int`). An `Enum` member is looked at through its `.value`.
-Raises `TypeError` for any other value. Useful for APIs that dispatch on the exact type (serializers, query builders).
+Returns the base value type a value should be treated as, looking past subclasses. The candidates, in order,
+are `BASE_VALUE_TYPES`: `NoneType`, `bool`, `int`, `float`, `str`, `bytes`, `bytearray`, `datetime`, `date`, `time`,
+`timedelta`, `UUID`, `Decimal` (`bool` is checked before `int`, `datetime` before `date`). An `Enum` member is looked at
+through its `.value`. Raises `TypeError` for any other value, a collection or a mapping included. Useful for APIs that dispatch on the exact type
+(serializers, query builders).
 
 ```python
+from datetime import datetime
 from enum import Enum
-from ddutils.value_helpers import get_builtin_base_type
+from uuid import UUID
+from ddutils.value_helpers import get_base_value_type
 
 
 class Kind(str, Enum):
     A = 'a'
 
 
-class UserId(int):
+class ProfileId(UUID):
     pass
 
 
-get_builtin_base_type(UserId(2))  # <class 'int'>
-get_builtin_base_type(True)  # <class 'bool'>
-get_builtin_base_type(Kind.A)  # <class 'str'>
-get_builtin_base_type(object())  # TypeError
+get_base_value_type(None)  # <class 'NoneType'>
+get_base_value_type(True)  # <class 'bool'>
+get_base_value_type(Kind.A)  # <class 'str'>
+get_base_value_type(ProfileId('12345678-1234-5678-1234-567812345678'))  # <class 'uuid.UUID'>
+get_base_value_type(datetime.now())  # <class 'datetime.datetime'>
+get_base_value_type(object())  # TypeError
+```
+
+### unwrap_enum
+
+Returns the `.value` of an `Enum` member and any other value as is. `str(Kind.A)` of a `class Kind(str, Enum)`
+is `'Kind.A'`, so a member has to be unwrapped before it is formatted or cast.
+
+```python
+from enum import Enum
+from ddutils.value_helpers import unwrap_enum
+
+
+class Kind(str, Enum):
+    A = 'a'
+
+
+unwrap_enum(Kind.A)  # 'a'
+unwrap_enum('a')  # 'a'
 ```
 
 ### is_complex_sequence_value

{ddutils-0.2.4 → ddutils-0.3.1}/ddutils/__init__.py

@@ -10,6 +10,7 @@ from . import (
     safe_decorators,
     scoped_registry,
     sequence_helpers,
+    value_helpers,
 )
 
 __all__ = (
@@ -24,4 +25,5 @@ __all__ = (
     'safe_decorators',
     'scoped_registry',
     'sequence_helpers',
+    'value_helpers',
 )

ddutils-0.3.1/ddutils/connections.py

@@ -0,0 +1,81 @@
+from collections.abc import Callable, Hashable, Mapping
+from typing import Any, Generic, TypeVar
+
+from ddutils.scoped_registry import ScopedRegistry
+
+# The name a connection is registered under and selected by, like Django's `using` alias
+ConnectionAliasT = TypeVar('ConnectionAliasT', bound=Hashable)
+# The object a registry holds for a connection: a pooled client, a session
+ConnectionT = TypeVar('ConnectionT')
+# The context manager the factory opens on the chosen registry
+ConnectionManagerT = TypeVar('ConnectionManagerT')
+
+
+class ConnectionManager(Generic[ConnectionT]):
+    """
+    Default connection manager: hands out the connection of the registry's current scope and releases nothing on exit.
+
+    The connection is created on first use via `registry.set()` and kept for the life of its scope,
+    typically a process, since a client is itself a connection pool (ClickHouse, Redis, a Kafka producer). Databases
+    with transactions need their own connection manager on top of the registry, e.g. a unit of work that begins,
+    commits and closes a session on exit.
+    """
+
+    def __init__(self, registry: ScopedRegistry[ConnectionT]) -> None:
+        self._registry = registry
+
+    async def __aenter__(self) -> ConnectionT:
+        return await self._registry.set()
+
+    async def __aexit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: Any) -> None:
+        return None
+
+
+class ConnectionManagerFactory(Generic[ConnectionAliasT, ConnectionT, ConnectionManagerT]):
+    """
+    Resolves a connection alias to its registry and opens a connection manager on it, like Django's `using`.
+
+    `connection_manager_class` is the context manager opened on the chosen registry: `ConnectionManager` by
+    default, a project class for anything that needs setup and teardown around the connection (transactions):
+
+        clickhouse = ConnectionManagerFactory(client_registries, default=ClickhouseAlias.PRIMARY)
+        atomic = ConnectionManagerFactory(session_registries, default=PostgresAlias.PRIMARY, connection_manager_class=Atomic)
+
+        async with clickhouse() as client: ...
+        async with atomic(alias=PostgresAlias.REPLICA) as session: ...
+        await clickhouse.close()  # on shutdown
+    """
+
+    def __init__(
+        self,
+        registries: Mapping[ConnectionAliasT, ScopedRegistry[ConnectionT]],
+        default: ConnectionAliasT,
+        connection_manager_class: Callable[[ScopedRegistry[ConnectionT]], ConnectionManagerT] = ConnectionManager,  # type: ignore[assignment]
+    ) -> None:
+        if default not in registries:
+            raise ValueError(f'Default connection {default!r} is not among the registries')
+        self.registries = registries
+        self.default = default
+        self.connection_manager_class = connection_manager_class
+
+    def registry(self, alias: Hashable | None = None) -> ScopedRegistry[ConnectionT]:
+        """The registry of `alias`, or of the default connection; `Hashable` because `Adapter.alias` is untyped."""
+        alias = self.default if alias is None else alias
+        if alias not in self.registries:
+            raise KeyError(f'Unknown connection {alias!r}; expected one of {list(self.registries)!r}')
+        return self.registries[alias]  # type: ignore[index]
+
+    def __call__(self, alias: Hashable | None = None) -> ConnectionManagerT:
+        return self.connection_manager_class(self.registry(alias))
+
+    async def close(self) -> None:
+        """
+        Clears every registry for the current scope, calling the connection's destructor: the shutdown hook of
+        a process-scoped client (a pool, a producer with a buffer to flush). A registry without a connection in
+        the current scope is left alone, so the hook is safe to call for aliases that were never used.
+        """
+        for registry in self.registries.values():
+            await registry.clear()
+
+
+__all__ = ('ConnectionManager', 'ConnectionManagerFactory')

ddutils-0.3.1/ddutils/convertors.py

@@ -0,0 +1,86 @@
+from collections.abc import Callable
+from datetime import date, datetime, time, timedelta
+from decimal import Decimal
+from types import NoneType
+from typing import Any, Protocol
+from uuid import UUID
+
+from ddutils.value_helpers import BASE_VALUE_TYPES, get_base_value_type, unwrap_enum
+
+
+class ClassInstanceWithDict(Protocol):
+    __dict__: dict
+
+
+def convert_camel_case_to_snake_case(string: str) -> str:
+    return ''.join(f'_{char.lower()}' if char.isupper() else char for char in string).lstrip('_')
+
+
+def convert_to_repr(obj: ClassInstanceWithDict) -> str:
+    class_name = obj.__class__.__name__
+    if not hasattr(obj, '__dict__'):
+        raise TypeError(f'Instance of {class_name} class does not have a `__dict__` attribute.')
+
+    attrs = ', '.join(f'{key}={value!r}' for key, value in obj.__dict__.items() if not key.startswith('_'))
+    return f'{class_name}({attrs})'
+
+
+def convert_timedelta_to_milliseconds(delta: timedelta) -> int:
+    return int(delta.total_seconds() * 1000)
+
+
+def _convert_to_datetime(value: datetime) -> datetime:
+    return datetime(
+        value.year, value.month, value.day, value.hour, value.minute, value.second, value.microsecond,
+        value.tzinfo, fold=value.fold,
+    )  # fmt: skip
+
+
+def _convert_to_date(value: date) -> date:
+    return date(value.year, value.month, value.day)
+
+
+def _convert_to_time(value: time) -> time:
+    return time(value.hour, value.minute, value.second, value.microsecond, value.tzinfo, fold=value.fold)
+
+
+def _convert_to_timedelta(value: timedelta) -> timedelta:
+    # not `total_seconds()`: it goes through a float and loses microseconds on large values
+    return timedelta(days=value.days, seconds=value.seconds, microseconds=value.microseconds)
+
+
+def _convert_to_uuid(value: UUID) -> UUID:
+    return UUID(int=value.int)
+
+
+# A cast for every type of `BASE_VALUE_TYPES`: the constructor where it accepts an instance of a subclass,
+# a function building the value from its fields otherwise
+BASE_VALUE_CONVERTORS: dict[type, Callable[[Any], Any]] = {
+    NoneType: lambda _: None,
+    bool: bool,
+    int: int,
+    float: float,
+    str: str,
+    bytes: bytes,
+    bytearray: bytearray,
+    datetime: _convert_to_datetime,
+    date: _convert_to_date,
+    time: _convert_to_time,
+    timedelta: _convert_to_timedelta,
+    UUID: _convert_to_uuid,
+    Decimal: Decimal,
+}
+
+if set(BASE_VALUE_CONVERTORS) != set(BASE_VALUE_TYPES):
+    raise RuntimeError('`BASE_VALUE_CONVERTORS` must define a convertor for exactly the types of `BASE_VALUE_TYPES`')
+
+
+def convert_to_base_value(value: Any) -> Any:
+    """
+    Cast a value to its base value type (see `get_base_value_type`): a `str` subclass becomes a plain `str`,
+    a `UUID` subclass a plain `UUID`, a `datetime` subclass a plain `datetime` with the same `tzinfo` and `fold`,
+    an `Enum` member becomes its `.value` cast the same way, `None` stays `None`.
+    Raises `TypeError` for a value without a base type.
+    """
+    value = unwrap_enum(value)
+    return BASE_VALUE_CONVERTORS[get_base_value_type(value)](value)

ddutils-0.3.1/ddutils/value_helpers.py

@@ -0,0 +1,37 @@
+from collections.abc import Sequence
+from datetime import date, datetime, time, timedelta
+from decimal import Decimal
+from enum import Enum
+from types import NoneType
+from typing import Any
+from uuid import UUID
+
+from ddutils.annotation_helpers import NON_COMPLEX_SEQUENCE_TYPES
+
+# The order matters, a value is matched against the first type it is an instance of:
+# `bool` is a subclass of `int`, `datetime` is a subclass of `date`
+BASE_VALUE_TYPES = (NoneType, bool, int, float, str, bytes, bytearray, datetime, date, time, timedelta, UUID, Decimal)
+
+
+def unwrap_enum(value: Any) -> Any:
+    """Return the `.value` of an `Enum` member, any other value as is."""
+    return value.value if isinstance(value, Enum) else value
+
+
+def get_base_value_type(value: Any) -> type:
+    """
+    Return the base value type a value should be treated as, looking past subclasses: one of `BASE_VALUE_TYPES`
+    (`NoneType`, `bool`, `int`, `float`, `str`, `bytes`, `bytearray`, `datetime`, `date`, `time`, `timedelta`, `UUID`,
+    `Decimal`). An `Enum` member is looked at through its `.value`. Raises `TypeError` for any other value.
+    """
+    value = unwrap_enum(value)
+    for base_type in BASE_VALUE_TYPES:
+        if isinstance(value, base_type):
+            return base_type
+
+    raise TypeError(f'Value of type `{type(value).__name__}` has no base value type')
+
+
+def is_complex_sequence_value(value: Any) -> bool:
+    """Return whether a value is a sequence other than `str`, `bytes` or `bytearray`; subclasses are handled."""
+    return isinstance(value, Sequence) and not isinstance(value, NON_COMPLEX_SEQUENCE_TYPES)

{ddutils-0.2.4 → ddutils-0.3.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "ddutils"
 description = "Domain Driven Utils Library"
-version = "0.2.4"
+version = "0.3.1"
 license = "MIT"
 license-files = ["LICENSE"]
 readme = "README.md"

{ddutils-0.2.4 → ddutils-0.3.1}/pyproject.toml.orig

@@ -1,7 +1,7 @@
 [project]
 name = "ddutils"
 description = "Domain Driven Utils Library"
-version = "0.2.4"
+version = "0.3.1"
 authors = [{ name = "davyddd" }]
 license = "MIT"
 license-files = ["LICENSE"]

ddutils-0.2.4/ddutils/convertors.py

@@ -1,34 +0,0 @@
-from datetime import timedelta
-from typing import Any, Protocol
-
-from ddutils.value_helpers import get_builtin_base_type, unwrap_enum
-
-
-class ClassInstanceWithDict(Protocol):
-    __dict__: dict
-
-
-def convert_camel_case_to_snake_case(string: str) -> str:
-    return ''.join(f'_{char.lower()}' if char.isupper() else char for char in string).lstrip('_')
-
-
-def convert_to_repr(obj: ClassInstanceWithDict) -> str:
-    class_name = obj.__class__.__name__
-    if not hasattr(obj, '__dict__'):
-        raise TypeError(f'Instance of {class_name} class does not have a `__dict__` attribute.')
-
-    attrs = ', '.join(f'{key}={value!r}' for key, value in obj.__dict__.items() if not key.startswith('_'))
-    return f'{class_name}({attrs})'
-
-
-def convert_timedelta_to_milliseconds(delta: timedelta) -> int:
-    return int(delta.total_seconds() * 1000)
-
-
-def convert_to_builtin(value: Any) -> bool | int | float | str | bytes:
-    """
-    Cast a value to its builtin base type (see `get_builtin_base_type`): a `str` subclass becomes a plain `str`,
-    an `Enum` member becomes its `.value` cast the same way. Raises `TypeError` for a value without a builtin base.
-    """
-    value = unwrap_enum(value)
-    return get_builtin_base_type(value)(value)

ddutils-0.2.4/ddutils/value_helpers.py

@@ -1,30 +0,0 @@
-from collections.abc import Sequence
-from enum import Enum
-from typing import Any
-
-from ddutils.annotation_helpers import NON_COMPLEX_SEQUENCE_TYPES
-
-# `bool` goes before `int` because `bool` is a subclass of `int`
-BUILTIN_BASE_TYPES = (bool, int, float, str, bytes)
-
-
-def unwrap_enum(value: Any) -> Any:
-    return value.value if isinstance(value, Enum) else value
-
-
-def get_builtin_base_type(value: Any) -> type:
-    """
-    Return the builtin type a value should be treated as, looking past subclasses: `bool`, `int`, `float`, `str`
-    or `bytes`. An `Enum` member is looked at through its `.value`. Raises `TypeError` for any other value.
-    """
-    value = unwrap_enum(value)
-    for base_type in BUILTIN_BASE_TYPES:
-        if isinstance(value, base_type):
-            return base_type
-
-    raise TypeError(f'Value of type `{type(value).__name__}` has no builtin base type')
-
-
-def is_complex_sequence_value(value: Any) -> bool:
-    """Return whether a value is a sequence other than `str`, `bytes` or `bytearray`; subclasses are handled."""
-    return isinstance(value, Sequence) and not isinstance(value, NON_COMPLEX_SEQUENCE_TYPES)