python-base-toolkit 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

python_base_toolkit/consts/operating_system.py

@@ -0,0 +1,4 @@
+class Platform:
+    WINDOWS = "Windows"
+    LINUX = "Linux"
+    MACOS = "macOS"

python_base_toolkit/consts/units/__init__.py

@@ -2,6 +2,6 @@ import python_base_toolkit.consts.units.binary_units
 import python_base_toolkit.consts.units.time_units
 
 __all__ = [
-    'binary_units',
-    'time_units',
+    "binary_units",
+    "time_units",
 ]

python_base_toolkit/consts/units/binary_units.py

@@ -7,7 +7,7 @@ PiB = TiB * 1024
 EiB = PiB * 1024
 
 KB = 1000  # 1 kilobyte (KB) = 1000 bytes in decimal (SI)
-GB = 1000 ** 3  # 1 gigabyte (GB) = 1000^3 bytes in decimal (SI)
-TB = 1000 ** 4  # 1 terabyte (TB) = 1000^4 bytes in decimal (SI)
-PB = 1000 ** 5  # 1 petabyte (PB) = 1000^5 bytes in decimal (SI)
-EB = 1000 ** 6  # 1 exabyte (EB) = 1000^6 bytes in decimal (SI)
+GB = 1000**3  # 1 gigabyte (GB) = 1000^3 bytes in decimal (SI)
+TB = 1000**4  # 1 terabyte (TB) = 1000^4 bytes in decimal (SI)
+PB = 1000**5  # 1 petabyte (PB) = 1000^5 bytes in decimal (SI)
+EB = 1000**6  # 1 exabyte (EB) = 1000^6 bytes in decimal (SI)

python_base_toolkit/decorators/telemetry.py

@@ -1,8 +1,9 @@
+import datetime
 import json
 import time
+from collections.abc import Callable
 from functools import wraps
-import datetime
-from typing import Callable, Any
+from typing import Any
 
 from custom_python_logger import get_logger
 
@@ -10,11 +11,7 @@ logger = get_logger(__name__)
 
 
 def report_telemetry(
-    func: Callable[..., Any],
-    start_time: datetime.datetime,
-    end_time: datetime.datetime,
-    *args: Any,
-    **kwargs: Any
+    func: Callable[..., Any], start_time: datetime.datetime, end_time: datetime.datetime, *args: Any, **kwargs: Any
 ) -> None:
     data = {
         "function_name": func.__name__,
@@ -25,7 +22,8 @@ def report_telemetry(
         "timestamp": time.time(),
     }
     logger.info(
-        f"Sending telemetry data with the following data: {json.dumps(data, indent=4, sort_keys=False, default=str)}")
+        f"Sending telemetry data with the following data: {json.dumps(data, indent=4, sort_keys=False, default=str)}"
+    )
 
 
 def report_func_telemetry(func: Callable[..., Any]) -> Callable[..., Any]:
@@ -37,7 +35,7 @@ def report_func_telemetry(func: Callable[..., Any]) -> Callable[..., Any]:
         start_time = datetime.datetime.now(datetime.UTC)
         result = func(*args, **kwargs)
         end_time = datetime.datetime.now(datetime.UTC)
-        report_telemetry(func=func, start_time=start_time, end_time=end_time, *args, **kwargs)
+        report_telemetry(*args, func=func, start_time=start_time, end_time=end_time, **kwargs)
         return result
 
     return wrapper

python_base_toolkit/decorators/timer.py

@@ -1,6 +1,7 @@
 import time
+from collections.abc import Callable
 from functools import wraps
-from typing import Callable, Any
+from typing import Any
 
 from custom_python_logger import get_logger
 
@@ -8,12 +9,17 @@ logger = get_logger(__name__)
 
 
 class Timer:
-    def __enter__(self):
+    def __init__(self) -> None:
+        self.start_time = None
+        self.end_time = None
+        self.elapsed_time = None
+
+    def __enter__(self) -> "Timer":
         self.start_time = time.perf_counter()
         logger.info("Timer started.")
         return self
 
-    def __exit__(self, exc_type, exc_value, exc_traceback):
+    def __exit__(self, exc_type: type, exc_value: Exception, exc_traceback: object) -> None:
         # logger.info(exc_type, exc_value, exc_traceback)
         self.end_time = time.perf_counter()
         self.elapsed_time = self.end_time - self.start_time
@@ -25,4 +31,5 @@ def timer(func: Callable[..., Any]) -> Callable[..., Any]:
     def wrapper(*args: Any, **kwargs: Any) -> Any:
         with Timer():
             return func(*args, **kwargs)
+
     return wrapper

python_base_toolkit/instances/instance_manager.py

@@ -1,18 +1,19 @@
 from custom_python_logger.logger import get_logger
 
+
 class InstanceManager:
-    def __init__(self):
+    def __init__(self) -> None:
         self.logger = get_logger(__class__.__name__)
         self._instances = []
 
-    def add(self, instance):
+    def add(self, instance: object) -> None:
         self._instances.append(instance)
 
-    def close_all(self):
+    def close_all(self) -> None:
         for instance in reversed(self._instances):
             _instance_name = instance.__class__.__name__
             try:
-                if hasattr(instance, 'close'):
+                if hasattr(instance, "close"):
                     instance.close()
                 else:  # hasattr(instance, '__exit__'):
                     instance.__exit__(None, None, None)
@@ -20,31 +21,31 @@ class InstanceManager:
             except Exception as e:
                 self.logger.info(f"Failed to close instance {instance}: {e}")
 
-    def __enter__(self):
+    def __enter__(self) -> "InstanceManager":
         return self
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(self, exc_type: type, exc_value: Exception, traceback: object) -> None:
         self.close_all()
 
 
-def main():
+def main() -> None:
     class SomeInstance:
-        def __init__(self, add_to_instance_manager: bool = False):
+        def __init__(self, add_to_instance_manager: bool = False) -> None:
             self.logger = get_logger(__class__.__name__)
 
             if add_to_instance_manager:
-                instance_manager.add(self)
+                instance_manager.add(self)  # pylint: disable=E0601
 
         @property
