holado 0.4.2__py3-none-any.whl → 0.5.2__py3-none-any.whl

holado_db/tools/db/clients/base/db_client.py

@@ -41,6 +41,8 @@ class DBClient(object):
         
         self.__connection = None
         self.__query_builder = None
+        self.__audit_manager = None
+        self.__column_names_by_table = {}
     
     @property
     def name(self):
@@ -68,6 +70,19 @@ class DBClient(object):
             raise TechnicalException(f"DB client '{self.__name}' doesn't manage cursor")
         return self.__cursor
     
+    @property
+    def audit_manager(self):
+        if self.__audit_manager is None:
+            self.__audit_manager = self._new_audit_manager()
+        return self.__audit_manager
+    
+    def _new_audit_manager(self):
+        """Create a new audit manager.
+        By default, use a audit manager with a single table of audit for whole DB and with triggers on audited tables.
+        Override this method in order to define which audit manager to use.
+        """
+        raise NotImplementedError()
+    
     def connect(self):
         try:
             self.__connection = self._connect(**self.__connect_kwargs)
@@ -83,22 +98,45 @@ class DBClient(object):
         if not self.is_connected:
             raise FunctionalException(f"DB Client '{self.name}' is not connected")
     
-    def is_query_type(self, sql_or_query, query_type):
-        if isinstance(sql_or_query, pypika.queries.QueryBuilder):
-            sql = self.query_builder.to_sql(sql_or_query)
-        else:
-            sql = sql_or_query
-        if not isinstance(sql, str):
-            raise TechnicalException(f"Unexpected type '{Typing.get_object_class_fullname(sql)}' for parameter sql_or_query")
-        
-        if isinstance(query_type, str):
-            query_type = QueryType[query_type.upper()]
-        if not isinstance(query_type, QueryType):
-            raise TechnicalException(f"Unmanage query_type of type '{Typing.get_object_class_fullname(query_type)}'")
-        
-        p = sql_metadata.Parser(sql)
-        return p.query_type == query_type
+    # Manage queries
+    
+    def insert(self, table_name, data: dict, do_commit=None):
+        """
+        Insert given data.
+        Parameter 'data' has to be a dictionary with keys equal to table column names.
+        """
+        query, values = self.query_builder.insert(table_name, data)
+        return self.execute_query(query, *values, do_commit=do_commit)
+    
+    def update(self, table_name, data: dict, where_data: dict=None, where_compare_data: list=None, do_commit=None):
+        """
+        Update given data.
+        Parameters 'data' and 'where_data' have to be dictionaries with keys equal to table column names.
+        """
+        query, values = self.query_builder.update(table_name, data, where_data=where_data, where_compare_data=where_compare_data)
+        return self.execute_query(query, *values, do_commit=do_commit)
+    
+    def select(self, table_name, where_data: dict=None, where_compare_data: list=None, sql_return="*", **kwargs):
+        """
+        Select by filtering on given where data.
+        @param where_data: dictionary of (field_name, value) for simple where clauses.
+        @param where_compare_data: list of tuples (field_name, operator, value) for where clauses comparing fields with values.
+        """
+        query, values = self.query_builder.select(table_name, where_data=where_data, where_compare_data=where_compare_data, sql_return=sql_return)
+        return self.execute_query(query, *values, do_commit=False, **kwargs)
+    
+    def delete(self, table_name, where_data: dict=None, where_compare_data: list=None, do_commit=None):
+        """
+        Delete by filtering on given where data.
+        Parameter 'where_data' has to be a dictionary with keys equal to table column names.
+        """
+        query, values = self.query_builder.delete(table_name, where_data=where_data, where_compare_data=where_compare_data)
+        return self.execute_query(query, *values, do_commit=do_commit)
     
+    def count(self, table_name, where_data: dict=None, where_compare_data: list=None):
+        result = self.select(table_name, where_data=where_data, where_compare_data=where_compare_data, sql_return="count(*)")
+        return result[0][0].content
+        
     def execute_query(self, query, *args, **kwargs):
         sql = self.query_builder.to_sql(query)
         
@@ -126,7 +164,7 @@ class DBClient(object):
         
         # Execute
         if Tools.do_log(logger, logging.DEBUG):
-            logger.debug(f"[{self.name}] Executing SQL [{sql}] with parameters [{args if args else ''}{kwargs if kwargs else ''}]...")
+            logger.debug(f"[{self.name}] Executing SQL [{Tools.truncate_text(sql, 1000)}] (args: {Tools.truncate_text(args, 1000)} ; kwargs: {Tools.truncate_text(kwargs, 1000)})...")
         try:
             if args:
                 self.cursor.execute(sql, args)
