holado 0.13.22__py3-none-any.whl

holado_system/system/filesystem/file.py

@@ -0,0 +1,150 @@
+
+#################################################
+# 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.common.handlers.object import DeleteableObject
+import os
+from typing import AnyStr, List
+from holado_python.standard_library.typing import Typing
+from holado_core.common.exceptions.technical_exception import TechnicalException
+import copy
+
+
+class File(DeleteableObject):
+    """
+    Manage a file
+    """
+
+    def __init__(self, path, auto_flush=True, do_open=False, **open_kwargs):
+        """ Manage a file
+        @param path: file path
+        @param do_open: if file must be open during this file initialization
+        @param open_kwargs: arguments to open method
+        """
+        super().__init__(f"file '{path}'")
+
+        self.__path = path
+        self.__auto_flush = auto_flush
+        self.__file = None
+        self.__open_kwargs = open_kwargs
+        if do_open:
+            self.open()
+
+    def _delete_object(self):
+        self.close()
+    
+    def __enter__(self):
+        if not self.is_open:
+            self.open()
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+    
+    @property
+    def path(self):
+        return self.__path
+
+    @property
+    def internal_file(self):
+        return self.__file
+    
+    @property
+    def is_open(self):
+        return self.__file is not None
+
+    def open(self, **kwargs):
+        if self.is_open:
+            raise TechnicalException(f"File '{self.path}' is already opened")
+        open_kwargs = copy.copy(self.__open_kwargs)
+        if kwargs:
+            open_kwargs.update(kwargs)
+        
+        self.__file = open(self.__path, **open_kwargs)
+
+    def close(self):
+        if self.__file:
+            self.__file.close()
+            self.__file = None
+
+    def write(self, data):
+        res = self.internal_file.write(data)
+        if self.__auto_flush:
+            self.internal_file.flush()
+        return res
+
+    def writelines(self, lines, add_line_sep=True):
+        for line in lines:
+            self.internal_file.write(line)
+            if add_line_sep and not line.endswith(os.linesep):
+                self.internal_file.write(os.linesep)
+        if self.__auto_flush:
+            self.internal_file.flush()
+
+    def read(self, n: int = -1) -> AnyStr:
+        return self.internal_file.read(n)
+
+    def readline(self, limit: int = -1) -> AnyStr:
+        return self.internal_file.readline(limit)
+
+    def readlines(self, hint: int = -1, strip_newline=False) -> List[AnyStr]:
+        res = self.internal_file.readlines(hint)
+        if strip_newline:
+            res = [l.strip('\n') for l in res]
+        return res
+
+
+
+    @classmethod
+    def read_file_content(cls, path, **open_kwargs):
+        with File(path, **open_kwargs) as file:
+            res = file.read()
+        return res
+
+    @classmethod
+    def read_file_content_in_base64(cls, path, **open_kwargs):
+        import base64
+        
+        # Force to read file in binary mode
+        open_kwargs['mode'] = 'rb'
+        
+        with File(path, **open_kwargs) as fin:
+            content = fin.read()
+        res = base64.b64encode(content)
+        
+        return res
+
+    @classmethod
+    def read_file_content_in_hexadecimal(cls, path, **open_kwargs):
+        # Force to read file in binary mode
+        open_kwargs['mode'] = 'rb'
+        
+        with File(path, **open_kwargs) as fin:
+            content = fin.read()
+        res = content.hex()
+        
+        return res
+
+    @classmethod
+    def write_file_with_content(cls, path, content):
+        if isinstance(content, str):
+            with File(path, mode='wt') as fout:
+                fout.write(content)
+        elif isinstance(content, bytes):
+            with File(path, mode='wb') as fout:
+                fout.write(content)
+        else:
+            raise TechnicalException(f"Unexpected content type {Typing.get_object_class_fullname(content)} (allowed types: str, bytes)")
+
+
+
+

holado_system/system/global_system.py

