DUBSlib 0.1.0__py3-none-any.whl

dubslib/__init__.py

@@ -0,0 +1,2 @@
+
+from .constants import *

dubslib/constants/__init__.py

@@ -0,0 +1,13 @@
+from .ordinals import (
+    LETTER_CHARS, LETTER_DICT, LETTER_ORDS,
+    NUMBER_CHARS, NUMBER_DICT, NUMBER_ORDS,
+    WHITE_SPACE_CHARS, WHITE_SPACE_DICT, WHITE_SPACE_ORDS,
+    OPERATOR_CHARS, OPERATOR_ORDS, OPERATORS_DICT
+)
+
+__all__ = [
+    "LETTER_CHARS", "LETTER_DICT", "LETTER_ORDS", 
+    "NUMBER_CHARS", 'NUMBER_DICT', 'NUMBER_ORDS',
+    "WHITE_SPACE_CHARS", "WHITE_SPACE_DICT", "WHITE_SPACE_ORDS",
+    "OPERATOR_CHARS", "OPERATOR_ORDS", "OPERATORS_DICT"
+]

dubslib/constants/ordinals/__init__.py

@@ -0,0 +1,13 @@
+from .classification import (
+    LETTER_CHARS, LETTER_DICT, LETTER_ORDS, 
+    NUMBER_CHARS, NUMBER_DICT, NUMBER_ORDS,
+    WHITE_SPACE_CHARS, WHITE_SPACE_DICT, WHITE_SPACE_ORDS,
+    OPERATOR_CHARS, OPERATOR_ORDS, OPERATORS_DICT
+)
+
+__all__ = [
+    "LETTER_CHARS", "LETTER_DICT", "LETTER_ORDS", 
+    "NUMBER_CHARS", 'NUMBER_DICT', 'NUMBER_ORDS',
+    "WHITE_SPACE_CHARS", "WHITE_SPACE_DICT", "WHITE_SPACE_ORDS",
+    "OPERATOR_CHARS", "OPERATOR_ORDS", "OPERATORS_DICT"
+]

dubslib/constants/ordinals/classification.py

@@ -0,0 +1,125 @@
+
+WHITE_SPACE_CHARS = [
+"\n",
+"\t",
+" "
+]
+
+OPERATOR_CHARS = [
+"!",
+"\"",
+"#",
+"$",
+"%",
+"&",
+"'",
+"(",
+")",
+"*",
+"+",
+",",
+"-",
+".",
+"/",
+":",
+";",
+"<",
+"=",
+">",
+"?",
+"@",
+"[",
+"\\",
+"]",
+"^",
+"_",
+"`",
+"{",
+"|",
+"}",
+"~"
+]
+
+NUMBER_CHARS = [
+"0",
+"1",
+"2",
+"3",
+"4",
+"5",
+"6",
+"7",
+"8",
+"9"
+]
+
+LETTER_CHARS = [
+"A",
+"B",
+"C",
+"D",
+"E",
+"F",
+"G",
+"H",
+"I",
+"J",
+"K",
+"L",
+"M",
+"N",
+"O",
+"P",
+"Q",
+"R",
+"S",
+"T",
+"U",
+"V",
+"W",
+"X",
+"Y",
+"Z",
+"a",
+"b",
+"c",
+"d",
+"e",
+"f",
+"g",
+"h",
+"i",
+"j",
+"k",
+"l",
+"m",
+"n",
+"o",
+"p",
+"q",
+"r",
+"s",
+"t",
+"u",
+"v",
+"w",
+"x",
+"y",
+"z"
+]
+
+WHITE_SPACE_ORDS = [ord(i) for i in WHITE_SPACE_CHARS]
+
+OPERATOR_ORDS = [ord(i) for i in OPERATOR_CHARS]
+
+NUMBER_ORDS = [ord(i) for i in NUMBER_CHARS]
+
+LETTER_ORDS = [ord(i) for i in LETTER_CHARS]
+
+WHITE_SPACE_DICT = dict(zip(WHITE_SPACE_CHARS, WHITE_SPACE_ORDS))
+
+OPERATORS_DICT = dict(zip(OPERATOR_CHARS, OPERATOR_ORDS))
+
+NUMBER_DICT = dict(zip(NUMBER_CHARS, NUMBER_ORDS))
+
+LETTER_DICT = dict(zip(LETTER_CHARS, LETTER_ORDS))

