mbpc-improved 1.0.0__tar.gz

mbpc_improved-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pac-Dessert1436
+
+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.

mbpc_improved-1.0.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include LICENSE
+recursive-include mbpc *.py
+global-exclude Guidelines.md

mbpc_improved-1.0.0/PKG-INFO

@@ -0,0 +1,301 @@
+Metadata-Version: 2.4
+Name: mbpc-improved
+Version: 1.0.0
+Summary: Enhanced version of MBPC (Much Better Python Classes) for advanced OOP in Python
+Author-email: Pac-Dessert1436 <pac-dessert1436@example.com>
+Maintainer-email: Pac-Dessert1436 <pac-dessert1436@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Pac-Dessert1436/mbpc-improved
+Project-URL: Bug Reports, https://github.com/Pac-Dessert1436/mbpc-improved/issues
+Project-URL: Source, https://github.com/Pac-Dessert1436/mbpc-improved
+Project-URL: Documentation, https://github.com/Pac-Dessert1436/mbpc-improved#readme
+Project-URL: Changelog, https://github.com/Pac-Dessert1436/mbpc-improved/blob/main/CHANGELOG.md
+Project-URL: Repository, https://github.com/Pac-Dessert1436/mbpc-improved.git
+Keywords: oop,object-oriented,classes,interfaces,structs,type-safe,decorators,inheritance,metaprogramming,code-generation
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: flake8>=5.0; extra == "dev"
+Requires-Dist: black>=22.0; extra == "dev"
+Requires-Dist: isort>=5.0; extra == "dev"
+Requires-Dist: twine>=4.0; extra == "dev"
+Requires-Dist: build>=0.7; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Dynamic: license-file
+
+# `mbpc-improved`: Enhanced "Much Better Python Classes"
+
+## Description
+
+`mbpc-improved` is an enhanced version of [MBPC](https://github.com/MintLF/MBPC/) ("Much Better Python Classes"), a powerful library that introduces advanced object-oriented programming capabilities to Python. It provides utilities for defining interfaces, classes, and structs in a more structured, type-safe manner, bringing some of the best features of statically-typed languages to Python's dynamic environment.
+
+### Key Improvements Over Original MBPC
+- **Snake_case Consistency**: All identifiers converted from camelCase to Python's standard snake_case.
+- **Improved Readability**: Lambda expressions replaced with explicit `def-return` statements.
+- **Struct Support**: Added `structdef` for creating data-focused structures with interface support.
+- **Simplified Initialization**: Renamed `initialize` method to `init` for brevity and consistency.
+- **Object Cloning**: Added `clone` method for deep copying objects.
+- **Enhanced Iterability**: Eliminated need for manual list conversion when iterating over interfaces.
+
+_Note: For built-in iterability, simply use Python's `reversed(...)` function._
+
+## Installation
+
+### Prerequisites
+- Python 3.7 or higher
+
+### Via `pip`
+Install the package directly from PyPI:
+
+```bash
+pip install mbpc-improved
+```
+
+### From Source
+1. Clone the repository:
+
+```bash
+git clone https://github.com/Pac-Dessert1436/mbpc-improved.git
+cd mbpc-improved
+```
+
+2. Install in development mode:
+
+```bash
+pip install -e .
+```
+
+> **Note**: Avoid running scripts directly within the `mbpc` directory, as this may cause import errors. Always run from the project root or install the package first.
+
+## Core Components
+
+`mbpc-improved` provides three primary decorators for defining structured components:
+
+| Component | Description |
+|-----------|-------------|
+| `interfacedef` | Define interfaces with required methods that must be implemented by classes or structs. |
+| `classdef` | Create classes with inheritance and interface implementation capabilities. |
+| `structdef` | Define data-focused structures (similar to C structs) with interface support. |
+
+## Usage Examples
+
+### 1. Defining Interfaces
+
+Interfaces define contracts that classes or structs must implement. Use `interfacedef` to create interfaces with required methods:
+
+```python
+from mbpc.interfacedef import interfacedef
+
+@interfacedef()
+def Hashable(self):
+    """Interface for objects that can be hashed."""
+    @self.method
+    def hashcode() -> int: ...  # Must return an integer hash value
+
+@interfacedef()
+def Equatable(self):
+    """Interface for objects that can be compared for equality."""
+    @self.method
+    def equals(other) -> bool: ...  # Must return a boolean
+
+# NOTE: Common interfaces like Hashable and Equatable are already available in `mbpc.interfaces`
+```
+
+### 2. Creating Structs
+
+Structs are lightweight, data-focused structures that can implement interfaces. They're ideal for simple data containers:
+
+```python
+from mbpc.structdef import structdef
+from mbpc.interfaces import Hashable, Equatable
+
+@structdef(Hashable, Equatable)
+def Point(self, x: int, y: int):
+    """A 2D point struct with x and y coordinates."""
+    # Initialize instance variables
+    self.x = x
+    self.y = y
+
+    # Implement Hashable interface
+    @self.method
+    def hashcode(self) -> int:
+        """Generate a hash value for the point."""
+        return hash((self.x, self.y))
+
+    # Implement Equatable interface
+    @self.method
+    def equals(self, other) -> bool:
+        """Compare two points for equality."""
+        if not hasattr(other, 'x') or not hasattr(other, 'y'):
+            return False
+        return self.x == other.x and self.y == other.y
+
+# Example Usage:
+p1 = Point(2, 3)
+p2 = Point(2, 3)
+p3 = Point(5, 7)
+
+print(p1.x, p1.y)         # Output: 2 3
+print(p1.hashcode())      # Output: (hash value of (2, 3))
+print(p1.equals(p2))      # Output: True
+print(p1.equals(p3))      # Output: False
+print(p1.to_string())     # Output: {'x': 2, 'y': 3} (built-in method)
+print(p1.clone())         # Output: Point(x=2, y=3) (deep copy)
+```
+
+### 3. Defining Classes
+
+Classes support full object-oriented features including inheritance and interface implementation, but the parent constructor are always called first:
+
+```python
+from mbpc.classdef import classdef
+from mbpc.interfaces import Equatable
+
+@classdef()
+def Person(self, name: str, age: int):
+    """A person class with name and age attributes."""
+    # Call parent constructor (required for all classes)
+    self.super.init()
+    
+    # Initialize instance variables
+    self.name = name
+    self.age = age
+
+    # Define instance methods
+    @self.method
+    def greet(self) -> str:
+        """Return a greeting message."""
+        return f"Hello, my name is {self.name}"
+
+    # Implement Equatable interface
+    @self.method
+    def equals(self, other) -> bool:
+        """Compare two Person objects for equality."""
+        if not isinstance(other, Person):
+            return False
+        return self.name == other.name and self.age == other.age
+
+    # Define to_string method (built-in method override)
+    @self.method
+    def to_string(self) -> str:
+        """Return a string representation of the person."""
+        return f"Person(name='{self.name}', age={self.age})"
+
+# Example Usage:
+person1 = Person("Alice", 30)
+person2 = Person("Alice", 30)
+person3 = Person("Bob", 25)
+
+print(person1.greet())      # Output: Hello, my name is Alice
+print(person1.equals(person2))  # Output: True
+print(person1.equals(person3))  # Output: False
+print(person1.to_string())  # Output: Person(name='Alice', age=30)
+```
+
+### 4. Class Inheritance
+
+Classes can inherit from other classes, overriding methods as needed:
+
+```python
+from mbpc.classdef import classdef
+
+# Inherit from the Person class defined in the previous example
+@classdef(Person)  # Specify the parent class
+def Student(self, name: str, age: int, major: str, student_id: str):
+    """A Student class inheriting from Person."""
+    # Call parent constructor with required parameters
+    self.super.init(name, age)
+    
+    # Add new instance variables
+    self.major = major
+    self.student_id = student_id
+
+    # Override the greet method from Person
+    @self.method
+    def greet(self) -> str:
+        """Return a student-specific greeting."""
+        return f"Hello, I'm {self.name}, studying {self.major} (ID: {self.student_id})"
+
+    # Override to_string to include student-specific information
+    @self.method
+    def to_string(self) -> str:
+        """Return a string representation of the student."""
+        return f"Student(name='{self.name}', age={self.age}, major='{self.major}', id='{self.student_id}')"
+
+# Example Usage:
+student = Student("Bob", 20, "Computer Science", "CS12345")
+print(student.greet())  # Output: Hello, I'm Bob, studying Computer Science (ID: CS12345)
+print(student.to_string())  # Output: Student(name='Bob', age=20, major='Computer Science', id='CS12345')
+
+# Access inherited attributes
+print(student.name)  # Output: Bob
+print(student.age)   # Output: 20
+```
+
+## Interface Enforcement
+
+`mbpc-improved` enforces strict interface implementation at runtime, ensuring that classes and structs adhere to the contracts defined by interfaces:
+
+### Validation Checks
+- **Missing Methods**: Raises `InterfaceError` if any required interface method is not implemented.
+- **Incorrect Signatures**: Validates method parameters and return type hints.
+- **Method Types**: Supports both instance methods and static methods.
+
+### Example of Enforcement
+
+```python
+from mbpc.interfacedef import interfacedef
+from mbpc.classdef import classdef
+from mbpc.interfaces import InterfaceError
+
+@interfacedef()
+def Countable(self):
+    @self.method
+    def count() -> int: ...  # Must return an integer
+
+# This will raise an error because count() is not implemented
+@classdef(Countable)
+def BrokenCounter(self):
+    self.value = 0
+    
+    # Missing count() method implementation
+    
+# This will also raise an error because count() returns wrong type
+@classdef(Countable)
+def WrongReturnType(self):
+    self.value = 0
+    
+    @self.method
+    def count(self) -> str:  # Should return int, not str
+        return "5"
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit issues, feature requests, or pull requests on the [GitHub repository](https://github.com/Pac-Dessert1436/mbpc-improved).
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+## Authors
+
+- Original MBPC by [MintLF](https://github.com/MintLF)
+- Enhanced version by [Pac-Dessert1436](https://github.com/Pac-Dessert1436)
+
+## Support
+
+If you encounter any issues or have questions, please [open an issue](https://github.com/Pac-Dessert1436/mbpc-improved/issues) on GitHub.

mbpc_improved-1.0.0/README.md

@@ -0,0 +1,263 @@
+# `mbpc-improved`: Enhanced "Much Better Python Classes"
+
+## Description
+
+`mbpc-improved` is an enhanced version of [MBPC](https://github.com/MintLF/MBPC/) ("Much Better Python Classes"), a powerful library that introduces advanced object-oriented programming capabilities to Python. It provides utilities for defining interfaces, classes, and structs in a more structured, type-safe manner, bringing some of the best features of statically-typed languages to Python's dynamic environment.
+
+### Key Improvements Over Original MBPC
+- **Snake_case Consistency**: All identifiers converted from camelCase to Python's standard snake_case.
+- **Improved Readability**: Lambda expressions replaced with explicit `def-return` statements.
+- **Struct Support**: Added `structdef` for creating data-focused structures with interface support.
+- **Simplified Initialization**: Renamed `initialize` method to `init` for brevity and consistency.
+- **Object Cloning**: Added `clone` method for deep copying objects.
+- **Enhanced Iterability**: Eliminated need for manual list conversion when iterating over interfaces.
+
+_Note: For built-in iterability, simply use Python's `reversed(...)` function._
+
+## Installation
+
+### Prerequisites
+- Python 3.7 or higher
+
+### Via `pip`
+Install the package directly from PyPI:
+
+```bash
+pip install mbpc-improved
+```
+
+### From Source
+1. Clone the repository:
+
+```bash
+git clone https://github.com/Pac-Dessert1436/mbpc-improved.git
+cd mbpc-improved
+```
+
+2. Install in development mode:
+
+```bash
+pip install -e .
+```
+
+> **Note**: Avoid running scripts directly within the `mbpc` directory, as this may cause import errors. Always run from the project root or install the package first.
+
+## Core Components
+
+`mbpc-improved` provides three primary decorators for defining structured components:
+
+| Component | Description |
+|-----------|-------------|
+| `interfacedef` | Define interfaces with required methods that must be implemented by classes or structs. |
+| `classdef` | Create classes with inheritance and interface implementation capabilities. |
+| `structdef` | Define data-focused structures (similar to C structs) with interface support. |
+
+## Usage Examples
+
+### 1. Defining Interfaces
+
+Interfaces define contracts that classes or structs must implement. Use `interfacedef` to create interfaces with required methods:
+
+```python
+from mbpc.interfacedef import interfacedef
+
+@interfacedef()
+def Hashable(self):
+    """Interface for objects that can be hashed."""
+    @self.method
+    def hashcode() -> int: ...  # Must return an integer hash value
+
+@interfacedef()
+def Equatable(self):
+    """Interface for objects that can be compared for equality."""
+    @self.method
+    def equals(other) -> bool: ...  # Must return a boolean
+
+# NOTE: Common interfaces like Hashable and Equatable are already available in `mbpc.interfaces`
+```
+
+### 2. Creating Structs
+
+Structs are lightweight, data-focused structures that can implement interfaces. They're ideal for simple data containers:
+
+```python
+from mbpc.structdef import structdef
+from mbpc.interfaces import Hashable, Equatable
+
+@structdef(Hashable, Equatable)
+def Point(self, x: int, y: int):
+    """A 2D point struct with x and y coordinates."""
+    # Initialize instance variables
+    self.x = x
+    self.y = y
+
+    # Implement Hashable interface
+    @self.method
+    def hashcode(self) -> int:
+        """Generate a hash value for the point."""
+        return hash((self.x, self.y))
+
+    # Implement Equatable interface
+    @self.method
+    def equals(self, other) -> bool:
+        """Compare two points for equality."""
+        if not hasattr(other, 'x') or not hasattr(other, 'y'):
+            return False
+        return self.x == other.x and self.y == other.y
+
+# Example Usage:
+p1 = Point(2, 3)
+p2 = Point(2, 3)
+p3 = Point(5, 7)
+
+print(p1.x, p1.y)         # Output: 2 3
+print(p1.hashcode())      # Output: (hash value of (2, 3))
+print(p1.equals(p2))      # Output: True
+print(p1.equals(p3))      # Output: False
+print(p1.to_string())     # Output: {'x': 2, 'y': 3} (built-in method)
+print(p1.clone())         # Output: Point(x=2, y=3) (deep copy)
+```
+
+### 3. Defining Classes
+
+Classes support full object-oriented features including inheritance and interface implementation, but the parent constructor are always called first:
+
+```python
+from mbpc.classdef import classdef
+from mbpc.interfaces import Equatable
+
+@classdef()
+def Person(self, name: str, age: int):
+    """A person class with name and age attributes."""
+    # Call parent constructor (required for all classes)
+    self.super.init()
+    
+    # Initialize instance variables
+    self.name = name
+    self.age = age
+
+    # Define instance methods
+    @self.method
+    def greet(self) -> str:
+        """Return a greeting message."""
+        return f"Hello, my name is {self.name}"
+
+    # Implement Equatable interface
+    @self.method
+    def equals(self, other) -> bool:
+        """Compare two Person objects for equality."""
+        if not isinstance(other, Person):
+            return False
+        return self.name == other.name and self.age == other.age
+
+    # Define to_string method (built-in method override)
+    @self.method
+    def to_string(self) -> str:
+        """Return a string representation of the person."""
+        return f"Person(name='{self.name}', age={self.age})"
+
+# Example Usage:
+person1 = Person("Alice", 30)
+person2 = Person("Alice", 30)
+person3 = Person("Bob", 25)
+
+print(person1.greet())      # Output: Hello, my name is Alice
+print(person1.equals(person2))  # Output: True
+print(person1.equals(person3))  # Output: False
+print(person1.to_string())  # Output: Person(name='Alice', age=30)
+```
+
+### 4. Class Inheritance
+
+Classes can inherit from other classes, overriding methods as needed:
+
+```python
+from mbpc.classdef import classdef
+
+# Inherit from the Person class defined in the previous example
+@classdef(Person)  # Specify the parent class
+def Student(self, name: str, age: int, major: str, student_id: str):
+    """A Student class inheriting from Person."""
+    # Call parent constructor with required parameters
+    self.super.init(name, age)
+    
+    # Add new instance variables
+    self.major = major
+    self.student_id = student_id
+
+    # Override the greet method from Person
+    @self.method
+    def greet(self) -> str:
+        """Return a student-specific greeting."""
+        return f"Hello, I'm {self.name}, studying {self.major} (ID: {self.student_id})"
+
+    # Override to_string to include student-specific information
+    @self.method
+    def to_string(self) -> str:
+        """Return a string representation of the student."""
+        return f"Student(name='{self.name}', age={self.age}, major='{self.major}', id='{self.student_id}')"
+
+# Example Usage:
+student = Student("Bob", 20, "Computer Science", "CS12345")
+print(student.greet())  # Output: Hello, I'm Bob, studying Computer Science (ID: CS12345)
+print(student.to_string())  # Output: Student(name='Bob', age=20, major='Computer Science', id='CS12345')
+
+# Access inherited attributes
+print(student.name)  # Output: Bob
+print(student.age)   # Output: 20
+```
+
+## Interface Enforcement
+
+`mbpc-improved` enforces strict interface implementation at runtime, ensuring that classes and structs adhere to the contracts defined by interfaces:
+
+### Validation Checks
+- **Missing Methods**: Raises `InterfaceError` if any required interface method is not implemented.
+- **Incorrect Signatures**: Validates method parameters and return type hints.
+- **Method Types**: Supports both instance methods and static methods.
+
+### Example of Enforcement
+
+```python
+from mbpc.interfacedef import interfacedef
+from mbpc.classdef import classdef
+from mbpc.interfaces import InterfaceError
+
+@interfacedef()
+def Countable(self):
+    @self.method
+    def count() -> int: ...  # Must return an integer
+
+# This will raise an error because count() is not implemented
+@classdef(Countable)
+def BrokenCounter(self):
+    self.value = 0
+    
+    # Missing count() method implementation
+    
+# This will also raise an error because count() returns wrong type
+@classdef(Countable)
+def WrongReturnType(self):
+    self.value = 0
+    
+    @self.method
+    def count(self) -> str:  # Should return int, not str
+        return "5"
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit issues, feature requests, or pull requests on the [GitHub repository](https://github.com/Pac-Dessert1436/mbpc-improved).
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+## Authors
+
+- Original MBPC by [MintLF](https://github.com/MintLF)
+- Enhanced version by [Pac-Dessert1436](https://github.com/Pac-Dessert1436)
+
+## Support
+
+If you encounter any issues or have questions, please [open an issue](https://github.com/Pac-Dessert1436/mbpc-improved/issues) on GitHub.

mbpc_improved-1.0.0/mbpc/__init__.py

@@ -0,0 +1,11 @@
+from . import classdef, interfacedef, structdef, interfaces
+
+__name__ = "mbpc"
+__author__ = "Pac-Dessert1436"
+__version__ = "1.0.0"
+__all__: list[str] = [
+    "classdef",
+    "interfacedef",
+    "structdef",
+    "interfaces"
+]

mbpc_improved-1.0.0/mbpc/classdef.py

@@ -0,0 +1,89 @@
+from .utilities import InterfaceError, MbpcSelf
+from inspect import signature
+
+
+def _ClassBase(self):
+    @self.method
+    def to_string(debug: bool = False):
+        return self.__dict__ if debug else f"{self.__classname__} object"
+
+    return self
+
+
+_ClassBase.__mbpctype__ = "class"
+_ClassBase.__interfaces__ = []
+
+
+def classdef(super_cls=_ClassBase, *interfaces):
+    interfaces = list(interfaces)
+    if super_cls.__mbpctype__ == "interface":
+        interfaces.insert(0, super_cls)
+        super_cls = _ClassBase
+    elif super_cls.__mbpctype__ == "struct":
+        raise InterfaceError(
+            f"Cannot inherit from a struct (super_cls: {super_cls.__name__}). Structs do not support inheritance."
+        )
+    interfaces.extend(super_cls.__interfaces__)
+
+    def myclass(deco_class):
+        def mybase(*args, **kwargs):
+            self = MbpcSelf()
+            args = list(args)
+            if args and type(args[0]) == type(self):
+                self = args[0]
+                args.pop(0)
+
+            def initialize(*args, **kwargs):
+                self.__dict__ |= super_cls(self, *args, **kwargs).__dict__
+
+            def super(): pass
+            for name in self.__dict__:
+                super.__dict__[name] = self.__dict__[name]
+            super.init = initialize
+            self.super = super
+
+            self.__classname__ = deco_class.__name__
+            deco_class(self, *args, **kwargs)
+
+            for interface in reversed(interfaces):
+                for k in interface.__interface__.methods.keys():
+                    if not k in self.__dict__:
+                        raise InterfaceError(
+                            f"Class \"{self.__classname__}\" does not implement the interface \"{interface.__interface__.__interfacename__}\" (missing the method \"{k}\")."
+                        )
+
+                    if not signature(self.__dict__[k]) == interface.__interface__.methods[k]:
+                        raise InterfaceError(
+                            f"Class \"{self.__classname__}\" does not implement the interface \"{interface.__interface__.__interfacename__}\" (incorrectly defining the method \"{k}\")."
+                        )
+            return self
+
+        def method(f):
+            mybase.__dict__[f.__name__] = f
+
+        mybase.__dict__ = super_cls.__dict__ | mybase.__dict__
+        mybase.method = method
+        mybase.__mbpctype__ = "class" if super_cls.__mbpctype__ == _ClassBase else "struct"
+        mybase.__interfaces__ = interfaces
+
+        def initialize():
+            for interface in reversed(interfaces):
+                for k in interface.__methods__.keys():
+                    if not k in mybase.__dict__:
+                        raise InterfaceError(
+                            f"Class \"{deco_class.__name__}\" does not implement the interface \"{interface.__interface__.__interfacename__}\" (missing the static method \"{k}\")."
+                        )
+
+                    if not signature(mybase.__dict__[k]) == interface.__methods__[k]:
+                        raise InterfaceError(
+                            f"Class \"{deco_class.__name__}\" does not implement the interface \"{interface.__interface__.__interfacename__}\" (incorrectly defining the static method \"{k}\")."
+                        )
+
+        def clone():
+            from copy import deepcopy
+            return deepcopy(mybase.__dict__)
+
+        mybase.init = initialize
+        mybase.clone = clone
+        return mybase
+    return myclass

mbpc_improved-1.0.0/mbpc/interfacedef.py

@@ -0,0 +1,40 @@
+from .utilities import InterfaceError
+from inspect import signature
+
+
+def _Interface():
+    def interface(): return ...
+    interface.methods = {}
+
+    def method(func):
+        interface.methods[func.__name__] = signature(func)
+
+    interface.method = method
+    return interface
+
+
+def interfacedef(*super_interfaces):
+    interface = _Interface()
+
+    for super_interface in reversed(super_interfaces):
+        interface.__dict__ |= super_interface.__interface__.__dict__
+
+    def wrapper(decorated_interface):
+        decorated_interface(interface)
+        interface.__interfacename__ = decorated_interface.__name__
+
+        def mybase(*args, **kwargs):
+            raise InterfaceError("Cannot initialize an interface object.")
+
+        mybase.__interface__ = interface
+        mybase.__mbpctype__ = "interface"
+
+        mybase.__methods__ = {}
+
+        def method(func):
+            mybase.__methods__[func.__name__] = signature(func)
+
+        mybase.method = method
+
+        return mybase
+    return wrapper

mbpc_improved-1.0.0/mbpc/interfaces.py

@@ -0,0 +1,13 @@
+from .interfacedef import interfacedef
+
+
+@interfacedef()
+def Hashable(self):
+    @self.method
+    def hashcode() -> int: ...
+
+
+@interfacedef()
+def Equatable(self):
+    @self.method
+    def equals(object) -> bool: ...

mbpc_improved-1.0.0/mbpc/structdef.py

@@ -0,0 +1,79 @@
+from .utilities import InterfaceError, MbpcSelf
+from inspect import signature
+
+def _StructBase(self):
+    existing = self.__dict__.copy()
+
+    @self.method
+    def to_string() -> str:
+        filtered = {}
+        method_names = [name for name, func in self.__dict__.items()
+                        if hasattr(func, '__name__') and func.__name__ in self.__dict__]
+        for key, value in self.__dict__.items():
+            if key not in [*existing, *method_names, "__classname__"]:
+                filtered[key] = value
+        return str(filtered)
+
+    return self
+
+
+_StructBase.__mbpctype__ = "struct"
+_StructBase.__interfaces__ = []
+
+
+def structdef(*interfaces):
+    interfaces = list(interfaces)
+    struct = _StructBase
+
+    def mystruct(deco_struct):
+        def mybase(*args, **kwargs):
+            self = MbpcSelf()
+            args = list(args)
+            if args and type(args[0]) == type(self):
+                self = args[0]
+                args.pop(0)
+            self.__dict__ |= struct(self).__dict__
+            self.__classname__ = deco_struct.__name__
+            deco_struct(self, *args, **kwargs)
+
+            for interface in reversed(interfaces):
+                for k in interface.__interface__.methods.keys():
+                    if not k in self.__dict__:
+                        raise InterfaceError(
+                            f"Struct \"{self.__classname__}\" does not implement the interface \"{interface.__interface__.__interfacename__}\" (missing the method \"{k}\")."
+                        )
+
+                    if not signature(self.__dict__[k]) == interface.__interface__.methods[k]:
+                        raise InterfaceError(
+                            f"Struct \"{self.__classname__}\" does not implement the interface \"{interface.__interface__.__interfacename__}\" (incorrectly defining the method \"{k}\")."
+                        )
+            return self
+
+        def method(f):
+            mybase.__dict__[f.__name__] = f
+
+        mybase.method = method
+        mybase.__mbpctype__ = "struct"
+        mybase.__interfaces__ = interfaces
+
+        def initialize():
+            for interface in reversed(interfaces):
+                for k in interface.__methods__.keys():
+                    if not k in mybase.__dict__:
+                        raise InterfaceError(
+                            f"Struct \"{deco_struct.__name__}\" does not implement the interface \"{interface.__interface__.__interfacename__}\" (missing the static method \"{k}\")."
+                        )
+
+                    if not signature(mybase.__dict__[k]) == interface.__methods__[k]:
+                        raise InterfaceError(
+                            f"Struct \"{deco_struct.__name__}\" does not implement the interface \"{interface.__interface__.__interfacename__}\" (incorrectly defining the static method \"{k}\")."
+                        )
+                    
+        def clone():
+            from copy import deepcopy
+            return deepcopy(mybase.__dict__)
+
+        mybase.init = initialize
+        mybase.clone = clone
+        return mybase
+    return mystruct

mbpc_improved-1.0.0/mbpc/utilities.py

@@ -0,0 +1,12 @@
+class InterfaceError(Exception):
+    pass
+
+
+def MbpcSelf():
+    def self(): pass
+
+    def method(f):
+        self.__dict__[f.__name__] = f
+
+    self.method = method
+    return self

mbpc_improved-1.0.0/mbpc_improved.egg-info/PKG-INFO

@@ -0,0 +1,301 @@
+Metadata-Version: 2.4
+Name: mbpc-improved
+Version: 1.0.0
+Summary: Enhanced version of MBPC (Much Better Python Classes) for advanced OOP in Python
+Author-email: Pac-Dessert1436 <pac-dessert1436@example.com>
+Maintainer-email: Pac-Dessert1436 <pac-dessert1436@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Pac-Dessert1436/mbpc-improved
+Project-URL: Bug Reports, https://github.com/Pac-Dessert1436/mbpc-improved/issues
+Project-URL: Source, https://github.com/Pac-Dessert1436/mbpc-improved
+Project-URL: Documentation, https://github.com/Pac-Dessert1436/mbpc-improved#readme
+Project-URL: Changelog, https://github.com/Pac-Dessert1436/mbpc-improved/blob/main/CHANGELOG.md
+Project-URL: Repository, https://github.com/Pac-Dessert1436/mbpc-improved.git
+Keywords: oop,object-oriented,classes,interfaces,structs,type-safe,decorators,inheritance,metaprogramming,code-generation
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: flake8>=5.0; extra == "dev"
+Requires-Dist: black>=22.0; extra == "dev"
+Requires-Dist: isort>=5.0; extra == "dev"
+Requires-Dist: twine>=4.0; extra == "dev"
+Requires-Dist: build>=0.7; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Dynamic: license-file
+
+# `mbpc-improved`: Enhanced "Much Better Python Classes"
+
+## Description
+
+`mbpc-improved` is an enhanced version of [MBPC](https://github.com/MintLF/MBPC/) ("Much Better Python Classes"), a powerful library that introduces advanced object-oriented programming capabilities to Python. It provides utilities for defining interfaces, classes, and structs in a more structured, type-safe manner, bringing some of the best features of statically-typed languages to Python's dynamic environment.
+
+### Key Improvements Over Original MBPC
+- **Snake_case Consistency**: All identifiers converted from camelCase to Python's standard snake_case.
+- **Improved Readability**: Lambda expressions replaced with explicit `def-return` statements.
+- **Struct Support**: Added `structdef` for creating data-focused structures with interface support.
+- **Simplified Initialization**: Renamed `initialize` method to `init` for brevity and consistency.
+- **Object Cloning**: Added `clone` method for deep copying objects.
+- **Enhanced Iterability**: Eliminated need for manual list conversion when iterating over interfaces.
+
+_Note: For built-in iterability, simply use Python's `reversed(...)` function._
+
+## Installation
+
+### Prerequisites
+- Python 3.7 or higher
+
+### Via `pip`
+Install the package directly from PyPI:
+
+```bash
+pip install mbpc-improved
+```
+
+### From Source
+1. Clone the repository:
+
+```bash
+git clone https://github.com/Pac-Dessert1436/mbpc-improved.git
+cd mbpc-improved
+```
+
+2. Install in development mode:
+
+```bash
+pip install -e .
+```
+
+> **Note**: Avoid running scripts directly within the `mbpc` directory, as this may cause import errors. Always run from the project root or install the package first.
+
+## Core Components
+
+`mbpc-improved` provides three primary decorators for defining structured components:
+
+| Component | Description |
+|-----------|-------------|
+| `interfacedef` | Define interfaces with required methods that must be implemented by classes or structs. |
+| `classdef` | Create classes with inheritance and interface implementation capabilities. |
+| `structdef` | Define data-focused structures (similar to C structs) with interface support. |
+
+## Usage Examples
+
+### 1. Defining Interfaces
+
+Interfaces define contracts that classes or structs must implement. Use `interfacedef` to create interfaces with required methods:
+
+```python
+from mbpc.interfacedef import interfacedef
+
+@interfacedef()
+def Hashable(self):
+    """Interface for objects that can be hashed."""
+    @self.method
+    def hashcode() -> int: ...  # Must return an integer hash value
+
+@interfacedef()
+def Equatable(self):
+    """Interface for objects that can be compared for equality."""
+    @self.method
+    def equals(other) -> bool: ...  # Must return a boolean
+
+# NOTE: Common interfaces like Hashable and Equatable are already available in `mbpc.interfaces`
+```
+
+### 2. Creating Structs
+
+Structs are lightweight, data-focused structures that can implement interfaces. They're ideal for simple data containers:
+
+```python
+from mbpc.structdef import structdef
+from mbpc.interfaces import Hashable, Equatable
+
+@structdef(Hashable, Equatable)
+def Point(self, x: int, y: int):
+    """A 2D point struct with x and y coordinates."""
+    # Initialize instance variables
+    self.x = x
+    self.y = y
+
+    # Implement Hashable interface
+    @self.method
+    def hashcode(self) -> int:
+        """Generate a hash value for the point."""
+        return hash((self.x, self.y))
+
+    # Implement Equatable interface
+    @self.method
+    def equals(self, other) -> bool:
+        """Compare two points for equality."""
+        if not hasattr(other, 'x') or not hasattr(other, 'y'):
+            return False
+        return self.x == other.x and self.y == other.y
+
+# Example Usage:
+p1 = Point(2, 3)
+p2 = Point(2, 3)
+p3 = Point(5, 7)
+
+print(p1.x, p1.y)         # Output: 2 3
+print(p1.hashcode())      # Output: (hash value of (2, 3))
+print(p1.equals(p2))      # Output: True
+print(p1.equals(p3))      # Output: False
+print(p1.to_string())     # Output: {'x': 2, 'y': 3} (built-in method)
+print(p1.clone())         # Output: Point(x=2, y=3) (deep copy)
+```
+
+### 3. Defining Classes
+
+Classes support full object-oriented features including inheritance and interface implementation, but the parent constructor are always called first:
+
+```python
+from mbpc.classdef import classdef
+from mbpc.interfaces import Equatable
+
+@classdef()
+def Person(self, name: str, age: int):
+    """A person class with name and age attributes."""
+    # Call parent constructor (required for all classes)
+    self.super.init()
+    
+    # Initialize instance variables
+    self.name = name
+    self.age = age
+
+    # Define instance methods
+    @self.method
+    def greet(self) -> str:
+        """Return a greeting message."""
+        return f"Hello, my name is {self.name}"
+
+    # Implement Equatable interface
+    @self.method
+    def equals(self, other) -> bool:
+        """Compare two Person objects for equality."""
+        if not isinstance(other, Person):
+            return False
+        return self.name == other.name and self.age == other.age
+
+    # Define to_string method (built-in method override)
+    @self.method
+    def to_string(self) -> str:
+        """Return a string representation of the person."""
+        return f"Person(name='{self.name}', age={self.age})"
+
+# Example Usage:
+person1 = Person("Alice", 30)
+person2 = Person("Alice", 30)
+person3 = Person("Bob", 25)
+
+print(person1.greet())      # Output: Hello, my name is Alice
+print(person1.equals(person2))  # Output: True
+print(person1.equals(person3))  # Output: False
+print(person1.to_string())  # Output: Person(name='Alice', age=30)
+```
+
+### 4. Class Inheritance
+
+Classes can inherit from other classes, overriding methods as needed:
+
+```python
+from mbpc.classdef import classdef
+
+# Inherit from the Person class defined in the previous example
+@classdef(Person)  # Specify the parent class
+def Student(self, name: str, age: int, major: str, student_id: str):
+    """A Student class inheriting from Person."""
+    # Call parent constructor with required parameters
+    self.super.init(name, age)
+    
+    # Add new instance variables
+    self.major = major
+    self.student_id = student_id
+
+    # Override the greet method from Person
+    @self.method
+    def greet(self) -> str:
+        """Return a student-specific greeting."""
+        return f"Hello, I'm {self.name}, studying {self.major} (ID: {self.student_id})"
+
+    # Override to_string to include student-specific information
+    @self.method
+    def to_string(self) -> str:
+        """Return a string representation of the student."""
+        return f"Student(name='{self.name}', age={self.age}, major='{self.major}', id='{self.student_id}')"
+
+# Example Usage:
+student = Student("Bob", 20, "Computer Science", "CS12345")
+print(student.greet())  # Output: Hello, I'm Bob, studying Computer Science (ID: CS12345)
+print(student.to_string())  # Output: Student(name='Bob', age=20, major='Computer Science', id='CS12345')
+
+# Access inherited attributes
+print(student.name)  # Output: Bob
+print(student.age)   # Output: 20
+```
+
+## Interface Enforcement
+
+`mbpc-improved` enforces strict interface implementation at runtime, ensuring that classes and structs adhere to the contracts defined by interfaces:
+
+### Validation Checks
+- **Missing Methods**: Raises `InterfaceError` if any required interface method is not implemented.
+- **Incorrect Signatures**: Validates method parameters and return type hints.
+- **Method Types**: Supports both instance methods and static methods.
+
+### Example of Enforcement
+
+```python
+from mbpc.interfacedef import interfacedef
+from mbpc.classdef import classdef
+from mbpc.interfaces import InterfaceError
+
+@interfacedef()
+def Countable(self):
+    @self.method
+    def count() -> int: ...  # Must return an integer
+
+# This will raise an error because count() is not implemented
+@classdef(Countable)
+def BrokenCounter(self):
+    self.value = 0
+    
+    # Missing count() method implementation
+    
+# This will also raise an error because count() returns wrong type
+@classdef(Countable)
+def WrongReturnType(self):
+    self.value = 0
+    
+    @self.method
+    def count(self) -> str:  # Should return int, not str
+        return "5"
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit issues, feature requests, or pull requests on the [GitHub repository](https://github.com/Pac-Dessert1436/mbpc-improved).
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+## Authors
+
+- Original MBPC by [MintLF](https://github.com/MintLF)
+- Enhanced version by [Pac-Dessert1436](https://github.com/Pac-Dessert1436)
+
+## Support
+
+If you encounter any issues or have questions, please [open an issue](https://github.com/Pac-Dessert1436/mbpc-improved/issues) on GitHub.

mbpc_improved-1.0.0/mbpc_improved.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+mbpc/__init__.py
+mbpc/classdef.py
+mbpc/interfacedef.py
+mbpc/interfaces.py
+mbpc/structdef.py
+mbpc/utilities.py
+mbpc_improved.egg-info/PKG-INFO
+mbpc_improved.egg-info/SOURCES.txt
+mbpc_improved.egg-info/dependency_links.txt
+mbpc_improved.egg-info/requires.txt
+mbpc_improved.egg-info/top_level.txt

mbpc_improved-1.0.0/mbpc_improved.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mbpc_improved-1.0.0/mbpc_improved.egg-info/requires.txt

@@ -0,0 +1,10 @@
+
+[dev]
+pytest>=7.0
+pytest-cov>=4.0
+flake8>=5.0
+black>=22.0
+isort>=5.0
+twine>=4.0
+build>=0.7
+mypy>=1.0

mbpc_improved-1.0.0/mbpc_improved.egg-info/top_level.txt

@@ -0,0 +1 @@
+mbpc

mbpc_improved-1.0.0/pyproject.toml

@@ -0,0 +1,88 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mbpc-improved"
+version = "1.0.0"
+description = "Enhanced version of MBPC (Much Better Python Classes) for advanced OOP in Python"
+readme = "README.md"
+requires-python = ">=3.7"
+license = {text = "MIT"}
+authors = [
+    {name = "Pac-Dessert1436", email = "pac-dessert1436@example.com"}
+]
+maintainers = [
+    {name = "Pac-Dessert1436", email = "pac-dessert1436@example.com"}
+]
+keywords = [
+    "oop",
+    "object-oriented",
+    "classes",
+    "interfaces",
+    "structs",
+    "type-safe",
+    "decorators",
+    "inheritance",
+    "metaprogramming",
+    "code-generation"
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Code Generators",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Utilities"
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "flake8>=5.0",
+    "black>=22.0",
+    "isort>=5.0",
+    "twine>=4.0",
+    "build>=0.7",
+    "mypy>=1.0"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/Pac-Dessert1436/mbpc-improved"
+"Bug Reports" = "https://github.com/Pac-Dessert1436/mbpc-improved/issues"
+"Source" = "https://github.com/Pac-Dessert1436/mbpc-improved"
+"Documentation" = "https://github.com/Pac-Dessert1436/mbpc-improved#readme"
+"Changelog" = "https://github.com/Pac-Dessert1436/mbpc-improved/blob/main/CHANGELOG.md"
+"Repository" = "https://github.com/Pac-Dessert1436/mbpc-improved.git"
+
+[tool.setuptools]
+packages = ["mbpc"]
+
+[tool.setuptools.package-data]
+mbpc = ["*.py"]
+
+[tool.black]
+line-length = 100
+target-version = ['py37', 'py38', 'py39', 'py310', 'py311']
+
+[tool.isort]
+profile = "black"
+line_length = 100
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+
+[tool.mypy]
+python_version = "3.7"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = false

mbpc_improved-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mbpc_improved-1.0.0/setup.py

@@ -0,0 +1,10 @@
+"""
+Minimal setup.py for backward compatibility with older pip versions.
+Main configuration is in pyproject.toml (PEP 621 compliant).
+"""
+
+from setuptools import setup
+
+# All configuration is in pyproject.toml
+# This file exists only for compatibility with very old pip versions
+setup()