holado 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

holado_db/tools/db/query/pypika/pypika_query_builder.py

@@ -0,0 +1,193 @@
+
+#################################################
+# 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_core.common.exceptions.technical_exception import TechnicalException
+from holado_db.tools.db.query.base.query_builder import QueryBuilder
+from holado_core.common.tools.tools import Tools
+from holado_core.common.tools.comparators.comparator import CompareOperator
+from holado_python.standard_library.typing import Typing
+
+
+logger = logging.getLogger(__name__)
+
+try:
+    import pypika.functions
+    from pypika.queries import Table, Query
+    from pypika.terms import Parameter
+    with_pypika = True
+except Exception as exc:
+    if Tools.do_log(logger, logging.DEBUG):
+        logger.debug(f"PyPika is not available for QueryBuilder. Initialization failed on error: {exc}")
+    with_pypika = False
+
+
+
+class PypikaQueryBuilder(QueryBuilder):
+    """
+    Query builder for PyPika library.
+    """
+    @classmethod
+    def is_available(cls):
+        return with_pypika
+    
+    def __init__(self, name, db_client=None):
+        super().__init__(name, db_client)
+    
+    def select(self, table_name, where_data: dict=None, sql_return="*"):
+        """
+        Simple query & values builder of a select by filtering on given where data.
+        Parameter 'where_data' has to be a dictionary with keys equal to table column names.
+        """
+        table = Table(table_name)
+        res = Query.from_(table)
+        values = ()
+        
+        if sql_return == "count(*)":
+            res = res.select(pypika.functions.Count("*"))
+        elif isinstance(sql_return, list):
+            res = res.select(*sql_return)
+        else:
+            res = res.select(sql_return)
+        
+        if where_data:
+            res, values = self.where(res, values, where_data)
+            
+        return res, values
+    
+    def insert(self, table_name, data: dict):
+        """
+        Simple query & values builder of an insert of given data.
+        Parameter 'data' has to be a dictionary with keys equal to table column names.
+        """
+        col_names = tuple(sorted(data.keys()))
+        values = tuple((data[c] for c in col_names))
+        sql_placeholder = self.db_client._get_sql_placeholder()
+        
+        values_placeholder = [Parameter(sql_placeholder)] * len(col_names)
+        res = Query.into(table_name).columns(*col_names).insert(*values_placeholder)
+        
+        return res, values
+    
+    def update(self, table_name, data: dict, where_data: dict):
+        """
+        Simple query & values builder of an update of given data.
+        Parameters 'data' and 'where_data' have to be dictionaries with keys equal to table column names.
+        """
+        col_names = tuple(sorted(data.keys()))
+        values = tuple((data[c] for c in col_names))
+        sql_placeholder = self.db_client._get_sql_placeholder()
+        
+        table = Table(table_name)
+        res = Query.update(table)
+        for c in col_names:
+            res = res.set(c, Parameter(sql_placeholder))
+            
+        if where_data:
+            res, values = self.where(res, values, where_data)
+        
+        return res, values
+    
+    def delete(self, table_name, where_data: dict=None):
+        """
+        Simple query & values builder of a delete by filtering on given where data.
+        Parameter 'where_data' has to be a dictionary with keys equal to table column names.
+        """
+        table = Table(table_name)
+        res = Query.from_(table).delete()
+        values = ()
+        
+        if where_data:
+            res, values = self.where(res, values, where_data)
+            
+        return res, values
+    
+    def where(self, query, values, where_data: dict):
+        col_names = tuple(sorted(where_data.keys()))
+        where_values = tuple((where_data[c] for c in col_names))
+        sql_placeholder = self.db_client._get_sql_placeholder()
+        
+        res = query
+        table = self.__get_table(query)
+        for c in col_names:
+            res = res.where(getattr(table, c) == Parameter(sql_placeholder))
+        
+        if values is not None:
+            values = (*values, *where_values)
+        else:
+            values = where_values
+        return res, values
+    
+    def where_compare(self, query, values, field_name, operator:CompareOperator, value):
+        table = self.__get_table(query)
+        sql_placeholder = self.db_client._get_sql_placeholder()
+        
+        if operator == CompareOperator.Different:
+            res = query.where(getattr(table, field_name) != Parameter(sql_placeholder))
+        elif operator == CompareOperator.Equal:
+            res = query.where(getattr(table, field_name) == Parameter(sql_placeholder))
+        elif operator == CompareOperator.Inferior:
+            res = query.where(getattr(table, field_name) < Parameter(sql_placeholder))
+        elif operator == CompareOperator.InferiorOrEqual:
+            res = query.where(getattr(table, field_name) <= Parameter(sql_placeholder))
+        elif operator == CompareOperator.Superior:
+            res = query.where(getattr(table, field_name) > Parameter(sql_placeholder))
+        elif operator == CompareOperator.SuperiorOrEqual:
+            res = query.where(getattr(table, field_name) >= Parameter(sql_placeholder))
+        else:
+            raise TechnicalException(f"Unmanaged compare operator {operator}")
+            
+        if values is not None:
+            values = (*values, value)
+        else:
+            values = (value)
+        return res, values
+    
+    def where_in(self, query, values, field_name, field_values, not_in=False):
+        table = self.__get_table(query)
+        if not_in:
+            res = query.where(getattr(table, field_name).notin(field_values))
+        else:
+            res = query.where(getattr(table, field_name).isin(field_values))
+        return res, values
+    
+    def where_json_value(self, query, values, field_name, key, value, as_text_value=False):
+        table = self.__get_table(query)
+        sql_placeholder = self.db_client._get_sql_placeholder()
+        
+        if as_text_value:
+            res = query.where(getattr(table, field_name).get_text_value(key) == Parameter(sql_placeholder))
+        else:
+            res = query.where(getattr(table, field_name).get_json_value(key) == Parameter(sql_placeholder))
+        
+        if values is not None:
+            values = (*values, value)
+        else:
+            values = (value)
+        return res, values
+    
+    def to_sql(self, query):
+        if query.__module__.startswith('pypika'):
+            return query.get_sql()
+        else:
+            raise TechnicalException(f"Unmanaged query of type {Typing.get_object_class_fullname(query)}")
+        
+    def __get_table(self, query):
+        if query._from is not None and len(query._from) > 0:
+            return query._from[0]
+        elif query._insert_table is not None:
+            return query._insert_table
+        elif query._update_table is not None:
+            return query._update_table
+        else:
+            raise TechnicalException(f"Failed to extract table from query [{query}]: {Tools.represent_object(query)}")

