atomicshop 3.3.28__py3-none-any.whl → 3.10.0__py3-none-any.whl

atomicshop/python_functions.py

@@ -4,7 +4,7 @@ from typing import Union
 from .print_api import print_api
 
 
-def get_current_python_version_string() -> str:
+def get_python_version_string() -> str:
     """
     Function gets version MAJOR.MINOR.MICRO from 'sys.version_info' object and returns it as a string.
     :return: python MAJOR.MINOR.MICRO version string.
@@ -13,120 +13,35 @@ def get_current_python_version_string() -> str:
     return f'{sys.version_info[0]}.{sys.version_info[1]}.{sys.version_info[2]}'
 
 
-# noinspection PyUnusedLocal
-def check_if_version_object_is_tuple_or_string(version_object: any,
-                                               **kwargs) -> tuple:
-    """
-    Function checks if 'version_object' that was passed is tuple or string.
-    If it's tuple then returns it back. If it's string, converts to tuple then returns it.
-    If the object is none of the above, returns None.
-
-    :param version_object: Can be string ('3.10') or tuple of integers ((3, 10)).
-    :return:
-    """
-    # Check if tuple was passed.
-    if isinstance(version_object, tuple):
-        return version_object
-    else:
-        # Then check if a string was passed.
-        if isinstance(version_object, str):
-            # The check will be against tuple of integers, so we'll convert a string to tuple of integers.
-            return tuple(map(int, version_object.split('.')))
-        else:
-            message = f'[*] Function: [check_if_version_object_is_tuple_or_string]\n' \
-                      f'[*] [version_object] object passed is not tuple or string.\n' \
-                      f'[*] Object type: {type(version_object)}\n' \
-                      f'[*] Object content {version_object}\n' \
-                      f'Exiting...'
-            print_api(message, error_type=True, logger_method='critical', **kwargs)
-
-            return None
-
-
-# noinspection PyUnusedLocal
 def check_python_version_compliance(
-        minimum_version: Union[str, tuple] = None,
-        maximum_version: Union[str, tuple] = None,
-        minor_version: Union[str, tuple] = None,
-        **kwargs
-) -> bool:
+        min_ver: tuple = None,
+        max_ver: tuple = None,
+) -> str | None:
     """
     Python version check. Should be executed before importing external libraries, since they depend on Python version.
 
-    :param minimum_version: Can be string ('3.10') or tuple of integers ((3, 10)).
-    :param maximum_version: Can be string ('3.10') or tuple of integers ((3, 10)).
+    :param min_ver: tuple of integers (3, 10).
+    :param max_ver: tuple of integers (3, 10).
         If maximum version is not specified, it will be considered as all versions above the minimum are compliant.