dubslib/io/__init__.py

@@ -0,0 +1,8 @@
+from .data.io import Persistence
+from .raw import write_to_file, read_from_file
+
+__all__ = [
+    "write_to_file",
+    "read_from_file",
+    "Persistence"
+    ]

dubslib/io/data/__init__.py

@@ -0,0 +1,5 @@
+from .io import Persistence
+
+__all__ = [
+           Persistence
+           ]

dubslib/io/data/io.py

@@ -0,0 +1,75 @@
+# This file is part of dubslib
+# Copyright (C) 2026 Donald Raymond Reilly Jr.
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import json
+from pathlib import Path
+from dubslib.io.exceptions import UnsupportedFormatError
+
+# WORK [ ]: Module doc string.
+class Persistence:
+    """
+    Provides a unified entry point for data structure Input and output.
+    
+    Persistence provides an ergonomic API file input and output.
+    """
+    def __init__(self):
+
+        self._loaders = {
+            "json":(json, json.load)
+            }
+
+        self._dumpers = {
+            "json": (json.dump, {"indent": 4, "default": str})
+            }
+
+    def to_file(self, pydict: dict, file_path: (Path | str), format: str):
+        """
+        Write the provided dictionary to file, using the chosen format.
+
+        Params:
+            pydict(dict): The python dictionary to be saved to file.
+            file_path(str | Path): Path to file.
+            format(str): Format for saved dictionary if None default is used.
+
+        Raises:
+            UnsupportedFormatError(format; AcceptedFormats)
+        """
+
+        if format not in self._dumpers:
+            raise UnsupportedFormatError(format, self._loaders.keys())
+        else:
+
+            with open(file_path, 'w', encoding="utf-8") as dict_file:
+                self._dumpers[format][0](pydict, dict_file, **self._dumpers[format][1])
+
+    def from_file(self, file_path, format):
+        """
+        Reads a data set from file and returns a dictionary.
+
+        Params:
+            file_path(str | path): Path to a file.
+            format: The format of the saved file.
+
+        Raises:
+            UnsupportedFormatError: If format not Supported
+        """
+
+        if format not in self._loaders:
+            raise UnsupportedFormatError(format, self._loaders.keys())
+        else:
+            with open(file_path, 'r', encoding="utf-8") as config_file:
+                return self._loaders[format](config_file)
+

dubslib/io/exceptions/__init__.py

@@ -0,0 +1,3 @@
+from .serializationerror import UnsupportedFormatError, UnsupportedReadModeError
+
+__all__ = ["UnsupportedFormatError", "UnsupportedReadModeError"]

dubslib/io/exceptions/serializationerror.py

@@ -0,0 +1,57 @@
+# This file is part of dubslib
+# Copyright (C) 2026 Donald Raymond Reilly Jr.
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+class SerializationError(Exception):
+    """
+    Base exception for all serialization errors.
+    """
+
+    pass
+
+class UnsupportedFormatError(SerializationError):
+    
+    def __init__(self, format, supported_formats):
+        """
+        Unsupported serialization format.
+    
+        Params:
+            format(module): The intended format of the serialized data.
+            supported_formats(list[module]): A list of the supported formats.    
+        """
+        self.format = format
+
+        self.supported_formats = tuple(supported_formats)
+
+        error_message = (f"Unexpected format: {format!r} ." 
+                         f"Expected one of; {', '.join(supported_formats)}")
+        super().__init__(error_message)
+
+class UnsupportedReadModeError(SerializationError):
+
+    def __init__(self, read_mode, supported_modes):
+        """
+        Unsupported serialization format.
+    
+        Params:
+            read_mode(str): The read mode requested.
+            supported_modes(list[strings]): A list of the supported modes.    
+        """
+
+        self.supported_modes = tuple(supported_modes)
+
+        error_message = (f"Unexpected Read Mode: {read_mode!r} ." 
+                         f"Expected one of; {', '.join(supported_modes)}")
+        super().__init__(error_message)

dubslib/io/raw/__init__.py