@@ -172,7 +210,7 @@ class DBClient(object):
         else:
             res = None
         
-        self.__log_sql_result(res, message=f"Executed SQL [{sql}] with parameters [{args if args else ''}{kwargs if kwargs else ''}]")
+        self.__log_sql_result(res, message=f"Executed SQL [{Tools.truncate_text(sql, 1000)}] (args: {Tools.truncate_text(args, 1000)} ; kwargs: {Tools.truncate_text(kwargs, 1000)})")
         
         # Manage commit
         if do_commit:
@@ -184,6 +222,52 @@ class DBClient(object):
             
         return res
     
+    def is_query_type(self, sql_or_query, query_type):
+        if isinstance(sql_or_query, pypika.queries.QueryBuilder):
+            sql = self.query_builder.to_sql(sql_or_query)
+        else:
+            sql = sql_or_query
+        if not isinstance(sql, str):
+            raise TechnicalException(f"Unexpected type '{Typing.get_object_class_fullname(sql)}' for parameter sql_or_query")
+        sql = sql.lower()
+        
+        # Parsing query with sql_metadata can be costly, thus begin by fast and simple methods
+        query_type_str = query_type.lower() if isinstance(query_type, str) else query_type.name.lower()
+        for qt in ['select', 'insert', 'update', 'delete']:
+            if sql.startswith(qt):
+                return qt == query_type_str
+        
+        # Parse more complex queries
+        if isinstance(query_type, str):
+            query_type = QueryType[query_type.upper()]
+        if not isinstance(query_type, QueryType):
+            raise TechnicalException(f"Unmanage query_type of type '{Typing.get_object_class_fullname(query_type)}'")
+        
+        try:
+            p = sql_metadata.Parser(sql)
+            res = p.query_type == query_type
+        except ValueError as exc:
+            if "Not supported query type" in str(exc):
+                res = False
+            else:
+                raise TechnicalException(f"Failed to define query type") from exc
+        except Exception as exc:
+            raise TechnicalException(f"Failed to define query type") from exc
+        
+        return res
+    
+    def set_or_update_json_key_value(self, table_name, field_name, json_key, json_value, where_data: dict=None, where_compare_data: list=None):
+        """
+        Set or update a json field with key=value.
+        """
+        raise NotImplementedError()
+        
+    def _get_sql_placeholder(self):
+        """
+        Return the character/string to use as placeholder in SQL requests.
+        """
+        raise NotImplementedError()
+
     def _get_base_exception_type(self):
         raise NotImplementedError()
     
@@ -203,57 +287,59 @@ class DBClient(object):
         else:
             return str(sql_result)
     
+    
+    # Manage transactions
+    
     def commit(self):
         self.connection.commit()
         
     def rollback(self):
         self.connection.rollback()
-        
+    
+    
+    # Manage tables
+    
     def exist_table(self, table_name):
         raise NotImplementedError()
     
-    def insert(self, table_name, data: dict, do_commit=None):
-        """
-        Insert given data.
-        Parameter 'data' has to be a dictionary with keys equal to table column names.
-        """
-        query, values = self.query_builder.insert(table_name, data)
-        return self.execute_query(query, *values, do_commit=do_commit)
-    
-    def update(self, table_name, data: dict, where_data: dict=None, where_compare_data: list=None, do_commit=None):
-        """
-        Update given data.
-        Parameters 'data' and 'where_data' have to be dictionaries with keys equal to table column names.
-        """
-        query, values = self.query_builder.update(table_name, data, where_data=where_data, where_compare_data=where_compare_data)
-        return self.execute_query(query, *values, do_commit=do_commit)
+    def create_table(self, table_name, create_sql, raise_if_exist=False, do_commit=True, do_audit=False):
+        if not self.exist_table(table_name):
+            self.execute(create_sql, do_commit=do_commit)
+            if not self.exist_table(table_name):
+                raise TechnicalException(f"Failed to create table '{table_name}' with SQL request [{create_sql}]")
+            
+            # Audit table
+            if do_audit:
+                self.audit_manager.audit_table(table_name)
+        elif raise_if_exist:
+            raise FunctionalException(f"Table '{table_name}' already exists")
     