@@ -0,0 +1,187 @@
+
+#################################################
+# 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
+from holado.common.handlers.enums import AutoNumber
+import platform
+from holado_core.common.exceptions.technical_exception import TechnicalException
+import time
+import os
+from holado_core.common.tools.tools import Tools
+import threading
+from holado_core.common.tools.converters.converter import Converter
+
+logger = logging.getLogger(__name__)
+
+
+
+class OSTypes(AutoNumber):
+    """
+    Types of operating systems.
+    """
+    Windows = ()
+    MacOS = ()
+    Linux = ()
+    Other = ()
+
+
+class GlobalSystem(object):
+    """
+    System methods.
+    """
+    __detected_os_type:OSTypes = None
+    __detected_os_version = None
+
+    @classmethod
+    def get_os_type(cls):
+        """
+        Detect the operating system from the os.name System property and cache
+        the result
+        @return the operating system detected
+        """
+        if cls.__detected_os_type is None:
+            os_ = platform.system()
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"Detected OS: {os_}")
+            if os_ == 'Darwin':
+                cls.__detected_os_type = OSTypes.MacOS
+            elif os_ == 'Windows':
+                cls.__detected_os_type = OSTypes.Windows
+            elif os_ == 'Linux':
+                cls.__detected_os_type = OSTypes.Linux
+            else:
+                cls.__detected_os_type = OSTypes.Other
+            logger.info(f"Detected OS type: {cls.__detected_os_type.name}")
+        return cls.__detected_os_type
+
+    @classmethod
+    def get_os_version(cls):
+        """
+        Detect the operating system from the os.name System property and cache
+        the result
+        @return the operating system detected
+        """
+        if cls.__detected_os_version is None:
+            cls.__detected_os_version = platform.release()
+            if '-' in cls.__detected_os_version:
+                cls.__detected_os_version = cls.__detected_os_version[:cls.__detected_os_version.index('-')]
+            logger.info(f"Detected OS version: {cls.__detected_os_version}")
+        return cls.__detected_os_version
+
+    @classmethod
+    def execute_curl(cls, curl_parameters, do_log_output=False):
+        cmd = f"curl {curl_parameters}"
+        return cls.execute_command(cmd, do_log_output=do_log_output, do_raise_on_stderr=False)
+
+    @classmethod
+    def execute_command(cls, cmd, do_log_output=False, do_raise_on_stderr=False):
+        from holado_system.system.command.command import Command, CommandStates
+        from holado_system.system.command.command_result import CommandResult
+        
+        command = Command(cmd, do_log_output=do_log_output, do_raise_on_stderr=do_raise_on_stderr)
+        command.start()
+        command.join()
+        
+        if command.state == CommandStates.Error:
+            raise TechnicalException(f"Error while executing command [{cmd}]: [{command.error if command.error else command.stderr}]")
+        return CommandResult(cmd, command.stdout, command.stderr)
+    
+    @classmethod
+    def log_resource_usage(cls, prefix=None, level=logging.DEBUG, logger_=None):
+        # cls.log_memory_usage(prefix, level, logger_)
+        
+        # Log all resources usage of this process and children processes
+        if cls.get_os_type() == OSTypes.Linux:
+            import resource
+            cls.__log_resource_usage(resource.RUSAGE_SELF, None, None, prefix, level, logger_)
+            cls.__log_resource_usage(resource.RUSAGE_CHILDREN, None, None, prefix, level, logger_)
+        else:
+            raise NotImplementedError(f"Not implemented for OS type '{cls.get_os_type().name}'")
+        
+        # Log threads
+        cls.__log_threads(prefix, level, logger_)
+    
+    @classmethod
+    def log_memory_usage(cls, prefix=None, level=logging.DEBUG, logger_=None):
+        if cls.get_os_type() == OSTypes.Linux:
+            import resource
+            cls.__log_resource_usage(resource.RUSAGE_SELF, 'maxrss', 'maximum resident set size', prefix, level, logger_)
+            cls.__log_resource_usage(resource.RUSAGE_CHILDREN, 'maxrss', 'maximum resident set size', prefix, level, logger_)
+        else:
+            raise NotImplementedError(f"Not implemented for OS type '{cls.get_os_type().name}'")
+    
+    @classmethod
+    def __log_resource_usage(cls, which_process=None, resource_attr_name=None, resource_description=None, prefix=None, level=logging.DEBUG, logger_=None):
+        if logger_ is None:
+            logger_ = logger
+        if not logger_.isEnabledFor(level):
+            return
+        
+        if cls.get_os_type() == OSTypes.Linux:
+            import resource
+            if which_process is None:
+                which_process = resource.RUSAGE_SELF
+            
+            ru = resource.getrusage(which_process)
+            field_names = ['utime', 'stime', 'maxrss', 'minflt', 'majflt', 'inblock', 'oublock', 'nvcsw', 'nivcsw']
+            resource_usage = {fn:getattr(ru, f'ru_{fn}') for fn in field_names}
+            
+            if which_process == resource.RUSAGE_SELF:
+                usage_descr = "Process resource usage"
+            elif which_process == resource.RUSAGE_CHILDREN:
+                usage_descr = "Child processes resource usage"
+            else:
+                usage_descr = "Other resource usage"
+            if resource_attr_name is not None:
+                logger_.log(level, f"{prefix if prefix else ''}{usage_descr}: {resource_description} = {getattr(resource_usage, resource_attr_name)}")
+            else:
+                logger_.log(level, f"{prefix if prefix else ''}{usage_descr}: {resource_usage}")
+        else:
+            raise NotImplementedError(f"Not implemented for OS type '{cls.get_os_type().name}'")
+    
+    @classmethod
+    def __log_threads(cls, prefix=None, level=logging.DEBUG, logger_=None):
+        if logger_ is None:
+            logger_ = logger
+        if not logger_.isEnabledFor(level):
+            return
+        
+        thread_names = [t.name for t in threading.enumerate()]
+        logger_.log(level, f"{prefix if prefix else ''}Process has {len(thread_names)} threads: {thread_names}")
+        
+    @classmethod
+    def yield_processor(cls):
+        if cls.get_os_type() == OSTypes.Windows:
+            time.sleep(0.0001)
+        else:
+            os.sched_yield()
+    
+    @classmethod
+    def get_used_ports(cls):
+        if cls.get_os_type() == OSTypes.Linux:
+            cmd = "netstat -tunlep | grep LISTEN | awk '{print $4}' | awk '{gsub(\".*:\",\"\");print}'"
+            result = cls.execute_command(cmd, do_log_output=False, do_raise_on_stderr=False)
+            res = {Converter.to_integer(v) for v in result.output.split('\n') if len(v) > 0}
+            return res
+        else:
+            raise NotImplementedError(f"Not implemented for OS type '{cls.get_os_type().name}'")
+    
+    @classmethod
+    def get_first_available_anonymous_port(cls):
+        used_ports = cls.get_used_ports()
+        for port in range(32768, 65536):
+            if port not in used_ports:
+                return port
+        return None
+    
+    

