holado 0.22.7.dev2__tar.gz → 0.22.8.dev1__tar.gz

{holado-0.22.7.dev2 → holado-0.22.8.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: holado
-Version: 0.22.7.dev2
+Version: 0.22.8.dev1
 Summary: HolAdo framework
 Project-URL: Homepage, https://gitlab.com/holado_framework/python
 Project-URL: Issues, https://gitlab.com/holado_framework/python/-/issues

holado-0.22.8.dev1/packaging/VERSION

@@ -0,0 +1 @@
+0.22.8.dev1

{holado-0.22.7.dev2 → holado-0.22.8.dev1}/src/holado/common/handlers/object.py

@@ -24,15 +24,12 @@ def initialize_logger():
 
 class Object(object):
     def __init__(self, name=None):
-        self.__name = name
+        self.__name = name or str(self)
         self.__obj_state = ObjectStates.Created
 
     @property
     def name(self):
-        if self.__name:
-            return self.__name
-        else:
-            return str(self)
+        return self.__name
 
     @property
     def object_state(self):

{holado-0.22.7.dev2 → holado-0.22.8.dev1}/src/holado_data/data/encoder/BaseXEncoder.py

@@ -42,6 +42,9 @@ class BaseXEncoder(object):
         else:
             self.__padding_character = padding_character
 
+    @property
+    def max_base(self):
+        return len(self.__digs)
 
     def encode(self, value, base=62, padding_length=None, padding_character=None, raise_if_padding_impossible=True):
         """ Encode given value in given base
@@ -60,7 +63,7 @@ class BaseXEncoder(object):
         else:
             raise TechnicalException("Value has to be of any type in (int, bytes, hex string)")
 
-        res = self.__encode_int_until_base62(int_value, base)
+        res = self.__encode_int(int_value, base)
 
         if padding_length:
             if len(res) > padding_length and raise_if_padding_impossible:
@@ -74,7 +77,16 @@ class BaseXEncoder(object):
 
         return res
 
-    def __encode_int_until_base62(self, x, base):
+    def decode(self, txt, base=62):
+        """ Decode given text in given base
+        :param txt: encoded text
+        :param base: Base (default: 62)
+        :return: decoded text as integer
+        """
+        return self.__decode_txt(txt, base)
+
+
+    def __encode_int(self, x, base):
         if x < 0: 
             sign = -1
         elif x == 0: 
@@ -91,6 +103,13 @@ class BaseXEncoder(object):
         digits.reverse()
         return ''.join(digits)
 
+    def __decode_txt(self, x, base):
+        res = 0
+        for c in x:
+            res *= base
+            res += self.__digs.index(c)
+        return res
+
     @classmethod
     def get_max_int_for_base_length(cls, base, length):
         """

{holado-0.22.7.dev2 → holado-0.22.8.dev1}/src/holado_data/data/uid/uid_generator.py

@@ -12,9 +12,11 @@
 
 import abc
 import logging
+import re
 
 from holado.common.context.session_context import SessionContext
 from holado.common.handlers.undefined import default
+from holado_core.common.exceptions.technical_exception import TechnicalException
 from holado_data.data.generator.base import BaseGenerator
 from holado_resource.resource.persisted_key_value_manager import PersistedKeyValueManager
 from holado_value.common.tools.unique_value_manager import UniqueValueManager
@@ -33,8 +35,25 @@ class BaseUIDGenerator(BaseGenerator):
         raise NotImplementedError()
 
     def _format_uid(self, unique_text):
+        """
+        :param unique_text: Unique text
+        :return: Formatted UID with given unique text
+        """
         return self.__uid_format.format(unique_text=unique_text)
 
+    def _unformat_uid(self, uid):
+        """
+        :param uid: UID to unformat
+        :return: Unique text that resulted to given UID after format
+        """
+        escaped_format = self.__uid_format.replace("(", "\(").replace(")", "\)")
+        pattern = re.compile(escaped_format.replace("{unique_text}", "(.*)"))
+        match = pattern.match(uid)
+        if match is None:
+            raise TechnicalException(f"Unable to unformat UID '{uid}' with format '{self.__uid_format}'")
+
+        return match.group(1)
+
 
 class StandaloneUIDGenerator(BaseUIDGenerator):
     """ Standalone UID generator
@@ -43,9 +62,13 @@ class StandaloneUIDGenerator(BaseUIDGenerator):
     Generation mechanism ensures that next UID will be greater than configured last generated UID.
     """
     def __init__(self, name=None, uid_format=default, last_uid=None, unique_value_manager=default):
-        super().__init__(name=name or "Standalone UID generator", uid_format=uid_format)
-        self.__last_uid = last_uid
-        self.__unique_value_manager = unique_value_manager if unique_value_manager is not default else UniqueValueManager()
+        name = name or "Standalone UID generator"
+        super().__init__(name=name, uid_format=uid_format)
+        self.__last_uid = None
+        self.__unique_value_manager = unique_value_manager if unique_value_manager is not default else UniqueValueManager(name)
+
+        if last_uid:
+            self.last_uid = last_uid
 
     @property
     def last_uid(self):
@@ -55,6 +78,10 @@ class StandaloneUIDGenerator(BaseUIDGenerator):
     def last_uid(self, last_uid):
         self.__last_uid = last_uid
 
+        # Update internal unique value manager
+        unique_string = self._unformat_uid(last_uid)
+        self.__unique_value_manager.update_internal_counter_from_string(unique_string)
+
     def __next__(self):
         uid = self._format_uid(self.__unique_value_manager.new_string())
         if self.__last_uid:

{holado-0.22.7.dev2 → holado-0.22.8.dev1}/src/holado_data/data/version/version_manager.py

@@ -87,7 +87,7 @@ class UIDHashVersionManager(Object):
 
     def __get_last_version(self, uid):
         client = self.__get_db_client()
-        result = client.select("uid_hash_versions", where_data={'scope': self.__scope, 'uid': uid}, sql_return="version", order_bys=[('id', 'DESC')])
+        result = client.select("uid_hash_versions", where_data={'scope': self.__scope, 'uid': uid}, sql_return="version", order_bys=[('created_at', 'DESC')])
         if result.nb_rows == 0:
             return None
         else:

holado-0.22.8.dev1/src/holado_logging/tests/behave/steps/__init__.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+
+#################################################
+# 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.
+#################################################
+
+
+from .logging.logger_steps import *

holado-0.22.8.dev1/src/holado_logging/tests/behave/steps/logging/logger_steps.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+from holado_report.report.report_manager import ReportManager
+#################################################
+# 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.
+#################################################
+
+
+from holado_test.scenario.step_tools import StepTools
+from holado.common.context.session_context import SessionContext
+from holado_test.behave.behave import *  # @UnusedWildImport
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_scripting.text.interpreter.text_interpreter import TextInterpreter
+from holado_scripting.common.tools.variable_manager import VariableManager
+from holado_test.common.context.scenario_context import ScenarioContext
+import logging
+from holado_redis.tools.redis.redis_client import RedisClient
+from holado_redis.tools.redis.redis_manager import RedisManager
+from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
+from holado_value.common.tables.converters.value_table_converter import ValueTableConverter
+
+logger = logging.getLogger(__name__)
+
+
+
+def __get_session_context() -> SessionContext:
+    return SessionContext.instance()
+
+def __get_scenario_context() -> ScenarioContext:
+    return __get_session_context().get_scenario_context()
+
+def __get_variable_manager() -> VariableManager:
+    return __get_scenario_context().get_variable_manager()
+
+def __get_report_manager() -> ReportManager:
+    return SessionContext.instance().report_manager
+
+
+@Given(r"(?P<var_name>{Variable}) = new logger in file (?P<file_name>{Str})")
+def step_impl(context, var_name, file_name):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    file_name = StepTools.evaluate_scenario_parameter(file_name)
+
+    if not __get_report_manager().has_report_path:
+        raise TechnicalException(f"This step needs a session with reporting")
+
+    res = logging.getLogger(f"{file_name}")
+    file_path = __get_report_manager().get_path("logs", file_name)
+    SessionContext.instance().log_manager.add_file_handler(file_path, res)
+
+    __get_variable_manager().register_variable(var_name, res)
+
+@Step(r"log (?P<msg>{AnyStr})(?: \((?P<unlimited_str>unlimited)\))? \(logger: (?P<var_logger>{Variable})\)")
+def step_impl(context, msg, unlimited_str, var_logger):
+    msg = StepTools.evaluate_scenario_parameter(msg)
+    unlimited = unlimited_str is not None
+    logger_ = StepTools.evaluate_variable_value(var_logger)
+
+    # Add multiline text if present
+    text = BehaveStepTools.get_step_multiline_text(context, raise_exception_if_none=False, log_level=logging.TRACE)  # @UndefinedVariable
+    if text is not None:
+        msg += '\n' + text
+
+    # Add table if present
+    table = BehaveStepTools.get_step_table(context)
+    if table:
+        msg += '\n' + table.represent(4)
+
+    if unlimited:
+        logger_.print(msg, msg_size_limit=-1)
+    else:
+        logger_.print(msg)
+
+

{holado-0.22.7.dev2 → holado-0.22.8.dev1}/src/holado_python/common/iterables.py

@@ -14,6 +14,9 @@
 
 
 import logging
+
+from holado.common.handlers.undefined import undefined_argument, default
+from holado_core.common.exceptions.functional_exception import FunctionalException
 from holado_core.common.exceptions.technical_exception import TechnicalException
 from holado_python.standard_library.typing import Typing
 
@@ -36,3 +39,16 @@ def remove_all(iterable, value):
     new_list = [x for x in iterable if x != value]
     del iterable[:]
     iterable.extend(new_list)
+
+def get_dict_key_of_value(dictionary, value, default_key=default, raise_if_not_exist=False):
+    """ Return the first key with given value.
+    If value doesn't exist, return default_key if defined, else raise an exception if raise_if_not_exist=True else return None.
+    """
+    res = next((k for k, v in dictionary.items() if v == value), default_key)
+    if res is default:
+        if raise_if_not_exist:
+            raise FunctionalException(f"Value [{value}] not found in dictionary {dictionary}")
+        else:
+            res = None
+    return res
+

{holado-0.22.7.dev2 → holado-0.22.8.dev1}/src/holado_python/common/tools/datetime.py

@@ -254,14 +254,14 @@ class DateTime(object):
             return (dt - epoch).total_seconds()
     
     @classmethod
-    def timestamp_to_datetime(cls, ts, epoch=None):
+    def timestamp_to_datetime(cls, ts, epoch=None, tz=TIMEZONE_UTC):
         """
         Convert timestamp to UTC datetime
         """
         ts = cls._get_timestamp(ts)
         epoch = cls._get_epoch_datetime(epoch)
         
-        res = datetime.datetime.fromtimestamp(ts, tz=datetime.timezone.utc)
+        res = datetime.datetime.fromtimestamp(ts, tz=tz)
         if epoch is not None:
             res = epoch + (res - EPOCH_1970)
         return res
@@ -275,13 +275,13 @@ class DateTime(object):
         return cls.timestamp_to_seconds_nanos(ts)
     
     @classmethod
-    def seconds_nanos_to_datetime(cls, seconds, nanos, epoch=None, round_func=round):
+    def seconds_nanos_to_datetime(cls, seconds, nanos, epoch=None, round_func=round, tz=TIMEZONE_UTC):
         """
         Convert timestamp to UTC datetime
         @param round_func: defines the rounding method applied to microseconds (default: round ; possible methods: round, math.ceil, math.trunc)
         """
         ts = cls.seconds_nanos_to_timestamp(seconds, nanos, round_func=round_func)
-        return cls.timestamp_to_datetime(ts, epoch)
+        return cls.timestamp_to_datetime(ts, epoch, tz=tz)
     
     @classmethod
     def timestamp_to_seconds_nanos(cls, ts):

{holado-0.22.7.dev2 → holado-0.22.8.dev1}/src/holado_rabbitmq/tests/behave/steps/tools/rabbitmq_client_steps.py

@@ -487,7 +487,29 @@ if rabbitmq_client.RMQClient.is_available():
         res = __get_rabbitmq_manager().received_messages_as_protobuf_objects(con, proto_type_str)
         
         __get_variable_manager().register_variable(var_name, res)
-        
+
+
+    @Step(r"(?P<var_name>{Variable}) = pop received messages \(RMQ consumer: (?P<var_con>{Variable})\)")
+    def step_impl(context, var_name, var_con):
+        var_name = StepTools.evaluate_variable_name(var_name)
+        con = StepTools.evaluate_variable_value(var_con)
+
+        messages = con.pop_messages()
+        res = [m[3] for m in messages]
+
+        __get_variable_manager().register_variable(var_name, res)
+
+
+    @Step(r"(?P<var_name>{Variable}) = pop received messages as (?P<proto_type_str>{Str}) Protobuf objects \(RMQ consumer: (?P<var_con>{Variable})\)")
+    def step_impl(context, var_name, proto_type_str, var_con):
+        var_name = StepTools.evaluate_variable_name(var_name)
+        con = StepTools.evaluate_variable_value(var_con)
+
+        res = __get_rabbitmq_manager().pop_received_messages_as_protobuf_objects(con, proto_type_str)
+
+        __get_variable_manager().register_variable(var_name, res)
+
+
     @Step(r"(?P<var_name>{Variable}) = pop first received message \(RMQ consumer: (?P<var_con>{Variable})\)")
     def step_impl(context, var_name, var_con):
         var_name = StepTools.evaluate_variable_name(var_name)

{holado-0.22.7.dev2 → holado-0.22.8.dev1}/src/holado_rabbitmq/tools/rabbitmq/rabbitmq_client.py

@@ -621,7 +621,7 @@ class RMQBufferConsumer(Object):
         self.__consumer = RMQConsumer(client, connection, channel, queue, self.__message_callback)
         
         self.__messages = []
-        self.__messages_lock = threading.Lock()
+        self.__messages_lock = threading.RLock()
     
     @property
     def connection(self):
@@ -672,14 +672,23 @@ class RMQBufferConsumer(Object):
             if Tools.do_log(logger, logging.DEBUG):
                 logger.debug(f"[{self.name}] Reset messages (delete {len(self.__messages)} messages)")
             self.__messages.clear()
-        
+
+    def pop_messages(self):
+        with self.__messages_lock:
+            res = []
+            while self.nb_messages > 0:
+                res.append(self.__messages.pop(0))
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"[{self.name}] Pop messages: {res}")
+            return res
+
     def pop_first_message(self):
         with self.__messages_lock:
             res = self.__messages.pop(0)
             if Tools.do_log(logger, logging.DEBUG):
                 logger.debug(f"[{self.name}] Pop first message (remaining: {len(self.__messages)}): {res}")
             return res