-        def __class_name__(self):
+        def class_name(self) -> str:
             return self.__class__.__name__
 
-        def __enter__(self):
-            self.logger.info(f"Entering {self.__class_name__}")
+        def __enter__(self) -> "SomeInstance":
+            self.logger.info(f"Entering {self.class_name}")
             return self
 
-        def __exit__(self, exc_type, exc_value, exc_traceback):
-            self.logger.info(f"Exiting {self.__class_name__}")
+        def __exit__(self, exc_type: type, exc_value: Exception, traceback: object) -> bool:
+            self.logger.info(f"Exiting {self.class_name}")
             # Handle any cleanup here
             if exc_type:
                 self.logger.info(f"Exception: {exc_value}")
@@ -52,8 +53,8 @@ def main():
 
     SomeInstance(add_to_instance_manager=True)
 
-    resource1 = open('file1.txt', 'w')
-    resource2 = open('file2.txt', 'w')
+    resource1 = open("file1.txt", "w")  # pylint: disable=R1732
+    resource2 = open("file2.txt", "w")  # pylint: disable=R1732
 
     instance_manager.add(resource1)
     instance_manager.add(resource2)

python_base_toolkit/utils/data_serialization.py

@@ -1,6 +1,6 @@
 import json
 from dataclasses import is_dataclass
-from datetime import datetime, date, time
+from datetime import date, datetime, time
 from decimal import Decimal
 from enum import Enum
 from pathlib import Path
@@ -23,7 +23,7 @@ def default_serialize(obj: object) -> object:
         return list(obj)
     if isinstance(obj, tuple):
         return list(obj)
-    if isinstance(obj, (datetime, date, time)):
+    if isinstance(obj, datetime | date | time):
         return obj.isoformat()
     if isinstance(obj, Decimal):
         return float(obj)
@@ -31,7 +31,7 @@ def default_serialize(obj: object) -> object:
         return str(obj)
     if obj is pd.NA:
         return None
-    logger.error(f'Object is not serializable: {obj}')
+    logger.error(f"Object is not serializable: {obj}")
     raise TypeError(f"Type {type(obj)} not serializable")
 
 

python_base_toolkit/utils/date_time.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 from zoneinfo import ZoneInfo
 
-utc_timezone = ZoneInfo('UTC')
+utc_timezone = ZoneInfo("UTC")
 
 
 def datetime_now_with_timezone(timezone: ZoneInfo = utc_timezone) -> datetime:
@@ -9,6 +9,6 @@ def datetime_now_with_timezone(timezone: ZoneInfo = utc_timezone) -> datetime:
         raise TypeError(f"Expected pytz timezone, got {type(timezone).__name__}")
 
     now_utc = datetime.now(timezone)
-    if timezone.key == 'UTC':
+    if timezone.key == "UTC":
         return now_utc
     return now_utc.astimezone(timezone)

python_base_toolkit/utils/execute.py