-    :param minor_version: Can be string ('3.10') or tuple of integers ((3, 10)).
-        If minor version is specified, it will be considered as all the versions with the same major, minor version
-        are compliant. Example: if minor_version is '3.10', then all the versions with '3.10.x' are compliant.
-    :return:
+    :return: If version is not compliant, returns string with error message. Otherwise, returns None.
     """
 
-    if not minimum_version and not maximum_version and not minor_version:
+    if not min_ver and not max_ver:
         raise ValueError("At least one of the version parameters should be passed.")
 
-    if minor_version and (minimum_version or maximum_version):
-        raise ValueError("Minor version should be passed alone.")
-
-    # Check objects for string or tuple and get the tuple.
-    if minimum_version:
-        minimum_version_scheme: tuple = check_if_version_object_is_tuple_or_string(minimum_version, **kwargs)
-    else:
-        minimum_version_scheme = tuple()
-    # If 'maximum_version' object was passed, check it for string or tuple and get the tuple.
-    if maximum_version:
-        maximum_version_scheme: tuple = check_if_version_object_is_tuple_or_string(maximum_version, **kwargs)
-    else:
-        maximum_version_scheme = tuple()
-
-    # If 'minor_version' object was passed, check it for string or tuple and get the tuple.
-    if minor_version:
-        minor_version_scheme: tuple = check_if_version_object_is_tuple_or_string(minor_version, **kwargs)
+    current_version_info: tuple = sys.version_info[:3]
+    if min_ver and not max_ver:
+        if current_version_info < min_ver:
+            return f'Python version {".".join(map(str, min_ver))} or higher is required. '\
+                   f'Current version is {".".join(map(str, current_version_info))}.'
+    elif max_ver and not min_ver:
+        if current_version_info > max_ver:
+            return f'Python version up to {".".join(map(str, max_ver))} is required. '\
+                   f'Current version is {".".join(map(str, current_version_info))}.'
+    elif min_ver and max_ver:
+        if not (min_ver <= current_version_info <= max_ver):
+            return f'Python version between {".".join(map(str, min_ver))} and '\
+                   f'{".".join(map(str, max_ver))} is required. '\
+                   f'Current version is {".".join(map(str, current_version_info))}.'
     else:
-        minor_version_scheme = tuple()
-
-    # Get current python version.
-    python_version_full: str = get_current_python_version_string()
-
-    message = f"[*] Current Python Version: {python_version_full}"
-    print_api(message, logger_method='info', **kwargs)
-
-    if minor_version_scheme:
-        # Check if current python version is later or equals to the minimum required version.
-        if sys.version_info[:2] != minor_version_scheme:
-            message = f"[!!!] YOU NEED TO INSTALL ANY PYTHON " \
-                      f"[{'.'.join(str(i) for i in minor_version_scheme)}] version, " \
-                      f"to work properly."
-            print_api(message, error_type=True, logger_method='critical', **kwargs)
-
-            return False
-    elif minimum_version_scheme and maximum_version_scheme:
-        if not sys.version_info >= minimum_version_scheme or not sys.version_info < maximum_version_scheme:
-            message = f"[!!!] YOU NEED TO INSTALL AT LEAST PYTHON " \
-                      f"[{'.'.join(str(i) for i in minimum_version_scheme)}], " \
-                      f"AND EARLIER THAN [{'.'.join(str(i) for i in maximum_version_scheme)}], " \
-                      f"to work properly."
-            print_api(message, error_type=True, logger_method='critical', **kwargs)
-
-            return False
-    elif minimum_version_scheme and not maximum_version_scheme:
-        if not sys.version_info >= minimum_version_scheme:
-            message = f"[!!!] YOU NEED TO INSTALL AT LEAST PYTHON " \
-                      f"[{'.'.join(str(i) for i in minimum_version_scheme)}], " \
-                      f"to work properly."
-            print_api(message, error_type=True, logger_method='critical', **kwargs)
-
-            return False
-    elif not minimum_version_scheme and maximum_version_scheme:
-        if not sys.version_info < maximum_version_scheme:
-            message = f"[!!!] YOU NEED TO INSTALL EARLIER THAN PYTHON " \
-                      f"[{'.'.join(str(i) for i in maximum_version_scheme)}], " \
-                      f"to work properly."
-            print_api(message, error_type=True, logger_method='critical', **kwargs)
-
-            return False
-
-    message = "[*] Version Check PASSED."
-    print_api(message, logger_method='info', **kwargs)
-
-    return True
+        return None

atomicshop/speech_recognize.py

@@ -1,3 +1,11 @@
+# TODO: Change manual wrapper to:
+# from ffmpy import FFmpeg
+# ff = FFmpeg(
+#     inputs={'input.mp4': None},
+#     outputs={'output.avi': None}
+# )
+# ff.run()
+
 from .wrappers.ffmpegw import FFmpegWrapper
 from .tempfiles import TempFile
 from .web import download

atomicshop/ssh_remote.py

@@ -1,7 +1,7 @@
 import sys
-import base64
 import logging
 from pathlib import Path
+import shlex
 
 try:
     import paramiko
@@ -11,7 +11,12 @@ except ImportError as exception_object:
 
 from .print_api import print_api
 from .wrappers.loggingw import loggingw
-from .wrappers.socketw import base
+from .wrappers.socketw import socket_base
+
+
+class SSHRemoteWrapperNoPythonFound(Exception):
+    """Raised when no usable Python 3 interpreter found on remote host."""
+    pass
 
 
 class SSHRemote:
@@ -100,17 +105,23 @@ class SSHRemote:
         # Initializing paramiko SSHClient class
         self.ssh_client = paramiko.SSHClient()
 
+        # Variable to store detected python command on remote (python3 / python).
+        self.python_cmd: str | None = None
+
         if logger:
             # Create child logger for the provided logger with the module's name.
             self.logger: logging.Logger = loggingw.get_logger_with_level(f'{logger.name}.{Path(__file__).stem}')
         else:
             self.logger: logging.Logger = logger
 
-    def connect(self):
+    def connect(
+            self,
+            timeout: int = 60
+    ):
         error: str = str()
 
         # Get all local interfaces IPv4 addresses.
-        local_interfaces_ipv4 = base.get_local_network_interfaces_ip_address("ipv4", True)
+        local_interfaces_ipv4 = socket_base.get_local_network_interfaces_ip_address("ipv4", True)
         # Check if the target IP address is in the list of local interfaces.
         if self.ip_address in local_interfaces_ipv4:
             # If it is, we don't need to connect to it via SSH, it means that we want to connect to ourselves.
@@ -130,7 +141,7 @@ class SSHRemote:
         self.ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
 
         # Executing SSH connection to client.
-        self.ssh_client.connect(self.ip_address, username=self.username, password=self.password, timeout=60)
+        self.ssh_client.connect(self.ip_address, username=self.username, password=self.password, timeout=timeout)
 
         return error
 
@@ -151,17 +162,50 @@ class SSHRemote:
                 if "ModuleNotFoundError: No module named" in line:
                     function_result = f"Python library is not installed - {line}"
                     break
+        else:
+            function_result = console_output_string
 
         return function_result
 
-    def remote_execution(self, script_string: str) -> tuple[str, str]:
+    def remote_execution(
+            self,
+            command: str,
+            script_string: str = None
+    ) -> tuple[str, str]:
+        """
+        Function to execute any command over SSH.
+
+        :param command: command to execute over SSH.
+        :param script_string: string representation of script to execute as input.
+            Example:
+                command = "python - 56734"
+                script_string = "import sys;print(f'sys.argv[0]')"
+
+            Under ssh in terminal it would execute like this:
+                ssh User@HostIpv4
+
+                python - 56734 << EOF
+                import sys;print(f'sys.argv[0]')
+                EOF
+
+            Or as onliner:
+                ssh User@HostIpv4 "python - 56734 << EOF import sys;print(f'sys.argv[0]') EOF"
+
+            or using a specific file path:
+                ssh User@HostIpv4 "python - 56734" < /path/to/script.py
+
+        :return: SSH console output, Error output
+        """
         output_result: str = str()
         error_result: str = str()
 
         # Execute the command over SSH remotely.
-        # Don't put debugging break point over the next line in PyCharm. For some reason it gets stuck.
-        # Put the point right after that.
-        stdin, stdout, stderr = self.ssh_client.exec_command(command=script_string, timeout=30)
+        stdin, stdout, stderr = self.ssh_client.exec_command(command=command, timeout=30)
+
+        # Writing the script string into stdin buffer.
+        if script_string:
+            stdin.write(script_string)
+            stdin.channel.shutdown_write()
 
         # Reading the buffer of stdout.
         output_lines: list = stdout.readlines()
@@ -182,53 +226,68 @@ class SSHRemote:
 
         return output_result, error_result
 
-    def remote_execution_python(self, script_string: str):
+    def _detect_remote_python_cmd_name(self) -> str:
         """
