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

python_base_toolkit/consts/units/__init__.py

@@ -0,0 +1,7 @@
+import python_base_toolkit.consts.units.binary_units
+import python_base_toolkit.consts.units.time_units
+
+__all__ = [
+    'binary_units',
+    'time_units',
+]

python_base_toolkit/consts/units/binary_units.py

@@ -0,0 +1,13 @@
+B = 8
+KiB = 1024
+MiB = KiB * 1024
+GiB = MiB * 1024
+TiB = GiB * 1024
+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)

python_base_toolkit/consts/units/time_units.py

@@ -0,0 +1,11 @@
+Pico_Second = 0.000000000001
+Nano_Second = 0.000000001
+Micro_Second = 0.000001
+Milli_Second = 0.001
+Second = 1
+Minute = Second * 60
+Hour = Minute * 60
+Day = Hour * 24
+Week = Day * 7
+Month = Day * 30
+Year = Day * 365

python_base_toolkit/decorators/telemetry.py

@@ -0,0 +1,43 @@
+import json
+import time
+from functools import wraps
+import datetime
+from typing import Callable, Any
+
+from custom_python_logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def report_telemetry(
+    func: Callable[..., Any],
+    start_time: datetime.datetime,
+    end_time: datetime.datetime,
+    *args: Any,
+    **kwargs: Any
+) -> None:
+    data = {
+        "function_name": func.__name__,
+        "args": args,
+        "kwargs": kwargs,
+        "start_time": start_time.isoformat(),
+        "end_time": end_time.isoformat(),
+        "timestamp": time.time(),
+    }
+    logger.info(
+        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]:
+    @wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        # logger.info(f"Calling function: {func.__name__}, with arguments: {args} and keyword arguments: {kwargs}")
+        # return func(*args, **kwargs)
+        logger.info(f"calling {report_telemetry.__name__} to report the telemetry of {func.__name__}")
+        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)
+        return result
+
+    return wrapper

python_base_toolkit/decorators/timer.py

@@ -0,0 +1,28 @@
+import time
+from functools import wraps
+from typing import Callable, Any
+
+from custom_python_logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class Timer:
+    def __enter__(self):
+        self.start_time = time.perf_counter()
+        logger.info("Timer started.")
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        # logger.info(exc_type, exc_value, exc_traceback)
+        self.end_time = time.perf_counter()
+        self.elapsed_time = self.end_time - self.start_time
+        logger.info(f"Timer stopped. Elapsed time: {self.elapsed_time:.2f} seconds.")
+
+
+def timer(func: Callable[..., Any]) -> Callable[..., Any]:
+    @wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        with Timer():
+            return func(*args, **kwargs)
+    return wrapper

python_base_toolkit/instances/instance_manager.py

@@ -0,0 +1,69 @@
+from custom_python_logger.logger import get_logger
+
+class InstanceManager:
+    def __init__(self):
+        self.logger = get_logger(__class__.__name__)
+        self._instances = []
+
+    def add(self, instance):
+        self._instances.append(instance)
+
+    def close_all(self):
+        for instance in reversed(self._instances):
+            _instance_name = instance.__class__.__name__
+            try:
+                if hasattr(instance, 'close'):
+                    instance.close()
+                else:  # hasattr(instance, '__exit__'):
+                    instance.__exit__(None, None, None)
+                self.logger.info(f"Instance: {_instance_name} closed successfully.")
+            except Exception as e:
+                self.logger.info(f"Failed to close instance {instance}: {e}")
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close_all()
+
+
+def main():
+    class SomeInstance:
+        def __init__(self, add_to_instance_manager: bool = False):
+            self.logger = get_logger(__class__.__name__)
+
+            if add_to_instance_manager:
+                instance_manager.add(self)
+
+        @property
+        def __class_name__(self):
+            return self.__class__.__name__
+
+        def __enter__(self):
+            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__}")
+            # Handle any cleanup here
+            if exc_type:
+                self.logger.info(f"Exception: {exc_value}")
+            return True
+
+    SomeInstance(add_to_instance_manager=True)
+
+    resource1 = open('file1.txt', 'w')
+    resource2 = open('file2.txt', 'w')
+
+    instance_manager.add(resource1)
+    instance_manager.add(resource2)
+
+    # do stuff...
+
+    instance_manager.close_all()  # or, if inside `with manager:`, it will happen automatically
+
+
+if __name__ == "__main__":
+    instance_manager = InstanceManager()
+
+    main()

python_base_toolkit/utils/data_serialization.py

