holado 0.13.22__py3-none-any.whl

holado_python/common/tools/datetime.py

@@ -0,0 +1,341 @@
+# -*- 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.
+#################################################
+
+import logging
+import datetime
+import dateutil.parser
+import re
+from holado_core.common.exceptions.functional_exception import FunctionalException
+from holado_core.common.exceptions.technical_exception import TechnicalException
+import os
+from holado_core.common.tools.converters.converter import Converter
+from enum import Enum
+from holado_python.common.enums import ArithmeticOperator
+from datetime import timedelta
+from dateutil.relativedelta import relativedelta
+import math
+from decimal import Decimal
+from holado_python.standard_library.typing import Typing
+
+logger = logging.getLogger(__name__)
+
+
+EPOCH_1970 = datetime.datetime(year=1970, month=1, day=1, tzinfo=datetime.timezone.utc)
+EPOCH_JULIAN_CNES = datetime.datetime(year=1950, month=1, day=1, tzinfo=datetime.timezone.utc)
+EPOCH_JULIAN_NASA = datetime.datetime(year=1968, month=5, day=24, tzinfo=datetime.timezone.utc)
+
+FORMAT_DATETIME_ISO = '%Y-%m-%dT%H:%M:%S.%fZ'
+FORMAT_DATETIME_ISO_SECONDS = '%Y-%m-%dT%H:%M:%SZ'
+FORMAT_DATETIME_HUMAN_SECOND = '%Y-%m-%d %H:%M:%S'
+FORMAT_TIME_ISO = '%H:%M:%S.%f'
+FORMAT_TIME_ISO_SECONDS = '%H:%M:%S'
+
+TIMEZONE_LOCAL = datetime.datetime.now().astimezone().tzinfo
+TIMEZONE_UTC = datetime.timezone.utc
+default_timezone = TIMEZONE_UTC
+
+
+class DurationUnit(str, Enum):
+    # Nanosecond = "nanosecond"
+    Microsecond = "microsecond"
+    Millisecond = "millisecond"
+    Second = "second"
+    Minute = "minute"
+    Hour = "hour"
+    Day = "day"
+    Week = "week"
+    Month = "month"
+    Year = "year"
+    
+
+
+class DateTime(object):
+    """ Tools to manipulate datetimes.
+    Note: Naive and aware datetimes cannot be compared. Thus HolAdo methods always set datetime timezone when it is known.
+          In methods unable to define the timezone (ex: str_2_datetime), it is highly recommended to specify 'tz' argument.
+    """
+    
+    __is_system_time_in_tai = None
+    __is_system_time_expected_in_tai = None
+    __utc_to_tai_timedelta = None
+    
+    
+    def __init__(self):
+        pass
+    
+    @classmethod
+    def is_system_time_in_tai(cls):
+        """Return if system time is in TAI (International Atomic Time)"""
+        if cls.__is_system_time_in_tai is None:
+            cls.__is_system_time_in_tai = Converter.to_boolean(os.getenv("HOLADO_SYSTEM_TIME_IS_IN_TAI", False))
+        return cls.__is_system_time_in_tai
+    
+    @classmethod
+    def now(cls, tz=default_timezone):  # @UndefinedVariable
+        return datetime.datetime.now(tz=tz)
+    
+    @classmethod
+    def utcnow(cls):
+        if cls.is_system_time_in_tai():
+            return cls.now(TIMEZONE_UTC) - cls.utc_to_tai_timedelta()
+        else:
+            return cls.now(TIMEZONE_UTC)
+    
+    @classmethod
+    def tainow(cls):
+        if cls.is_system_time_in_tai():
+            return cls.now(TIMEZONE_UTC)
+        else:
+            return cls.now(TIMEZONE_UTC) + cls.utc_to_tai_timedelta()
+    
+    @classmethod
+    def utc_to_tai_timedelta(cls):
+        """Return the timedelta to add to an UTC datetime to obtain a TAI datetime.
+        Note: Currently, only years 2020-2029 are managed"""
+        if cls.__utc_to_tai_timedelta is None:
+            cls.__utc_to_tai_timedelta = datetime.timedelta(seconds=37)
+        return cls.__utc_to_tai_timedelta
+    
+    @classmethod
+    def apply_delta_on_datetime(cls, date:datetime, operator:ArithmeticOperator, duration, duration_unit:DurationUnit) -> datetime:
+        args={duration_unit.value+'s':duration}
+        if duration_unit in [DurationUnit.Millisecond]:
+            delta = timedelta(**args)
+        else:
+            delta = relativedelta(**args)
+        
+        if operator == ArithmeticOperator.Subtraction: 
+            res = date - delta
+        elif operator == ArithmeticOperator.Addition:
+            res = date + delta
+        else:
+            raise TechnicalException(f"Unmanaged operator '{operator.value}'")
+        
+        return res
+    
+    ### Conversions to/from str
+    
+    @classmethod
+    def is_str_datetime(cls, dt_str, dt_format=None):
+        """Return if a string is a datetime of given format"""
+        res = True
+        try:
+            DateTime.str_2_datetime(dt_str, dt_format)
+        except (dateutil.parser._parser.ParserError, ValueError, TypeError):
+            res = False
+        return res
+
+    @classmethod
+    def str_2_datetime(cls, dt_str, dt_format=None, tz=None):
+        """Convert string to datetime instance
+        @param dt_format If defined, use this format to parse string rather than using first matching format
+        @param tz If defined, return a datetime with this timezone. 
+                  If string already defines a timezone, the datetime is converted to this timezone, 
+                  else the string is supposed to represent a datetime in this timezone and timezone is set in result datetime.
+        Note: Naive and aware datetimes cannot be compared. Thus HolAdo methods always set datetime timezone when it is known.
+              It is highly recommended to specify 'tz' argument
+        """
+        res = None
+        if dt_format is None:
+            res = dateutil.parser.parse(dt_str)
+        else:
+            res = datetime.datetime.strptime(dt_str, dt_format)
+        
+        # Set timezone if needed
+        if tz is not None:
+            if res.tzinfo is None:
+                res = res.replace(tzinfo=tz)
+            else:
+                res = res.astimezone(tz)
+        
+        return res
+
+    @classmethod
+    def str_2_timedelta(cls, dur_str):
+        """Convert string to timedelta instance"""
+        res = None
+        dur_regex = re.compile(r"(\d+(?:\.\d*)?) (?:s|sec|seconds)")
+        r = dur_regex.match(dur_str)
+        if r:
+            res = datetime.timedelta(seconds=float(r.group(1)))
+        else:
+            raise FunctionalException(r"Duration string must match pattern '\d+(\.\d*)? (s|sec|seconds)'")
+        return res
+    
+    @classmethod
+    def datetime_2_str(cls, dt_value, dt_format=None):
+        res = None
+        if dt_format is None:
+            res = datetime.datetime.isoformat(dt_value)
+        else:
+            res = dt_value.strftime(dt_format)
+        return res
+    
+    @classmethod
+    def _get_datetime(cls, dt, tz_in_str=None):
+        res = None
+        if dt is not None:
+            if isinstance(dt, datetime.datetime):
+                res = dt
+            elif isinstance(dt, str):
+                res = DateTime.str_2_datetime(dt, tz=tz_in_str)
+            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, tz_in_str=None):
+        res = None
+        if epoch is not None:
+            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, tz=tz_in_str)
+            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:
+            return dt.timestamp()
+        else:
+            return (dt - epoch).total_seconds()
+    
+    @classmethod
+    def timestamp_to_datetime(cls, ts, epoch=None):
+        """
+        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)
+        if epoch is not None:
+            res = epoch + (res - EPOCH_1970)
+        return res
+    
+    
+    ### Conversions to/from (seconds, nanos)
+    
+    @classmethod
+    def datetime_to_seconds_nanos(cls, dt, epoch=None):
+        ts = cls.datetime_to_timestamp(dt, epoch)
+        return cls.timestamp_to_seconds_nanos(ts)
+    
+    @classmethod
+    def seconds_nanos_to_datetime(cls, seconds, nanos, epoch=None, round_func=round):
+        """
+        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)
+    
+    @classmethod
+    def timestamp_to_seconds_nanos(cls, ts):
+        return round(ts), round(ts * 1e6 % 1e6)
+    
+    @classmethod
+    def seconds_nanos_to_timestamp(cls, seconds, nanos, cast_func=float, round_func=round):
+        """
+        Convert (seconds, nanos) to timestamp.
+        By default, it returns a timestamp as float with nanos rounded to microsecond precision.
+        To keep nanosecond precision, set cast_func=None and round_func=None, it will returns a timestamp as decimal.Decimal.
+        @param cast_func: Type of the returned value (default: float). If None, no cast is applied, and result is of type decimal.Decimal, usefull to keep nanosecond precision.
+        @param round_func: defines the rounding method applied to microseconds (default: round ; possible methods: round, math.ceil, math.trunc). If None, value is not rounded.
+        """
+        res_dec = Decimal(seconds) + Decimal(nanos) / Decimal(1e9)
+        if round_func is not None:
+            res_dec = round_func(res_dec * 1000000) / 1000000
+        if cast_func is not None:
+            return cast_func(res_dec)
+        else:
+            return res_dec
+    
+    
+    ### Conversions to/from Julian date
+    
+    @classmethod
+    def datetime_to_julian_date(cls, dt, epoch=None):
+        if epoch is None:
+            return cls.datetime_to_julian_date(dt, epoch=EPOCH_JULIAN_CNES) + 2433282.5
+        else:
+            td = (dt - epoch)
+            return td.days + td.seconds / (3600 * 24)
+        
+    @classmethod
+    def julian_date_to_datetime(cls, jd, epoch=None, precision_nb_digits=6):
+        """ Convert a Julian date to a datetime instance
+        @param precision_nb_digits Precision of the Julian date (default: 6 = microseconds)
+        """
+        if epoch is None:
+            return cls.julian_date_to_datetime(jd - 2433282.5, epoch=EPOCH_JULIAN_CNES)
+        else:
+            jd_decimal, jd_days = math.modf(jd)
+            jd_seconds = round(jd_decimal * 3600 * 24, precision_nb_digits)
+            td = datetime.timedelta(days=round(jd_days), seconds=jd_seconds)
+            return epoch + td
+        
+    @classmethod
+    def datetime_utc_to_tai(cls, dt, dt_format=None):
+        """ Convert a datetime in UTC to a datetime in TAI
+        @param dt Datetime in UTC
+        @param dt_format Format to use if 'dt' is a string (can be None for format autodetection)
+        """
+        dt_src = dt
+        if isinstance(dt_src, str):
+            dt_src = cls.str_2_datetime(dt_src, dt_format, tz=TIMEZONE_UTC)
+        
+        return dt_src + DateTime.utc_to_tai_timedelta()
+    
+    @classmethod
+    def datetime_tai_to_utc(cls, dt, dt_format=None):
+        """ Convert a datetime in TAI to a datetime in UTC
+        @param dt Datetime in TAI
+        @param dt_format Format to use if 'dt' is a string (can be None for format autodetection)
+        """
+        dt_src = dt
+        if isinstance(dt_src, str):
+            dt_src = cls.str_2_datetime(dt_src, dt_format, tz=TIMEZONE_UTC)
+        
+        return dt_src - DateTime.utc_to_tai_timedelta()
+        
+    @classmethod
+    def truncate_datetime(cls, dt, precision_nanoseconds=1):
+        total_us = cls.datetime_to_timestamp(dt) * 1e9
+        trunc_total_us = total_us // precision_nanoseconds * precision_nanoseconds
+        return cls.timestamp_to_datetime(trunc_total_us / 1e9)
+        