-    def select(self, table_name, where_data: dict=None, where_compare_data: list=None, sql_return="*", **kwargs):
-        """
-        Select by filtering on given where data.
-        @param where_data: dictionary of (field_name, value) for simple where clauses.
-        @param where_compare_data: list of tuples (field_name, operator, value) for where clauses comparing fields with values.
-        """
-        query, values = self.query_builder.select(table_name, where_data=where_data, where_compare_data=where_compare_data, sql_return=sql_return)
-        return self.execute_query(query, *values, do_commit=False, **kwargs)
+    def drop_table(self, table_name, raise_if_not_exist=False, do_commit=True):
+        if self.exist_table(table_name):
+            sql = f"drop table {table_name};"
+            self.execute(sql, do_commit=do_commit)
+            if self.exist_table(table_name):
+                raise TechnicalException(f"Failed to drop table '{table_name}' with SQL request [{sql}]")
+        elif raise_if_not_exist:
+            raise FunctionalException(f"Table '{table_name}' doesn't exist")
     
-    def delete(self, table_name, where_data: dict=None, where_compare_data: list=None, do_commit=None):
-        """
-        Delete by filtering on given where data.
-        Parameter 'where_data' has to be a dictionary with keys equal to table column names.
-        """
-        query, values = self.query_builder.delete(table_name, where_data=where_data, where_compare_data=where_compare_data)
-        return self.execute_query(query, *values, do_commit=do_commit)
+    def get_table_column_names(self, table_name):
+        if table_name not in self.__column_names_by_table:
+            self.__column_names_by_table[table_name] = self._get_table_column_names(table_name)
+        return self.__column_names_by_table[table_name]
     
-    def set_or_update_json_key_value(self, table_name, field_name, json_key, json_value, where_data: dict=None, where_compare_data: list=None):
-        """
-        Set or update a json field with key=value.
-        """
-        raise NotImplementedError()
+    def _get_table_column_names(self, table_name):
+        sql = f"select * from {table_name} limit 1"
+        try:
+            self.cursor.execute(sql)
+        except self._get_base_exception_type() as exc:
+            self.rollback()
+            raise TechnicalException(f"[{self.name}] Error while executing SQL [{sql}]") from exc
+        
+        if self.cursor.description:
+            res = [field[0] for field in self.cursor.description]
+        else:
+            raise TechnicalException(f"Failed to get column names of table {table_name}")
+        
+        return res
         
-    def _get_sql_placeholder(self):
-        """
-        Return the character/string to use as placeholder in SQL requests.
-        """
-        raise NotImplementedError()
-

holado_db/tools/db/clients/postgresql/postgresql_audit.py

@@ -0,0 +1,75 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2023 by Eric Klumpp
+# 
+# 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.
+#################################################
+
+import logging
+from holado.common.handlers.undefined import default_value
+from holado_db.tools.db.clients.base.db_audit import TriggerAuditManager
+
+logger = logging.getLogger(__name__)
+
+
+class PostgreSQLTriggerAuditManager(TriggerAuditManager):
+    """Manage audit of tables by triggers.
+    WARNING: This case is not tested yet
+    """
+    def __init__(self, name, db_client):
+        super().__init__(name, db_client)
+    
+    def _get_audit_table_sql_create(self, audit_table_name=default_value):
+        audit_table_name = self._get_audit_table_name(audit_table_name)
+        return f"""CREATE TABLE {audit_table_name} (
+                id SERIAL PRIMARY KEY,
+                table_name TEXT,
+                record_id INTEGER,
+                operation_type TEXT,
+                changed_at TIMESTAMP DEFAULT now(),
+                changed_by TEXT,
+                previous_values JSONB,
+                new_values JSONB
+            )"""
+    
+    def _get_drop_trigger_sql_of_audit_table_operation(self, table_name, operation_type, audit_table_name):
+        audit_table_name = self._get_audit_table_name(audit_table_name)
+        trigger_name = self.get_trigger_name(table_name, operation_type)
+        return f"DROP TRIGGER IF EXISTS {trigger_name} on {table_name}"
+    
+    def _get_create_trigger_sql_to_audit_table_operation(self, table_name, operation_type, audit_table_name):
+        audit_table_name = self._get_audit_table_name(audit_table_name)
+        trigger_name = self.get_trigger_name(table_name, operation_type)
+        trigger_insert_sql = self.__get_trigger_insert_sql(table_name, operation_type, audit_table_name)
+        return f"""CREATE TRIGGER {trigger_name} AFTER {operation_type.upper()} ON {table_name}
+                BEGIN
+                    {trigger_insert_sql}
+                END;
+                """
+    
+    def __get_trigger_insert_sql(self, table_name, operation_type, audit_table_name):
+        rowid_txt = "NEW.id" if operation_type in ['insert', 'update'] else "OLD.id"
+        op_type = operation_type[0]
+        prev_vals_txt = "to_jsonb(OLD)" if operation_type in ['update', 'delete'] else "NULL"
+        new_vals_txt = "to_jsonb(NEW)" if operation_type in ['insert', 'update'] else "NULL"
+        
+        audit_info = [f"'{table_name}'",
+                      rowid_txt,
+                      f"'{op_type}'",
+                      "current_user",
+                      prev_vals_txt,
+                      new_vals_txt,
+                     ]
+        audit_info = ','.join(audit_info)
+        
+        return f"""INSERT INTO {audit_table_name} (table_name, record_id, operation_type, changed_by, previous_values, new_values) 
+                   VALUES ({audit_info});"""
+
+
+