@@ -0,0 +1,41 @@
+import json
+from dataclasses import is_dataclass
+from datetime import datetime, date, time
+from decimal import Decimal
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+from custom_python_logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def default_serialize(obj: object) -> object:
+    if isinstance(obj, type):
+        return obj.__name__
+    if is_dataclass(obj) and not isinstance(obj, type):
+        return obj.__dict__
+    if isinstance(obj, Enum):
+        return obj.value
+    if isinstance(obj, set):
+        return list(obj)
+    if isinstance(obj, tuple):
+        return list(obj)
+    if isinstance(obj, (datetime, date, time)):
+        return obj.isoformat()
+    if isinstance(obj, Decimal):
+        return float(obj)
+    if isinstance(obj, Path):
+        return str(obj)
+    if obj is pd.NA:
+        return None
+    logger.error(f'Object is not serializable: {obj}')
+    raise TypeError(f"Type {type(obj)} not serializable")
+
+
+def to_json_serializable(obj: Any) -> Any:
+    """Convert an object to a JSON-serializable structure."""
+    serialized_json = json.dumps(obj, default=default_serialize)
+    return json.loads(serialized_json)

python_base_toolkit/utils/date_time.py

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

python_base_toolkit/utils/execute.py

@@ -0,0 +1,62 @@
+from collections.abc import Callable
+from time import sleep, time
+from typing import Any
+
+from tqdm import tqdm
+
+
+def _timed_execution(
+    func: Callable[[], Any],
+    timeout: int = 60,
+    interval: int = 1,
+    expect_true: bool = True,
+    pb_description: str = "Executing",
+    return_result: bool = False,
+) -> Any | bool | None:
+    pbar = tqdm(total=timeout, desc=pb_description, unit="s", ncols=100)
+    start_time = time()
+
+    while time() - start_time < timeout:
+        res = func()
+        if (expect_true and res) or (not expect_true and not res):
+            pbar.close()
+            return res if return_result else True
+        pbar.update(interval)
+        sleep(interval)
+
+    pbar.close()
+    return None if return_result else False
+
+
+def timed_execution_bool(
+    func: Callable[[], Any],
+    timeout: int = 60,
+    interval: int = 1,
+    expect_true: bool = True,
+    pb_description: str = "Executing",
+) -> bool:
+    return _timed_execution(
+        func=func,
+        timeout=timeout,
+        interval=interval,
+        expect_true=expect_true,
+        pb_description=pb_description,
+        return_result=False,
+    )
+
+
+def timed_execution_result(
+    func: Callable[[], Any],
+    timeout: int = 60,
+    interval: int = 1,
+    expect_true: bool = True,
+    pb_description: str = "Executing",
+) -> Any:
+    return _timed_execution(
+        func=func,
+        timeout=timeout,
+        interval=interval,
+        expect_true=expect_true,
+        pb_description=pb_description,
+        return_result=True,
+    )

python_base_toolkit/utils/file_utils.py

@@ -0,0 +1,256 @@
+import gzip
+import os
+import hashlib
+import shutil
+import json
+import csv
+import yaml
+import re
+from typing import Optional, Union, BinaryIO, TextIO, cast, Any
+import tarfile
+import zipfile
+
+from custom_python_logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class FilePath:
+    @staticmethod
+    def ensure_dir(directory: str) -> str:
+        if not os.path.exists(directory):
+            os.makedirs(directory)
+        return directory
+
+    @staticmethod
+    def file_exists(path: str) -> bool:
+        return os.path.isfile(path)
+
+    @staticmethod
+    def get_file_extension(path: str) -> str:
+        return os.path.splitext(path)[1][1:]
+
+    @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]
+
+    @staticmethod
+    def get_relative_path(path: str, base_path: str) -> str:
+        return os.path.relpath(path, base_path)
+
+    @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
+
+
+class FileIO:
+    @staticmethod
+    def safe_open(
+        filename: str,
+        mode: str = 'r',
+        encoding: Optional[str] = None,
+        **kwargs
+    ) -> Union[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))
+
+    @staticmethod
+    def read_text(filename: str, encoding: str = 'utf-8') -> str:
+        with open(filename, 'r', 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:
+            f.write(text)
+
+    def read_json(self, filename: str) -> dict[str, Any]:
+        with self.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:
+            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:
+            return yaml.safe_load(f)
+
+    @staticmethod
+    def write_yaml(data: Any, filename: str, **kwargs) -> 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:
+            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:
+        if not data:
+            return
+
+        if fieldnames is None:
+            fieldnames = list(data[0].keys())
+
+        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:
+            chunk = f.read(chunk_size)
+        return b'\0' in chunk
+
+    @staticmethod
+    def is_file_empty(path: str) -> bool:
+        return os.path.getsize(path) == 0
+
+
+class FfileManipulation:
+    @staticmethod
+    def remove_emojis(text: str) -> str:
+        return re.sub(r'[\U00010000-\U0010ffff]', '', text).strip()
+
+
+class FileSystem:
+    @staticmethod
+    def copy_file(src: str, dst: str) -> None:
+        shutil.copy2(src, dst)
+
+    @staticmethod
+    def move_file(src: str, dst: str) -> None:
+        shutil.move(src, dst)
+
+    @staticmethod
+    def delete_file(path: str) -> None:
+        if os.path.isfile(path):
+            os.remove(path)
+
+    @staticmethod
+    def file_size(path: str) -> int:
+        return os.path.getsize(path)
+
+
+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()
+
+    @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()
+
+    @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 FileCompression:
+    @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}")
+
+    @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}")
+
+    @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
+
+    @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)
+
+        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

