encommon 0.22.9__py3-none-any.whl → 0.22.11__py3-none-any.whl

encommon/times/timers.py

@@ -8,8 +8,13 @@ is permitted, for more information consult the project license file.
 
 
 from copy import deepcopy
+from threading import Lock
+from typing import Annotated
 from typing import Optional
 from typing import TYPE_CHECKING
+from typing import Type
+
+from pydantic import Field
 
 from sqlalchemy import Column
 from sqlalchemy import String
@@ -23,6 +28,9 @@ from .common import PARSABLE
 from .params import TimersParams
 from .time import Time
 from .timer import Timer
+from ..types import BaseModel
+from ..types import DictStrAny
+from ..types import LDictStrAny
 
 if TYPE_CHECKING:
     from .params import TimerParams
@@ -33,17 +41,7 @@ TIMERS = dict[str, Timer]
 
 
 
-class SQLBase(DeclarativeBase):
-    """
-    Some additional class that SQLAlchemy requires to work.
-
-    .. note::
-       Input parameters are not defined, check parent class.
-    """
-
-
-
-class TimersTable(SQLBase):
+class TimersTable(DeclarativeBase):
     """
     Schematic for the database operations using SQLAlchemy.
 
@@ -69,7 +67,74 @@ class TimersTable(SQLBase):
         String,
         nullable=False)
 
-    __tablename__ = 'timers'
+
+
+class TimersRecord(BaseModel):
+    """
+    Contain the information of the record from the database.
+
+    :param record: Record from the SQLAlchemy query routine.
+    """
+
+    group: Annotated[
+        str,
+        Field(...,
+              description='Group the children by category',
+              min_length=1)]
+
+    unique: Annotated[
+        str,
+        Field(...,
+              description='Unique identifier for the child',
+              min_length=1)]
+
+    last: Annotated[
+        str,
+        Field(...,
+              description='Last interval for the period',
+              min_length=20,
+              max_length=32)]
+
+    update: Annotated[
+        str,
+        Field(...,
+              description='When the record was updated',
+              min_length=20,
+              max_length=32)]
+
+
+    def __init__(
+        self,
+        record: Optional[DeclarativeBase] = None,
+    ) -> None:
+        """
+        Initialize instance for class using provided parameters.
+        """
+
+        fields = [
+            'group',
+            'unique',
+            'last',
+            'update']
+
+        params = {
+            x: getattr(record, x)
+            for x in fields}
+
+
+        timefs = [
+            'last',
+            'update']
+
+        params |= {
+            k: (Time(v).simple
+                if v else None)
+            for k, v in
+            params.items()
+            if k in timefs}
+
+
+        super().__init__(**params)
 
 
 
@@ -106,13 +171,15 @@ class Timers:
 
     __store: str
     __group: str
+    __table: Type[TimersTable]
+    __locker: Lock
 
     __sengine: Engine
     __session: (
         # pylint: disable=unsubscriptable-object
         sessionmaker[Session])
 
-    __timers: TIMERS
+    __childs: TIMERS
 
 
     def __init__(
@@ -120,6 +187,7 @@ class Timers:
         params: Optional['TimersParams'] = None,
         *,
         store: str = 'sqlite:///:memory:',
+        table: str = 'timers',
         group: str = 'default',
     ) -> None:
         """
@@ -137,15 +205,25 @@ class Timers:
         self.__store = store
         self.__group = group
 
-        self.__make_engine()
+        class SQLBase(DeclarativeBase):
+            pass
 
+        self.__table = type(
+            f'encommon_timers_{table}',
+            (SQLBase, TimersTable),
+            {'__tablename__': table})
 
-        self.__timers = {}
+        self.__locker = Lock()
 
