private-attribute-cpp 2.1.14__cp315-cp315-win_arm64.whl

private_attribute.pyi

@@ -0,0 +1,211 @@
+"""A module that provides a metaclass for creating classes with private attributes.
+Private attributes are defined in the `__private_attrs__` sequence and are only
+You can use the `PrivateAttrBase` metaclass to create classes with private attributes.
+The attributes which are private are not on the instance's `__dict__` and cannot be accessed outside
+but in the methods defined in class it is reachable.
+Usage example:
+```python
+class MyClass(PrivateAttrBase):
+    __private_attrs__ = ('_private_attr1',)
+    def __init__(self):
+        self._private_attr1 = 1
+
+    @property
+    def public_attr1(self):
+        return self._private_attr1
+```
+"""
+from typing import Any, TypeVar, Callable, TypedDict, Sequence, Generic, Optional, cast
+from types import FunctionType
+
+# define the dict that must have a key "__private_attrs__" and value must be the sequence of strings
+class _PrivateAttrDict(TypedDict):
+    __private_attrs__: Optional[Sequence[str]]
+
+_T = TypeVar('_T')
+
+class _PrivateWrap(Generic[_T]):
+    @property
+    def result(self) -> _T:
+        "the final result of decorating"
+        ...
+
+    @property
+    def funcs(self) -> tuple[FunctionType]:
+        "the original functions"
+        ...
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self.result, name)
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        if callable(self.result):
+            return self.result(*args, **kwargs)
+        raise TypeError(f'{self.result!r} is not callable')
+
+    def __get__(self, instance: Any, owner: type) -> Any:
+        if hasattr(self.result, "__get__"):
+            descriptor = cast(Any, self.result)
+            return descriptor.__get__(instance, owner)
+        return self.result
+
+_TVar = TypeVar('_TVar')
+
+class PrivateWrapProxy(Generic[_TVar, _T]):
+    """
+    PrivateWrapProxy is a proxy for private attributes.
+    Usage:
+    ```
+    from private_attribute import PrivateWrapProxy, PrivateAttrBase
+
+    class MyClass(PrivateAttrBase):
+        __private_attrs__ = ()
+        @PrivateWrapProxy(decorator)
+        def my_method(self): ...
+
+        @PrivateWrapProxy(decorator)
+        def my_method2(self): ...
+    ```
+    It returned a '_PrivateWrap' object.
+
+    If you need to decorate more function, use like this:
+    ```
+    from private_attribute import PrivateWrapProxy, PrivateAttrBase
+
+    class MyClass(PrivateAttrBase):
+        __private_attrs__ = ()
+        @PrivateWrapProxy(decorator)
+        def my_method(self): ...
+
+        @PrivateWrapProxy(my_method.some_decorator, my_method)
+        def my_method(self): ...
+    ```
+    """
+    def __init__(self, decorator: Callable[[_TVar], _T], orig: _PrivateWrap[Any]|None = None, /) -> None: ...
+    def __call__(self, func: _TVar | _PrivateWrap[_TVar], /) -> _PrivateWrap[_T]: ...
+
+class PrivateAttrType(type):
+    "metaclass for private attributes"
+    def __new__(cls, name: str, bases: tuple,
+                attrs: _PrivateAttrDict, /, *,
+                private_func: Callable[[int, str], str]|None = None) -> PrivateAttrType: ...
+
+class PrivateAttrBase(metaclass=PrivateAttrType):
+    "The class to help to create private attribute. It does not have any special behavior."
+    __slots__ = ()
+    __private_attrs__ = ()
+
+
+class _PrivateTemp:
+    @property
+    def name(self) -> str: ...
+    @property
+    def bases(self) -> tuple[type]: ...
+    @property
+    def attrs(self) -> dict[str, Any]: ...
+    @property
+    def kwds(self) -> dict[str, Any]: ...
+
+def prepare(name: str, bases: tuple, attrs: _PrivateAttrDict, /, **kwds) -> _PrivateTemp:
+    """
+    function for custom metaclass to create private attributes class.
+
+    def prepare(name: str, bases: tuple, attrs: dict, **kwds) -> tempobject:
+        the function to prepare for creating private attributes class. It will return a temporary object which has the same information as the arguments.
+
+    def postprocess(type: type, tmp: tempobject) -> None:
+        the function to postprocess for creating private attributes class. The custom metaclass can call this
+
+    def register_metaclass(metaclass: type) -> None:
+        the function to register custom metaclass. The custom metaclass must call this function to register itself before creating any private attributes class,
+        otherwise the private attributes class created by this custom metaclass will not work.
+
+    All usage of this module should be like:
+    ```
+    from abc import ABCMeta
+    import private_attribute
+
+    class PrivateAbcMeta(ABCMeta):
+        def __new__(cls, *args, **kwargs):
+            temp = private_attribute.prepare(*args, **kwargs)
+            typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+            private_attribute.postprocess(typ, temp)
+            return typ
+
+    private_attribute.register_metaclass(PrivateAbcMeta)
+    ```
+    """
+    ...
+
+def postprocess(typ: type, temp: _PrivateTemp, /) -> None:
+    """
+    function for custom metaclass to create private attributes class.
+
+    def prepare(name: str, bases: tuple, attrs: dict, **kwds) -> tempobject:
+        the function to prepare for creating private attributes class. It will return a temporary object which has the same information as the arguments.
+
+    def postprocess(type: type, tmp: tempobject) -> None:
+        the function to postprocess for creating private attributes class. The custom metaclass can call this
+
+    def register_metaclass(metaclass: type) -> None:
+        the function to register custom metaclass. The custom metaclass must call this function to register itself before creating any private attributes class,
+        otherwise the private attributes class created by this custom metaclass will not work.
+
+    All usage of this module should be like:
+    ```
+    from abc import ABCMeta
+    import private_attribute
+
+    class PrivateAbcMeta(ABCMeta):
+        def __new__(cls, *args, **kwargs):
+            temp = private_attribute.prepare(*args, **kwargs)
+            typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+            private_attribute.postprocess(typ, temp)
+            return typ
+
+    private_attribute.register_metaclass(PrivateAbcMeta)
+    ```
+    """
+    ...
+def register_metaclass(typ: type, /) -> None:
+    """
+    function for custom metaclass to create private attributes class.
+
+    def prepare(name: str, bases: tuple, attrs: dict, **kwds) -> tempobject:
+        the function to prepare for creating private attributes class. It will return a temporary object which has the same information as the arguments.
+
+    def postprocess(type: type, tmp: tempobject) -> None:
+        the function to postprocess for creating private attributes class. The custom metaclass can call this
+
+    def register_metaclass(metaclass: type) -> None:
+        the function to register custom metaclass. The custom metaclass must call this function to register itself before creating any private attributes class,
+        otherwise the private attributes class created by this custom metaclass will not work.
+
+    All usage of this module should be like:
+    ```
+    from abc import ABCMeta
+    import private_attribute
+
+    class PrivateAbcMeta(ABCMeta):
+        def __new__(cls, *args, **kwargs):
+            temp = private_attribute.prepare(*args, **kwargs)
+            typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+            private_attribute.postprocess(typ, temp)
+            return typ
+
+    private_attribute.register_metaclass(PrivateAbcMeta)
+    ```
+    """
+    ...
+def ensure_type(typ: type, /) -> None:
+    """function for custom metaclass to ensure the type is a private attributes class.
+    def ensure_type(type: type) -> None:
+        the function to ensure the type is a private attributes class `tp_getattro`, `tp_setattro` and `tp_finalizer`.
+    """
+    ...
+def ensure_metaclass(typ: type, /) -> None:
+    """function for custom metaclass to ensure the metaclass is working.
+    def ensure_metaclass(metaclass: type) -> None:
+        the function to ensure the metaclass `tp_getattro`, `tp_setattro` and `tp_finalizer`.
+    """
+    ...