-        Function to execute python script over SSH.
+        Try 'python3' then 'python' on the remote, return the one that is Python 3.
+        Raises if neither works.
+        """
+        for candidate in ("python3", "python"):
+            # Use a simple version check that works on both Windows and Linux
+            cmd = f'{candidate} -c "import sys; print(sys.version_info[0])"'
+            stdin, stdout, stderr = self.ssh_client.exec_command(cmd, timeout=5)
+
+            out = stdout.read().decode().strip()
+            exit_status = stdout.channel.recv_exit_status()
 
-        Example:
-                network.logger.info("Initializing SSH connection to get the calling process.")
-
-                # Initializing SSHRemote class.
-                ssh_client = SSHRemote(ip_address=client_message.client_ip, username=username, password=password)
-                # Making actual SSH Connection to the computer.
-                ssh_connection_error = ssh_client.connect()
-                # If there's an exception / error during connection.
-                if ssh_connection_error:
-                    # Put the error in the process name value.
-                    client_message.process_name = ssh_connection_error
-                else:
-                    # If no error, then initialize the variables for python script execution over SSH.
-                    remote_output = remote_error = None
-
-                    # Put source port variable inside the string script.
-                    script_string: str = \
-                        put_variable_into_string_script(ssh_script_port_by_process_string, client_message.source_port)
-
-                    # Execute the python script on remote computer over SSH.
-                    remote_output, remote_error = ssh_client.remote_execution_python(script_string)
-
-                    # If there was an error during execution, put it in process name.
-                    if remote_error:
-                        client_message.process_name = remote_error
-                    # If there was no error during execution, put the output of the ssh to process name.
-                    else:
-                        client_message.process_name = remote_output
-                        network.logger.info(f"Remote SSH: Client executing Command Line: {client_message.process_name}")
+            if exit_status == 0 and out == "3":
+                print_api(f"Detected remote Python 3 interpreter (once per client port): {candidate}", logger=self.logger)
+                return candidate
+
+        raise SSHRemoteWrapperNoPythonFound("No usable Python 3 interpreter found on remote host")
+
+    def _get_python_cmd(self) -> str:
+        if self.python_cmd is None:
+            self.python_cmd = self._detect_remote_python_cmd_name()
+        return self.python_cmd
+
+    def remote_execution_python(
+            self,
+            script_string: str,
+            script_arg_values: tuple = None,
+            script_kwargs: dict = None,
+    ):
+        """
+        Function to execute python script over SSH.
 
         :param script_string: string representation of python script.
