atomicshop 2.11.47__py3-none-any.whl → 3.10.5__py3-none-any.whl

atomicshop/startup/win/task_scheduler.py

@@ -0,0 +1,119 @@
+import os
+import datetime
+
+import win32com.client
+import pythoncom
+
+
+TRIGGER_ONE_TIME: int = 1
+TRIGGER_DAILY: int = 2
+TRIGGER_AT_SYSTEM_STARTUP: int = 8
+TRIGGER_ON_LOGON: int = 9
+
+
+def create_on_logon_task_with_system_privileges(exe_file_path: str, task_name: str, user_id: str = None):
+    """
+    This function will add a task to the Windows Task Scheduler with system privileges.
+
+    :param exe_file_path: The path to your executable file.
+    :param task_name: The name of the task to create in the Task Scheduler.
+    :param user_id: The user ID to run the task as.
+        None: the task will run for every user that logs on.
+        "SYSTEM": is a common user ID to run tasks with system privileges.
+    :return: True if the task was added successfully, False otherwise.
+    """
+
+    scheduler = win32com.client.Dispatch('Schedule.Service')
+    scheduler.Connect()
+
+    root_folder = scheduler.GetFolder('\\')
+    task_def = scheduler.NewTask(0)
+
+    # Set up registration information for the task
+    reg_info = task_def.RegistrationInfo
+    reg_info.Description = f'Task to run {os.path.basename(exe_file_path)} at logon'
+    reg_info.Author = 'Your Name'
+
+    # Set up the principal for the task
+    principal = task_def.Principal
+    if user_id is not None:
+        principal.UserId = user_id
+    # principal.LogonType = 3  # TaskLogonTypeInteractiveToken, Only run when the user is logged on.
+    principal.LogonType = 1  # 1 is for password not required
+    principal.RunLevel = 1  # TaskRunLevelHighest
+
+    # Create the logon trigger
+    trigger = task_def.Triggers.Create(TRIGGER_ON_LOGON)
+    if user_id:
+        trigger.UserId = user_id
+    trigger.Id = "LogonTriggerId"
+    trigger.Enabled = True
+    trigger.StartBoundary = datetime.datetime.now().isoformat()  # Set start boundary to current time in ISO format
+
+    # Create the action to run the executable
+    action = task_def.Actions.Create(0)  # 0 stands for TASK_ACTION_EXEC
+    action.Path = exe_file_path
+    action.WorkingDirectory = os.path.dirname(exe_file_path)
+    action.Arguments = ''
+
+    # Set task settings
+    settings = task_def.Settings
+    settings.Enabled = True
+    settings.StartWhenAvailable = True
+    settings.Hidden = False
+    settings.StopIfGoingOnBatteries = False
+    settings.DisallowStartIfOnBatteries = False
+    # Sets the limit to zero, which means the task will run indefinitely. The default is 3 days.
+    settings.ExecutionTimeLimit = 'PT0S'
+
+    # Register the task
+    root_folder.RegisterTaskDefinition(
+        task_name, task_def, 6,  # 6 is for CREATE_OR_UPDATE
+        None,  # No user (runs in system context)
+        None,  # No password
+        3
+    )
+
+
+def is_task_in_scheduler(task_name: str, scheduler_instance=None) -> bool:
+    """
+    This function will check if the task is in the Windows Task Scheduler.
+
+    :param task_name: The name of the task to check in the Task Scheduler.
+    :param scheduler_instance: The instance of the Task Scheduler to use.
+        If None, a new instance will be created.
+    :return: True if the task is in the Task Scheduler, False otherwise.
+    """
+
+    if scheduler_instance is None:
+        scheduler_instance = win32com.client.Dispatch('Schedule.Service')
+        scheduler_instance.Connect()
+
+    try:
+        root_folder = scheduler_instance.GetFolder('\\')
+        root_folder.GetTask(task_name)
+        return True
+    except pythoncom.com_error as e:
+        if e.hresult == -2147352567 and e.excepinfo[5] == -2147024894:  # HRESULT code for "Task does not exist"
+            return False
+        else:
+            raise
+
+
+def remove_task_from_scheduler(task_name: str) -> bool:
+    """
+    This function will remove the task from the Windows Task Scheduler.
+
+    :param task_name: The name of the task to remove from the Task Scheduler.
+    :return: True if the task was removed successfully, False otherwise.
+    """
+
+    scheduler_instance = win32com.client.Dispatch('Schedule.Service')
+    scheduler_instance.Connect()
+
+    if not is_task_in_scheduler(task_name, scheduler_instance=scheduler_instance):
+        return False
+    else:
+        root_folder = scheduler_instance.GetFolder('\\')
+        root_folder.GetTask(task_name)
+        return True