python_base_toolkit/utils/logo.py

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

python_base_toolkit/utils/network.py

@@ -0,0 +1,102 @@
+import ipaddress
+import re
+from typing import Optional
+
+
+def get_ip_version(ip: str) -> Optional[int]:
+    """
+    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)
+    """
+    try:
+        _ip = ipaddress.ip_address(ip)
+        return _ip.version
+    except ValueError:
+        return None
+
+
+def normalize_connection_string(ip: str, port: Optional[int] = None) -> str:
+    """
+    Returns a normalized connection string (IPv4:port or [IPv6]:port)
+    :param ip: IP address (String)
+    :param port: Port (Integer or None) - Optional for cases where the port is not needed (E.G. for SCP)
+
+    Output:
+    w/ Port - IPv4:port or [IPv6]:port
+    w/o Port - IPv4: or [IPv6]:
+    """
+    _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}')
+
+
+def normalize_http_url(ip: str, port: Optional[int] = 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)}'
+
+
+def parse_ifconfig_to_json(ifconfig_output: str) -> dict:
+    """
+    Output Example:
+    {
+        'interface_name': {
+            'mac_address': <String>,
+            'ipv4_address': <String>,
+            'ipv4_netmask': <String>,
+            'ipv6_address': <String>
+            'ipv6_prefixlen': <String>
+        }
+    }
+    """
+    interfaces = {}
+    current_interface = None
+
+    for line in ifconfig_output.splitlines():
+        match_interface = re.match(r'^(\S+):\s', line)
+        if match_interface:
+            current_interface = match_interface.group(1)
+            interfaces[current_interface] = {}
+
+        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)
+
+        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)
+
+        # Try different netmask patterns
+        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'):
+                # Handle hex format
+                netmask_int = int(netmask, 16)
+            else:
+                # Handle decimal format (255.255.255.0)
+                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')
+
+        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)
+
+        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)
+
+    return interfaces

python_base_toolkit/utils/path_utils.py

@@ -0,0 +1,23 @@
+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}'):
+            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__)}',
+    )
+
+
+def get_project_path_by_file(markers: set = None) -> Path:
+    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:
+            if (parent / marker).exists():
+                return parent
+    raise RuntimeError(f'Project root with markers "{markers}" not found.')

python_base_toolkit/utils/pretty_print.py

@@ -0,0 +1,22 @@
+import json
+import logging
+from typing import Any, Callable
+
+from custom_python_logger import get_logger
+
+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
+) -> None:
+    formatted_data = json.dumps(data, indent=indent, sort_keys=sort_keys, default=default)
+
+    level_name = logging.getLevelName(log_level).lower()
+    log_method = getattr(logger, level_name, logger.debug)
+
+    log_method("\n%s", formatted_data)

python_base_toolkit/utils/pycache.py

@@ -0,0 +1,27 @@
+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__)
+
+
+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'}
+
+    for path in root_dir.rglob('__pycache__'):
+        if any(ignored in path.parts for ignored in ignored_dirs):
+            continue
+
+        logger.info(f"Cleaning: {path}")
+        try:
+            shutil.rmtree(path)
+            logger.info(f"Deleted: {path}")
+        except FileNotFoundError:
+            logger.exception(f"Already removed: {path}")
+        except Exception as e:
+            logger.exception(f"Failed to delete {path}: {e}")
+    logger.info("Finished cleaning __pycache__ folders.")

python_base_toolkit/utils/random_utils.py

