inspy-logger 3.0.dev5__tar.gz → 3.0.2.dev1__tar.gz

{inspy_logger-3.0.dev5 → inspy_logger-3.0.2.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: inspy-logger
-Version: 3.0.dev5
+Version: 3.0.2.dev1
 Summary: Colorable, scalable logger for CLI
 Home-page: https://github.com/Inspyre-Softworks/inSPy-Logger
 License: MIT

inspy_logger-3.0.2.dev1/inspy_logger/Scripts/main.py

@@ -0,0 +1,105 @@
+"""
+
+File: 
+    inspy_logger/Scripts/main.py
+
+Author: 
+    Inspyre Softworks
+    
+"""
+INSPY_LOG_LEVEL = 'info'
+
+from argparse import ArgumentParser
+from inspy_logger.helpers.debug.environment import fetch_system_info
+from inspy_logger.version import parse_version, get_full_version_name, PyPiVersionInfo
+from rich import print
+from rich.table import Table
+import sys
+
+# ---- SET UP PARSER --------------------------------
+
+parser = ArgumentParser('inspy-logger-version', description='Displays version information for inspy-logger.')
+
+parser.add_argument('-v', '--version', action='version', version=parse_version())
+
+# ---- SET UP SUBPARSERS --------------------------------
+
+subparsers = parser.add_subparsers(title='subcommands', dest='subcommand')
+
+# ---- UPDATE COMMAND --------------------------------
+
+update_parser =subparsers.add_parser('update', help='Checks for updates to inspy-logger.')
+
+update_parser.add_argument('-p', '--pre-release', action='store_true', help='When checking for updates, include pre-release versions.')
+
+# ---- DEBUG COMMAND --------------------------------
+
+debug_parser = subparsers.add_parser('debug', help='Fetches a collection of  environment information to help debug inspy-logger.')
+
+debug_parser.add_argument('-C', '--copy-to-clipboard', action='store_true', help='Copies the debug information to the clipboard.')
+debug_parser.add_argument('-P', '--print', action='store_true', help='Prints the debug information to the console.', default=True)
+
+# ---- FORMAT FLAGS --------------------------------
+
+fmt_grp = debug_parser.add_mutually_exclusive_group()
+
+fmt_grp.add_argument('-M', '--markdown', action='store_true', help='Formats the debug information in Markdown.')
+
+fmt_grp.add_argument('-J', '--json', action='store_true', help='Formats the debug information in JSON.')
+
+fmt_grp.add_argument('-T', '--text', action='store_true', help='Formats the debug information in plain text.')
+
+# Parse the arguments
+parsed_args = parser.parse_args()
+
+# END PARSER SETUP
+
+if parsed_args.subcommand == 'update':
+    INCLUDE_PRE_RELEASE_FOR_UPDATE_CHECK = parsed_args.pre_release
+else:
+    INCLUDE_PRE_RELEASE_FOR_UPDATE_CHECK = False
+
+
+
+
+
+def main():
+
+    version = PyPiVersionInfo()
+
+    ACTIONS = {
+        'default': version.print_version_info,
+        'update': version.update,
+        'debug': fetch_system_info,
+
+    }
+
+    if parsed_args.subcommand is None:
+        parsed_args.subcommand = 'default'
+
+    if parsed_args.subcommand == 'debug':
+
+        if (
+            parsed_args.markdown
+            or not parsed_args.json
+            and not parsed_args.text
+        ):
+            fmt = 'markdown'
+        elif parsed_args.json:
+            fmt = 'json'
+        else:
+            fmt = 'text'
+
+        fetch_system_info(copy_to_clipboard=parsed_args.copy_to_clipboard, format_type=fmt, print_to_console=parsed_args.print)
+
+
+
+    if parsed_args.subcommand in ACTIONS:
+        ACTIONS[parsed_args.subcommand]()
+
+
+
+    return parsed_args
+
+if __name__ == '__main__':
+    main()

{inspy_logger-3.0.dev5 → inspy_logger-3.0.2.dev1}/inspy_logger/__about__.py

@@ -19,16 +19,3 @@ __authors__ = [
         ('Inspyre-Softworks', 'https://inspyre.tech'),
         ('Taylor-Jayde Blackstone', '<t.blackstone@inspyre.tech')
 ]
-
-'''
-File Change History:
-11/5/22 - 4:21 AM (v2.1.2):
-  -  Added description to docstring. (target: 2.1.2)
- 
-11/5/22 - 4:41 AM:
-  - Version bump (target: 2.1.3)
-  
-08/16/2023 - 13:49 (v3.0):
-  - Version bump (v2.1.3 -> v3.0-dev.1)
-
-'''

{inspy_logger-3.0.dev5 → inspy_logger-3.0.2.dev1}/inspy_logger/__init__.py

@@ -251,10 +251,12 @@ class Logger:
             """
             self._log(logging.INFO, message, args=(), stacklevel=2)
 
+
     def warning(self, message):
         """
         Logs a warning message.
 
+
         Args:
             message (str): The message to log.
         """
@@ -264,6 +266,7 @@ class Logger:
         """
         Logs an error message.
 
+
         Args:
             message (str): The message to log.
         """
@@ -284,6 +287,7 @@ class Logger:
 
         return f'<Logger: {name} w/ level {self.logger.level} at {hex_id}{parent_part}>'
 
+
     @classmethod
     def create_logger_for_caller(cls):
         """

{inspy_logger-3.0.dev5 → inspy_logger-3.0.2.dev1}/inspy_logger/helpers/base_classes.py

@@ -61,6 +61,16 @@ class Loggable:
     class_logger = None
 
     def __init__(self, parent_log_device=None, **kwargs):
+        """
+        Initializes an instance of the class.
+
+        Args:
+            parent_log_device (optional): The parent log device. Defaults to None.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            None
+        """
         self.parent_log_device = parent_log_device
         self.__log_name = self.__class__.__name__
         if self.parent_log_device is not None:

inspy_logger-3.0.2.dev1/inspy_logger/helpers/debug/environment.py

@@ -0,0 +1,179 @@
+import argparse
+import json
+import platform
+import sys
+import pyperclip
+from pyperclip import copy
+
+from inspy_logger.version import parse_version
+
+VALID_DATA_FORMATS = [
+    'markdown',
+    'json',
+    'text'
+]
+
+
+def determine_execution_mode():
+    """
+    Determines the execution mode of the program.
+
+    Returns:
+        str:
+            Either 'Script' or 'REPL' depending on the execution mode.
+    """
+    return "REPL" if len(sys.argv) == 1 else "Script"
+
+
+def get_operating_system_info():
+    """
+    Gets the operating system information.
+
+    Returns:
+        dict:
+            A dictionary containing the operating system information.
+    """
+
+    os_name = platform.system()
+
+    if os_name.lower() == 'windows':
+        from inspy_logger.helpers.debug.system.winx import get_win_version_info
+
+        return get_win_version_info()
+
+    return {
+        'name': platform.system(),
+        'version': platform.release()
+    }
+
+
+
+def is_valid_data_format(data_format):
+    """
+    Checks if the specified data format is valid.
+
+    This function is case-insensitive and compares the specified data format against the `VALID_DATA_FORMATS` list.
+
+
+    Note:
+        Valid formats are as follows:
+            - markdown
+            - json
+            - text
+
+    Parameters:
+        data_format (str):
+            The format you'd like the data to be returned in.
+
+    Returns:
+        bool:
+            Whether the specified data format is valid.
+
+    """
+    return data_format.lower() in VALID_DATA_FORMATS
+
+
+def get_system_info(format_type='markdown'):
+    """
+    Gathers system information and formats it based on the specified format type.
+
+    Parameters:
+        format_type (str):
+            The format type for the output. Options are 'markdown', 'json', 'text'.
+            Default is 'markdown'.
+
+            Note:
+                Valid formats are 'markdown', 'json', and 'text'.
+
+    Returns:
+        str:
+            A string containing the system information in the specified format.
+    """
+
+    if not is_valid_data_format(format_type):
+        raise ValueError(f"Invalid format type: {format_type}. Must be one of {VALID_DATA_FORMATS}")
+
+    # Gather system information
+    os_name = platform.system()
+    os_version = platform.release()
+
+    os_version_full = platform.version()
+
+    if os_name.lower() == 'windows' and os_version == '10':
+        from inspy_logger.helpers.debug.system.winx import is_win_11
+
+        if is_win_11(os_version_full):
+            os_version = '11'
+
+    os_version = f'{os_version} ({os_version_full})'
+
+
+
+    python_version = platform.python_version()
+
+
+
+    sys_info = {
+        'os_name': platform.system(),
+        'os_version': platform.release(),
+        'python_version': platform.python_version(),
+        'isl_version': parse_version(),
+        'execution_mode': "REPL" if len(sys.argv) == 1 else "Script"
+    }
+
+    # Format the information
+    if format_type == 'markdown':
+        return f"""
+💻 **System Info:**
+ - 💾 **Operating System**:
+     - [x] {os_name} {os_version}
+ - 🐍 **Python Version**: {python_version}
+ - 🌈 **InSPy-Logger Version**: {sys_info['isl_version']}
+ - - [{sys_info['execution_mode'] == 'Script'}] Script
+   - [{sys_info['execution_mode'] == 'REPL'}] REPL
+        """.strip()
+    elif format_type == 'json':
+        return json.dumps({
+            "System Info": {
+                "Operating System": f"{os_name} {os_version}",
+                "Python Version": python_version,
+                "InSPy-Logger Version": sys_info['isl_version'],
+                "Execution Mode": sys_info['execution_mode']
+            }
+        }, indent=4)
+    else:  # plain text
+        return f"""
+System Info:
+Operating System: {os_name} {os_version}
+Python Version: {python_version}
+InSPy-Logger Version: {sys_info['isl_version']}
+Execution Mode: {sys_info['execution_mode']}
+        """.strip()
+
+
+def fetch_system_info(copy_to_clipboard=False, format_type='markdown', print_to_console=None):
+    """
+    Fetches system information and formats it based on the specified format type.
+
+    Parameters:
+        copy_to_clipboard (bool):
+            Whether to copy the output to the clipboard. Default is False.
+
+        format_type (str):
+            The format type for the output. Options are 'markdown',
+            'json', 'text'. Default is 'markdown'.
+
+        print_to_console (bool):
+               Whether to print the output to the console. Default is None.
+
+               Note:
+                   If this is None, it will default to True.
+
+    Returns:
+        str:
+            A string containing the system information in the specified format.
+    """
+    info = get_system_info(format_type)
+    if copy_to_clipboard:
+        copy(info)
+    return info

inspy_logger-3.0.2.dev1/inspy_logger/helpers/debug/system/processor/__init__.py

@@ -0,0 +1,64 @@
+import platform
+import multiprocessing
+import psutil
+
+
+# Function to check if the system architecture is 64-bit
+def is_64bit():
+    """
+    Checks if the system architecture is 64-bit.
+
+    Returns:
+        bool: True if the system architecture is 64-bit, False otherwise.
+    """
+    return platform.architecture()[0] == '64bit'
+
+
+# Function to get the number of cores
+def number_of_cores():
+    """
+    Gets the number of cores in the system.
+
+    Returns:
+        int: The number of cores in the system.
+    """
+    return multiprocessing.cpu_count()
+
+
+# Function to get the processor core information
+def get_processor_core_info():
+    """
+    Gets the processor core information.
+
+    Returns:
+        dict: A dictionary containing the total number of cores, the number of physical cores, and the number of logical cores.
+    """
+    phys = psutil.cpu_count(logical=False)
+    total = number_of_cores()
+
+    return {
+        'total': total,
+        'physical': phys,
+        'logical': total - phys
+    }
+
+
+# Function to get the processor information
+def _get_processor_info():
+    """
+    Gets the processor information.
+
+    Returns:
+        dict: A dictionary containing the name of the processor, the architecture of the processor, and the core information of the processor.
+    """
+    cores = get_processor_core_info()
+
+    return {
+        'name': platform.processor(),
+        'architecture': '64-bit' if is_64bit() else '32-bit',
+        'cores': get_processor_core_info()
+    }
+
+
+# A dictionary containing the processor information
+PROCESSOR_INFO = _get_processor_info()

inspy_logger-3.0.2.dev1/inspy_logger/helpers/debug/system/winx/__init__.py

@@ -0,0 +1,25 @@
+from packaging import version
+import platform
+
+WIN_11_VERSION = version.parse('10.0.2200')
+
+
+def is_win_11(os_version):
+    return version.parse(os_version) >= WIN_11_VERSION
+
+def is_64bit():
+    return platform.architecture()[0] == '64bit'
+
+def get_win_version():
+    release, build_num, service_pack, _ = platform.win32_ver()
+
+    if release == '10' and is_win_11(build_num):
+        release = '11'
+
+    ver = {
+        'release': f'Windows {release}',
+        'build': build_num,
+        'service_pack': service_pack.replace('SP', ''),
+
+
+    }

{inspy_logger-3.0.dev5 → inspy_logger-3.0.2.dev1}/inspy_logger/helpers/network.py

@@ -27,8 +27,7 @@ from __future__ import annotations
 from urllib.parse import quote as url_safe
 
 import requests
-
-from inspy_logger.helpers.cache import TLDCache
+from public_suffix_list import PublicSuffixList
 
 DEFAULT_TEST_HOSTS = [
         ['https', 'inspyre', 'tech'],
@@ -44,10 +43,11 @@ hosts = []
 :obj:`list`[:obj:`Host`]:
     A list of host objects that will be used to connect to.
 """
+psl = PublicSuffixList()
 
-TLD_CACHE = TLDCache()
+URL_SUFFIXES = psl._suffixes
 
-VALID_TLDS = TLD_CACHE.TLDs
+VALID_TLDS = URL_SUFFIXES
 
 
 class Host():
@@ -169,7 +169,7 @@ class Host():
         def tld(self, new):
             if not isinstance(new, str):
                 raise TypeError(f"New value must be a string not {type(new)}")
-            if new not in TLD_CACHE.TLDs:
+            if new not in URL_SUFFIXES:
                 raise ValueError("TLD must be valid!")
 
             self.__tld = new

inspy_logger-3.0.2.dev1/inspy_logger/helpers/units.py

@@ -0,0 +1,57 @@
+class ByteConverter:
+    """
+    A class to convert between various units of digital storage.
+
+    Supported units: Bytes, Kilobytes, Megabytes, Gigabytes, Terabytes, Petabytes, Exabytes, Zettabytes, Yottabytes,
+                     Kibibytes, Mebibytes, Gibibytes, Tebibytes, Pebibytes, Exbibytes, Zebibytes, Yobibytes.
+
+    Methods:
+        convert(value, from_unit, to_unit): Converts the given value from one unit to another.
+    """
+
+    # Dictionary to store conversion rates relative to bytes
+    _conversion_rates = {
+        'bytes': 1,
+        'kilobytes':  1000,
+        'megabytes':  1000 ** 2,
+        'gigabytes':  1000 ** 3,
+        'terabytes':  1000 ** 4,
+        'petabytes':  1000 ** 5,
+        'exabytes':   1000 ** 6,
+        'zettabytes': 1000 ** 7,
+        'yottabytes': 1000 ** 8,
+        'kibibytes':  1024,
+        'mebibytes':  1024 ** 2,
+        'gibibytes':  1024 ** 3,
+        'tebibytes':  1024 ** 4,
+        'pebibytes':  1024 ** 5,
+        'exbibytes':  1024 ** 6,
+        'zebibytes':  1024 ** 7,
+        'yobibytes':  1024 ** 8
+    }
+
+    @classmethod
+    def convert(cls, value: float, from_unit: str, to_unit: str) -> float:
+        """
+        Converts the given value from one unit to another.
+
+        Args:
+            value (float): The value to convert.
+            from_unit (str): The unit to convert from. Must be one of the supported units.
+            to_unit (str): The unit to convert to. Must be one of the supported units.
+
+        Returns:
+            float: The converted value in the target unit.
+
+        Raises:
+            ValueError: If an unsupported unit is specified.
+        """
+        from_unit = from_unit.lower()
+        to_unit = to_unit.lower()
+
+        if from_unit not in cls._conversion_rates or to_unit not in cls._conversion_rates:
+            raise ValueError("Unsupported unit. Supported units are: " + ', '.join(cls._conversion_rates.keys()))
+
+        # Convert the value to bytes first, then to the target unit
+        value_in_bytes = value * cls._conversion_rates[from_unit]
+        return value_in_bytes / cls._conversion_rates[to_unit]

inspy_logger-3.0.2.dev1/inspy_logger/version.py

@@ -0,0 +1,240 @@
+import requests
+from packaging import version as pkg_version
+import sys
+from rich.table import Table
+from rich import print
+
+# Constants
+RELEASE_MAP = {
+    'dev': 'Development Build',
+    'alpha': 'Alpha Build',
+    'beta': 'Beta Build',
+    'rc': 'Release Candidate Build',
+    'final': 'Final Release Build'
+}
+
+__VERSION__ = {
+    'major': 3,
+    'minor': 0,
+    'patch': 2,
+    'release': 'dev',
+    'release_num': 1
+}
+
+
+def parse_version():
+    """
+    Parses the version information into a string.
+
+    Returns:
+        str: The version information.
+
+    Since:
+        v1.0
+    """
+    version = f'{__VERSION__["major"]}.{__VERSION__["minor"]}.{__VERSION__["patch"]}'
+
+    if __VERSION__['release'] != 'final':
+        version += f'-{__VERSION__["release"]}.{__VERSION__["release_num"]}'
+
+    return version
+
+
+def get_full_version_name():
+    """
+    Gets the full version name.
+
+    Returns:
+        str: The full version name.
+
+    Since:
+        v1.0
+    """
+    ver = parse_version()
+    ver = ver.split('-')[0]
+
+    release_type = RELEASE_MAP[__VERSION__["release"]]
+    release_num = __VERSION__["release_num"]
+    release_str = f" {release_type} {'' if __VERSION__['release'].lower() == 'final' else f'({release_num})'}"
+    return f'v{ver}{release_str}'
+
+
+class PyPiVersionInfo:
+    """
+    A class to represent the version information for this package from PyPi.
+
+    Attributes:
+        latest_stable (packaging.version.Version):
+            The latest stable version of the package on PyPi.
+
+        latest_pre_release (packaging.version.Version):
+            The latest pre-release version of the package.
+    Since:
+        v3.0
+    """
+    __url = 'https://pypi.org/pypi/inspy-logger/json'
+    __installed = parse_version()
+    __checked_for_update = False
+    __newer_available_version = None
+
+    def __init__(self, include_pre_release_for_update_check=False):
+        self.__latest_stable = None
+        self.__latest_pre_release = None
+        self.__all_versions = None
+        self.include_pre_release_for_update_check = include_pre_release_for_update_check
+        self.__query_versions()
+
+    @property
+    def all_versions(self):
+        if self.__all_versions is None:
+            self.__query_versions()
+        return sorted([pkg_version.parse(v) for v in self.__all_versions])
+
+    @property
+    def checked_for_update(self):
+        return self.__checked_for_update
+
+    @property
+    def installed(self):
+        """
+        Gets the installed version of the package.
+        """
+        return pkg_version.parse(self.__installed)
+
+    @property
+    def installed_newer_than_latest(self):
+        return self.installed > self.latest
+
+    @property
+    def latest(self):
+        return (
+            self.all_versions[-1]
+            if self.include_pre_release_for_update_check
+            else self.latest_stable
+        )
+
+    @property
+    def latest_stable(self):
+        """
+        Gets the latest stable version of the package on PyPi.
+        """
+        if self.__latest_stable is None:
+            self.__query_versions()
+        return pkg_version.parse(self.__latest_stable)
+
+    @property
+    def latest_pre_release(self):
+        """
+        Gets the latest pre-release version of the package.
+        """
+        if self.__all_versions is None:
+            self.__query_versions()
+        pre_release_versions = [v for v in self.all_versions if v.is_prerelease]
+        return pre_release_versions[-1] if pre_release_versions else None
+
+    @property
+    def newer_available_version(self):
+
+        if self.__newer_available_version is None:
+            self.check_for_update()
+
+        return self.__newer_available_version
+
+    def __query_versions(self):
+        """
+        Queries the versions from PyPi.
+        """
+        try:
+            response = requests.get(self.__url)
+            response.raise_for_status()
+            data = response.json()
+
+            self.__all_versions = list(data['releases'].keys())
+            self.__latest_stable = data['info']['version']
+        except requests.RequestException as e:
+            # Handle connection errors, HTTP errors, etc.
+            print(f"Error querying PyPi: {e}")
+
+    @property
+    def update_available(self):
+        """
+        Checks if an update is available.
+        """
+        if self.__newer_available_version is None:
+            self.check_for_update()
+        return self.__newer_available_version is not None
+
+    def check_for_update(self, include_pre_releases=False):
+        latest_version = self.latest_stable
+
+        if include_pre_releases or self.include_pre_release_for_update_check:
+            latest_version = max(latest_version, self.latest_pre_release)
+
+        if latest_version > self.installed:
+            self.__newer_available_version = latest_version
+
+        self.__checked_for_update = True
+
+        return latest_version > self.installed
+
+    def update(self):
+        """
+        Checks for updates to inspy-logger.
+
+        Returns:
+            None`
+
+        Since:
+            v3.0
+        """
+
+        local_newer_statement = 'Local version is newer than latest version. This is likely a development build.'
+
+        if not self.installed_newer_than_latest:
+            local_newer_statement = ''
+
+        try:
+            if self.update_available:
+                print(f'\n\n[bold green]Update Available![/bold green] New version: '
+                      f'[bold cyan]{self.update_available}[/bold cyan]')
+            else:
+                print(f'\n\n[bold green]No update available.[/bold green] Current version: '
+                      f'[bold cyan]{parse_version()}[/bold cyan] {local_newer_statement}')
+
+        except Exception as e:
+            print(f'An error occurred during the update check: {str(e)}')
+
+    def print_version_info(self):
+        """
+        Print version information in a formatted table.
+
+        This function creates a table using the `Table` class and populates it with version information about the current Python environment. It then prints the table to the console.
+
+        Parameters:
+            self: The current instance of the class.
+
+        Returns:
+            None
+        """
+
+        # Create a table
+
+        table = Table(show_header=False, show_lines=True, expand=True, border_style='bright_blue',
+                      row_styles=['none', 'dim'])
+
+        # Add columns
+        table.add_column('Property', style='cyan', width=20)
+        table.add_column('Value', justify='center')
+
+        # Add rows
+        table.add_row('Version', parse_version(), )
+        table.add_row('Full Version Name', get_full_version_name())
+
+        if self.update_available:
+            table.add_row('Update Available', '[bold green]Yes[/bold green]')
+            table.add_row('Latest Version', f'{self.new_version_available_num}')
+
+        table.add_row('Python Executable Path', sys.executable)
+        table.add_row('Python Version', sys.version)
+
+        print(table)

{inspy_logger-3.0.dev5 → inspy_logger-3.0.2.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "inspy-logger"
-version = "3.0-dev.5"
+version = "3.0.2-dev.1"
 description = "Colorable, scalable logger for CLI"
 authors = ["Taylor-Jayde Blackstone <tayjaybabee@gmail.com>"]
 homepage = 'https://github.com/Inspyre-Softworks/inSPy-Logger'
@@ -62,6 +62,10 @@ sphinxcontrib-autoprogram = "^0.1.8"
 [tool.poetry.group.dev.dependencies]
 poetry-plugin-export = "^1.6.0"
 
+
+[tool.poetry.group.debug.dependencies]
+pyperclip = "^1.8.2"
+
 [build-system]
 requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"

inspy_logger-3.0.dev5/inspy_logger/Scripts/main.py

@@ -1,91 +0,0 @@
-"""
-
-File: 
-    inspy_logger/Scripts/main.py
-
-Author: 
-    Inspyre Softworks
-    
-"""
-INSPY_LOG_LEVEL = 'info'
-
-from inspy_logger.version import parse_version, get_full_version_name, PyPiVersionInfo
-import sys
-from rich import print
-from rich.table import Table
-from argparse import ArgumentParser
-
-
-parser = ArgumentParser('inspy-logger-version', description='Displays version information for inspy-logger.')
-
-parser.add_argument('-v', '--version', action='version', version=parse_version())
-
-subparsers = parser.add_subparsers(title='subcommands', dest='subcommand')
-
-update_parser =subparsers.add_parser('update', help='Checks for updates to inspy-logger.')
-
-update_parser.add_argument('-p', '--pre-release', action='store_true', help='When checking for updates, include pre-release versions.')
-
-parsed_args = parser.parse_args()
-
-
-if parsed_args.subcommand == 'update':
-    INCLUDE_PRE_RELEASE_FOR_UPDATE_CHECK = parsed_args.pre_release
-else:
-    INCLUDE_PRE_RELEASE_FOR_UPDATE_CHECK = False
-
-
-pypi_info = PyPiVersionInfo(include_pre_release_for_update_check=INCLUDE_PRE_RELEASE_FOR_UPDATE_CHECK)
-
-
-def update():
-    """
-    Checks for updates to inspy-logger.
-
-    Returns:
-        None
-
-    Since:
-        v3.0
-    """
-    try:
-        if pypi_info.update_available:
-            print(f'\n\n[bold green]Update Available![/bold green] New version: [bold cyan]{pypi_info.new_version_available}[/bold cyan]')
-        else:
-            print(f'\n\n[bold green]No update available.[/bold green] Current version: [bold cyan]{parse_version()}[/bold cyan] {"which is newer than the available version on PyPi.org" if pypi_info.installed_newer_than_latest else ""}')
-    except Exception as e:
-        print(f'An error occurred during the update check: {str(e)}')
-
-
-def get_version_info():
-    # Create a table
-    table = Table(show_header=False, show_lines=True, expand=True, border_style='bright_blue',
-                  row_styles=['none', 'dim'])
-
-    # Add columns
-    table.add_column('Property', style='cyan', width=20)
-    table.add_column('Value', justify='center')
-
-    # Add rows
-    table.add_row('Version', parse_version(), )
-    table.add_row('Full Version Name', get_full_version_name())
-
-    if pypi_info.update_available:
-        table.add_row('Update Available', '[bold green]Yes[/bold green]')
-        table.add_row('Latest Version', f'{pypi_info.new_version_available_num}')
-
-    table.add_row('Python Executable Path', sys.executable)
-    table.add_row('Python Version', sys.version)
-
-    print(table)
-
-
-
-def main():
-
-    return update() if parsed_args.subcommand == 'update' else get_version_info()
-
-
-
-if __name__ == '__main__':
-    main()

inspy_logger-3.0.dev5/inspy_logger/helpers/cache.py

@@ -1,140 +0,0 @@
-from __future__ import annotations
-
-from os import makedirs
-from pathlib import Path
-from pickle import dump as pkl_dump
-from pickle import load as pkl_load
-from time import time
-from appdirs import user_cache_dir
-from domain_suffixes.suffixes import Suffixes
-from humanize.time import precisedelta
-
-PICKLE_FILEPATH = Path(
-    user_cache_dir(
-        appname='InspyLogger',
-        appauthor='Inspyre-Softworks'
-    )
-).joinpath('tld.pkl')
-
-
-class TLDCache(object):
-
-    parent_dir = PICKLE_FILEPATH.parent
-
-    def __init__(self):
-        self.__created_ts = None
-        self.__pickle_fp_exists = None
-        self.__num_tlds = None
-        self.__tlds = None
-        self.__data = None
-        self.__last_renewal_ts = None
-        self.__renewal_hist = None
-
-    def build(self):
-        self.__data = {
-                'created_ts': time(),
-                'renewal_data': {
-                        'last_ts': None,
-                        'history': [],
-                },
-                'tlds': self.fetch_from_source()
-        }
-
-        return self.__data
-
-    @staticmethod
-    def load(self):
-        """ Load the pickle file for the cache.
-
-        Will attempt to load the pickle file into memory from the path indicated by :obj:`PICKLE_FILEPATH`
-
-        Raises:
-            :exception:`FileNotFoundError`: If the pickle file does not exist.
-
-        """
-        with open(PICKLE_FILEPATH, 'rb') as pfp:
-            res = pkl_load(pfp)
-
-        return res
-
-    def write(self):
-        """ Write the pickle file.
-
-        Write the contents of the cache to the file-system path indicated by :obj:`PICKLE_FILEPATH`
-
-        Raises:
-            :exception:`PermissionError`: If the pickle file can't be written due to permissions writing the file to storage.
-        """
-
-        if not self.parent_dir.exists():
-            makedirs(self.parent_dir, exist_ok=True)
-
-        with open(PICKLE_FILEPATH, 'wb') as pfp:
-            pkl_dump(self.__data, pfp)
-
-    @staticmethod
-    def fetch_from_source(self):
-        """ Fetch the top-level-domain list from the source
-
-        Returns:
-            :class:`list`: A list of all known top-level domain suffixes from the domain-suffixes package.
-        """
-        suffixes = Suffixes()
-        return suffixes.get_all_tlds()
-
-    @property
-    def contents(self) -> dict:
-        if self.__data is None:
-            try:
-                self.__data = self.load()
-            except FileNotFoundError:
-                self.__data = self.build()
-                self.write()
-
-        return self.__data
-
-    @property
-    def TLDs(self) -> list:
-        """ Returns a list of TLDs (top-level domains) for validating against """
-        return self.contents['tlds']
-
-    @property
-    def created_timestamp(self) -> float:
-        """
-        An alias for :attr:`created_ts`
-
-        Returns:
-            created_ts (float):
-                The time (in seconds since Epoch) when the cache was created.
-
-        """
-        return self.created_ts
-
-    @property
-    def created_ts(self) -> float:
-        """
-        The time (in seconds since Epoch) when the cache was created
-        """
-        return self.contents['created_ts']
-
-    @property
-    def age_in_seconds(self) -> float:
-        """
-        The number of seconds that have elapsed since creation of the cache.
-        """
-        return time() - self.created_ts
-
-    @property
-    def age(self) -> str:
-        return precisedelta(self.age_in_seconds)
-
-
-"""
-File Change History:
-
-11/5/22 - 4:24 AM (target: v2.1.2):
-  - Code cleanup
-  - Transform from class functions to static methods;
-      - `TLDCache.load`
-      - `TLDCache.fetch_from_source`                
-"""

inspy_logger-3.0.dev5/inspy_logger/version.py

@@ -1,287 +0,0 @@
-import requests
-import packaging
-from packaging import version as pkg_version
-
-RELEASE_MAP = {
-    'dev': 'Development Build',
-    'alpha': 'Alpha Build',
-    'beta': 'Beta Build',
-    'rc': 'Release Candidate Build',
-    'final': 'Final Release Build'
-}
-
-
-__VERSION__ = {
-    'major': 3,
-    'minor': 0,
-    'patch': 0,
-    'release': 'dev',
-    'release_num': 5
-}
-
-
-def parse_version():
-    """
-    Parses the version information into a string.
-
-    Returns:
-        str: The version information.
-
-    Since:
-        v1.0
-    """
-    version = f'{__VERSION__["major"]}.{__VERSION__["minor"]}.{__VERSION__["patch"]}'
-
-    if __VERSION__['release'] != 'final':
-        version += f'-{__VERSION__["release"]}.{__VERSION__["release_num"]}'
-
-    return version
-
-
-def get_full_version_name():
-    """
-    Gets the full version name.
-
-    Returns:
-        str: The full version name.
-
-    Since:
-        v1.0
-    """
-    ver = parse_version()
-    ver = ver.split('-')[0]
-    return f'v{ver} {RELEASE_MAP[__VERSION__["release"]]} ({__VERSION__["release_num"]})'
-
-
-def get_pypi_info():
-    """
-    Gets the latest version information from PyPI.
-
-    Returns:
-        dict: The latest version information.
-
-    Since:
-        v1.0
-    """
-    url = 'https://pypi.org/pypi/inspy-logger/json'
-    resp = requests.get(url)
-    resp.raise_for_status()
-    resp = resp.json()
-    return resp
-
-
-class PyPiVersionInfo:
-    """
-    A class to represent the version information for this package from PyPi.
-
-    Attributes:
-        latest_stable (str):
-            The latest stable version of the package on PyPi.
-
-        latest_pre_release (str):
-            The latest pre-release version of the package.
-    Since:
-        v3.0
-    """
-    __url                                  = 'https://pypi.org/pypi/inspy-logger/json'
-    __queried                              = False
-    __installed                            = parse_version()
-    __include_pre_release_for_update_check = False
-    __new_version_available_num            = None
-    __checked_for_update                   = False
-    __installed_newer_than_latest          = None
-
-    def __init__(self, include_pre_release_for_update_check=__include_pre_release_for_update_check):
-        self.__latest_stable = None
-        self.__latest_pre_release = None
-
-        self.__all_versions = None
-
-        self.include_pre_release_for_update_check = include_pre_release_for_update_check
-
-        self.__query_versions()
-
-    @property
-    def all_versions(self):
-        return self.__all_versions
-
-    @property
-    def checked_for_update(self):
-        return self.__checked_for_update
-
-    @property
-    def include_pre_release_for_update_check(self):
-        """
-        Gets whether pre-release versions should be included when checking for updates.
-
-        Returns:
-            bool:
-                True if pre-release versions should be included, False otherwise.
-
-        Since:
-            v3.0
-
-        """
-        return self.__include_pre_release_for_update_check
-
-    @property
-    def installed_newer_than_latest(self):
-        return self.installed > self.latest_stable
-
-    @include_pre_release_for_update_check.setter
-    def include_pre_release_for_update_check(self, new):
-        if isinstance(new, bool):
-            self.__include_pre_release_for_update_check = new
-        else:
-            raise TypeError(f'Expected bool, received {type(new)}.')
-
-    @property
-    def installed(self):
-        """
-        Gets the installed version of the package.
-
-        Returns:
-            packaging.version.Version:
-                The installed version of the package.
-
-        """
-        return pkg_version.parse(self.__installed)
-
-    @property
-    def latest_stable(self):
-        """
-        Gets the latest stable version of the package on PyPi.
-
-        Returns:
-            str: The latest stable version of the package on PyPi.
-
-        Since:
-            v3.0
-        """
-        if self.__latest_stable is not  None:
-            return pkg_version.parse(self.__latest_stable)
-
-        return self.__latest_stable
-
-    @property
-    def latest_pre_release(self):
-        """
-        Gets the latest pre-release version of the package.
-
-        Returns:
-            str: The latest pre-release version of the package.
-
-        Since:
-            v3.0
-        """
-        if self.all_versions is not None and self.__latest_pre_release is None:
-            most_recent = pkg_version.parse(self.all_versions[-1])
-            if most_recent.is_prerelease:
-                self.__latest_pre_release = most_recent
-
-        return self.__latest_pre_release
-
-    @property
-    def new_version_available_num(self):
-        """
-        Gets the number of the latest version available on PyPi.
-
-        Returns:
-            int: The number of the latest version available on PyPi.
-
-        Since:
-            v3.0
-        """
-        if not self.checked_for_update:
-            self.update_available
-        return self.__new_version_available_num
-
-    @property
-    def queried(self):
-        """
-        Checks if the versions have been queried.
-
-        Returns:
-            bool: True if the versions have been queried, False otherwise.
-
-        Since:
-            v3.0
-        """
-        return self.__queried
-
-    @property
-    def update_available(self):
-        """
-        Checks if an update is available.
-
-        Returns:
-            bool: True if an update is available, False otherwise.
-
-        Since:
-            v3.0
-        """
-        if not self.queried:
-            #print('Querying versions')
-            self.__query_versions()
-
-        if not self.checked_for_update:
-            #print('Checking for update')
-            self.__compare_latest()
-            self.__checked_for_update = True
-
-        if self.new_version_available_num is None and not self.queried:
-            #print('Getting latest')
-            self.__compare_latest()
-
-        return self.new_version_available_num is not None
-
-
-
-
-    def __query_versions(self):
-        """
-        Queries the versions from PyPi.
-
-        Returns:
-            dict: The versions from PyPi.
-
-        Since:
-            v3.0
-        """
-        if not self.queried:
-            resp = requests.get(self.__url)
-            resp.raise_for_status()
-            #print(resp.status_code)
-            resp = resp.json()
-
-            self.__all_versions = list(resp['releases'].keys())
-            #print(self.all_versions)
-
-            self.__latest_stable = resp['info']['version']
-            #print(self.latest_stable)
-
-
-
-            self.__queried = True
-
-    def __compare_latest(self):
-        latest = self.__get_latest()
-
-        if latest is not None and latest > self.installed:
-            self.__new_version_available_num = latest
-
-    def __get_latest(self):
-        if not self.queried:
-            #print('Querying versions')
-            self.__query_versions()
-
-        if self.include_pre_release_for_update_check:
-            latest = self.latest_pre_release
-
-        else:
-            latest = self.latest_stable
-
-        #print(f'Using latest {latest}')
-
-
-        return latest