libres 0.7.3__py3-none-any.whl → 0.9.0__py3-none-any.whl

libres/__init__.py

@@ -1,9 +1,11 @@
+from __future__ import annotations
+
 from libres.context.registry import create_default_registry
 from libres.db import new_scheduler
 
 registry = create_default_registry()
 
-__version__ = '0.7.3'
+__version__ = '0.9.0'
 __all__ = (
     'new_scheduler',
     'registry'

libres/context/core.py

@@ -1,17 +1,23 @@
+from __future__ import annotations
+
 import enum
 import libres
 import threading
-
 from contextlib import contextmanager
 from functools import cached_property
 
 from libres.modules import errors
 
 
-import typing as _t
-if _t.TYPE_CHECKING:
+from typing import Any
+from typing import Literal
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from collections.abc import Iterator
     from sqlalchemy.orm import Session
     from sqlalchemy.orm.session import SessionTransaction
+    from typing_extensions import TypeAlias
     from uuid import UUID
 
     from libres.context.registry import Registry
@@ -24,8 +30,8 @@ class _Marker(enum.Enum):
     required = enum.auto()
 
 
-missing_t = _t.Literal[_Marker.missing]
-required_t = _t.Literal[_Marker.required]
+missing_t: TypeAlias = Literal[_Marker.missing]  # noqa: PYI042
+required_t: TypeAlias = Literal[_Marker.required]  # noqa: PYI042
 missing: missing_t = _Marker.missing
 required: required_t = _Marker.required
 
@@ -51,19 +57,19 @@ class ContextServicesMixin:
 
     """
 
-    context: 'Context'
+    context: Context
 
     @cached_property
-    def is_allocation_exposed(self) -> _t.Callable[['Allocation'], bool]:
-        return self.context.get_service('exposure').is_allocation_exposed
+    def is_allocation_exposed(self) -> Callable[[Allocation], bool]:
+        return self.context.get_service('exposure').is_allocation_exposed  # type: ignore[no-any-return]
 
     @cached_property
-    def generate_uuid(self) -> _t.Callable[[str], 'UUID']:
-        return self.context.get_service('uuid_generator')
+    def generate_uuid(self) -> Callable[[str], UUID]:
+        return self.context.get_service('uuid_generator')  # type: ignore[no-any-return]
 
     @cached_property
-    def validate_email(self) -> _t.Callable[[str], bool]:
-        return self.context.get_service('email_validator')
+    def validate_email(self) -> Callable[[str], bool]:
+        return self.context.get_service('email_validator')  # type: ignore[no-any-return]
 
     def clear_cache(self) -> None:
         """ Clears the cache of the mixin. """
@@ -84,20 +90,20 @@ class ContextServicesMixin:
             pass
 
     @property
-    def session_provider(self) -> 'SessionProvider':
-        return self.context.get_service('session_provider')
+    def session_provider(self) -> SessionProvider:
+        return self.context.get_service('session_provider')  # type: ignore[no-any-return]
 
     @property
-    def session(self) -> 'Session':
+    def session(self) -> Session:
         """ Returns the current session. """
-        return self.session_provider.session()
+        return self.session_provider.session()  # type: ignore[no-any-return]
 
     def close(self) -> None:
         """ Closes the current session. """
         self.session.close()
 
     @property
-    def begin_nested(self) -> _t.Callable[[], 'SessionTransaction']:
+    def begin_nested(self) -> Callable[[], SessionTransaction]:
         return self.session.begin_nested
 
     def commit(self) -> None:
@@ -143,13 +149,13 @@ class Context:
     def __init__(
         self,
         name: str,
-        registry: _t.Optional['Registry'] = None,
-        parent: _t.Optional['Context'] = None,
+        registry: Registry | None = None,
+        parent: Context | None = None,
         locked: bool = False
     ):
         self.name = name
         self.registry = registry or libres.registry
-        self.values: _t.Dict[str, _t.Any] = {}
+        self.values: dict[str, Any] = {}
         self.parent = parent
         self.locked = False
         self.thread_lock = threading.RLock()
@@ -158,7 +164,7 @@ class Context:
         return f"<Libres Context(name='{self.name}')>"
 
     @contextmanager
-    def as_current_context(self) -> _t.Iterator[None]:
+    def as_current_context(self) -> Iterator[None]:
         with self.registry.context(self.name):
             yield
 
@@ -173,7 +179,7 @@ class Context:
         with self.thread_lock:
             self.locked = False
 
-    def get(self, key: str) -> _t.Union[_t.Any, missing_t]:
+    def get(self, key: str) -> Any | missing_t:
         if key in self.values:
             return self.values[key]
         elif self.parent:
@@ -181,7 +187,7 @@ class Context:
         else:
             return missing
 
-    def set(self, key: str, value: _t.Any) -> None:
+    def set(self, key: str, value: Any) -> None:
         if self.locked:
             raise errors.ContextIsLocked
 
@@ -195,21 +201,21 @@ class Context:
 
             self.values[key] = value
 
-    def get_setting(self, name: str) -> _t.Any:
+    def get_setting(self, name: str) -> Any:
         return self.get(f'settings.{name}')
 
-    def set_setting(self, name: str, value: _t.Any) -> None:
+    def set_setting(self, name: str, value: Any) -> None:
         with self.thread_lock:
             self.set(f'settings.{name}', value)
 
-    def get_service(self, name: str) -> _t.Any:
-        service_id = '/'.join(('service', name))
+    def get_service(self, name: str) -> Any:
+        service_id = f'service/{name}'
         service = self.get(service_id)
 
         if service is missing:
             raise errors.UnknownService(service_id)
 
-        cache_id = '/'.join(('service', name, 'cache'))
+        cache_id = f'service/{name}/cache'
         cache = self.get(cache_id)
 
         # no cache
@@ -226,13 +232,13 @@ class Context:
     def set_service(
         self,
         name: str,
-        factory: _t.Callable[..., _t.Any],
+        factory: Callable[..., Any],
         cache: bool = False
     ) -> None:
         with self.thread_lock:
-            service_id = '/'.join(('service', name))
+            service_id = f'service/{name}'
             self.set(service_id, factory)
 
             if cache:
-                cache_id = '/'.join(('service', name, 'cache'))
+                cache_id = f'service/{name}/cache'
                 self.set(cache_id, required)

libres/context/exposure.py

@@ -1,9 +1,13 @@
-import typing as _t
-if _t.TYPE_CHECKING:
+from __future__ import annotations
+
+
+from typing import Literal
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
     from libres.db.models import Allocation
 
 
 class Exposure:
     @staticmethod
-    def is_allocation_exposed(allocation: 'Allocation') -> _t.Literal[True]:
+    def is_allocation_exposed(allocation: Allocation) -> Literal[True]:
         return True

libres/context/registry.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import threading
 
 from contextlib import contextmanager
@@ -6,12 +8,14 @@ from libres.modules import errors
 from libres.context.core import Context
 
 
-import typing as _t
-if _t.TYPE_CHECKING:
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from collections.abc import Iterator
     from uuid import UUID
 
 
-def create_default_registry() -> 'Registry':
+def create_default_registry() -> Registry:
     """ Creates the default registry for libres. """
 
     import re
@@ -28,7 +32,7 @@ def create_default_registry() -> 'Registry':
     def session_provider(context: Context) -> SessionProvider:
         return SessionProvider(context.get_setting('dsn'))
 
-    def email_validator_factory(context: Context) -> _t.Callable[[str], bool]:
+    def email_validator_factory(context: Context) -> Callable[[str], bool]:
         # A very simple and stupid email validator. It's way too simple, but
         # it can be extended to do more powerful checks.
         def is_valid_email(email: str) -> bool:
@@ -39,11 +43,11 @@ def create_default_registry() -> 'Registry':
     def exposure_factory(context: Context) -> Exposure:
         return Exposure()
 
-    def uuid_generator_factory(context: Context) -> _t.Callable[[str], 'UUID']:
-        def uuid_generator(name: str) -> 'UUID':
+    def uuid_generator_factory(context: Context) -> Callable[[str], UUID]:
+        def uuid_generator(name: str) -> UUID:
             return new_namespace_uuid(
                 context.get_setting('uuid_namespace'),
-                '/'.join((context.name, name))
+                f'{context.name}/{name}'
             )
         return uuid_generator
 
@@ -77,8 +81,8 @@ class Registry:
 
     """
 
-    contexts: _t.Dict[str, Context]
-    master_context: _t.Optional[Context] = None
+    contexts: dict[str, Context]
+    master_context: Context | None = None
 
     def __init__(self) -> None:
         self.thread_lock = threading.RLock()
@@ -94,7 +98,7 @@ class Registry:
         if not hasattr(self.local, 'current_context'):
             self.local.current_context = self.master_context
 
-        return self.local.current_context
+        return self.local.current_context  # type: ignore[no-any-return]
 
     def is_existing_context(self, name: str) -> bool:
         return name in self.contexts
@@ -137,7 +141,7 @@ class Registry:
             self.local.current_context = self.get_context(name)
 
     @contextmanager
-    def context(self, name: str) -> _t.Iterator[Context]:
+    def context(self, name: str) -> Iterator[Context]:
         previous = self.current_context.name
         self.switch_context(name)
         yield self.current_context

libres/context/session.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from sqlalchemy import create_engine
 from sqlalchemy.pool import QueuePool
 from sqlalchemy.orm import scoped_session, sessionmaker
@@ -5,7 +7,7 @@ from sqlalchemy.orm import scoped_session, sessionmaker
 from libres.context.core import StoppableService
 
 
-import typing as _t
+from typing import Any
 
 
 SERIALIZABLE = 'SERIALIZABLE'
@@ -24,8 +26,8 @@ class SessionProvider(StoppableService):
     def __init__(
         self,
         dsn: str,
-        engine_config: _t.Optional[_t.Dict[str, _t.Any]] = None,
-        session_config: _t.Optional[_t.Dict[str, _t.Any]] = None
+        engine_config: dict[str, Any] | None = None,
+        session_config: dict[str, Any] | None = None
     ):
         self.assert_valid_postgres_version(dsn)
         self.dsn = dsn
@@ -53,13 +55,13 @@ class SessionProvider(StoppableService):
         self.engine.raw_connection().invalidate()
         self.engine.dispose()
 
-    def get_postgres_version(self, dsn: str) -> _t.Tuple[str, int]:
+    def get_postgres_version(self, dsn: str) -> tuple[str, int]:
         """ Returns the postgres version as a tuple (string, integer).
 
         Uses it's own connection to be independent from any session.
 
         """
-        assert 'postgres' in dsn, "Not a postgres database"
+        assert 'postgres' in dsn, 'Not a postgres database'
 
         query = """
             SELECT current_setting('server_version'),
@@ -80,6 +82,6 @@ class SessionProvider(StoppableService):
         v, n = self.get_postgres_version(dsn)
 
         if n < 90100:
-            raise RuntimeError(f"PostgreSQL 9.1+ is required, got {v}")
+            raise RuntimeError(f'PostgreSQL 9.1+ is required, got {v}')
 
         return dsn

libres/context/settings.py

@@ -1,13 +1,16 @@
+from __future__ import annotations
+
 import textwrap
 from uuid import UUID
 
 
-import typing as _t
-if _t.TYPE_CHECKING:
+from typing import Any
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
     from libres.context.core import Context
 
 
-_default: _t.Dict[str, _t.Tuple[_t.Any, str]] = {}
+_default: dict[str, tuple[Any, str]] = {}
 
 _default['settings.dsn'] = (
     None,
@@ -31,7 +34,7 @@ _default['settings.uuid_namespace'] = (
 )
 
 
-def set_default_settings(context: 'Context') -> None:
+def set_default_settings(context: Context) -> None:
     for name, (value, _) in _default.items():
         context.set(name, value)
 
@@ -42,9 +45,9 @@ doc = []
 for name, (value, help_str) in _default.items():
     reference = f'.. _{name}:\n'
     title = '{name}\n{line}'.format(name=name, line='-' * len(name))
-    default = f'default: **{repr(value)}**'
+    default = f'default: **{value!r}**'
     help_str = textwrap.dedent(help_str)
 
-    doc.append('\n'.join((reference, title, default, help_str)))
+    doc.append(f'{reference}\n{title}\n{default}\n{help_str}')
 
 __doc__ = '\n'.join(doc)

libres/db/__init__.py

@@ -1,4 +1,6 @@
-from libres.db.scheduler import Scheduler as new_scheduler
+from __future__ import annotations
+
+from libres.db.scheduler import Scheduler as new_scheduler  # noqa: N813
 
 __all__ = (
     'new_scheduler',

libres/db/models/__init__.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from libres.db.models.base import ORMBase
 from libres.db.models.allocation import Allocation
 from libres.db.models.reserved_slot import ReservedSlot