@@ -0,0 +1,7 @@
+from .o import write_to_file
+from .i import read_from_file
+
+__all__ = [
+    "read_from_file",
+    "write_to_file"
+    ]

dubslib/io/raw/i.py

@@ -0,0 +1,90 @@
+# This file is part of dubslib
+# Copyright (C) 2026 Donald Raymond Reilly Jr.
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from pathlib import Path
+from dubslib.io.exceptions import UnsupportedReadModeError
+
+def _yield_from_file(file_path: str):
+    """
+    Yeild lines from the provided file. Defaults to utf-8 encoding.
+
+    Params:
+        file_path(str): Path to the file.
+
+    Yields:
+        str: Each line in the file (including newline characters).
+    """
+
+    with open(file_path, mode="r", encoding="utf-8") as rawtext:
+        yield from rawtext
+
+def _list_from_file(file_path: str)-> list:
+    """
+    Read all lines from a file into a list.
+
+    Params:
+        file_path(str): Path to the file.
+
+    Returns:
+        list[str]: List of lines (including newline characters).
+    """
+
+    with open(file_path, mode="r", encoding="utf-8") as rawtext:
+        return list(rawtext)
+
+def _string_from_file(file_path: str | Path)-> str:
+    """
+    Read entire file contents as a single string.
+
+    Params:
+        file_path(str): Path to the file.
+
+    Returns:
+        str: Full file contents.
+    """
+
+    with open(file_path, mode="r", encoding="utf-8") as rawtext:
+        return rawtext.read()
+
+def read_from_file(file_path: str | Path, read_mode: str):
+    """
+    Reads a file, read_from_file either yields a list, reads the entire contents to a single string, or reads the contents to a list of lines.
+
+    Params:
+        file_path(str): Path to the file to read from.
+        read_mode(str): How the file is to be read. 
+            Accepted: "String", "List", "Yield", "string", "list", "yield, 'S', 'L', 'Y', 's', 'l', 'y' 
+
+    Raises:    
+        UnsupportedFormatError(format; AcceptedFormats)
+    """
+    supported_modes = (
+        "String", "List", "Yield",
+        "string", "list", "yield",
+        'S', 'L', 'Y',
+        's', 'l', 'y'
+    )
+    from_file = {
+        "s": _string_from_file,
+        "l": _list_from_file,
+        "y": _yield_from_file
+    }
+
+    if read_mode in supported_modes:
+        rm = read_mode[0].lower()
+        return from_file[rm](file_path)
+    else:
+        raise UnsupportedReadModeError(read_mode, supported_modes)

dubslib/io/raw/o.py

@@ -0,0 +1,97 @@
+# This file is part of dubslib
+# Copyright (C) 2026 Donald Raymond Reilly Jr.
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from dubslib.io.exceptions import UnsupportedFormatError
+from pathlib import Path
+
+def _write_string_to_file(file_path: str, content: str):
+    """
+    Overwrite a file with a string.
+
+    Params:
+        file_path(str): Path to the file.
+        content(str): Text to write.
+    """
+
+    with open(file_path, "w", encoding="utf-8") as f:
+        f.write(content)
+
+def _write_lines_to_file(file_path: str, lines: list[str]):
+    """
+    Overwrite a file with a sequence of lines.
+
+    Params:
+        file_path(str): Path to the file.
+        lines (Iterable[str]): Lines to write (must include newline characters if desired).
+    """
+
+    with open(file_path, "w", encoding="utf-8") as f:
+        f.writelines(lines)
+
+def _append_string_to_file(file_path: str, content: str):
+    """
+    Append a string to the end of a file.
+
+    Params:
+        file_path(str): Path to the file.
+        content(str): Text to append.
+    """
+
+    with open(file_path, "a", encoding="utf-8") as f:
+        f.write(content)
+
+def _append_lines_to_file(file_path: str, lines: list[str]):
+    """
+    Append multiple lines to the end of a file.
+
+    Params:
+        file_path(str): Path to the file.
+        lines(Iterable[str]): Lines to append (must include newline characters if desired).
+    """
+
+    with open(file_path, "a", encoding="utf-8") as f:
+        f.writelines(lines)
+
+def write_to_file(file_path: str| Path,
+                  content: str | list[str],
+                  write_mode: str
+                  ):
+    """
+    Writes/appends contents of a list or string to the specified file. The 
+    write type is not assumed and must be provided. 
+
+    Params:
+        file_path(str): Path to the file to overwrite, create or append to.
+        content(str): String or list of strings to write to file.
+        write_mode(str): How to write the file. 
+            Accepted: "Write", "Appened", "write", "appened", 'w', 'a' 
+
+    Raises:    
+        UnsupportedFormatError(format; AcceptedFormats)
+    """
+    to_file = {
+        "w": {
+            str: _write_string_to_file,
+            list: _write_lines_to_file
+        },
+        "a": {
+            str: _append_string_to_file,
+            list: _append_lines_to_file
+        }
+    }
+    mode = write_mode[0].lower()
+    if mode in to_file:
+        to_file[mode][type(content)](file_path, content)