holado_python/standard_library/csv.py

@@ -0,0 +1,207 @@
+# -*- 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.
+#################################################
+
+import logging
+import csv
+from holado_core.common.tables.table_with_header import TableWithHeader
+from holado_core.common.tables.table_row import TableRow
+from holado.common.context.session_context import SessionContext
+from holado_core.common.tables.table import Table
+from holado_core.common.tables.table_manager import TableManager
+from holado_data.data.generator.base import BaseGenerator
+
+logger = logging.getLogger(__name__)
+
+
+
+
+class CsvManager():
+    # Default settings for CSV files: dialect Excel but with ';' delimiter
+    default_dialect = "excel"
+    default_delimiter = ";"
+    default_quotechar = None
+    default_quoting = None
+
+    @classmethod
+    def __get_path_manager(cls):
+        return SessionContext.instance().path_manager
+    
+    @classmethod
+    def _get_csv_kwargs(cls, dialect, delimiter, quotechar, quoting):
+        csv_kwargs = {}
+        
+        if dialect is not None:
+            csv_kwargs['dialect'] = dialect
+        elif cls.default_dialect is not None:
+            csv_kwargs['dialect'] = cls.default_dialect
+            
+        if delimiter is not None:
+            csv_kwargs['delimiter'] = delimiter
+        elif cls.default_delimiter is not None:
+            csv_kwargs['delimiter'] = cls.default_delimiter
+            
+        if quotechar is not None:
+            csv_kwargs['quotechar'] = quotechar
+        elif cls.default_quotechar is not None:
+            csv_kwargs['quotechar'] = cls.default_quotechar
+            
+        if quoting is not None:
+            csv_kwargs['quoting'] = quoting
+        elif cls.default_quoting is not None:
+            csv_kwargs['quoting'] = cls.default_quoting
+            
+        return csv_kwargs
+        
+    @classmethod
+    def table_with_content_of_CSV_file(cls, path, encoding=None, dialect=None, delimiter=None, quotechar=None, quoting=None, with_header=True):
+        csv_kwargs = cls._get_csv_kwargs(dialect, delimiter, quotechar, quoting)
+        
+        with open(path, 'r', encoding=encoding) as fin:
+            if with_header:
+                dr = csv.DictReader(fin, **csv_kwargs)
+                
+                res = TableWithHeader()
+                res.header = TableRow(cells_content=dr.fieldnames)
+                
+                for row in dr:
+                    nrow=dict(row)
+                    res.add_row(contents_by_colname=nrow)
+            else:
+                reader = csv.reader(fin, **csv_kwargs)
+                
+                res = Table()
+                for row in reader:
+                    res.add_row(cells_content=row)
+        
+        return res
+        
+    @classmethod
+    def dict_list_with_content_of_CSV_file(cls, path, encoding=None, dialect=None, delimiter=None, quotechar=None, quoting=None):
+        dg = cls.dict_generator_with_content_of_CSV_file(path, encoding, dialect, delimiter, quotechar, quoting)
+        return [d for d in dg]
+    
+    @classmethod
+    def dict_generator_with_content_of_CSV_file(cls, path, encoding=None, dialect=None, delimiter=None, quotechar=None, quoting=None):
+        csv_kwargs = cls._get_csv_kwargs(dialect, delimiter, quotechar, quoting)
+        
+        class DictCSVGenerator(BaseGenerator):
+            def __init__(self, path, encoding, csv_kwargs):
+                super().__init__(name="dict CSV generator")
+                
+                self.__path = path
+                self.__encoding = encoding
+                self.__csv_kwargs = csv_kwargs
+                
+                self.__fin = None
+                self.__dict_reader = None
+            
+            def __open_file_if_needed(self):
+                if self.__fin is None:
+                    self.__fin = open(self.__path, 'r', encoding=self.__encoding)
+                    self.__dict_reader = csv.DictReader(self.__fin, **self.__csv_kwargs)
+            
+            def __close_file(self):
+                self.__dict_reader = None
+                self.__fin.close()
+                self.__fin = None
+                
+            def __next__(self):
+                self.__open_file_if_needed()
+                try:
+                    return dict(next(self.__dict_reader))
+                except StopIteration as exc:
+                    self.__close_file()
+                    raise exc
+        
+        return DictCSVGenerator(path, encoding, csv_kwargs)
+    
+    @classmethod
+    def tuple_list_with_content_of_CSV_file(cls, path, encoding=None, dialect=None, delimiter=None, quotechar=None, quoting=None):
+        tg = cls.tuple_generator_with_content_of_CSV_file(path, encoding, dialect, delimiter, quotechar, quoting)
+        return [t for t in tg]
+    
+    @classmethod
+    def tuple_generator_with_content_of_CSV_file(cls, path, encoding=None, dialect=None, delimiter=None, quotechar=None, quoting=None):
+        csv_kwargs = cls._get_csv_kwargs(dialect, delimiter, quotechar, quoting)
+        
+        class TupleCSVGenerator(BaseGenerator):
+            def __init__(self, path, encoding, csv_kwargs):
+                super().__init__(name="tuple CSV generator")
+                
+                self.__path = path
+                self.__encoding = encoding
+                self.__csv_kwargs = csv_kwargs
+                
+                self.__fin = None
+                self.__reader = None
+            
+            def __open_file_if_needed(self):
+                if self.__fin is None:
+                    self.__fin = open(self.__path, 'r', encoding=self.__encoding)
+                    self.__reader = csv.reader(self.__fin, **self.__csv_kwargs)
+            
+            def __close_file(self):
+                self.__reader = None
+                self.__fin.close()
+                self.__fin = None
+                
+            def __next__(self):
+                self.__open_file_if_needed()
+                try:
+                    return tuple(next(self.__reader))
+                except StopIteration as exc:
+                    self.__close_file()
+                    raise exc
+        
+        return TupleCSVGenerator(path, encoding, csv_kwargs)
+    
+    @classmethod
+    def create_csv_file(cls, path, table, encoding=None, dialect=None, delimiter=None, quotechar=None, quoting=None):
+        csv_kwargs = cls._get_csv_kwargs(dialect, delimiter, quotechar, quoting)
+        
+        cls.__get_path_manager().makedirs(path)
+        
+        with open(path, 'w', encoding=encoding) as fout:
+            if TableManager.is_table_with_header(table):
+                fieldnames = table.header.cells_content
+                dw = csv.DictWriter(fout, fieldnames=fieldnames, **csv_kwargs)
+                
+                dw.writeheader()
+                for row in table.rows:
+                    rowdict = {fieldnames[i]:row[i].string_content for i in range(len(fieldnames))}
+                    dw.writerow(rowdict)
+            else:
+                writer = csv.writer(fout, **csv_kwargs)
+                for row in table.rows:
+                    cells_content = [c.string_content for c in row]
+                    writer.writerow(cells_content)
+    
+    @classmethod
+    def merge_csv(cls, input_paths, output_path=None, sort_column=None, with_header=True):
+        input_tables = [cls.table_with_content_of_CSV_file(ip, with_header=with_header) for ip in input_paths]
+        
+        # Merge tables
+        output_table = input_tables[0]
+        for i in range(1, len(input_tables)):
+            output_table.extend(input_tables[i])
+        
+        # Sort rows
+        if sort_column is not None:
+            output_table.sort(names=[sort_column])
+        
+        if output_path is not None:
+            cls.create_csv_file(output_path, output_table)
+        else:
+            return output_table
+    