holado_system/tests/behave/steps/__init__.py

@@ -0,0 +1,18 @@
+# -*- 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 .system.commands_steps import *
+from .system.file_steps import *
+from .system.system_steps import *

holado_system/tests/behave/steps/system/commands_steps.py

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+
+import logging
+from holado.common.context.session_context import SessionContext
+from holado_system.system.command.command import Command, CommandStates
+from holado_core.common.exceptions.functional_exception import FunctionalException
+from holado_test.scenario.step_tools import StepTools
+from holado_core.tools.abstracts.blocking_command_service import BlockingCommandService
+from holado_test.behave.behave import *  # @UnusedWildImport
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
+from holado_value.common.tables.converters.value_table_converter import ValueTableConverter
+from holado_core.common.tools.tools import Tools
+
+logger = logging.getLogger(__name__)
+
+def __get_scenario_context():
+    return SessionContext.instance().get_scenario_context()
+
+def __get_text_interpreter():
+    return __get_scenario_context().get_text_interpreter()
+
+def __get_variable_manager():
+    return __get_scenario_context().get_variable_manager()
+
+@Given(r"(?P<var_name>{Variable}) = new command (?P<cmd>{AnyStr})(?<! with)")
+def step_impl(context, var_name, cmd):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    cmd = StepTools.evaluate_string_parameter(cmd)
+    obj_cmd = Command(cmd)
+    __get_variable_manager().register_variable(var_name, obj_cmd)
+
+@Given(r"(?P<var_name>{Variable}) = new command (?P<cmd>{AnyStr}) with")
+def step_impl(context, var_name, cmd):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    cmd = StepTools.evaluate_scenario_parameter(cmd)
+    table = BehaveStepTools.convert_step_table_2_value_table_with_header(context.table)
+    arguments_dict = ValueTableConverter.convert_name_value_table_2_dict(table)
+    
+    
+    blocking = False
+    auto_stop = False
+    do_log_output = False
+    do_raise_on_stderr = False
+    name = ''
+    
+    if 'blocking' in arguments_dict:
+        blocking = arguments_dict['blocking']
+        if 'name' in arguments_dict:
+            name = arguments_dict['name']
+        if 'auto_stop' in arguments_dict:
+            auto_stop = arguments_dict['auto_stop']
+    else:
+        if 'name' in arguments_dict:
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug("Argument 'name' is useless for non-blocking commands")
+        if 'auto_stop' in arguments_dict:
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug("Argument 'auto_stop' is useless for non-blocking commands")
+    if 'do_log_output' in arguments_dict:
+        do_log_output = arguments_dict['do_log_output']
+    if 'do_raise_on_stderr' in arguments_dict:
+        do_raise_on_stderr = arguments_dict['do_raise_on_stderr']
+    
+    if blocking:
+        obj_cmd = BlockingCommandService(name, cmd, do_log_output=do_log_output, do_raise_on_stderr=do_raise_on_stderr)
+        obj_cmd.auto_stop = auto_stop
+    else:
+        obj_cmd = Command(cmd, do_log_output=do_log_output, do_raise_on_stderr=do_raise_on_stderr)
+    
+    __get_variable_manager().register_variable(var_name, obj_cmd)
+
+@Then(r"command (?P<var_name>{Variable}) has status (?P<expected_status>Ready|Running|Success|Error)")
+def step_impl(context, var_name, expected_status):
+    obj_cmd =  StepTools.evaluate_variable_value(var_name)
+    
+    if isinstance(obj_cmd, Command):
+        state = obj_cmd.state
+    elif isinstance(obj_cmd, BlockingCommandService):
+        state = obj_cmd.status
+    else:
+        raise TechnicalException(f"Variable {var_name} is not a command")
+        
+    if state is not CommandStates[expected_status]:
+        raise FunctionalException(f"Command state error : expected {expected_status} found {state.name}")
+    
+@Given(r"run command (?P<var_name>{Variable})")
+def step_impl(context, var_name):
+    obj_cmd =  StepTools.evaluate_variable_value(var_name)
+    obj_cmd.start()
+    
+    