+        :param script_arg_values: values arguments to pass to the script. Example for first argument: 56734
+        :param script_kwargs: keyword arguments to pass to the script.
+            Example: {'-r': None}
+            Interpreted as: -r
+            Example: {'-f': 'value'}
+            Interpreted as: -f value
+            Example: {'--arg': value}
+            Interpreted as: --arg value
+
         :return: SSH console output, Error output
         """
         # Defining variables.
         error_result: str | None = None
 
-        encoded_base64_string = base64.b64encode(script_string.encode('ascii'))
-        command_string: str = fr'python -c "import base64;exec(base64.b64decode({encoded_base64_string}))"'
+        python_cmd = self._get_python_cmd()
+        command: str = f"{python_cmd} -"
 
-        # remote_output, remote_error = ssh_client.remote_execution('ipconfig')
-        # remote_output, remote_error = ssh_client.remote_execution("python -c print('Hello')")
-        # remote_output, remote_error = ssh_client.remote_execution("python -c import psutil")
-        remote_output, remote_error = self.remote_execution(command_string)
+        if script_arg_values:
+            for arg in script_arg_values:
+                command += " " + shlex.quote(str(arg))
+
+        if script_kwargs:
+            for key, value in script_kwargs.items():
+                command += f" {shlex.quote(str(key))}"
+                if value is not None:
+                    command += " " + shlex.quote(str(value))
+
+        remote_output, remote_error = self.remote_execution(command=command, script_string=script_string)
 
         # If there was an error during remote execution
         if remote_error:
@@ -238,10 +297,15 @@ class SSHRemote:
             if console_check:
                 # 'execution_error' variable will be that full error.
                 error_result = console_check
+            else:
+                error_result = remote_error
 
         return remote_output, error_result
 
-    def connect_get_client_commandline(self, script_string):
+    def connect_get_client_commandline(
+            self,
+            port: int,
+            script_string: str):
         # Defining locals.
         execution_output: str | None = None
 
@@ -249,18 +313,18 @@ class SSHRemote:
         execution_error = self.connect()
         # if there was an error, try to connect again.
         if execution_error:
-            self.logger.info("Retrying SSH Connection Initialization.")
+            print_api("Retrying SSH Connection Initialization.", logger=self.logger, logger_method='info')
             execution_error = self.connect()
 
         # If there was still an error, we won't be executing the script. And the error will be passed to
         # 'process_name'.
         if not execution_error:
-            self.logger.info("Executing SSH command to acquire the calling process.")
+            print_api("Executing SSH command to acquire the calling process.", logger=self.logger, logger_method='info')
 
-            execution_output, execution_error = self.remote_execution_python(script_string)
+            execution_output, execution_error = self.remote_execution_python(script_string=script_string, script_arg_values=(str(port),))
 
             # Closing SSH connection at this stage.
             self.close()
-            self.logger.info("Acquired. Closed SSH connection.")
+            print_api("Acquired. Closed SSH connection.", logger=self.logger, logger_method='info')
 
         return execution_output, execution_error

atomicshop/web.py

@@ -7,8 +7,8 @@ import http.client
 
 # noinspection PyPackageRequirements
 import certifi
+from dkarchiver.arch_wrappers import zips
 
-from .archiver import zips
 from .urls import url_parser
 from .file_io import file_io
 from .wrappers.playwrightw import scenarios
@@ -18,10 +18,12 @@ from . import filesystem, print_api
 # https://www.useragents.me/
 # https://user-agents.net/
 USER_AGENTS = {
-    'Chrome_111.0.0_Windows_10-11_x64':
+    'Chrome 111.0.0 Windows_10/11 x64':
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36',
-    'Chrome 132.0.0, Windows 10/11':
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36'
+    'Chrome 132.0.0 Windows 10/11 x64':
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36',
+    'Chrome 142.0.0 Windows 10/11 x64':
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36'
 }
 
 
@@ -75,7 +77,7 @@ def get_page_bytes(
         raise ValueError('ERROR: [user_agent] specified and [chrome_user_agent] usage is [True]. Choose one.')
 
     if chrome_user_agent:
-        user_agent = USER_AGENTS['Chrome_111.0.0_Windows_10-11_x64']
+        user_agent = USER_AGENTS['Chrome 142.0.0 Windows 10/11 x64']
 
     if user_agent:
         # Create a 'Request' object with the URL and user agent.
@@ -159,6 +161,7 @@ def download(
         target_directory: str = None,
         file_name: str = None,
         headers: dict = None,
+        overwrite: bool = False,
         # use_certifi_ca_repository: bool = False,
         **kwargs
 ) -> str | None:
@@ -174,6 +177,9 @@ def download(
     :param file_name: string, file name (example: file.zip) that you want the downloaded file to be saved as.
         If not specified, the default filename from 'file_url' will be used.
     :param headers: dictionary, HTTP headers to use when downloading the file.
+    :param overwrite: boolean, if True, the file will be overwritten if it already exists.
+        If False, the file will not be overwritten and the function will return None if the file already exists.
+        Default is False.
     :param use_certifi_ca_repository: boolean, if True, the certifi CA store will be used for SSL context
         instead of the system's default CA store.
     :return: string, full file path of downloaded file. If download failed, 'None' will be returned.
@@ -201,6 +207,13 @@ def download(
     # Build full path to file.
     file_path: str = f'{target_directory}{os.sep}{file_name}'
 
+    if os.path.exists(file_path):
+        if overwrite:
+            print_api.print_api(f'File already exists: {file_path}. Overwriting...', **kwargs)
+        else:
+            print_api.print_api(f'File already exists: {file_path}. Skipping download.', **kwargs)
+            return file_path
+
     print_api.print_api(f'Downloading: {file_url}', **kwargs)
     print_api.print_api(f'To: {file_path}', **kwargs)
 
@@ -301,7 +314,7 @@ def download_and_extract_file(
         Default is empty. If it is empty, then the filename will be extracted from 'file_url'.
     :param target_directory: string, target directory where to save the file.
     :param archive_remove_first_directory: boolean, sets if archive extract function will extract the archive without
-        first directory in the archive. Check reference in the 'extract_archive_with_zipfile' function.
+        first directory in the archive. Check reference in the 'dkarchiver.arch_wrappers.zips.extract_archive_with_zipfile' function.
     :param headers: dictionary, HTTP headers to use when downloading the file.
     :return:
     """