-        
+
     def pop_and_save_messages(self, file:File, max_messages=None):
         res = 0
         

{holado-0.22.7.dev2 → holado-0.22.8.dev1}/src/holado_rabbitmq/tools/rabbitmq/rabbitmq_manager.py

@@ -34,8 +34,22 @@ class RMQManager:
             res.append(msg)
             # logger.debug(f"+++++ New message: type={Typing.get_object_class_fullname(msg)} ; dir={dir(msg)}")
         return res
-    
-        
+
+    def pop_received_messages_as_protobuf_objects(self, consumer, message_type_fullname):
+        """Unserialize messages received by a buffer consumer to given Protobuf message type, and remove them from consumer"""
+
+        if not isinstance(consumer, RMQBufferConsumer):
+            raise TechnicalException(f"Consumer has to be a buffer consumer (obtained type: {Typing.get_object_class_fullname(consumer)})")
+
+        res = []
+        for ind, m in enumerate(consumer.pop_messages()):
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"Received message [{ind}]: {m[3]}")
+            msg = self.__protobuf_messages.new_message(message_type_fullname, serialized_string=m[3])
+            res.append(msg)
+            # logger.debug(f"+++++ New message: type={Typing.get_object_class_fullname(msg)} ; dir={dir(msg)}")
+        return res
+
     def await_message_reception(self, consumers, timeout_seconds=None, polling_seconds=None, raise_exception=True):
         """Wait until one of the buffer consumers has received a message.
         @param consumers: list of buffer consumers

{holado-0.22.7.dev2 → holado-0.22.8.dev1}/src/holado_test/scenario/step_tools.py

@@ -130,7 +130,7 @@ class StepTools(object):
         if Tools.do_log_if_objects_are_different(logger, log_level, text_param, res):
             logger.log(log_level, f"evaluate_scenario_parameter: [{text_param}] -> [{res}] (type: {Typing.get_object_class_fullname(res)})")
         return res
- 
+
     @staticmethod
     def evaluate_list_scenario_parameter(text_param, param_name, log_level=logging.DEBUG):
         res = StepTools.evaluate_scenario_parameter(text_param, log_level=log_level)
@@ -145,7 +145,22 @@ class StepTools(object):
         if Tools.do_log_if_objects_are_different(logger, log_level, text_param, res):
             logger.log(log_level, f"evaluate_list_scenario_parameter for parameter '{param_name}': {text_param} -> {res}")
         return res
-    
+
+    @staticmethod
+    def evaluate_tuple_scenario_parameter(text_param, param_name, log_level=logging.DEBUG):
+        res = StepTools.evaluate_scenario_parameter(text_param, log_level=log_level)
+        if isinstance(res, str):
+            regex = re.compile(r"^\s*\((.*)\)\s*$")
+            m = regex.match(res)
+            if m:
+                param_names = m.group(1).split(',')
+                res = [StepTools.evaluate_scenario_parameter(pn.strip()) for pn in param_names]
+            else:
+                raise FunctionalException(f"Parameter '{param_name}' must be specified in a tuple format (ex: \"('Name1', 'Name2',...)\")")
+        if Tools.do_log_if_objects_are_different(logger, log_level, text_param, res):
+            logger.log(log_level, f"evaluate_tuple_scenario_parameter for parameter '{param_name}': {text_param} -> {res}")
+        return res
+
     @classmethod
     def replace_variable_names(cls, text, log_level=logging.DEBUG):
         res = text
@@ -563,5 +578,8 @@ class StepTools(object):
         cls.register_type('List', 
                           r"{Variable}|\[.*\]".format(Variable=cls.get_registered_type_pattern('Variable')), 
                           StepTools.evaluate_list_scenario_parameter)
+        cls.register_type('Tuple',
+                          r"{Variable}|\(.*\)".format(Variable=cls.get_registered_type_pattern('Variable')),
+                          StepTools.evaluate_tuple_scenario_parameter)
 
 

holado-0.22.8.dev1/src/holado_test/tools/test_server/server/requirements.txt

@@ -0,0 +1,2 @@
+# HolAdo framework
+holado[api-connexion,ssl]>=0.22.7.dev2

{holado-0.22.7.dev2 → holado-0.22.8.dev1}/src/holado_value/common/tools/unique_value_manager.py

@@ -15,6 +15,7 @@ from builtins import int
 import logging
 from datetime import datetime
 
+from holado.common.handlers.object import Object
 from holado.common.handlers.undefined import default
 from holado_core.common.exceptions.technical_exception import TechnicalException
 from holado_core.common.tools.tools import Tools
@@ -25,7 +26,7 @@ logger = logging.getLogger(__name__)
 
 
 
-class UniqueValueManager(object):
+class UniqueValueManager(Object):
     """
     @summary: Unique value manager.
     An internal counter is used to generate a unique integer at any moment.