holado_system/tests/behave/steps/system/file_steps.py

@@ -0,0 +1,231 @@
+# -*- 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 holado_test.scenario.step_tools import StepTools
+from holado.common.context.session_context import SessionContext
+from holado_test.behave.behave import *  # @UnusedWildImport
+import logging
+from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
+from holado_value.common.tables.converters.value_table_converter import ValueTableConverter
+from holado_system.system.filesystem.file import File
+import base64
+import os.path
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_python.standard_library.typing import Typing
+from zipfile import ZipFile
+
+logger = logging.getLogger(__name__)
+
+
+
+def __get_scenario_context():
+    return SessionContext.instance().get_scenario_context()
+
+def __get_text_interpreter():
+    return __get_scenario_context().get_text_interpreter()
+
+def __get_variable_manager():
+    return __get_scenario_context().get_variable_manager()
+
+def __get_report_manager():
+    return SessionContext.instance().report_manager
+
+def __get_path_manager():
+    return SessionContext.instance().path_manager
+
+
+@Then(r"file (?P<path>{Str}) (?P<exists_str>exists|doesn't exist)")
+def step_impl(context, path, exists_str):  # @DuplicatedSignature
+    path = StepTools.evaluate_scenario_parameter(path)
+    exists = exists_str == "exists"
+    
+    __get_path_manager().check_file_exists(path, do_exist=exists, raise_exception=True)
+
+@Given(r"(?P<var_name>{Variable}) = is path (?P<path>{Str}) an absolute file path")
+def step_impl(context, var_name, path):  # @DuplicatedSignature
+    var_name = StepTools.evaluate_variable_name(var_name)
+    path = StepTools.evaluate_scenario_parameter(path)
+    res = os.path.isabs(path)
+    __get_variable_manager().register_variable(var_name, res)
+
+@Given(r"(?P<var_name>{Variable}) = file name of path (?P<path>{Str})(?: \((?P<without_extension_str>without extension)\))?")
+def step_impl(context, var_name, path, without_extension_str):  # @DuplicatedSignature
+    var_name = StepTools.evaluate_variable_name(var_name)
+    path = StepTools.evaluate_scenario_parameter(path)
+    
+    res = os.path.basename(path)
+    if without_extension_str is not None:
+        res = os.path.splitext(res)
+    
+    __get_variable_manager().register_variable(var_name, res)
+
+@Given(r"(?P<var_name>{Variable}) = open file (?P<path>{Str}) in mode (?P<mode>{Str})")
+def step_impl(context, var_name, path, mode):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    execute_steps(u"""
+        Given {var_name} = open file {path}
+            | Name    | Value  |
+            | 'mode'  | {mode} |
+        """.format(var_name=var_name, path=path, mode=mode))
+
+@Given(r"(?P<var_name>{Variable}) = open file (?P<path>{Str})")
+def step_impl(context, var_name, path):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    path = StepTools.evaluate_scenario_parameter(path)
+    table = BehaveStepTools.convert_step_table_2_value_table_with_header(context.table)
+    open_kwargs = ValueTableConverter.convert_name_value_table_2_dict(table)
+    
+    __get_path_manager().makedirs(path)
+    res = File(path, **open_kwargs)
+
+    __get_variable_manager().register_variable(var_name, res)
+
+@Given(r"close \(file: (?P<file>{Variable})\)")
+def step_impl(context, file):
+    file = StepTools.evaluate_scenario_parameter(file)
+    file.close()
+
+@When(r"write line (?P<line>{Str}) \(file: (?P<file>{Variable})\)")
+def step_impl(context, line, file):
+    line = StepTools.evaluate_scenario_parameter(line)
+    file = StepTools.evaluate_scenario_parameter(file)
+    
+    file.writelines([line])
+    
+@When(r"write lines (?P<lines_list>{List}) \(file: (?P<file>{Variable})\)")
+def step_impl(context, lines_list, file):
+    lines_list = StepTools.evaluate_scenario_parameter(lines_list)
+    file = StepTools.evaluate_scenario_parameter(file)
+    
+    file.writelines(lines_list)
+    
+@When(r"write (?P<data>{Str}) \(file: (?P<file>{Variable})\)")
+def step_impl(context, data, file):
+    data = StepTools.evaluate_scenario_parameter(data)
+    file = StepTools.evaluate_scenario_parameter(file)
+    
+    file.write(data)
+
+@Given(r"(?P<var_name>{Variable}) = content of(?:(?P<is_text_file_str> text))? file (?P<path>{Str})")
+def step_impl(context, var_name, is_text_file_str, path):  # @DuplicatedSignature
+    var_name = StepTools.evaluate_variable_name(var_name)
+    is_text_file = is_text_file_str is not None
+    path = StepTools.evaluate_scenario_parameter(path)
+    
+    mode = 'rt' if is_text_file else 'rb'
+    res = File.read_file_content(path, mode=mode)
+    
+    __get_variable_manager().register_variable(var_name, res)
+
+@Given(r"(?P<var_name>{Variable}) = content of file (?P<path>{Str}) in base 64")
+def step_impl(context, var_name, path):  # @DuplicatedSignature
+    var_name = StepTools.evaluate_variable_name(var_name)
+    path = StepTools.evaluate_scenario_parameter(path)
+
+    res = File.read_file_content_in_base64(path)
+    
+    __get_variable_manager().register_variable(var_name, res)
+
+@Given(r"(?P<var_name>{Variable}) = content of file (?P<path>{Str}) in hexadecimal")
+def step_impl(context, var_name, path):  # @DuplicatedSignature
+    var_name = StepTools.evaluate_variable_name(var_name)
+    path = StepTools.evaluate_scenario_parameter(path)
+
+    res = File.read_file_content_in_hexadecimal(path)
+    
+    __get_variable_manager().register_variable(var_name, res)
+
+@Given(r"(?P<var_name>{Variable}) = lines of file (?P<path>{Str})")
+def step_impl(context, var_name, path):  # @DuplicatedSignature
+    var_name = StepTools.evaluate_variable_name(var_name)
+    path = StepTools.evaluate_scenario_parameter(path)
+
+    with File(path, mode="r") as fin:
+        lines = fin.readlines()
+    res = list(map(lambda x: x.strip('\n'), lines))
+    
+    __get_variable_manager().register_variable(var_name, res)
+
+
+@Given(r"(?P<var_name>{Variable}) = path to file with name (?P<filename>{Str})")
+def step_impl(context, var_name, filename):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    filename = StepTools.evaluate_scenario_parameter(filename)
+    
+    dest_path = __get_report_manager().current_scenario_report.get_path("files")
+    res = os.path.join(dest_path, filename)
+    
+    __get_variable_manager().register_variable(var_name, res)
+
+@Given(r"(?P<var_name>{Variable}) = path to timestamped file with prefix (?P<path_prefix>{Str}) and extension (?P<path_ext>{Str})")
+def step_impl(context, var_name, path_prefix, path_ext):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    prefix = StepTools.evaluate_scenario_parameter(path_prefix)
+    ext = StepTools.evaluate_scenario_parameter(path_ext)
+
+    res = __get_path_manager().get_timestamped_path(prefix, ext)
+    
+    __get_variable_manager().register_variable(var_name, res)
+
+@Given(r"(?P<var_name>{Variable}) = create file with prefix (?P<path_prefix>{Str}) and extension (?P<path_ext>{Str}) and content (?P<content>{Str})")
+def step_impl(context, var_name, path_prefix, path_ext, content):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    execute_steps(u"""
+        Given __FILENAME__@ = path to timestamped file with prefix {path_prefix} and extension {path_ext}
+        Given {var_name} = create file with name __FILENAME__@ and content {content}
+        """.format(path_prefix=path_prefix, path_ext=path_ext, var_name=var_name, content=content) )
+
+@Given(r"(?P<var_name>{Variable}) = create file with name (?P<path_name>{Str}) and content (?P<content>{Str})")
+def step_impl(context, var_name, path_name, content):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    filename = StepTools.evaluate_scenario_parameter(path_name)
+    content = StepTools.evaluate_scenario_parameter(content)
+    
+    dest_path = __get_report_manager().current_scenario_report.get_path("files")
+    file_path = os.path.join(dest_path, filename)
+    __get_path_manager().makedirs(file_path)
+    
+    File.write_file_with_content(file_path, content)
+
+    __get_variable_manager().register_variable(var_name, file_path)
+
+
+@Given(r"(?P<var_name>{Variable}) = create file with name (?P<path_name>{Str})")
+def step_impl(context, var_name, path_name):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    content = BehaveStepTools.get_step_multiline_text(context, raise_exception_if_none=False)
+    if content is None:
+        content = ""
+    __get_variable_manager().register_variable("__FILE_CONTENT__@", content)
+    
+    execute_steps(u"""
+        Given {var_name} = create file with name {path_name} and content __FILE_CONTENT__@
+        """.format(var_name=var_name, path_name=path_name) )
+
+
+@Step(r"extract files from zip file (?P<zip_path>{Str}) in path (?P<dest_path>{Str})")
+def step_impl(context, zip_path, dest_path):
+    """
+    extracts zip contents into the specified path.
+    """
+    zip_path = StepTools.evaluate_scenario_parameter(zip_path)
+    dest_path = StepTools.evaluate_scenario_parameter(dest_path)
+    
+    __get_path_manager().makedirs(dest_path)
+    
+    # Extract files from the zip archive
+    with ZipFile(zip_path, 'r') as zip_ref:
+        zip_ref.extractall(dest_path)
+        logger.debug(f"Extracted files to {dest_path}")