@@ -313,7 +326,7 @@ def download_and_extract_file(
     # Extract the archive and remove the first directory.
     zips.extract_archive_with_zipfile(
         archive_path=f'{file_path}', extract_directory=target_directory,
-        remove_first_directory=archive_remove_first_directory, **kwargs)
+        remove_first_directory=archive_remove_first_directory)
 
     # Remove the archive file.
     filesystem.remove_file(file_path=f'{file_path}', **kwargs)

atomicshop/web_apis/google_llm.py

@@ -1,7 +1,7 @@
-import os
 from typing import Literal
 
-import google.generativeai as genai
+from google import genai
+from google.genai.types import GenerateContentConfig
 
 from . import google_custom_search
 from ..wrappers.playwrightw import scenarios
@@ -11,6 +11,14 @@ from .. import urls
 class GoogleCustomSearchError(Exception):
     pass
 
+class GoogleLLMNoContentError(Exception):
+    pass
+
+
+"""
+Rate Limits and Quotas: https://ai.google.dev/gemini-api/docs/rate-limits
+"""
+
 
 class GoogleLLM:
     def __init__(
@@ -26,13 +34,10 @@ class GoogleLLM:
         :param search_engine_id: str, the search engine ID for the Google Custom Search API.
         """
 
-        self.genai = genai
+        self.client = genai.Client(api_key=llm_api_key)
         self.search_api_key: str = search_api_key
         self.search_engine_id: str = search_engine_id
 
-        os.environ["API_KEY"] = llm_api_key
-        genai.configure(api_key=os.environ["API_KEY"])
-
     def get_current_models(
             self,
             full_info: bool = False
@@ -43,7 +48,7 @@ class GoogleLLM:
         :param full_info: bool, if True, returns the full information about the models, otherwise only the names for API usage.
         """
         result_list: list = []
-        for model in self.genai.list_models():
+        for model in self.client.models.list():
             if full_info:
                 result_list.append(model)
             else:
@@ -68,7 +73,7 @@ class GoogleLLM:
             temperature: float = 0,
             # max_output_tokens: int = 4096,
             # model_name: str = 'gemini-2.0-flash-thinking-exp-01-21'
-            model_name: str = 'models/gemini-2.5-pro-preview-03-25'
+            model_name: str = 'gemini-2.5-pro'
     ) -> str:
         """
         Function to get the answer to a question by searching Google Custom Console API and processing the content using Gemini API.
@@ -112,6 +117,9 @@ class GoogleLLM:
                 urls=links[:number_of_top_links], number_of_characters_per_link=number_of_characters_per_link,
                 text_fetch_method=text_fetch_method)
 
+        if not contents:
+            raise GoogleLLMNoContentError("No content was fetched from the provided URL(s).")
+
         combined_content = ""
         for content in contents:
             combined_content += f'{content}\n\n\n\n================================================================'
@@ -126,12 +134,12 @@ class GoogleLLM:
         gemini_response = self.ask_gemini(final_question, temperature, model_name)
         return gemini_response
 
-    @staticmethod
     def ask_gemini(
+            self,
             question: str,
             temperature: float,
             # max_output_tokens: int,
-            model_name: str = 'gemini-2.0-flash-thinking-exp-01-21'
+            model_name: str = 'gemini-2.5-pro'
     ) -> str:
         """
         Function to ask the Gemini API a question and get the response.