holado_db/tools/db/query/query_manager.py

@@ -0,0 +1,77 @@
+
+#################################################
+# 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_core.common.exceptions.technical_exception import TechnicalException
+from holado_core.common.tools.tools import Tools
+
+
+logger = logging.getLogger(__name__)
+
+
+
+class QueryManager():
+    """
+    Manage Query builders, agnostic to managed libraries.
+    """
+    
+    def __init__(self, name):
+        self.__name = name if name else "QueryManager"
+        
+        self.__builder_new_func_by_type = {}
+        self.__default_builder_type = None
+        
+    def initialize(self):
+        from holado_db.tools.db.query.pypika.pypika_query_builder import PypikaQueryBuilder
+        if PypikaQueryBuilder.is_available():
+            self.register_query_builder("pypika", PypikaQueryBuilder)
+            self.__default_builder_type = "pypika"
+        else:
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug("PyPika package is not installed, this type of Query builder is not available")
+        
+    @property
+    def name(self):
+        return self.__name
+        
+    @property
+    def default_builder_type(self):
+        return self.__default_builder_type
+        
+    @default_builder_type.setter
+    def default_builder_type(self, builder_type):
+        self.__default_builder_type = builder_type
+    
+    def register_query_builder(self, builder_type, new_builder_func):
+        self.__builder_new_func_by_type[builder_type] = new_builder_func
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"Registered Query builder type '{builder_type}'")
+    
+    def new_default_query_builder(self, name, db_client):
+        if self.__default_builder_type is None:
+            raise TechnicalException(f"Default query builder type is not defined. Registered query builders: {list(self.__builder_new_func_by_type.keys())}")
+        return self.new_query_builder(name, self.__default_builder_type, db_client)
+    
+    def new_query_builder(self, name, builder_type, db_client):
+        if builder_type in self.__builder_new_func_by_type:
+            try:
+                res = self.__builder_new_func_by_type[builder_type](name, db_client)
+            except Exception as exc:
+                raise TechnicalException(f"Failed to create Query builder for builder type '{builder_type}'") from exc
+        else:
+            raise TechnicalException(f"Unmanaged Query builder type '{builder_type}'")
+        return res
+        
+        
+        
+        

holado_docker/__init__.py

@@ -0,0 +1,25 @@
+# -*- 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.
+#################################################
+
+
+def dependencies():
+    return None
+
+def register():
+    from holado.common.context.session_context import SessionContext
+    
+    from holado_docker.sdk.docker.docker_client import DockerClient
+    if DockerClient.is_available():
+        SessionContext.instance().services.register_service_type("docker_client", DockerClient)
+

holado_docker/sdk/docker/docker_client.py