dubslib/mockclasses/__init__.py

@@ -0,0 +1,4 @@
+from .mock_tkinter import MiniDesktopApp
+from .mock_custom_classes import DescriptorExample, GoldenBase, GoldenClass
+
+__all__ = ["MiniDesktopApp", "DescriptorExample", "GoldenBase", "GoldenClass"]

dubslib/mockclasses/mock_custom_classes.py

@@ -0,0 +1,99 @@
+
+class DescriptorExample:
+    """Simple descriptor to test descriptor behavior."""
+    def __init__(self, name):
+        self.name = name
+
+    def __get__(self, instance, owner):
+        return f"Descriptor __get__ called on {instance} for {self.name}"
+
+    def __set__(self, instance, value):
+        instance.__dict__[self.name] = value
+
+    def __delete__(self, instance):
+        del instance.__dict__[self.name]
+
+class GoldenBase:
+    """Base class to test inheritance."""
+    base_class_variable = 42
+
+    def base_method(self):
+        return "Base method called"
+
+class GoldenClass(GoldenBase):
+    """A fully loaded class for introspection testing."""
+
+    # Class variables
+    class_variable = "I am a class variable"
+    another_class_variable: int = 123
+
+    # Descriptor
+    descriptor_field = DescriptorExample("descriptor_field")
+
+    # Nested class
+    class Nested:
+        """Nested class inside GoldenClass."""
+        nested_var = "I am nested"
+
+        def nested_method(self):
+            return "Nested method called"
+
+    def __init__(self, x: int = 5, y: str = "hello", *args, **kwargs):
+        self.instance_var = "I am an instance variable"
+        self._private_var = "I am private"
+        self.x = x
+        self.y = y
+        self.args = args
+        self.kwargs = kwargs
+
+    # Regular method
+    def method_one(self, param1, param2: int = 10) -> str:
+        """This is method one"""
+        local_variable = "I am a local variable in method one"
+        return f"Method one called with {param1} and {param2}"
+
+    # Method with *args, **kwargs, keyword-only args
+    def method_two(self, a, b=3, *args, c, d=4, **kwargs):
+        """Method with complex signature"""
+        local_variable = "Local var in method two"
+        return a, b, c, d, args, kwargs
+
+    # Static method
+    @staticmethod
+    def static_method(alpha: float = 1.5):
+        """Static method example"""
+        return alpha * 2
+
+    # Class method
+    @classmethod
+    def class_method(cls, name: str):
+        """Class method example"""
+        return f"Called on {cls.__name__} with {name}"
+
+    # Property with getter, setter, deleter
+    @property
+    def my_property(self) -> str:
+        """This is a property"""
+        some_local_variable = "Local var in getter"
+        return self._private_var
+
+    @my_property.setter
+    def my_property(self, value: str = "that", other_value: str = "this", *, x, y) -> None:
+        """Setter for my_property"""
+        some_local_variable = "Local var in setter"
+        self._private_var = value
+
+    @my_property.deleter
+    def my_property(self) -> None:
+        """Deleter for my_property"""
+        del self._private_var
+
+    # Method referencing nested class
+    def create_nested(self):
+        """Returns an instance of the nested class."""
+        return self.Nested()
+
+    # Method returning a lambda (tests function parsing)
+    def lambda_factory(self):
+        """Returns a lambda function."""
+        return lambda z: z * 2