@@ -16,7 +16,7 @@ def _timed_execution(
     pbar = tqdm(total=timeout, desc=pb_description, unit="s", ncols=100)
     start_time = time()
 
-    while time() - start_time < timeout:
+    while time() - start_time < timeout:  # pylint: disable=W0149
         res = func()
         if (expect_true and res) or (not expect_true and not res):
             pbar.close()

python_base_toolkit/utils/file_utils.py

@@ -1,256 +1,263 @@
+import csv
 import gzip
-import os
 import hashlib
-import shutil
 import json
-import csv
-import yaml
+import os
 import re
-from typing import Optional, Union, BinaryIO, TextIO, cast, Any
+import shutil
 import tarfile
 import zipfile
+from typing import Any, BinaryIO, TextIO, cast
 
+import yaml
 from custom_python_logger import get_logger
 
 logger = get_logger(__name__)
 
 
-class FilePath:
+class _FileCompression:
     @staticmethod
-    def ensure_dir(directory: str) -> str:
-        if not os.path.exists(directory):
-            os.makedirs(directory)
-        return directory
+    def gzip_file(input_path: str, output_path: str | None = None) -> str:
+        if not os.path.isfile(input_path):
+            raise FileNotFoundError(f"Input file does not exist: {input_path}")
+
+        if output_path is None:
+            output_path = input_path + ".gz"
+
+        try:
+            with open(input_path, "rb") as f_in:
+                with gzip.open(output_path, "wb") as f_out:
+                    f_out.write(f_in.read())
+            return output_path
+        except Exception as e:
+            raise OSError(f"Error compressing file: {e}") from e
 
     @staticmethod
-    def file_exists(path: str) -> bool:
-        return os.path.isfile(path)
+    def ungzip_file(gz_path: str, output_path: str | None = None) -> str:
+        if not os.path.isfile(gz_path):
+            raise FileNotFoundError(f"Gzipped file does not exist: {gz_path}")
+
+        if output_path is None:
+            if gz_path.endswith(".gz"):
+                output_path = gz_path[:-3]  # Remove .gz extension
+            else:
+                output_path = gz_path + "_decompressed"
+
+        try:
+            with gzip.open(gz_path, "rb") as f_in:
+                with open(output_path, "wb") as f_out:
+                    f_out.write(f_in.read())
+            return output_path
+        except Exception as e:
+            raise OSError(f"Error decompressing file: {e}") from e
 
     @staticmethod
-    def get_file_extension(path: str) -> str:
-        return os.path.splitext(path)[1][1:]
+    def compress_directory(directory: str, output_path: str | None = None) -> str:
+        """Compress directory to tarball."""
+        if not os.path.isdir(directory):
+            raise FileNotFoundError(f"Directory does not exist: {directory}")
+
+        if output_path is None:
+            output_path = directory.rstrip(os.sep) + ".tar.gz"
+
+        with tarfile.open(output_path, "w:gz") as tar:
+            tar.add(directory, arcname=os.path.basename(directory))
+
+        return output_path
 
     @staticmethod
-    def get_filename(path: str, with_extension: bool = True) -> str:
-        if with_extension:
-            return os.path.basename(path)
-        return os.path.splitext(os.path.basename(path))[0]
+    def extract_archive(archive_path: str, output_dir: str | None = None) -> str:
+        """Extract archive file."""
+        if not os.path.isfile(archive_path):
+            raise FileNotFoundError(f"Archive does not exist: {archive_path}")
 
+        if output_dir is None:
+            output_dir = os.path.splitext(archive_path)[0]
+            # Handle double extensions like .tar.gz
+            if output_dir.endswith(".tar"):
+                output_dir = output_dir[:-4]
+
+        _FilePath.ensure_dir(output_dir)
+
+        if archive_path.endswith((".tar.gz", ".tgz")):
+            with tarfile.open(archive_path, "r:gz") as tar:
+                tar.extractall(path=output_dir)
+        elif archive_path.endswith(".tar.bz2"):
+            with tarfile.open(archive_path, "r:bz2") as tar:
+                tar.extractall(path=output_dir)
+        elif archive_path.endswith(".tar"):
+            with tarfile.open(archive_path, "r") as tar:
+                tar.extractall(path=output_dir)
+        elif archive_path.endswith(".zip"):
+            with zipfile.ZipFile(archive_path, "r") as zip_ref:
+                zip_ref.extractall(output_dir)
+        else:
+            raise ValueError(f"Unsupported archive format: {archive_path}")
+
+        return output_dir
+
+
+class _FileHash:
     @staticmethod
-    def get_relative_path(path: str, base_path: str) -> str:
-        return os.path.relpath(path, base_path)
+    def file_md5(filename: str, chunk_size: int = 8192) -> str:
+        """Calculate MD5 hash of a file."""
+        hash_md5 = hashlib.md5()
+        with open(filename, "rb") as f:
+            for chunk in iter(lambda: f.read(chunk_size), b""):
+                hash_md5.update(chunk)
+        return hash_md5.hexdigest()
 
     @staticmethod
-    def list_files(directory: str, extension: Optional[str] = None, recursive: bool = False) -> list[str]:
-        result = []
-        for root, _, files in os.walk(directory) if recursive else [(directory, [], os.listdir(directory))]:
-            for file in files:
-                if not extension or file.endswith(extension):
-                    result.append(os.path.join(root, file))
-        return result
+    def file_sha1(filename: str, chunk_size: int = 8192) -> str:
+        """Calculate SHA1 hash of a file."""
+        hash_sha1 = hashlib.sha1()
+        with open(filename, "rb") as f:
+            for chunk in iter(lambda: f.read(chunk_size), b""):
+                hash_sha1.update(chunk)
+        return hash_sha1.hexdigest()
+
+    @staticmethod
+    def file_sha256(filename: str, chunk_size: int = 8192) -> str:
+        """Calculate SHA256 hash of a file."""
+        hash_sha256 = hashlib.sha256()
+        with open(filename, "rb") as f:
+            for chunk in iter(lambda: f.read(chunk_size), b""):
+                hash_sha256.update(chunk)
+        return hash_sha256.hexdigest()
 
 
-class FileIO:
+class _FileIO:
     @staticmethod
-    def safe_open(
-        filename: str,
-        mode: str = 'r',
-        encoding: Optional[str] = None,
-        **kwargs
-    ) -> Union[TextIO, BinaryIO]:
-        if 'b' in mode:
+    def safe_open(filename: str, mode: str = "r", encoding: str | None = None, **kwargs: Any) -> TextIO | BinaryIO:
+        if "b" in mode:
             return cast(BinaryIO, open(filename, mode, **kwargs))
-        return cast(TextIO, open(filename, mode, encoding=encoding or 'utf-8', **kwargs))
+        return cast(TextIO, open(filename, mode, encoding=encoding or "utf-8", **kwargs))
 
     @staticmethod
-    def read_text(filename: str, encoding: str = 'utf-8') -> str:
-        with open(filename, 'r', encoding=encoding) as f:
+    def read_text(filename: str, encoding: str = "utf-8") -> str:
+        with open(filename, encoding=encoding) as f:
             return f.read()
 
     @staticmethod
-    def write_text(text: str, filename: str, encoding: str = 'utf-8') -> None:
-        with open(filename, 'w', encoding=encoding) as f:
+    def write_text(text: str, filename: str, encoding: str = "utf-8") -> None:
+        with open(filename, "w", encoding=encoding) as f:
             f.write(text)
 
-    def read_json(self, filename: str) -> dict[str, Any]:
-        with self.safe_open(filename, 'r') as f:
+    @staticmethod
+    def read_json(filename: str) -> dict[str, Any]:
+        with _FileIO.safe_open(filename, "r") as f:
             return json.load(f)
 
     @staticmethod
     def write_json(data: dict[str, Any], filename: str, indent: int = 2) -> None:
-        with open(filename, 'w', encoding='utf-8') as f:
+        with open(filename, "w", encoding="utf-8") as f:
             json.dump(data, f, indent=indent, ensure_ascii=False)
 
     @staticmethod
     def read_yaml(filename: str) -> Any:
-        with open(filename, 'r', encoding='utf-8') as f:
+        with open(filename, encoding="utf-8") as f:
             return yaml.safe_load(f)
 
     @staticmethod
-    def write_yaml(data: Any, filename: str, **kwargs) -> None:
-        with open(filename, 'w', encoding='utf-8') as f:
+    def write_yaml(data: Any, filename: str, **kwargs: Any) -> None:
+        with open(filename, "w", encoding="utf-8") as f:
             yaml.safe_dump(data, f, allow_unicode=True, **kwargs)
 
-    def read_csv(self, filename: str, **kwargs) -> list[dict[str, Any]]:
-        with self.safe_open(filename, 'r', newline='') as f:
+    def read_csv(self, filename: str, **kwargs: Any) -> list[dict[str, Any]]:
+        with self.safe_open(filename, "r", newline="") as f:
             reader = csv.DictReader(f, **kwargs)
             return list(reader)
 
     @staticmethod
-    def write_csv(data: list[dict[str, Any]], filename: str, fieldnames: Optional[list[str]] = None, **kwargs) -> None:
+    def write_csv(
+        data: list[dict[str, Any]], filename: str, fieldnames: list[str] | None = None, **kwargs: Any
+    ) -> None:
         if not data:
             return
 
         if fieldnames is None:
             fieldnames = list(data[0].keys())
 
-        with open(filename, 'w', newline='', encoding='utf-8') as f:
+        with open(filename, "w", newline="", encoding="utf-8") as f:
             writer = csv.DictWriter(f, fieldnames=fieldnames, **kwargs)
             writer.writeheader()
             writer.writerows(data)
 
     @staticmethod
     def is_binary_file(path: str, chunk_size: int = 1024) -> bool:
-        with open(path, 'rb') as f:
+        with open(path, "rb") as f:
             chunk = f.read(chunk_size)
-        return b'\0' in chunk
+        return b"\0" in chunk
 
     @staticmethod
     def is_file_empty(path: str) -> bool:
         return os.path.getsize(path) == 0
 
 
-class FfileManipulation:
+class _FileManipulation:
     @staticmethod
     def remove_emojis(text: str) -> str:
-        return re.sub(r'[\U00010000-\U0010ffff]', '', text).strip()
-
+        return re.sub(r"[\U00010000-\U0010ffff]", "", text).strip()
 
-class FileSystem:
-    @staticmethod
-    def copy_file(src: str, dst: str) -> None:
-        shutil.copy2(src, dst)
 
+class _FilePath:
     @staticmethod
-    def move_file(src: str, dst: str) -> None:
-        shutil.move(src, dst)
+    def ensure_dir(directory: str) -> str:
+        if not os.path.exists(directory):
+            os.makedirs(directory)
+        return directory
 
     @staticmethod
-    def delete_file(path: str) -> None:
-        if os.path.isfile(path):
-            os.remove(path)
+    def file_exists(path: str) -> bool:
+        return os.path.isfile(path)
 
     @staticmethod
-    def file_size(path: str) -> int:
-        return os.path.getsize(path)
-
+    def get_file_extension(path: str) -> str:
+        return os.path.splitext(path)[1][1:]
 
-class FileHash:
     @staticmethod
-    def file_md5(filename: str, chunk_size: int = 8192) -> str:
-        """Calculate MD5 hash of a file."""
-        hash_md5 = hashlib.md5()
-        with open(filename, "rb") as f:
-            for chunk in iter(lambda: f.read(chunk_size), b""):
-                hash_md5.update(chunk)
-        return hash_md5.hexdigest()
+    def get_filename(path: str, with_extension: bool = True) -> str:
+        if with_extension:
+            return os.path.basename(path)
+        return os.path.splitext(os.path.basename(path))[0]
 
     @staticmethod
-    def file_sha1(filename: str, chunk_size: int = 8192) -> str:
-        """Calculate SHA1 hash of a file."""
-        hash_sha1 = hashlib.sha1()
-        with open(filename, "rb") as f:
-            for chunk in iter(lambda: f.read(chunk_size), b""):
-                hash_sha1.update(chunk)
-        return hash_sha1.hexdigest()
+    def get_relative_path(path: str, base_path: str) -> str:
+        return os.path.relpath(path, base_path)
 
     @staticmethod
-    def file_sha256(filename: str, chunk_size: int = 8192) -> str:
-        """Calculate SHA256 hash of a file."""
-        hash_sha256 = hashlib.sha256()
-        with open(filename, "rb") as f:
-            for chunk in iter(lambda: f.read(chunk_size), b""):
-                hash_sha256.update(chunk)
-        return hash_sha256.hexdigest()
+    def list_files(directory: str, extension: str | None = None, recursive: bool = False) -> list[str]:
+        result = []
+        for root, _, files in os.walk(directory) if recursive else [(directory, [], os.listdir(directory))]:
+            for file in files:
+                if not extension or file.endswith(extension):
+                    result.append(os.path.join(root, file))
+        return result
 
 
-class FileCompression:
+class _FileSystem:
     @staticmethod
-    def gzip_file(input_path: str, output_path: Optional[str] = None) -> str:
-        if not os.path.isfile(input_path):
-            raise FileNotFoundError(f"Input file does not exist: {input_path}")
-
-        if output_path is None:
-            output_path = input_path + '.gz'
-
-        try:
-            with open(input_path, 'rb') as f_in:
-                with gzip.open(output_path, 'wb') as f_out:
-                    f_out.write(f_in.read())
-            return output_path
-        except Exception as e:
-            raise IOError(f"Error compressing file: {e}")
+    def copy_file(src: str, dst: str) -> None:
+        shutil.copy2(src, dst)
 
     @staticmethod
-    def ungzip_file(gz_path: str, output_path: Optional[str] = None) -> str:
-        if not os.path.isfile(gz_path):
-            raise FileNotFoundError(f"Gzipped file does not exist: {gz_path}")
-
-        if output_path is None:
-            if gz_path.endswith('.gz'):
-                output_path = gz_path[:-3]  # Remove .gz extension
-            else:
-                output_path = gz_path + '_decompressed'
-
-        try:
-            with gzip.open(gz_path, 'rb') as f_in:
-                with open(output_path, 'wb') as f_out:
-                    f_out.write(f_in.read())
-            return output_path
-        except Exception as e:
-            raise IOError(f"Error decompressing file: {e}")
+    def move_file(src: str, dst: str) -> None:
+        shutil.move(src, dst)
 
     @staticmethod
-    def compress_directory(directory: str, output_path: Optional[str] = None) -> str:
-        """Compress directory to tarball."""
-        if not os.path.isdir(directory):
-            raise FileNotFoundError(f"Directory does not exist: {directory}")
-
-        if output_path is None:
-            output_path = directory.rstrip(os.sep) + '.tar.gz'
-
-        with tarfile.open(output_path, 'w:gz') as tar:
-            tar.add(directory, arcname=os.path.basename(directory))
-
-        return output_path
+    def delete_file(path: str) -> None:
+        if os.path.isfile(path):
+            os.remove(path)
 
     @staticmethod
-    def extract_archive(archive_path: str, output_dir: Optional[str] = None) -> str:
-        """Extract archive file."""
-        if not os.path.isfile(archive_path):
-            raise FileNotFoundError(f"Archive does not exist: {archive_path}")
-
-        if output_dir is None:
-            output_dir = os.path.splitext(archive_path)[0]
-            # Handle double extensions like .tar.gz
-            if output_dir.endswith('.tar'):
-                output_dir = output_dir[:-4]
-
-        FilePath.ensure_dir(output_dir)
+    def file_size(path: str) -> int:
+        return os.path.getsize(path)
 
-        if archive_path.endswith(('.tar.gz', '.tgz')):
-            with tarfile.open(archive_path, 'r:gz') as tar:
-                tar.extractall(path=output_dir)
-        elif archive_path.endswith('.tar.bz2'):
-            with tarfile.open(archive_path, 'r:bz2') as tar:
-                tar.extractall(path=output_dir)
-        elif archive_path.endswith('.tar'):
-            with tarfile.open(archive_path, 'r') as tar:
-                tar.extractall(path=output_dir)
-        elif archive_path.endswith('.zip'):
-            with zipfile.ZipFile(archive_path, 'r') as zip_ref:
-                zip_ref.extractall(output_dir)
-        else:
-            raise ValueError(f"Unsupported archive format: {archive_path}")
 
-        return output_dir
+class FileUtils:
+    file_compression = _FileCompression
+    file_hash = _FileHash
+    file_io = _FileIO
+    file_manipulation = _FileManipulation
+    file_path = _FilePath
+    file_system = _FileSystem

python_base_toolkit/utils/generate_id.py

@@ -0,0 +1,35 @@
+import random
+import string
+from datetime import datetime
+
+from custom_python_logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def generate_id(length: int = 8) -> str:
+    # helper function for generating an id
+    id_ = "".join(random.choices(string.ascii_uppercase, k=length))
+    logger.info(f"id is: {id_}")
+    return id_
+
+
+def generate_id_by_date() -> str:
+    timestamp = datetime.now()
+    id_ = timestamp.strftime("%Y%m%d")
+    logger.info(f"id is: {id_}")
+    return id_
+
+
+def generate_id_by_time() -> str:
+    timestamp = datetime.now()
+    id_ = timestamp.strftime("%H%M%S%m")
+    logger.info(f"id is: {id_}")
+    return id_
+
+
+def generate_id_by_date_and_time() -> str:
+    timestamp = datetime.now()
+    id_ = timestamp.strftime("%Y%m%d%H%M%S%m")
+    logger.info(f"id is: {id_}")
+    return id_

python_base_toolkit/utils/logo.py

@@ -1,6 +1,6 @@
 from pyfiglet import Figlet
 
 
-def create_logo(text: str, font: str = 'big') -> str:
+def create_logo(text: str, font: str = "big") -> str:
     f = Figlet(font=font)
     return f.renderText(text)

python_base_toolkit/utils/network.py

@@ -1,9 +1,23 @@
 import ipaddress
+import os
 import re
-from typing import Optional
 
+from custom_python_logger import get_logger
 
-def get_ip_version(ip: str) -> Optional[int]:
+from python_base_toolkit.consts.operating_system import Platform
+
+logger = get_logger(__name__)
+
+
+def is_ip_address(ip: str) -> bool:
+    try:
+        ipaddress.ip_address(ip)
+        return True
+    except ValueError:
+        return False
+
+
+def get_ip_version(ip: str) -> int | None:
     """
     Returns the type of the IP address as integer (IPv4, IPv6 or None in case of an invalid IP address)
     :param ip: IP address (String)
@@ -15,7 +29,7 @@ def get_ip_version(ip: str) -> Optional[int]:
         return None
 
 
-def normalize_connection_string(ip: str, port: Optional[int] = None) -> str:
+def normalize_connection_string(ip: str, port: int | None = None) -> str:
     """
     Returns a normalized connection string (IPv4:port or [IPv6]:port)
     :param ip: IP address (String)
@@ -25,25 +39,25 @@ def normalize_connection_string(ip: str, port: Optional[int] = None) -> str:
     w/ Port - IPv4:port or [IPv6]:port
     w/o Port - IPv4: or [IPv6]:
     """
-    _operation = 'Normalize connection string'
+    _operation = "Normalize connection string"
 
     _ip_version = get_ip_version(ip)
     if _ip_version == 4:
         return f'{ip}:{port or ""}'
     if _ip_version == 6:
         return f'[{ip}]:{port or ""}'
-    raise ValueError(f'Invalid IP address: {ip} - {_operation}')
+    raise ValueError(f"Invalid IP address: {ip} - {_operation}")
 
 
-def normalize_http_url(ip: str, port: Optional[int] = None, https: bool = True) -> str:
+def normalize_http_url(ip: str, port: int | None = None, https: bool = True) -> str:
     """
     Returns a normalized HTTP URL (http://IPv4:port or http://[IPv6]:port)
     :param ip: IP address (String)
     :param port: Port (Integer)
     :param https: Use HTTPS (Boolean)
     """
-    url_schema = 'https' if https else 'http'
-    return f'{url_schema}://{normalize_connection_string(ip, port)}'
+    url_schema = "https" if https else "http"
+    return f"{url_schema}://{normalize_connection_string(ip, port)}"
 
 
 def parse_ifconfig_to_json(ifconfig_output: str) -> dict:
@@ -63,40 +77,70 @@ def parse_ifconfig_to_json(ifconfig_output: str) -> dict:
     current_interface = None
 
     for line in ifconfig_output.splitlines():
-        match_interface = re.match(r'^(\S+):\s', line)
-        if match_interface:
+        if match_interface := re.match("^(\\S+):\\s", line):
             current_interface = match_interface.group(1)
             interfaces[current_interface] = {}
 
-        match_mac = re.search(r'ether\s([0-9a-f:]+)', line)
+        match_mac = re.search(r"ether\s([0-9a-f:]+)", line)
         if match_mac and current_interface:
-            interfaces[current_interface]['mac_address'] = match_mac.group(1)
+            interfaces[current_interface]["mac_address"] = match_mac.group(1)
 
-        match_ipv4 = re.search(r'inet\s(\d+\.\d+\.\d+\.\d+)', line)
+        match_ipv4 = re.search(r"inet\s(\d+\.\d+\.\d+\.\d+)", line)
         if match_ipv4 and current_interface:
-            interfaces[current_interface]['ipv4_address'] = match_ipv4.group(1)
+            interfaces[current_interface]["ipv4_address"] = match_ipv4.group(1)
 
         # Try different netmask patterns
-        match_netmask = re.search(r'netmask\s+(0x[0-9a-f]+|(?:\d+\.){3}\d+)', line, re.IGNORECASE)
+        match_netmask = re.search(r"netmask\s+(0x[0-9a-f]+|(?:\d+\.){3}\d+)", line, re.IGNORECASE)
         if match_netmask and current_interface:
             netmask = match_netmask.group(1)
-            if netmask.startswith('0x'):
+            if netmask.startswith("0x"):
                 # Handle hex format
                 netmask_int = int(netmask, 16)
             else:
                 # Handle decimal format (255.255.255.0)
-                octets = [int(x) for x in netmask.split('.')]
+                octets = [int(x) for x in netmask.split(".")]
                 netmask_int = sum(octet << (24 - 8 * i) for i, octet in enumerate(octets))
 
-            binary_netmask = f'{netmask_int:032b}'
-            interfaces[current_interface]['ipv4_netmask'] = binary_netmask.count('1')
+            binary_netmask = f"{netmask_int:032b}"
+            interfaces[current_interface]["ipv4_netmask"] = binary_netmask.count("1")
 
-        match_ipv6 = re.search(r'inet6\s([0-9a-fA-F:]+)', line)
+        match_ipv6 = re.search(r"inet6\s([0-9a-fA-F:]+)", line)
         if match_ipv6 and current_interface:
-            interfaces[current_interface]['ipv6_address'] = match_ipv6.group(1)
+            interfaces[current_interface]["ipv6_address"] = match_ipv6.group(1)
 
-        match_subnet_mask = re.search(r'prefixlen\s([0-9a-f:]+)', line)
+        match_subnet_mask = re.search(r"prefixlen\s([0-9a-f:]+)", line)
         if match_subnet_mask and current_interface:
-            interfaces[current_interface]['ipv6_prefixlen'] = match_subnet_mask.group(1)
+            interfaces[current_interface]["ipv6_prefixlen"] = match_subnet_mask.group(1)
 
     return interfaces
+
+
+def check_ping_from_linux(ip_address: str, number_of_ping: int = 4) -> bool:
+    try:
+        if os.system(f"ping -c {number_of_ping} {ip_address}") == 0:
+            return True
+        return False
+    except Exception as e:
+        logger.exception(f"ping to {ip_address} failed: {e}")
+        return False
+
+
+def check_ping_from_windows(ip_address: str, number_of_ping: int = 4) -> bool:
+    try:
+        if os.system(f"ping -c {number_of_ping} {ip_address}") == 0:
+            return True
+        return False
+    except Exception as e:
+        logger.exception(f"ping to {ip_address} failed: {e}")
+        return False
+
+
+def check_ping_status(platform: Platform, ip_address: str, number_of_ping: int = 4) -> bool:
+    """
+    Check the ping status of an IP address based on the operating system platform.
+    """
+    if platform in [Platform.LINUX, Platform.MACOS]:
+        return check_ping_from_linux(ip_address, number_of_ping)
+    if platform == Platform.WINDOWS:
+        return check_ping_from_windows(ip_address, number_of_ping)
+    raise ValueError(f"Unsupported platform: {platform}")

python_base_toolkit/utils/path_utils.py

@@ -3,18 +3,17 @@ from pathlib import Path
 
 def get_project_path_by_name(project_name: str) -> str:
     current_path = Path(__file__).parent
-    while current_path != current_path.parent:
-        if str(current_path).endswith(f'/{project_name}'):
+    while current_path != current_path.parent:  # pylint: disable=W0149
+        if str(current_path).endswith(f"/{project_name}"):
             return str(current_path)
         current_path = current_path.parent
     raise FileNotFoundError(
-        f'Project "{project_name}" not found in any parent directories.\n'
-        f'Current path: {Path(__file__)}',
+        f'Project "{project_name}" not found in any parent directories.\n' f"Current path: {Path(__file__)}",
     )
 
 
 def get_project_path_by_file(markers: set = None) -> Path:
-    markers = markers or {'.git', '.gitignore', 'setup.py', 'pyproject.toml', 'LICENSE', 'README.md'}
+    markers = markers or {".git", ".gitignore", "setup.py", "pyproject.toml", "LICENSE", "README.md"}
     for marker in markers:
         path = Path(__file__).resolve()
         for parent in path.parents:

python_base_toolkit/utils/pretty_print.py

@@ -1,6 +1,7 @@
 import json
 import logging
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 from custom_python_logger import get_logger
 
@@ -8,11 +9,7 @@ logger = get_logger(__name__)
 
 
 def log_in_format(
-    data: Any,
-    log_level: int = logging.INFO,
-    indent: int = 4,
-    sort_keys: bool = True,
-    default: Callable = None
+    data: Any, log_level: int = logging.INFO, indent: int = 4, sort_keys: bool = True, default: Callable = None
 ) -> None:
     formatted_data = json.dumps(data, indent=indent, sort_keys=sort_keys, default=default)
 

python_base_toolkit/utils/pycache.py

@@ -1,8 +1,8 @@
-import logging
 import shutil
 from pathlib import Path
 
 from custom_python_logger.logger import get_logger
+
 from python_base_toolkit.utils.path_utils import get_project_path_by_file
 
 logger = get_logger(__name__)
@@ -10,9 +10,9 @@ logger = get_logger(__name__)
 
 def delete_pycache_folder(root_dir: Path = None, ignored_dirs: set = None) -> None:
     root_dir = Path(root_dir) if root_dir else get_project_path_by_file()
-    ignored_dirs = ignored_dirs or {'.venv'}
+    ignored_dirs = ignored_dirs or {".venv"}
 
-    for path in root_dir.rglob('__pycache__'):
+    for path in root_dir.rglob("__pycache__"):
         if any(ignored in path.parts for ignored in ignored_dirs):
             continue
 

python_base_toolkit/utils/random_utils.py

@@ -10,7 +10,7 @@ def generate_random_string(length: int = 8, charset: str = ascii_letters + digit
     :param charset: The set of characters to use for generating the string
     Return - A random string based on the specified character set
     """
-    return ''.join(choice(charset) for _ in range(length))
+    return "".join(choice(charset) for _ in range(length))
 
 
 def generate_random_password(length: int = 8) -> str:
@@ -25,14 +25,14 @@ def generate_random_password(length: int = 8) -> str:
     password += choice(ascii_lowercase)
 
     # Fill the remaining characters with a mix of all types
-    remaining_chars = ''.join(
+    remaining_chars = "".join(
         choice(ascii_letters + digits + special_characters) for _ in range(length - len(password))
     )
 
     password += remaining_chars
 
     # Shuffle the password to make it more random but keep the first character as a letter
-    return password[0] + ''.join(random.sample(password[1:], len(password) - 1))
+    return password[0] + "".join(random.sample(password[1:], len(password) - 1))
 
 
 def generate_random_ipv4() -> str:
@@ -43,9 +43,9 @@ def generate_random_ipv4() -> str:
 
 
 def generate_random_ipv6() -> str:
-    first_group = f'{random.randint(0x2000, 0x3fff):04x}'
-    other_groups = [f'{random.randint(0, 0xffff):04x}' for _ in range(7)]
-    return ':'.join([first_group] + other_groups)
+    first_group = f"{random.randint(0x2000, 0x3fff):04x}"
+    other_groups = [f"{random.randint(0, 0xffff):04x}" for _ in range(7)]
+    return ":".join([first_group] + other_groups)
 
 
 def generate_random_ip(ip_version: int) -> str:
@@ -64,4 +64,4 @@ def generate_random_ip(ip_version: int) -> str:
 def create_random_text(min_length: int = 64, max_length: int = 4096) -> str:
     """Generate a random string with a length between min_length and max_length characters."""
     length = random.randint(min_length, max_length)
-    return ''.join(random.choice(ascii_letters) for _ in range(length))
+    return "".join(random.choice(ascii_letters) for _ in range(length))

python_base_toolkit/utils/venv_details.py

@@ -1,10 +1,10 @@
-import sys
 import os
+import sys
 
 
 def get_venv_details() -> dict:
     return {
-        'python_executable_path': sys.executable,
-        'python_version': sys.version,
-        'venv_path': os.getenv('VIRTUAL_ENV'),
+        "python_executable_path": sys.executable,
+        "python_version": sys.version,
+        "venv_path": os.getenv("VIRTUAL_ENV"),
     }

{python_base_toolkit-0.0.1.dist-info → python_base_toolkit-0.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-base-toolkit
-Version: 0.0.1
+Version: 0.0.2
 Summary: A Python package for managing pytest plugins.
 Home-page: https://github.com/aviz92/python-base-toolkit
 Author: Avi Zaguri
@@ -13,6 +13,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: setuptools
 Requires-Dist: wheel
+Requires-Dist: python-dotenv
+Requires-Dist: pre-commit
 Requires-Dist: colorlog
 Requires-Dist: pathlib
 Requires-Dist: requests
@@ -47,15 +49,15 @@ pip install python-toolkit
 ---
 
 ## 🚀 Features
-- Constants Pack 
-  - binary 
+- Constants Pack
+  - binary
   - time
 
 - Decorators Pack
   - telemetry
   - timer
 
-- Instances Pack 
+- Instances Pack
   - instance_manager
 
 - Utilities Pack

python_base_toolkit-0.0.2.dist-info/RECORD

@@ -0,0 +1,30 @@
+python_base_toolkit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_base_toolkit/consts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_base_toolkit/consts/operating_system.py,sha256=8cnaHVz80AecTDhQjhU-i-s88bf1UZ-u0ouxHXxDsmA,80
+python_base_toolkit/consts/units/__init__.py,sha256=1sTK8_l5mO1Osk5dD9aWkyPVXrvYjRJU1brnCmpLdRk,157
+python_base_toolkit/consts/units/binary_units.py,sha256=fgRAP6HXIis6OX4uK8woD-OVD7HtBOBDuhDxJ6AGZVE,412
+python_base_toolkit/consts/units/time_units.py,sha256=aDwRnRR_mbOn2B7NUB9b2-qO98CLFzNE8-ZKfwUZ09Q,216
+python_base_toolkit/decorators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_base_toolkit/decorators/telemetry.py,sha256=XKQTYbTqt_3mLVyin5HY7ucgAyAs_hRX_qRd-d7zRJ4,1416
+python_base_toolkit/decorators/timer.py,sha256=MjfkM_aZ1gYG1mmG3Cos3sCM1QdWVyT2wEOEdFA-Uqs,1011
+python_base_toolkit/instances/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_base_toolkit/instances/instance_manager.py,sha256=iq72kcPlbc7-AQTuKcBOeqKZbC8vYcsU5GiFXvt5UMs,2278
+python_base_toolkit/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_base_toolkit/utils/data_serialization.py,sha256=Xf_JTMQPAQfCDM4b0CJxHK7CjmbmVassYViDa65B97A,1197
+python_base_toolkit/utils/date_time.py,sha256=U1P_8qPnEQzI4DguHVEofYLzlyuWfK7L6VsOKPbMa7c,429
+python_base_toolkit/utils/execute.py,sha256=6QYQWd1Z15Ofb4gcAtXCx90l1D-REwTWDZNybU6OibM,1560
+python_base_toolkit/utils/file_utils.py,sha256=XGiFocSNpb77GeX_hEuR_7juNsSwA-RikpH1CvEG4TM,8793
+python_base_toolkit/utils/generate_id.py,sha256=cXyt7AbHRvKvPsKzVE-zFZ3fPIcJ-VVhCaUh63yYUOA,817
+python_base_toolkit/utils/logo.py,sha256=GXCSyPR7RXNshTuMUq1pqZGVZUSJfaktCOv8dWLSz5Q,140
+python_base_toolkit/utils/network.py,sha256=9Y3appWnaIvliA8Jit6vM0uZOmwf6sDVRwzp6BIouHw,4922
+python_base_toolkit/utils/path_utils.py,sha256=zmyIs-bm5GSP6AH8D-ExCQ91aIc-GKwwjfSNzWgpICE,895
+python_base_toolkit/utils/pretty_print.py,sha256=tj1b6zYSsTLBRFfRMXVx3sYv09T5PvslXV8dpBAeq7g,555
+python_base_toolkit/utils/pycache.py,sha256=X-pWRjAd2xcBtMkcyCuKz34SbHWc2leBHBIjqOVoXmw,911
+python_base_toolkit/utils/random_utils.py,sha256=gTH6k1MKKGNZvBTLc5H-eSmtEGvXEdLqtzXN9aHuu-A,2730
+python_base_toolkit/utils/shorten_url.py,sha256=zsyW3wloFJdVb9s3fhR-olL6ekT03FDlFm2xbFY4viw,359
+python_base_toolkit/utils/venv_details.py,sha256=d1WlZr1LuWz2SXdFP0Hqh6VHXXXSIuXB0oTmWXJrGqM,210
+python_base_toolkit-0.0.2.dist-info/licenses/LICENSE,sha256=cSikHY6SZFsPZSBizCDAJ0-Bjjzxt-JtX6TVbKxwimo,1067
+python_base_toolkit-0.0.2.dist-info/METADATA,sha256=Wo5JsmwNIpe9y3IVV2o-L7RqmfkTC-GY82uD1fXGi0g,2208
+python_base_toolkit-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+python_base_toolkit-0.0.2.dist-info/top_level.txt,sha256=I9kK6FGKq_6z3aGySoWamY68GRgg0xsL6sS-uyaxJ2k,20
+python_base_toolkit-0.0.2.dist-info/RECORD,,

python_base_toolkit-0.0.1.dist-info/RECORD

@@ -1,28 +0,0 @@
-python_base_toolkit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_base_toolkit/consts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_base_toolkit/consts/units/__init__.py,sha256=-1lY3rI3SU7gZKlAKl9E6FjputEdKMGxO0K1GJRXSN0,157
-python_base_toolkit/consts/units/binary_units.py,sha256=8NssiyGO_cJ-FNAh4EYzVlCKRM5n4Q0GC8sL96kvNl4,420
-python_base_toolkit/consts/units/time_units.py,sha256=aDwRnRR_mbOn2B7NUB9b2-qO98CLFzNE8-ZKfwUZ09Q,216
-python_base_toolkit/decorators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_base_toolkit/decorators/telemetry.py,sha256=bxittYChUb0zRnDoX_miCZKFQukZ1rPjjPmYfXfcQzA,1400
-python_base_toolkit/decorators/timer.py,sha256=DU0JoqY5cN5hmLVDrNxaMgkPbYNvN3DGU3-FpZXtJK0,813
-python_base_toolkit/instances/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_base_toolkit/instances/instance_manager.py,sha256=NDNKVBaYSXvbASehM0YHBWCaYOSLWFJfuKZ7cf0iTho,2058
-python_base_toolkit/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_base_toolkit/utils/data_serialization.py,sha256=MCF9pALQU2s5tufWXTzW1Dwj3NS1cjI1Le_BL4717iI,1197
-python_base_toolkit/utils/date_time.py,sha256=ycWWTPnkLukENza4NzCX8vQ113UGu4ugPJHGyx4Dgx0,429
-python_base_toolkit/utils/execute.py,sha256=eppuC5YywOHDK-AwFSmcT5YpuO119fFgpJjcSQY80ks,1535
-python_base_toolkit/utils/file_utils.py,sha256=Na6Y1O8PAb21w0y-VnhBFWonOpXl40IrXnefBY8oKNk,8611
-python_base_toolkit/utils/logo.py,sha256=X4u0CmBgTJWqn3b_V0MG2mKV1Gw4rLGOLSQmY7hatIs,140
-python_base_toolkit/utils/network.py,sha256=i3RyWTJGHt77b45gYn0eO9zqXUkScYZvnq-hOFY_eAk,3585
-python_base_toolkit/utils/path_utils.py,sha256=xY0pMHIO-HoWLgc4In-WK8HjsfIwqwozDYzV_nxC_Ps,878
-python_base_toolkit/utils/pretty_print.py,sha256=66XQQKUDjTJcClqWIU_eNmKLKz0h7_1hxMItEAsxbyo,544
-python_base_toolkit/utils/pycache.py,sha256=YwYGYiERSYQJWg1gYDQH1JmjpZpRYWSdacWd8n6zHD8,925
-python_base_toolkit/utils/random_utils.py,sha256=g3yXqei1bGEGxPnAXsdnVtG2DXIF0t68clqul14cAN8,2730
-python_base_toolkit/utils/shorten_url.py,sha256=zsyW3wloFJdVb9s3fhR-olL6ekT03FDlFm2xbFY4viw,359
-python_base_toolkit/utils/venv_details.py,sha256=B67fyXSXdkLnU-fc7QJgSCSpJX5Sv6D13K7to_CDmf4,210
-python_base_toolkit-0.0.1.dist-info/licenses/LICENSE,sha256=cSikHY6SZFsPZSBizCDAJ0-Bjjzxt-JtX6TVbKxwimo,1067
-python_base_toolkit-0.0.1.dist-info/METADATA,sha256=8-kOqa9CkOUB3kopAtR8ZX0wqL0MN35Pi-Emuvx_tnk,2156
-python_base_toolkit-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-python_base_toolkit-0.0.1.dist-info/top_level.txt,sha256=I9kK6FGKq_6z3aGySoWamY68GRgg0xsL6sS-uyaxJ2k,20
-python_base_toolkit-0.0.1.dist-info/RECORD,,