holado_db/tools/db/clients/postgresql/postgresql_client.py

@@ -17,6 +17,7 @@ from holado_core.common.tables.table_with_header import TableWithHeader
 from holado_core.common.tools.tools import Tools
 import json
 from pypika.terms import Function, LiteralValue
+from holado_db.tools.db.clients.postgresql.postgresql_audit import PostgreSQLTriggerAuditManager
 
 logger = logging.getLogger(__name__)
 
@@ -43,6 +44,9 @@ class PostgreSQLClient(DBClient):
     def __init__(self, name, connect_kwargs):
         super().__init__(name if name else 'PostgreSQL', connect_kwargs)
         
+    def _new_audit_manager(self):
+        return PostgreSQLTriggerAuditManager("Audit with triggers", self)
+        
     def _get_base_exception_type(self):
         return psycopg.Error
     

holado_db/tools/db/clients/sqlite/sqlite_audit.py

@@ -0,0 +1,70 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2023 by Eric Klumpp
+# 
+# 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.
+#################################################
+
+import logging
+from holado.common.handlers.undefined import default_value
+from holado_db.tools.db.clients.base.db_audit import TriggerAuditManager
+
+logger = logging.getLogger(__name__)
+
+
+class SQLite3TriggerAuditManager(TriggerAuditManager):
+    def __init__(self, name, db_client):
+        super().__init__(name, db_client)
+    
+    def _get_audit_table_sql_create(self, audit_table_name=default_value):
+        audit_table_name = self._get_audit_table_name(audit_table_name)
+        return f"""CREATE TABLE {audit_table_name} (
+                id INTEGER PRIMARY KEY,
+                table_name TEXT,
+                record_id INTEGER,
+                operation_type TEXT,
+                changed_at TEXT,
+                previous_values TEXT,
+                new_values TEXT
+            )"""
+    
+    def _get_drop_trigger_sql_of_audit_table_operation(self, table_name, operation_type, audit_table_name):
+        trigger_name = self.get_trigger_name(table_name, operation_type)
+        return f"DROP TRIGGER IF EXISTS {trigger_name}"
+    
+    def _get_create_trigger_sql_to_audit_table_operation(self, table_name, operation_type, audit_table_name):
+        audit_table_name = self._get_audit_table_name(audit_table_name)
+        trigger_name = self.get_trigger_name(table_name, operation_type)
+        trigger_insert_sql = self.__get_trigger_insert_sql(table_name, operation_type, audit_table_name)
+        return f"""CREATE TRIGGER {trigger_name} AFTER {operation_type.upper()} ON {table_name}
+                BEGIN
+                    {trigger_insert_sql}
+                END;
+                """
+    
+    def __get_trigger_insert_sql(self, table_name, operation_type, audit_table_name):
+        values = [f"'{table_name}'",
+                  "NEW.rowid" if operation_type in ['insert', 'update'] else "OLD.rowid",
+                  f"'{operation_type[0]}'",
+                  "DATETIME('now')",
+                  self.__get_row_version_json_object_sql(table_name, 'OLD') if operation_type in ['update', 'delete'] else "NULL",
+                  self.__get_row_version_json_object_sql(table_name, 'NEW') if operation_type in ['insert', 'update'] else "NULL",
+                 ]
+        
+        return f"""INSERT INTO {audit_table_name} (table_name, record_id, operation_type, changed_at, previous_values, new_values) 
+                   VALUES ({','.join(values)});"""
+    
+    def __get_row_version_json_object_sql(self, table_name, row_version):
+        col_names = self._db_client.get_table_column_names(table_name)
+        json_object_args = []
+        for cn in col_names:
+            json_object_args.append(f"'{cn}'")
+            json_object_args.append(f"{row_version}.{cn}")
+        return f"json_object({','.join(json_object_args)})"
+