@@ -161,8 +169,8 @@ class GoogleLLM:
             # "max_output_tokens": max_output_tokens,
         }
 
-        # model = genai.GenerativeModel('gemini-1.5-pro-latest',
-        # noinspection PyTypeChecker
-        model = genai.GenerativeModel(model_name, generation_config=model_config)
-        response = model.generate_content(question)
+        response = self.client.models.generate_content(
+            model=model_name,
+            contents=question,
+            config=GenerateContentConfig(**model_config))
         return response.text

atomicshop/wrappers/ctyping/msi_windows_installer/cabs.py

@@ -1,8 +1,9 @@
 import os
 from pathlib import Path
 
+from dkarchiver.arch_wrappers import sevenz_app_w
+
 from . import tables
-from ....archiver import sevenz_app_w
 
 
 def resolve_directory_path(directory_info, directory_key):

atomicshop/wrappers/ctyping/msi_windows_installer/extract_msi_main.py

@@ -1,11 +1,12 @@
 import os
 import argparse
 
+from dkarchiver.arch_wrappers import sevenz_app_w
+
 from .base import msi
 from . import base, tables, cabs
 from ... import olefilew
 from ....print_api import print_api
-from ....archiver import sevenz_app_w
 
 
 # Directory names.

atomicshop/wrappers/dockerw/dockerw.py

@@ -68,8 +68,8 @@ def change_image_content(
         dockerw.change_image_content(
             image_id_or_name="your_docker_image_id_or_name",
             list_of_commands=[
-                "apt-get update",
-                "apt-get install -y python3"
+                "apt update",
+                "apt install -y python3"
             ]
         )
     ----------------------