holado_python/standard_library/hashlib.py

@@ -0,0 +1,110 @@
+# -*- 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.
+#################################################
+
+import logging
+import hashlib
+from holado_core.common.exceptions.technical_exception import TechnicalException
+
+logger = logging.getLogger(__name__)
+
+
+
+
+class HashTools(object):
+    
+    @classmethod
+    def code(cls, content, code_size=None, prefix=None):
+        hex_size = code_size
+        if hex_size is not None:
+            if prefix is not None:
+                hex_size = hex_size - len(prefix)
+            hex_size = hex_size // 2 * 2
+        
+        res = cls.hexblake2(content, hex_size=hex_size)
+        
+        if prefix is not None:
+            res = prefix + res
+        
+        return res
+    
+    @classmethod
+    def hash(cls, algorithm_name, content, hash_size=None, **hash_kwargs):
+        hash_obj = hashlib.new(algorithm_name, **hash_kwargs)
+        cls._update_hash(hash_obj, content)
+        res = hash_obj.digest()
+        
+        # Truncate result size if needed
+        if hash_size is not None:
+            if not isinstance(hash_size, int):
+                raise TechnicalException(f"Parameter size must be an integer")
+            res = res[:hash_size]
+        
+        return res
+    
+    @classmethod
+    def hexhash(cls, algorithm_name, content, hex_size=None, **hash_kwargs):
+        hash_obj = hashlib.new(algorithm_name, **hash_kwargs)
+        cls._update_hash(hash_obj, content)
+        res = hash_obj.hexdigest()
+        
+        # Truncate result size if needed
+        if hex_size is not None:
+            if not isinstance(hex_size, int):
+                raise TechnicalException(f"Parameter hex_size must be an integer")
+            res = res[:hex_size]
+        
+        return res
+        
+    @classmethod
+    def hexmd5(cls, content):
+        hash_obj = hashlib.md5()
+        cls._update_hash(hash_obj, content)
+        return hash_obj.hexdigest()
+    
+    @classmethod
+    def hexblake2(cls, content, hex_size=None, **hash_kwargs):
+        if hex_size is not None:
+            if isinstance(hex_size, int):
+                digest_size = hex_size // 2
+            else:
+                raise TechnicalException(f"Parameter hex_size must be an integer")
+            hash_kwargs['digest_size'] = digest_size
+        
+        hash_obj = hashlib.blake2b(**hash_kwargs)
+        cls._update_hash(hash_obj, content)
+        return hash_obj.hexdigest()
+    
+    @classmethod
+    def _update_hash(cls, hash_obj, content):
+        # Manage list separately for memory purpose
+        done = False
+        if not isinstance(content, str): 
+            try:
+                for cont in content:
+                    if type(cont) != bytes:
+                        cont = cont.encode('utf-8')
+                    hash_obj.update(cont)
+                done = True
+            except TypeError:
+                done = False
+    
+        if not done:
+            if type(content) != bytes:
+                content = content.encode('utf-8')
+            hash_obj.update(content)
+    
+    
+    
+    
+