@@ -0,0 +1,67 @@
+import random
+from random import choice
+from string import ascii_letters, ascii_lowercase, ascii_uppercase, digits
+
+
+def generate_random_string(length: int = 8, charset: str = ascii_letters + digits) -> str:
+    """
+    Generate a random string of a given length using a specified character set
+    :param length: The length of the string to generate
+    :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))
+
+
+def generate_random_password(length: int = 8) -> str:
+    """
+    Generate a random password with a given length
+    """
+    special_characters = "!@#%^*"
+    # Ensure the password starts with a letter
+    password = choice(ascii_uppercase)
+    # Ensure the password contains at least one digit or special character and one lowercase letter
+    password += choice(digits + special_characters)
+    password += choice(ascii_lowercase)
+
+    # Fill the remaining characters with a mix of all types
+    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))
+
+
+def generate_random_ipv4() -> str:
+    # Generate the first octet (1-223 to avoid multicast and reserved ranges)
+    first_octet = random.randint(1, 223)
+    remaining_octets = [str(random.randint(0, 255)) for _ in range(3)]
+    return f"{first_octet}.{'.'.join(remaining_octets)}"
+
+
+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)
+
+
+def generate_random_ip(ip_version: int) -> str:
+    """
+    Generate a random IP address based on the specified version
+    If the cluster IP type matters, please use this function as follows:
+    generate_random_ip(ip_version=client.cluster.get_ip_version()) to get the IP version based on the cluster
+    """
+    if ip_version == 4:
+        return generate_random_ipv4()
+    if ip_version == 6:
+        return generate_random_ipv6()
+    raise ValueError(f"Unsupported IP version: {ip_version}. Supported versions are 4 and 6.")
+
+
+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))

python_base_toolkit/utils/shorten_url.py

@@ -0,0 +1,13 @@
+import urllib.parse
+
+import requests
+
+BASE_TINY_URL = "https://tinyurl.com/api-create.php"
+
+
+def shorten_url(url: str) -> str:
+    encoded_url = urllib.parse.urlencode({"url": url})
+    full_url = f"{BASE_TINY_URL}?{encoded_url}"
+    res = requests.get(full_url, timeout=5)
+    res.raise_for_status()  # Raises HTTPError for non-200 codes
+    return res.text

python_base_toolkit/utils/venv_details.py

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

python_base_toolkit-0.0.1.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: python-base-toolkit
+Version: 0.0.1
+Summary: A Python package for managing pytest plugins.
+Home-page: https://github.com/aviz92/python-base-toolkit
+Author: Avi Zaguri
+Author-email: 
+Project-URL: Repository, https://github.com/aviz92/python-base-toolkit
+Classifier: Framework :: Pytest
+Classifier: Programming Language :: Python
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: setuptools
+Requires-Dist: wheel
+Requires-Dist: colorlog
+Requires-Dist: pathlib
+Requires-Dist: requests
+Requires-Dist: PyYAML
+Requires-Dist: tqdm
+Requires-Dist: pyfiglet
+Requires-Dist: pandas
+Requires-Dist: custom-python-logger
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Python Toolkit
+A powerful, production-ready Python toolkit designed to accelerate development by providing essential utilities and common functionality across multiple domains. <br>
+Built with type safety, comprehensive error handling, and modern Python practices, this toolkit streamlines everyday development tasks including file operations, network utilities, data manipulation, performance monitoring, resource management, and more.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install python-toolkit
+```
+
+---
+
+## 🚀 Features
+- Constants Pack 
+  - binary 
+  - time
+
+- Decorators Pack
+  - telemetry
+  - timer
+
+- Instances Pack 
+  - instance_manager
+
+- Utilities Pack
+  - data_serialization
+  - date_time
+  - execute
+  - file_utils
+  - logo
+  - network
+  - path_utils
+  - pretty_print
+  - pycache
+  - random_utils
+  - shorten_url
+  - venv_details
+
+---
+
+## 🤝 Contributing
+If you have a helpful tool, pattern, or improvement to suggest:
+Fork the repo <br>
+Create a new branch <br>
+Submit a pull request <br>
+I welcome additions that promote clean, productive, and maintainable development. <br>
+
+---
+
+## 📄 License
+MIT License — see [LICENSE](LICENSE) for details.
+
+---
+
+## 🙏 Thanks
+Thanks for exploring this repository! <br>
+Happy coding! <br>

python_base_toolkit-0.0.1.dist-info/RECORD

@@ -0,0 +1,28 @@
+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,,

python_base_toolkit-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

python_base_toolkit-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Avi Zaguri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

python_base_toolkit-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+python_base_toolkit