atomicshop/system_resource_monitor.py

@@ -2,8 +2,7 @@ from typing import Union
 import threading
 import multiprocessing.managers
 
-from .print_api import print_api
-from . import system_resources
+from . import system_resources, print_api
 
 
 class SystemResourceMonitor:
@@ -109,66 +108,77 @@ class SystemResourceMonitor:
         self.thread: Union[threading.Thread, None] = None
         # Sets the running state of the monitoring process. Needed to stop the monitoring and queue threads.
         self.running: bool = False
-        # The shared results dictionary.
+        # The shared results' dictionary.
         self.results: dict = {}
 
-    def start(self, print_kwargs: dict = None):
+    def start(
+            self,
+            print_kwargs: dict = None,
+            thread_as_daemon: bool = True
+    ):
         """
         Start the monitoring process.
         :param print_kwargs:
+        :param thread_as_daemon: bool, set the thread as daemon. If you're running the monitoring process in the main
+            process, set it to True. If you're running the monitoring process in a separate process, set it to False.
+            In child processes created by multiprocessing.Process, the thread works differently. You might not
+            get the desired result.
         :return:
         """
 
-        def run_check_system_resources(
-                interval, get_cpu, get_memory, get_disk_io_bytes, get_disk_files_count, get_disk_busy_time,
-                get_disk_used_percent, calculate_maximum_changed_disk_io, maximum_disk_io, queue_list, manager_dict):
-            """
-            Continuously update the system resources in the shared results dictionary.
-            This function runs in a separate process.
-            """
-
-            while self.running:
-                # Get the results of the system resources check function and store them in temporary results dictionary.
-                results = system_resources.check_system_resources(
-                    interval=interval, get_cpu=get_cpu, get_memory=get_memory,
-                    get_disk_io_bytes=get_disk_io_bytes, get_disk_files_count=get_disk_files_count,
-                    get_disk_busy_time=get_disk_busy_time, get_disk_used_percent=get_disk_used_percent)
-
-                if calculate_maximum_changed_disk_io:
-                    if results['disk_io_read'] > maximum_disk_io['read_bytes_per_sec']:
-                        maximum_disk_io['read_bytes_per_sec'] = results['disk_io_read']
-                    if results['disk_io_write'] > maximum_disk_io['write_bytes_per_sec']:
-                        maximum_disk_io['write_bytes_per_sec'] = results['disk_io_write']
-                    if results['disk_files_count_read'] > maximum_disk_io['read_files_count_per_sec']:
-                        maximum_disk_io['read_files_count_per_sec'] = results['disk_files_count_read']
-                    if results['disk_files_count_write'] > maximum_disk_io['write_files_count_per_sec']:
-                        maximum_disk_io['write_files_count_per_sec'] = results['disk_files_count_write']
-                    results['maximum_disk_io'] = maximum_disk_io
-
-                if queue_list is not None:
-                    for queue in queue_list:
-                        queue.put(results)
-
-                # Update the shared results dictionary with the temporary results dictionary.
-                # This is done in separate steps to avoid overwriting the special 'multiprocessing.Manager.dict' object.
-                # So we update the shared results dictionary with the temporary results dictionary.
-                if manager_dict is not None:
-                    manager_dict.update(results)
-
-                self.results = results
-
         if print_kwargs is None:
             print_kwargs = {}
 
         if self.thread is None:
             self.running = True