private_attribute_cpp-2.1.14.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.13.1
+Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-_ko9vbhl\\cp315-win_arm64\\build\\venv\\Scripts\\delvewheel', 'repair', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-_ko9vbhl\\cp315-win_arm64\\repaired_wheel', '-v', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-_ko9vbhl\\cp315-win_arm64\\built_wheel\\private_attribute_cpp-2.1.14-cp315-cp315-win_arm64.whl']

private_attribute_cpp-2.1.14.dist-info/METADATA

@@ -0,0 +1,271 @@
+Metadata-Version: 2.4
+Name: private_attribute_cpp
+Version: 2.1.14
+Summary: A Python package that provides a way to define private attributes in C++ implementation.
+Home-page: https://github.com/Locked-chess-official/private_attribute_cpp
+Author: HuangHaoHua
+Author-email: 13140752715@example.com
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# Private Attribute (c++ implementation)
+
+## Introduction
+
+This package provide a way to create the private attribute like "C++" does.
+
+## All Base API
+
+```python
+from private_attribute import (PrivateAttrBase, PrivateWrapProxy)      # 1 Import public API
+
+def my_generate_func(obj_id, attr_name):                           # 2 Optional: custom name generator
+    return f"_hidden_{obj_id}_{attr_name}"
+
+class MyClass(PrivateAttrBase, private_func=my_generate_func):     # 3 Inherit + optional custom generator
+    __private_attrs__ = ['a', 'b', 'c', 'result', 'conflicted_name']  # 4 Must declare all private attrs
+
+    def __init__(self):
+        self.a = 1
+        self.b = 2
+        self.c = 3
+        self.result = 42                    # deliberately conflicts with internal names
+
+    # Normal methods can freely access private attributes
+    def public_way(self):
+        print(self.a, self.b, self.c)
+
+    # Real-world case: method wrapped by multiple decorators
+    @PrivateWrapProxy(memoize())                                   # 5 Apply any decorator safely
+    @PrivateWrapProxy(login_required())                            # 5 Stack as many as needed
+    @PrivateWrapProxy(rate_limit(calls=10))                        # 5
+    def expensive_api_call(self, x):                               # First definition (will be wrapped)
+        def inner(...):
+            return some_implementation(self.a, self.b, self.c, x)
+        inner(...)
+        return heavy_computation(self.a, self.b, self.c, x)
+
+    # Fix decorator order + resolve name conflicts
+    @PrivateWrapProxy(expensive_api_call.result.name2, expensive_api_call)    # 6 Chain .result to push decorators down
+    @PrivateWrapProxy(expensive_api_call.result.name1, expensive_api_call)    # 6 Resolve conflict with internal names
+    def expensive_api_call(self, x):         # Final real implementation
+        return heavy_computation(self.a, self.b, self.c, x)
+
+
+# ====================== Usage ======================
+obj = MyClass()
+obj.public_way()                    # prints: 1 2 3
+
+print(hasattr(obj, 'a'))            # False – truly hidden from outside
+print(obj.expensive_api_call(10))   # works with all decorators applied
+```
+
+| # | API | Purpose | Required? |
+| --- | ---------------------------------------- | ------------------------------------------------------- | ----------- |
+| 1 | PrivateAttrBase | Base class – must inherit | Yes |
+| 1 | PrivateWrapProxy | Decorator wrapper for arbitrary decorators | When needed |
+| 2 | private_func=callable | Custom hidden-name generator | Optional |
+| 3 | Pass private_func in class definition | Same as above | Optional |
+| 4 | \_\_private_attrs\_\_ list | Declare which attributes are private | Optional (changed in 2.1.4) |
+| 5 | @PrivateWrapProxy(...) | Make any decorator compatible with private attributes | When needed |
+| 6 | method.result.xxx chain + dummy wrap | Fix decorator order and name conflicts | When needed |
+
+## Usage
+
+This is a simple usage about the module:
+
+```python
+from private_attribute import PrivateAttrBase
+
+class MyClass(PrivateAttrBase):
+    __private_attrs__ = ['a', 'b', 'c']
+    def __init__(self):
+        self.a = 1
+        self.b = 2
+        self.c = 3
+
+    def public_way(self):
+        print(self.a, self.b, self.c)
+
+obj = MyClass()
+obj.public_way()  # (1, 2, 3)
+
+print(hasattr(obj, 'a'))  # False
+print(hasattr(obj, 'b'))  # False
+print(hasattr(obj, 'c'))  # False
+```
+
+All of the attributes in `__private_attrs__` will be hidden from the outside world, and stored by another name.
+
+You can use your function to generate the name. It needs the id of the obj and the name of the attribute:
+
+```python
+def my_generate_func(obj_id, attr_name):
+    return some_string
+
+class MyClass(PrivateAttrBase, private_func=my_generate_func):
+    __private_attrs__ = ['a', 'b', 'c']
+    def __init__(self):
+        self.a = 1
+        self.b = 2
+        self.c = 3
+
+    def public_way(self):
+        print(self.a, self.b, self.c)
+
+obj = MyClass()
+obj.public_way()  # (1, 2, 3)
+
+```
+
+If the method will be decorated, the `property`, `classmethod` and `staticmethod` will be supported.
+For the other, you can use the `PrivateWrapProxy` to wrap the function:
+
+```python
+from private_attribute import PrivateAttrBase, PrivateWrapProxy
+
+class MyClass(PrivateAttrBase):
+    __private_attrs__ = ['a', 'b', 'c']
+    @PrivateWrapProxy(decorator1())
+    @PrivateWrapProxy(decorator2())
+    def method1(self):
+        ...
+
+    @PrivateWrapProxy(method1.attr_name, method1) # Use the argument "method1" to save old func
+    def method1(self):
+        ...
+
+    @PrivateWrapProxy(decorator3())
+    def method2(self):
+        ...
+
+    @PrivateWrapProxy(method2.attr_name, method2) # Use the argument "method2" to save old func
+    def method2(self):
+        ...
+
+
+```
+
+The `PrivateWrapProxy` is a decorator, and it will wrap the function with the decorator. When it decorates the method, it returns a `_PrivateWrap` object.
+
+The `_PrivateWrap` has the public api `result` and `funcs`. `result` returns the original decoratored result and `funcs` returns the tuple of the original functions.
+
+```python
+from private_attribute import PrivateAttrBase, PrivateWrapProxy
+
+class MyClass(PrivateAttrBase):
+    __private_attrs__ = ['a', 'b', 'c']
+    @PrivateWrapProxy(decorator1())
+    @PrivateWrapProxy(decorator2())
+    def method1(self):
+        ...
+
+    @PrivateWrapProxy(method1.result.conflict_attr_name1, method1) # Use the argument "method1" to save old func
+    def method1(self):
+        ...
+
+    @PrivateWrapProxy(method1.result.conflict_attr_name2, method1)
+    def method1(self):
+        ...
+
+    @PrivateWrapProxy(decorator3())
+    def method2(self):
+```
+
+## Advanced API
+
+### define your metaclass based on one metaclass
+
+You can define your metaclass based on one metaclass:
+
+```python
+from abc import ABCMeta, abstractmethod
+import private_attribute
+
+class PrivateAbcMeta(ABCMeta):
+    def __new__(cls, name, bases, attrs, **kwargs):
+        temp = private_attribute.prepare(name, bases, attrs, **kwargs)
+        typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+        private_attribute.postprocess(typ, temp)
+        return typ
+
+private_attribute.register_metaclass(PrivateAbcMeta)
+```
+
+By this way you create a metaclass both can behave as ABC and private attribute:
+
+```python
+class MyClass(metaclass=PrivateAbcMeta):
+    __private_attrs__ = ()
+    __slots__ = ()
+
+    @abstractmethod
+    def my_function(self): ...
+
+class MyImplement(MyClass):
+    __private_attrs__ = ("_a",)
+    def __init__(self, value=1):
+        self._a = value
+
+    def my_function(self):
+        return self._a
+```
+
+Finally:
+
+```python
+>>> a = MyImplement(1)
+>>> a.my_function()
+1
+>>> a._a
+Traceback (most recent call last):
+  File "<pyshell#2>", line 1, in <module>
+    a._a
+AttributeError: private attribute
+>>> MyClass()
+Traceback (most recent call last):
+  File "<pyshell#3>", line 1, in <module>
+    MyClass()
+TypeError: Can't instantiate abstract class MyClass without an implementation for abstract method 'my_function'
+```
+
+## Notes
+
+- ~~All of the private attributes class must contain the `__private_attrs__` attribute.~~(changed in 2.1.4)
+- The `__private_attrs__` attribute must be a sequence of strings or just one string.
+- You cannot define the name which in `__slots__` to `__private_attrs__`.
+- When you define `__slots__` and `__private_attrs__` in one class, the attributes in `__private_attrs__` can also be defined in the methods, even though they are not in `__slots__`.
+- All of the object that is the instance of the class "PrivateAttrBase" or its subclass are default to be unable to be pickled.
+- Finally the attributes' names in `__private_attrs__` will be change to a tuple with two hash.
+- Finally the `_PrivateWrap` object will be recoveried to the original object.
+- Don't use a decorator which will return the `_PrivateWrap` in `PrivateWrapProxy` which will raise `TypeError`.
+- One class defined in another class cannot use another class's private attribute.
+- One parent class defined an attribute which not in `__private_attrs__` or not a `PrivateAttrType` instance, the child class shouldn't contain the attribute in its `__private_attrs__`.
+- Since 2.1.0: the code of a subclass can no longer access the private attributes of its parent classes - a parent's private attribute is only reachable from the parent's own code, or from a class that declares the same name in its own `__private_attrs__`.
+- Since 2.1.0: if a subclass defines an attribute with the same name as a parent's private attribute, they are stored separately (instance attributes per declaring class, class-level attributes in `all_type_subclass_attr[parent][subclass]`). Class-level resolution is per-subject through the parent's code: reading the name on a subclass subject returns the subclass's own value, and the parent's own value is untouched. Such a same-name definition does NOT grant the subclass's own code access to the name.
+- CPython may change "tp_getattro", "tp_setattro" and so on when you change the attribute "\_\_getattribute\_\_", "\_\_setattr\_\_" and so on. If you are fear about it, you can use `ensure_type` to reset those tp slots. For the other metaclasses, you can use `ensure_metaclass` to reset those tp slots. Also, don't set those methods on these classes in your code.
+- `private_attribute.register_metaclass` must be called with the metaclass which supports weakref.
+- Don't set `__static_attributes__` in private attribute class, or it will be removed.
+
+## License
+
+MIT
+
+## Requirement
+
+This package require the c++ module "[picosha2](https://github.com/okdshin/PicoSHA2)" to compute the sha256 hash.
+
+## Support
+
+Now it only support Cpython.