-        self.load_children()
+        self.__build_engine()
 
 
-    def __make_engine(
+        self.__childs = {}
+
+        self.__build_objects()
+
+
+    def __build_engine(
         self,
     ) -> None:
         """
@@ -156,7 +234,7 @@ class Timers:
             self.__store,
             pool_pre_ping=True)
 
-        (SQLBase.metadata
+        (self.__table.metadata
          .create_all(sengine))
 
         session = (
@@ -166,6 +244,23 @@ class Timers:
         self.__session = session
 
 
+    def __build_objects(
+        self,
+    ) -> None:
+        """
+        Construct instances using the configuration parameters.
+        """
+
+        params = self.__params
+
+        items = (
+            params.timers
+            .items())
+
+        for name, item in items:
+            self.create(name, item)
+
+
     @property
     def params(
         self,
@@ -205,6 +300,19 @@ class Timers:
         return self.__group
 
 
+    @property
+    def store_table(
+        self,
+    ) -> Type[TimersTable]:
+        """
+        Return the value for the attribute from class instance.
+
+        :returns: Value for the attribute from class instance.
+        """
+
+        return self.__table
+
+
     @property
     def store_engine(
         self,
@@ -241,101 +349,53 @@ class Timers:
         :returns: Value for the attribute from class instance.
         """
 
-        return dict(self.__timers)
+        return dict(self.__childs)
 
 
-    def load_children(
+    def save_children(
         self,
     ) -> None:
         """
-        Construct the children instances for the primary class.
+        Save the child caches from the attribute into database.
         """
 
-        params = self.__params
-        timers = self.__timers
+        sess = self.__session()
+        lock = self.__locker
 
+        table = self.__table
         group = self.__group
-
-        session = self.store_session
-
-        config = params.timers
+        childs = self.__childs
 
 
-        _table = TimersTable
-        _group = _table.group
-        _unique = _table.unique
+        inserts: LDictStrAny = []
 
-        query = (
-            session.query(_table)
-            .filter(_group == group)
-            .order_by(_unique))
+        update = Time('now')
 
-        for record in query.all():
 
-            unique = str(record.unique)
-            last = str(record.last)
+        items = childs.items()
 
-            if unique not in config:
-                continue
+        for unique, cache in items:
 
-            _config = config[unique]
+            _last = cache.time.subsec
+            _update = update.subsec
 
-            _config.start = last
+            inputs: DictStrAny = {
+                'group': group,
+                'unique': unique,
+                'last': _last,
+                'update': _update}
 
+            inserts.append(inputs)
 
-        items = config.items()
 
-        for key, value in items:
+        with lock, sess as session:
 
-            if key in timers:
+            for insert in inserts:
 
-                timer = timers[key]
+                session.merge(
+                    table(**insert))
 
-                timer.update(value.start)
-
-                continue
-
-            timer = Timer(
-                value.timer,
-                start=value.start)
-
-            timers[key] = timer
-
-
-        self.__timers = timers
-
-
-    def save_children(
-        self,
-    ) -> None:
-        """
-        Save the child caches from the attribute into database.
-        """
-
-        timers = self.__timers
-
-        group = self.__group
-
-        session = self.store_session
-
-
-        items = timers.items()
-
-        for unique, timer in items:
-
-            update = Time('now')
-
-            append = TimersTable(
-                group=group,
-                unique=unique,
-                last=timer.time.subsec,
-                update=update.subsec)
-
-            session.merge(append)
-
-
-        session.commit()
-        session.close()
+            session.commit()
 
 
     def ready(
@@ -351,14 +411,14 @@ class Timers:
         :returns: Boolean indicating whether enough time passed.
         """
 
-        timers = self.__timers
+        childs = self.__childs
 
-        if unique not in timers:
+        if unique not in childs:
             raise ValueError('unique')
 
-        timer = timers[unique]
+        child = childs[unique]
 
-        ready = timer.ready(update)
+        ready = child.ready(update)
 
         if ready is True:
             self.save_children()
@@ -383,6 +443,52 @@ class Timers:
             unique, update)
 
 
+    def select(
+        self,
+        unique: str,
+    ) -> Optional[TimersRecord]:
+        """
+        Return the record from within the table in the database.
+
+        :returns: Record from within the table in the database.
+        """
+
+        sess = self.__session()
+        lock = self.__locker
+
+        table = self.__table
+        model = TimersRecord
+
+        table = self.__table
+        group = self.__group
+
+        _unique = table.unique
+        _group = table.group
+
+
+        with lock, sess as session:
+
+            query = (
+                session.query(table)
+                .filter(_unique == unique)
+                .filter(_group == group))
+
+            _records = list(query.all())
+
+
+        records = [
+            model(x)
+            for x in _records]
+
+
+        if len(records) == 0:
+            return None
+
+        assert len(records) == 1
+
+        return records[0]
+
+
     def create(
         self,
         unique: str,
@@ -396,20 +502,31 @@ class Timers:
         :returns: Newly constructed instance of related class.
         """
 
-        config = (
-            self.params
-            .timers)
+        childs = self.__childs
 
-        if unique in config:
+        if unique in childs:
             raise ValueError('unique')
 
-        config[unique] = params
+        timer = params.timer
+        start = params.start
+
+
+        select = self.select(unique)
+
+        if select is not None:
+            start = select.last
+
+
+        child = Timer(
+            timer=timer,
+            start=start)
+
+        childs[unique] = child
 
-        self.load_children()
 
         self.save_children()
 
-        return self.children[unique]
+        return child
 
 
     def update(
@@ -424,14 +541,14 @@ class Timers:
         :param value: Override the time updated for timer value.
         """
 
-        timers = self.__timers
+        childs = self.__childs
 
-        if unique not in timers:
+        if unique not in childs:
             raise ValueError('unique')
 
-        timer = timers[unique]
+        child = childs[unique]
 
-        timer.update(value)
+        child.update(value)
 
         self.save_children()
 
@@ -450,32 +567,26 @@ class Timers:
         :param unique: Unique identifier for the related child.
         """
 
-        params = self.__params
-        timers = self.__timers
+        sess = self.__session()
+        lock = self.__locker
+        childs = self.__childs
 
+        table = self.__table
         group = self.__group
 
-        session = self.store_session
-
-        config = params.timers
-
-
-        if unique in config:
-            del config[unique]
+        _unique = table.unique
+        _group = table.group
 
-        if unique in timers:
-            del timers[unique]
 
+        with lock, sess as session:
 
-        _table = TimersTable
-        _group = _table.group
-        _unique = _table.unique
+            (session.query(table)
+             .filter(_unique == unique)
+             .filter(_group == group)
+             .delete())
 
-        (session.query(_table)
-         .filter(_unique == unique)
-         .filter(_group == group)
-         .delete())
+            session.commit()
 
 
-        session.commit()
-        session.close()
+        if unique in childs:
+            del childs[unique]