@@ -0,0 +1,268 @@
+
+#################################################
+# 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_core.common.exceptions.functional_exception import FunctionalException
+import time
+import logging
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado.common.handlers.object import DeleteableObject
+from holado_core.common.tools.tools import Tools
+
+logger = logging.getLogger(__name__)
+
+try:
+    import docker
+    with_docker = True
+except Exception as exc:
+    if Tools.do_log(logger, logging.DEBUG):
+        logger.debug(f"DockerClient is not available. Initialization failed on error: {exc}")
+    with_docker = False
+
+
+class DockerClient(object):
+    @classmethod
+    def is_available(cls):
+        return with_docker
+    
+    def __init__(self):
+        self.__client = docker.from_env()
+        self.__containers = {}
+        self.__volumes = {}
+        
+    @property
+    def client(self):
+        return self.__client
+    
+    def has_container(self, name, in_list = True):
+        # Note: Even if name exists in __containers, it is possible that the container has been removed
+        if in_list:
+            c = self.__get_container_from_list(name)
+            res = c is not None
+        else:
+            res = name in self.__containers
+        return res
+    
+    def get_container(self, name):
+        if name not in self.__containers:
+            c = self.__get_container_from_list(name)
+            if c:
+                self.__containers[name] = DockerContainer(self, c)
+        return self.__containers.get(name)
+    
+    def get_all_container_names(self):
+        for _ in range(3):
+            try:
+                return [c.name for c in self.__client.containers.list(all=True)]
+            except docker.errors.NotFound:
+                pass
+    
+    def __get_container_from_list(self, name):
+        res = None
+        for _ in range(3):
+            try:
+                for c in self.__client.containers.list(all=True):
+                    if c.name == name:
+                        res = c
+                        break
+            except docker.errors.NotFound:
+                pass
+        return res
+    
+    def has_volume(self, name, in_list = False):
+        res = name in self.__volumes
+        if not res and in_list:
+            v = self.__get_volume_from_list(name)
+            res = v is not None
+        return res
+    
+    def get_volume(self, name):
+        if name not in self.__volumes:
+            v = self.__get_volume_from_list(name)
+            if v:
+                self.__volumes[name] = DockerVolume(v)
+        return self.__volumes.get(name)
+    
+    def get_all_volume_names(self):
+        return [v.name for v in self.__client.volumes.list()]
+    
+    def __get_volume_from_list(self, name):
+        res = None
+        for v in self.__client.volumes.list():
+            if v.name == name:
+                res = v
+                break
+        return res
+    
+    def run_container(self, name, image, remove_existing=False, wait_running=True, auto_stop=True, **kwargs):
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"Running docker container '{name}' with image '{image}' and arguments {kwargs}{', and waiting running status' if wait_running else ''}")
+        
+        # Manage remove if already existing
+        cont = self.get_container(name)
+        if cont:
+            if remove_existing:
+                if cont.status == "running":
+                    if Tools.do_log(logger, logging.DEBUG):
+                        logger.debug(f"Docker container '{name}' is running, stopping it before remove")
+                    self.stop_container(name)
+                
+                if self.has_container(name):    # After stop, container is able to be automatically removed depending on its run parameters 
+                    self.remove_container(name)
+            else:
+                logger.info(f"Docker container '{name}' is already running")
+                return
+        
+        # Run container
+        c = self.__client.containers.run(image, name=name, detach=True, **kwargs)
+        container = DockerContainer(self, c)
+        self.__containers[name] = container
+        
+        # Manage wait running status
+        if wait_running:
+            for _ in range(100):
+                time.sleep(1)
+                if container.status == "running":
+                    break
+        if container.status != "running":
+            raise TechnicalException("Failed to run container of name '{}' (status: {})".format(name, container.status))
+        else:
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"Run docker container '{name}' with image '{image}' and arguments {kwargs}{', and wait running status' if wait_running else ''}")
+            
+        # Set properties
+        container.auto_stop = auto_stop
+        
+        return container
+    
+    def start_container(self, name, wait_running=True, **kwargs):
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"Starting docker container '{name}' with arguments {kwargs}{', and waiting running status' if wait_running else ''}")
+        container = self.get_container(name)
+        if not container:
+            raise FunctionalException("Container of name '{}' doesn't exist")
+        
+        container.start(**kwargs)
+        
+        if wait_running:
+            for _ in range(120):
+                time.sleep(1)
+                if container.status == "running":
+                    break
+        if container.status != "running":
+            raise TechnicalException("Failed to run container of name '{}' (status: {})".format(name, container.status))
+        else:
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"Started docker container '{name}' with arguments {kwargs}{', and waited running status' if wait_running else ''}")
+        
+    def stop_container(self, name):
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"Stopping docker container of name '{name}'")
+        if name not in self.__containers:
+            raise FunctionalException("Unknown container of name '{}'".format(name))
+        elif self.__containers[name].status != "running":
+            raise FunctionalException("Container of name '{}' is not running (status: {})".format(name, self.__containers[name].status))
+        
+        self.__containers[name].stop()
+        try:
+            self.__containers[name].wait()
+        except docker.errors.NotFound:
+            # This exception occurs on containers automatically removed on stop
+            pass
+        
+        if self.__containers[name].status == "running":
+            raise FunctionalException("Failed to stop container of name '{}' (status: {})".format(name, self.__containers[name].status))
+        else:
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"Stopped docker container of name '{name}'")
+        
+    def remove_container(self, name):
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"Removing docker container of name '{name}'")
+        if not self.has_container(name):
+            raise FunctionalException(f"Container of name '{name}' doesn't exist")
+        
+        del self.__containers[name]
+        self.client.api.remove_container(name)
+        
+        if self.has_container(name):
+            raise FunctionalException(f"Failed to remove container of name '{name}'")
+        else:
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"Removed docker container of name '{name}'")
+        
+class DockerContainer(DeleteableObject):
+    def __init__(self, docker_client, container):
+        super().__init__(container.name)
+        
+        self.__docker_client = docker_client
+        self.__container = container
+        self.__auto_stop = False
+        
+    def _delete_object(self):
+        if self.auto_stop and self.__docker_client and self.__docker_client.has_container(self.name) \
+                and self.__docker_client.get_container(self.name).status == "running":
+            self.__docker_client.stop_container(self.name)
+        
+    @property
+    def container(self):
+        self.__container
+        
+    @property
+    def status(self):
+        try:
+            self.__container.reload()
+        except docker.errors.NotFound:
+            return "removed"
+        return self.__container.status
+        
+    @property
+    def auto_stop(self):
+        self.__auto_stop
+        
+    @auto_stop.setter
+    def auto_stop(self, auto_stop):
+        self.__auto_stop = auto_stop
+    
+    def start(self, **kwargs):
+        return self.__container.start(**kwargs)
+    
+    def stop(self, **kwargs):
+        return self.__container.stop(**kwargs)
+    
+    def wait(self, **kwargs):
+        return self.__container.wait(**kwargs)
+        
+class DockerVolume(object):
+    def __init__(self, volume):
+        self.__volume = volume
+        
+    @property
+    def volume(self):
+        self.__volume
+        
+    @property
+    def attributes(self):
+        self.__volume.reload()
+        return self.__volume.attrs
+    
+    def get_attribute(self, attr_path):
+        names = attr_path.split('.')
+        attrs = self.attributes
+        res = attrs
+        for i, name in enumerate(names):
+            if name in res:
+                res = res[name]
+            else:
+                raise FunctionalException(f"Attribute '{'.'.join(names[:i+1])}' doesn't exist (requested attribute: '{attr_path}' ; volume attributes: {attrs})")
+        return res
+    