holado_db/tools/db/clients/sqlite/sqlite_client.py

@@ -15,6 +15,7 @@ import logging
 from holado_db.tools.db.clients.base.db_client import DBClient
 from holado_core.common.exceptions.functional_exception import FunctionalException
 from holado_core.common.tools.tools import Tools
+from holado_db.tools.db.clients.sqlite.sqlite_audit import SQLite3TriggerAuditManager
 
 logger = logging.getLogger(__name__)
 
@@ -35,6 +36,9 @@ class SQLite3Client(DBClient):
     def __init__(self, name, connect_kwargs):
         super().__init__(name if name else 'SQLite3', connect_kwargs)
         
+    def _new_audit_manager(self):
+        return SQLite3TriggerAuditManager("Audit with triggers", self)
+    
     def _get_base_exception_type(self):
         return sqlite3.Error
         

holado_django/server/patch_djangogrpcframework.py

@@ -0,0 +1,46 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# 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.
+#################################################
+
+
+#################################################
+#
+# Patches are done to follow ITU recommendation:
+# https://www.e-navigation.nl/sites/default/files/R-REC-M.1371-5-201402-I!!PDF-E_1.pdf
+#
+#################################################
+
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+# Since Django 4.1, requires_system_checks cannot be a boolean anymore.
+# Framework djangogrpcframework is not maintained anymore.
+# Patch it by removing reference to requires_system_checks
+#
+# USAGE:
+#    1. If not using holado in django project, copy this file in django project
+#    2. In manage.py, import this file
+
+try:
+    import django_grpc_framework  # @UnusedImport
+    with_django_grpc_framework = True
+except:
+    with_django_grpc_framework = True
+
+if with_django_grpc_framework:
+    from django_grpc_framework.management.commands.grpcrunserver import Command  # @UnusedImport
+    del Command.requires_system_checks
+
+

holado_logging/common/logging/holado_logger.py

@@ -43,12 +43,7 @@ class HALogger(logging.Logger):
         
         if msg_size_limit is None:
             msg_size_limit = HALogger.default_message_size_limit
-            
-        if msg_size_limit is not None and msg_size_limit > 0 and len(msg) > msg_size_limit:
-            truncated_suffix = f"[...({len(msg)-msg_size_limit})]"
-            msg_to_log = Tools.truncate_text(msg, msg_size_limit, truncated_suffix)
-        else:
-            msg_to_log = msg
+        msg_to_log = Tools.truncate_text(msg, msg_size_limit)
             
         logging.Logger._log(self, level, msg_to_log, args, exc_info=exc_info, extra=extra, stack_info=stack_info, stacklevel=stacklevel)
     

holado_multitask/multithreading/thread.py

@@ -22,20 +22,21 @@ from holado.common.handlers.undefined import undefined_argument, default_context
 from holado_core.common.exceptions.technical_exception import TimeoutTechnicalException
 from holado_core.common.exceptions.functional_exception import FunctionalException
 from holado_python.common.tools.datetime import DateTime, FORMAT_DATETIME_ISO
+from holado.common.handlers.object import DeleteableObject
 
 logger = logging.getLogger(__name__)
 
 
-class Thread(threading.Thread):
+class Thread(threading.Thread, DeleteableObject):
     """ Helper class managing a thread."""
     
     def __init__(self, name, default_wait_timeout=None, register_thread=True, register_scope=default_context, delay_before_run_sec=None):
-        super().__init__()
+        threading.Thread.__init__(self)
+        DeleteableObject.__init__(self, name)
         
         if default_wait_timeout is None:
             default_wait_timeout = Config.timeout_seconds * 1000
             
-        self.__name = name
         # Note: if SessionContext doesn't have an instance (like during session context reset), use name+now as unique name
         self.__unique_name = SessionContext.instance().multitask_manager.prepare_thread(name) if SessionContext.has_instance() else f"{name}_{DateTime.datetime_2_str(DateTime.now(), FORMAT_DATETIME_ISO)}"
         self.__default_wait_timeout = default_wait_timeout
@@ -51,14 +52,15 @@ class Thread(threading.Thread):
         
         # Register thread
         # Note: Do not register thread if session context doesn't have an instance (like during session context reset)