@@ -33,12 +34,20 @@ class UniqueValueManager(object):
     
     This manager can generate unique integers and unique strings.
     For strings, a unique integer is encoded in a base in range [2, 62] (default: 62).
+
+    It is possible to update internal counter from a unique value previously generated, with methods update_internal_counters_from_xxx.
+    If called, next unique value will be the same as if it just has generated this previous unique value.
+    Usually it is called at UniqueValueManager initialization.
+    Notes:
+        - method update_internal_counter_from_string can work properly only if method new_string is used without padding
+        - method update_internal_counter_from_hex can work properly only if method new_hex is used with length=None
     """
     
-    def __init__(self, padding_character=default):
-        self.__last_unique_int = None
+    def __init__(self, name=None, padding_character=default, digits=default):
+        super().__init__(name)
 
-        self.__encoder = BaseXEncoder(padding_character=padding_character)
+        self.__last_unique_int = None
+        self.__encoder = BaseXEncoder(padding_character=padding_character, digits=digits)
 
     def new_integer(self, do_log=True):
         if self.__last_unique_int is None:
@@ -50,7 +59,7 @@ class UniqueValueManager(object):
         
         if do_log:
             if Tools.do_log(logger, logging.DEBUG):
-                logger.debug(f"New unique integer: {res}")
+                logger.debug(f"[{self.name}] New unique integer: {res}")
         return res
     
     def new_hex(self, length=None, truncate_to_length=True, do_log=True):
@@ -60,22 +69,44 @@ class UniqueValueManager(object):
             if truncate_to_length:
                 res = res[-length:]
             else:
-                raise TechnicalException(f"Unique HEX integer ({res}) has length {len(res)} that exceeds expected length {length}")
+                raise TechnicalException(f"[{self.name}] Unique HEX integer ({res}) has length {len(res)} that exceeds expected length {length}")
         
         if do_log:
             if Tools.do_log(logger, logging.DEBUG):
-                logger.debug(f"New unique HEX integer: {res}")
+                logger.debug(f"[{self.name}] New unique HEX integer: {res}")
         return res
     
     def new_string(self, base=62, padding_length=None, padding_character=None, raise_if_padding_impossible=True, do_log=True):
-        if base < 2 or base > 62:
-            raise TechnicalException("Base must be in range [2, 62]")
+        if base < 2 or base > self.__encoder.max_base:
+            raise TechnicalException(f"[{self.name}] Base must be in range [2, {self.__encoder.max_base}]")
         value = self.new_integer(do_log=False)
         res = self.__encoder.encode(value, base, padding_length, padding_character, raise_if_padding_impossible)
 
         if do_log:
             if Tools.do_log(logger, logging.DEBUG):
-                logger.debug(f"New unique string: [{res}]")
+                logger.debug(f"[{self.name}] New unique string: [{res}]")
         return res
-    
+
+    def update_internal_counter_from_integer(self, value, force_update=False, do_log=True):
+        res = False
+        if self.__last_unique_int is None or value > self.__last_unique_int or force_update:
+            self.__last_unique_int = value
+            res = True
+            if do_log:
+                if Tools.do_log(logger, logging.DEBUG):
+                    logger.debug(f"[{self.name}] Internal counter updated to {value}")
+        return res
+
+    def update_internal_counter_from_hex(self, txt_hex, do_log=True):
+        """ Updates internal counter from hex string
+        Note: this method can work properly if new_hex was previously called with length=None.
+        """
+        return self.update_internal_counter_from_string(txt_hex, base=16, do_log=do_log)
+
+    def update_internal_counter_from_string(self, txt, base=62, do_log=True):
+        """ Updates internal counter from string
+        Note: this method can work properly if new_string was previously called without padding.
+        """
+        value = self.__encoder.decode(txt, base)
+        return self.update_internal_counter_from_integer(value, do_log=do_log)
 

holado-0.22.7.dev2/packaging/VERSION

@@ -1 +0,0 @@
-0.22.7.dev2

holado-0.22.7.dev2/src/holado_test/tools/test_server/server/requirements.txt

@@ -1,2 +0,0 @@
-# HolAdo framework
-holado[api-connexion,ssl]>=0.22.5