holado_docker/sdk/docker/docker_service.py

@@ -0,0 +1,71 @@
+
+#################################################
+# 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_docker.sdk.docker.docker_client import DockerClient
+from holado_core.common.exceptions.technical_exception import TechnicalException
+import logging
+from holado_core.tools.abstracts.service import Service
+from holado_system.system.command.command import CommandStates
+from holado_core.common.tools.tools import Tools
+
+logger = logging.getLogger(__name__)
+
+
+class DockerService(Service):
+    @classmethod
+    def is_available(cls):
+        return DockerClient.is_available()
+    
+    def __init__(self, name):
+        super().__init__(name) 
+        self.__docker_client = None
+        self.__docker_container = None
+    
+    @property
+    def status(self):
+        if self.__docker_container is not None and self.__docker_client.has_container(self.name):
+            status = self.__docker_container.status
+            if status in ["running", "paused", "restarting"]:
+                return CommandStates.Running
+            elif status == "exited":
+                result = self.__docker_container.wait(timeout=10)
+                error_code = result["StatusCode"]
+                if error_code == 0:
+                    return CommandStates.Success
+                else:
+                    return CommandStates.Error
+            else:
+                raise TechnicalException(f"Unmanaged docker status '{status}'")
+        else:
+            return None
+    
+    def run_as_docker(self, image, remove_existing=True, remove=True, auto_stop=True, **kwargs):
+        """
+        Run the service as a docker image.
+        
+        :param image: Image name
+        :param remove_existing: If true (default) and docker already exists, remove docker before creating a new one 
+        :param remove: If true (default), remove the docker at stop
+        :param auto_stop: If true (default), automatically stop docker when docker instance is released
+        """ 
+        self.__docker_client = DockerClient()
+        self.__docker_container = self.__docker_client.run_container(self.name, image, remove_existing=remove_existing, remove=remove, auto_stop=auto_stop, **kwargs)
+
+    def stop(self):
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"Stopping service '{self.name}'")
+        if self.__docker_container is not None:
+            if self.__docker_client.has_container(self.name) and self.__docker_client.get_container(self.name).status == "running":
+                self.__docker_client.stop_container(self.name)
+        else:
+            raise TechnicalException(f"Service '{self.name}' is not started")

holado_docker/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 .tools.docker_steps import *