+        self.__is_registered = False
+        self.__register_scope = None
         if register_thread and SessionContext.has_instance():
             # Registered name has to be unique
             SessionContext.instance().threads_manager.register_thread(self.__unique_name, self, scope=register_scope)
+            self.__is_registered = True
+            self.__register_scope = register_scope
+            self.on_delete_call_func(self.__unregister_thread)
         
-    @property
-    def name(self):
-        return self.__name
-
     @property
     def unique_name(self):
         return self.__unique_name
@@ -149,6 +151,10 @@ class Thread(threading.Thread):
                 elif wait_round_counter % 10 == 0:
                     logger.debug("[{}] Still waiting {} (round {})".format(self.name, event_details, wait_round_counter))
         logger.debug("[{}] Finished waiting {}...".format(self.name, event_details))
+    
+    def __unregister_thread(self):
+        if self.__is_registered:
+            SessionContext.instance().threads_manager.unregister_thread(self.__unique_name, self, scope=self.__register_scope)
 
 
 class InterruptableThread(Thread):

holado_multitask/multithreading/timer.py

@@ -40,7 +40,10 @@ class Timer(InterruptableThread):
         self.finished.set()
 
     def run(self):
+        # Wait timer interval or canceled (ie finished==True)
         self.finished.wait(self.interval)
+        
+        # Run function if not canceled
         if not self.finished.is_set():
             self.function(*self.args, **self.kwargs)
         self.finished.set()

holado_python/common/tools/datetime.py

@@ -158,26 +158,51 @@ class DateTime(object):
             res = dt_value.strftime(dt_format)
         return res
     
-    
-    ### Conversions to/from timestamp
+    @classmethod
+    def _get_datetime(cls, dt):
+        res = None
+        if dt is not None:
+            if isinstance(dt, datetime.datetime):
+                res = dt
+            elif isinstance(dt, str):
+                res = DateTime.str_2_datetime(dt)
+            else:
+                raise TechnicalException(f"Datetime can be a datetime, a str containing a datetime, or None")
+        return res
     
     @classmethod
     def _get_epoch_datetime(cls, epoch):
         res = None
         if epoch is not None:
-            if isinstance(epoch, str):
+            if isinstance(epoch, datetime.datetime):
+                res = epoch
+            elif isinstance(epoch, str):
                 if epoch in ['EPOCH_1970', 'EPOCH_JULIAN_CNES', 'EPOCH_JULIAN_NASA']:
                     res = eval(epoch)
                 else:
                     res = DateTime.str_2_datetime(epoch)
-            elif isinstance(epoch, datetime.datetime):
-                res = epoch
             else:
                 raise TechnicalException(f"Epoch can be a datetime, a str containing a datetime, a str containing an EPOCH name, or None")
         return res
         
+    @classmethod
+    def _get_timestamp(cls, ts):
+        res = None
+        if ts is not None:
+            if isinstance(ts, float) or isinstance(ts, int):
+                res = ts
+            elif isinstance(ts, str) and (Converter.is_float(ts) or Converter.is_integer(ts)):
+                res = Converter.to_float(ts)
+            else:
+                raise TechnicalException(f"Timestamp must be a float|int or a string containing a float|int (obtained type: {Typing.get_object_class_fullname(ts)})")
+        return res
+    
+    
+    ### Conversions to/from timestamp
+    
     @classmethod
     def datetime_to_timestamp(cls, dt, epoch=None):
+        dt = cls._get_datetime(dt)
         epoch = cls._get_epoch_datetime(epoch)
         
         if epoch is None:
@@ -190,16 +215,9 @@ class DateTime(object):
         """
         Convert timestamp to UTC datetime
         """
+        ts = cls._get_timestamp(ts)
         epoch = cls._get_epoch_datetime(epoch)
         
-        if isinstance(ts, str):
-            if Converter.is_float(ts) or Converter.is_integer(ts):
-                ts = Converter.to_float(ts)
-            else:
-                raise FunctionalException(f"Timestamp is a string that doesn't contain a float|int (obtained timestamp: '{ts}')")
-        if not isinstance(ts, float) and not isinstance(ts, int):
-            raise TechnicalException(f"Timestamp must be a float|int or a string containing a float|int (obtained type: {Typing.get_object_class_fullname(ts)})")
-        
         res = datetime.datetime.fromtimestamp(ts, tz=datetime.timezone.utc)
         if epoch is not None:
             res = epoch + (res - EPOCH_1970)