-            self.thread = threading.Thread(target=run_check_system_resources, args=(
+            self.thread = threading.Thread(target=self.run_check_system_resources, args=(
                 self.interval, self.get_cpu, self.get_memory, self.get_disk_io_bytes, self.get_disk_files_count,
                 self.get_disk_busy_time, self.get_disk_used_percent, self.calculate_maximum_changed_disk_io,
                 self.maximum_disk_io, self.queue_list, self.manager_dict))
+            self.thread.daemon = thread_as_daemon
             self.thread.start()
         else:
-            print_api("Monitoring is already running.", color='yellow', **print_kwargs)
+            print_api.print_api("Monitoring is already running.", color='yellow', **print_kwargs)
+
+    def run_check_system_resources(
+            self,
+            interval, get_cpu, get_memory, get_disk_io_bytes, get_disk_files_count, get_disk_busy_time,
+            get_disk_used_percent, calculate_maximum_changed_disk_io, maximum_disk_io, queue_list, manager_dict):
+        """
+        Continuously update the system resources in the shared results dictionary.
+        This function runs in a separate process.
+        """
+
+        while self.running:
+            # Get the results of the system resources check function and store them in
+            # temporary results' dictionary.
+            results = system_resources.check_system_resources(
+                interval=interval, get_cpu=get_cpu, get_memory=get_memory,
+                get_disk_io_bytes=get_disk_io_bytes, get_disk_files_count=get_disk_files_count,
+                get_disk_busy_time=get_disk_busy_time, get_disk_used_percent=get_disk_used_percent)
+
+            if calculate_maximum_changed_disk_io:
+                if results['disk_io_read'] > maximum_disk_io['read_bytes_per_sec']:
+                    maximum_disk_io['read_bytes_per_sec'] = results['disk_io_read']
+                if results['disk_io_write'] > maximum_disk_io['write_bytes_per_sec']:
+                    maximum_disk_io['write_bytes_per_sec'] = results['disk_io_write']
+                if results['disk_files_count_read'] > maximum_disk_io['read_files_count_per_sec']:
+                    maximum_disk_io['read_files_count_per_sec'] = results['disk_files_count_read']
+                if results['disk_files_count_write'] > maximum_disk_io['write_files_count_per_sec']:
+                    maximum_disk_io['write_files_count_per_sec'] = results['disk_files_count_write']
+                results['maximum_disk_io'] = maximum_disk_io
+
+            if queue_list is not None:
+                for queue in queue_list:
+                    queue.put(results)
+
+            # Update the shared results dictionary with the temporary results' dictionary.
+            # This is done in separate steps to avoid overwriting the special 'multiprocessing.Manager.dict' object.
+            # So we update the shared results dictionary with the temporary results' dictionary.
+            if manager_dict is not None:
+                manager_dict.update(results)
+
+            self.results = results
 
     def get_results(self) -> dict:
         """
@@ -203,6 +213,7 @@ def start_monitoring(
         calculate_maximum_changed_disk_io: bool = False,
         queue_list: list = None,
         manager_dict: multiprocessing.managers.DictProxy = None,      # multiprocessing.Manager().dict()
+        get_results_thread_as_daemon: bool = True,
         print_kwargs: dict = None
 ):
     """
@@ -233,6 +244,10 @@ def start_monitoring(
             multiprocessing.Process(
                 target=system_resource_monitor.start_monitoring, kwargs={'manager_dict': shared_dict}).start()
 
+    :param get_results_thread_as_daemon: bool, set the thread as daemon. If you're running the monitoring process in the
+        main process, set it to True. If you're running the monitoring process in a separate process, set it to False.
+        In child processes created by multiprocessing.Process, the thread works differently.
+        You might not get the desired result.
     :param print_kwargs: dict, print kwargs.
     :return:
     """
@@ -255,9 +270,9 @@ def start_monitoring(
             queue_list=queue_list,
             manager_dict=manager_dict
         )
-        SYSTEM_RESOURCES_MONITOR.start()
+        SYSTEM_RESOURCES_MONITOR.start(thread_as_daemon=get_results_thread_as_daemon)
     else:
-        print_api("System resources monitoring is already running.", color='yellow', **(print_kwargs or {}))
+        print_api.print_api("System resources monitoring is already running.", color='yellow', **(print_kwargs or {}))
 
 
 def stop_monitoring():

atomicshop/system_resources.py

@@ -5,9 +5,8 @@ import shutil
 import threading
 import multiprocessing.managers
 
-from .print_api import print_api
 from .wrappers.psutilw import cpus, memories, disks
-from . import system_resource_monitor
+from . import system_resource_monitor, print_api
 
 
 def check_system_resources(
@@ -129,13 +128,13 @@ def wait_for_resource_availability(
 
         if result['cpu_usage'] < cpu_percent_max and result['memory_usage'] < memory_percent_max:
             break
-        print_api(
+        print_api.print_api(
             f"Waiting for resources to be available... "
             f"CPU: {result['cpu_usage']}%, Memory: {result['memory_usage']}%", color='yellow')
         time.sleep(wait_time)  # Wait for 'wait_time' seconds before checking again
 
 
-def test_disk_speed_with_monitoring(
+def _test_disk_speed_with_monitoring(
         file_settings: list[dict],
         remove_file_after_each_copy: bool = False,
         target_directory=None,
@@ -144,6 +143,7 @@ def test_disk_speed_with_monitoring(
         print_kwargs: dict = None
 ):
     """
+    THIS IS NOT TESTED.
     Generates files and performs write and read operations in the specified target directory,
     while monitoring disk I/O speeds in a separate thread. Returns the maximum read and write rates,
     and the total operation time.
@@ -171,7 +171,7 @@ def test_disk_speed_with_monitoring(
     if monitoring:
         system_resource_monitor.start_monitoring(
             interval=1, get_cpu=False, get_memory=False, get_disk_io_bytes=True, get_disk_used_percent=False,
-            get_disk_files_count=True, calculate_maximum_changed_disk_io=True, use_queue=True)
+            get_disk_files_count=True, calculate_maximum_changed_disk_io=True)
 
     if target_directory is None:
         target_directory = tempfile.mkdtemp()
@@ -196,7 +196,7 @@ def test_disk_speed_with_monitoring(
             shutil.copy(src_file_path, dest_directory)
 
             target_file_path = os.path.join(dest_directory, os.path.basename(src_file_path))
-            print_api(f"Copied: {target_file_path}", **(print_kwargs or {}))
+            print_api.print_api(f"Copied: {target_file_path}", **(print_kwargs or {}))
 
             # Measure read speed.
             with open(target_file_path, "rb") as file:
@@ -212,7 +212,7 @@ def test_disk_speed_with_monitoring(
 
     overall_end_time = time.time()
     total_execution_time = overall_end_time - overall_start_time
-    print_api(f"Total execution time: {total_execution_time}", **(print_kwargs or {}))
+    print_api.print_api(f"Total execution time: {total_execution_time}", **(print_kwargs or {}))
 
     # Cleanup. Remove all created files and directories.
     shutil.rmtree(source_directory)
@@ -220,7 +220,7 @@ def test_disk_speed_with_monitoring(
 
     if monitoring:
         # Stop the I/O monitoring.
-        max_io_changes = system_resource_monitor.get_result()['maximum_disk_io']
+        max_io_changes = system_resource_monitor.get_results()['maximum_disk_io']
         system_resource_monitor.stop_monitoring()
 
     return total_execution_time, max_io_changes

atomicshop/tempfiles.py

@@ -1,4 +1,3 @@
-# v1.0.3 - 01.04.2021 - 15:30
 import os
 import datetime
 import tempfile
@@ -59,4 +58,4 @@ class TempFile:
         self.file_path: str = self.directory + os.sep + self.file_name
 
     def remove(self):
-        os.remove(self.file_path)
+        os.remove(self.file_path)

atomicshop/timer.py

@@ -7,7 +7,10 @@ class TimerError(Exception):
 
 class Timer:
     """ Custom timer class to measure elapsed time. Returns time in seconds (float) or nanoseconds with setting. """
-    def __init__(self, nanoseconds: bool = False):
+    def __init__(
+            self,
+            nanoseconds: bool = False
+    ):
         """
         Set up timer in seconds or nanoseconds
         Seconds are returned as float, nanoseconds as int.
@@ -17,6 +20,9 @@ class Timer:
         self._start_time = None
         self._nanoseconds: bool = nanoseconds
 
+        self.running: bool = False
+        self.last_measure = None
+
     def start(self):
         """Start a new timer"""
 
@@ -28,6 +34,8 @@ class Timer:
         else:
             self._start_time = time.perf_counter()
 
+        self.running = True
+
     def restart(self):
         """Reset the timer"""
 
@@ -37,20 +45,31 @@ class Timer:
     def measure(self):
         """Measure the elapsed time"""
 
-        if self._start_time is None:
-            raise TimerError(f"Timer is not running. Use .start() to start it")
+        # if self._start_time is None and self.last_measure is None:
+        #     raise TimerError(f"Timer is not running. Use .start() to start it")
 
-        if self._nanoseconds:
-            elapsed_time = time.perf_counter_ns() - self._start_time
-        else:
-            elapsed_time = time.perf_counter() - self._start_time
+        # If the timer is running, measure the elapsed time. If not, return the last measured time.
+        if self.running:
+            if self._nanoseconds:
+                self.last_measure = time.perf_counter_ns() - self._start_time
+            else:
+                self.last_measure = time.perf_counter() - self._start_time
 
-        return elapsed_time
+        return self.last_measure
+
+    def stop(self, measure: bool = True):
+        """
+        Stop the timer, and report the elapsed time
+
+        :param measure: True to measure the elapsed time, False to stop the timer without measuring.
+            Measuring, means that the timer will return the elapsed time and 'self.last_measure' will be updated.
+        """
 
-    def stop(self):
-        """Stop the timer, and report the elapsed time"""
+        elapsed_time = None
+        if measure:
+            elapsed_time = self.measure()
 
-        elapsed_time = self.measure()
         self._start_time = None
+        self.running = False
 
         return elapsed_time

atomicshop/urls.py

@@ -1,4 +1,5 @@
 from urllib.parse import urlparse
+import re
 
 
 def url_parser(url):
@@ -7,6 +8,11 @@ def url_parser(url):
     directories = parts.path.strip('/').split('/')
     queries = parts.query.strip('&').split('&')
 
+    if len(directories) > 1 and '.' in directories[-1]:
+        file = directories[-1]
+    else:
+        file = ''
+
     elements = {
         'scheme': parts.scheme,
         'netloc': parts.netloc,
@@ -16,6 +22,41 @@ def url_parser(url):
         'fragment': parts.fragment,
         'directories': directories,
         'queries': queries,
+        'file': file
     }
 
     return elements
+
+
+def is_valid_url(url):
+    """
+    Check if a URL is valid.
+    :param url:
+    :return:
+    """
+
+    parsed = urlparse(url)
+    return all([parsed.scheme, parsed.netloc])
+
+
+def find_urls_in_text(text: str) -> list[str]:
+    """
+    Find URLs in text
+
+    :param text: string, text to search for URLs.
+    :return: list of strings, URLs found in text.
+    """
+
+    url_pattern = re.compile(
+        r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+'
+    )
+    urls = url_pattern.findall(text)
+
+    # Filter URLs to remove common false positives
+    cleaned_urls = []
+    for u in urls:
+        cleaned_url = u.strip('",.:;!?)(')
+        if is_valid_url(cleaned_url):
+            cleaned_urls.append(cleaned_url)
+
+    return cleaned_urls

atomicshop/venvs.py

@@ -0,0 +1,28 @@
+import sys
+import os
+from typing import Union
+
+
+def is_running_venv() -> Union[str, None]:
+    """
+    Check if the script is running in a virtual environment.
+
+    :return: string of the virtual environment path if it is running in a virtual environment, None otherwise.
+    """
+    if hasattr(sys, 'real_prefix') or (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix):
+        return sys.prefix
+    else:
+        return None
+
+
+def add_venv_to_path():
+    """
+    Add the virtual environment to the PATH environment variable.
+    """
+
+    venv_environment = is_running_venv()
+    if venv_environment:
+        # We're in a virtual environment, so modify the PATH
+        venv_bin = os.path.join(venv_environment, 'bin')
+        # Prepend the virtual environment's bin directory to the existing PATH
+        os.environ['PATH'] = f"{venv_bin}:{os.environ['PATH']}"

atomicshop/versioning.py

@@ -0,0 +1,27 @@
+from typing import Union
+
+
+def is_target_newer(
+        base_version: Union[str, tuple],
+        target_version: Union[str, tuple]
+):
+    """
+    Check if the target version is newer than the base version.
+    Example: is_target_newer('1.0.0', '1.0.1') -> True
+    Example: is_target_newer('1.0.0', '1.0.0') -> False
+    Example: is_target_newer('1.0.1', '1.0.0') -> False
+    Example: is_target_newer('1.0.1', '1.0.2') -> True
+    Example: is_target_newer((1,0,1), (1,1,0)) -> True
+
+    :param base_version: The base version to compare against.
+    :param target_version: The target version to compare.
+    """
+
+    # Convert string to tuple if string was passed.
+    if isinstance(base_version, str):
+        base_version = tuple(map(int, base_version.split('.')))
+    if isinstance(target_version, str):
+        target_version = tuple(map(int, target_version.split('.')))
+
+    # Compare the versions.
+    return target_version > base_version