private_attribute_cpp-2.1.14.dist-info/RECORD

@@ -0,0 +1,9 @@
+private_attribute.cp315-win_arm64.pyd,sha256=uxBWaSsVTwE2l4pKinAxZN5uo1y1UZ-n0VOg18cpr4k,243712
+private_attribute.pyi,sha256=kyC8djcsqhDVmP60eLEebvQlmsUv0I5EIDAndmDFFFo,8313
+private_attribute_cpp-2.1.14.data/platlib/msvcp140-dfb0e03a4e9979ecd6332ad9d7325a56.dll,sha256=37DgOk6ZeezWMyrZ1zJaVi-2igGnmP2IEJQh0j00uFM,1365048
+private_attribute_cpp-2.1.14.dist-info/DELVEWHEEL,sha256=GJY7n9rEPI9_VMzju9Flo4XHyo9hPgqDcyNt5CslCG8,421
+private_attribute_cpp-2.1.14.dist-info/METADATA,sha256=y3cG53ujM-bFmMmK_HePfQ2I4Pd8_WfMxYmwnVf-Rl4,10599
+private_attribute_cpp-2.1.14.dist-info/RECORD,,
+private_attribute_cpp-2.1.14.dist-info/top_level.txt,sha256=vOfJKfFO3AgjCIvyK6ppYDBTyJSsEAkf5w34knGZ3JE,19
+private_attribute_cpp-2.1.14.dist-info/WHEEL,sha256=g1f1kqn4IVvU4p3uh1e39gJzHxbtC9umA5gNjEXIByA,101
+private_attribute_cpp-2.1.14.dist-info/licenses/LICENSE,sha256=9CxoYH5h5JhKa_BiNrnxhtzSZXC2fUEPFmJjWryvF0g,1099

private_attribute_cpp-2.1.14.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: false
+Tag: cp315-cp315-win_arm64
+

private_attribute_cpp-2.1.14.dist-info/licenses/LICENSE

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

private_attribute_cpp-2.1.14.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+
+private_attribute