MultiProxPy 0.0.1__tar.gz → 0.2.0__tar.gz

multiproxpy-0.2.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: MultiProxPy
+Version: 0.2.0
+Summary: An easy way to combine multiple objects into one
+License-Expression: Apache-2.0
+License-File: LICENSE
+Author: Eric aka CheesecakeTV
+Author-email: eric@swiftgui.de
+Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Project-URL: Documentation, https://github.com/CheesecakeTV/MultiProxPy
+Project-URL: Repository, https://github.com/CheesecakeTV/MultiProxPy
+Description-Content-Type: text/markdown
+
+# MultiProxPy
+A small python-package that allows you to "group" calls to objects.
+
+The cool part is that the resulting "MultiProxy"-object can be used like the referenced objects:
+```py
+from MultiProxPy import group_objects
+
+list1 = [3,1,2]
+list2 = [5,2]
+list3 = [7,8,9]
+
+list_proxy = group_objects(list1, list2, list3)
+
+list_proxy.sort()   # Sorts all lists
+list_proxy.append(15)   # Appends 15 to all lists
+list_proxy[0] = -1  # Sets the first elemet to 0 for all lists
+
+print(list1, list2, list3)
+```
+The grouping is very abstract and should work with any type of object.
+
+The best part is that your IDE will treat the proxy-object like one of the contained objects.
+It will suggest methods/attributes bound to that class:\
+![img.png](https://github.com/CheesecakeTV/MultiProxPy/blob/main/assets/images/SuggestionsOnProxyObject.png)
+
+Other examples can be found in the github-repository: https://github.com/CheesecakeTV/MultiProxPy
+
+## Limitations
+There are a few downsides you should be aware of.
+
+1. Any return-value on proxy-calls will be lost
+2. Simmilarely, math operations like additions don't work for the proxy. However, inline-operations do, e.g.: `list_proxy += [5]`
+3. The proxy can't fool `isinstance`, e.g.: `isinstance(list_proxy, list)` will return `False`
+4. Objects inside the proxy should have the same type, or a derived one. This is only a suggestion. If you are careful enough, you can mix different types
+
+

multiproxpy-0.2.0/README.md

@@ -0,0 +1,35 @@
+# MultiProxPy
+A small python-package that allows you to "group" calls to objects.
+
+The cool part is that the resulting "MultiProxy"-object can be used like the referenced objects:
+```py
+from MultiProxPy import group_objects
+
+list1 = [3,1,2]
+list2 = [5,2]
+list3 = [7,8,9]
+
+list_proxy = group_objects(list1, list2, list3)
+
+list_proxy.sort()   # Sorts all lists
+list_proxy.append(15)   # Appends 15 to all lists
+list_proxy[0] = -1  # Sets the first elemet to 0 for all lists
+
+print(list1, list2, list3)
+```
+The grouping is very abstract and should work with any type of object.
+
+The best part is that your IDE will treat the proxy-object like one of the contained objects.
+It will suggest methods/attributes bound to that class:\
+![img.png](https://github.com/CheesecakeTV/MultiProxPy/blob/main/assets/images/SuggestionsOnProxyObject.png)
+
+Other examples can be found in the github-repository: https://github.com/CheesecakeTV/MultiProxPy
+
+## Limitations
+There are a few downsides you should be aware of.
+
+1. Any return-value on proxy-calls will be lost
+2. Simmilarely, math operations like additions don't work for the proxy. However, inline-operations do, e.g.: `list_proxy += [5]`
+3. The proxy can't fool `isinstance`, e.g.: `isinstance(list_proxy, list)` will return `False`
+4. Objects inside the proxy should have the same type, or a derived one. This is only a suggestion. If you are careful enough, you can mix different types
+

{multiproxpy-0.0.1 → multiproxpy-0.2.0}/pyproject.toml

@@ -1,26 +1,27 @@
-[project]
-name = "MultiProxPy"
-version = "0.0.1"
-packages = [
-    { include = "MultiProxPy", from = "src" }
-]
-authors = [
-  { name="Eric aka CheesecakeTV", email="eric@swiftgui.de" },
-]
-description = "An easy way to combine multiple objects into one"
-readme = "README.md"
-requires-python = ">=3.10"
-classifiers = [
-    "Programming Language :: Python :: 3",
-    "Operating System :: OS Independent",
-]
-license = "Apache-2.0"
-license-files = ["LICEN[CS]E*"]
-dependencies = []
-[project.urls]
-Repository = "https://github.com/CheesecakeTV/MultiProxy"
-Documentation = "https://github.com/CheesecakeTV/MultiProxy"
-
-[build-system]
-requires = ["poetry-core>=2.0.0,<3.0.0"]
-build-backend = "poetry.core.masonry.api"
+[project]
+name = "MultiProxPy"
+version = "0.2.0"
+packages = [
+    { include = "MultiProxPy", from = "src" }
+]
+authors = [
+  { name="Eric aka CheesecakeTV", email="eric@swiftgui.de" },
+]
+description = "An easy way to combine multiple objects into one"
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "Apache-2.0"
+license-files = ["LICEN[CS]E*"]
+dependencies = []
+[project.urls]
+Repository = "https://github.com/CheesecakeTV/MultiProxPy"
+Documentation = "https://github.com/CheesecakeTV/MultiProxPy"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+

multiproxpy-0.2.0/src/MultiProxPy/ModifyMultiProxy.py

@@ -0,0 +1,134 @@
+from typing import Any, Callable, Iterable
+from MultiProxPy import MultiProxy
+from functools import wraps
+
+def _typecheck_multiprox(fct: Callable):
+    """
+    Only allows an instance of Multiproxy as the first parameter
+    :param fct:
+    :return:
+    """
+    @wraps(fct)
+    def inner(*args, **kwargs):
+        if not isinstance(args[0], MultiProxy):
+            raise TypeError("The passed object was not a MultiProxy.")
+
+        return fct(*args, **kwargs)
+
+    return inner
+
+@_typecheck_multiprox
+def get_object_list(multi_proxy: MultiProxy | Any) -> list[object]:
+    """
+    Returns the inner list of the given multi-proxy.
+    You may use it to edit the contents of a MultiProxy.
+
+    Use at your own risk, there are no type-checks beyond this point!
+
+    :param multi_proxy:
+    :return:
+    """
+    return object.__getattribute__(multi_proxy, "_objects")
+
+@_typecheck_multiprox
+def get_inner_type(multi_proxy: MultiProxy | Any) -> type:
+    """
+    Return the assumed type of a multi-proxy.
+    :param multi_proxy:
+    :return:
+    """
+    return object.__getattribute__(multi_proxy, "_type")
+
+def _assert_type_match(multi_proxy: MultiProxy | Any, assert_match: bool = True, *objects: object) -> bool:
+    """
+    Check if all objects
+    :param multi_proxy:
+    :param objects:
+    :return:
+    """
+    main_type: type = get_inner_type(multi_proxy)
+    all_mismatching = tuple(filter(lambda a:not isinstance(a, main_type), objects))
+    is_matching = not all_mismatching
+
+    if not (is_matching or assert_match):
+        raise TypeError("The passed objects do not match with the multi-proxys inner type.\n"
+                        f"Expected {main_type}, got some mismatching: {all_mismatching}\n"
+                        f"You may turn off this check by passing assert_type=False to the function you called.")
+
+    return is_matching
+
+@_typecheck_multiprox
+def append_objects(multi_proxy: MultiProxy | Any, *objects: object, assert_type: bool = True):
+    """
+    Add objects to a multi-proxy
+
+    :param multi_proxy:
+    :param objects:
+    :param assert_type:
+    :return:
+    """
+    _assert_type_match(multi_proxy, assert_match=assert_type)
+
+    inner_list = get_object_list(multi_proxy)
+    for obj in objects:
+        inner_list.append(obj)
+
+@_typecheck_multiprox
+def remove_index(multi_proxy: MultiProxy | Any, index: int) -> object:
+    """
+    Remove the linked object at that index from the passed multi-proxy.
+
+    :param multi_proxy:
+    :param index:
+    :return:
+    """
+    inner_list = get_object_list(multi_proxy)
+    return inner_list.pop(index)
+
+@_typecheck_multiprox
+def remove_object_by_value(multi_proxy: MultiProxy | Any, value_to_remove: object) -> object:
+    """
+    Remove the passed object from the passed multi-proxy and return its object.
+    The object is identified by its value.
+
+    :param multi_proxy:
+    :param value_to_remove: Value of the object to unlink
+    :return:
+    """
+    inner_list = get_object_list(multi_proxy)
+    index = inner_list.index(value_to_remove)
+    return inner_list.pop(index)
+
+@_typecheck_multiprox
+def remove_object(multi_proxy: MultiProxy | Any, object_to_remove: object, ignore_error: bool = False) -> object:
+    """
+    Remove the passed object from the passed multi-proxy and return the object.
+    The object is defined by the memory-address, so the passed object must be actually the same one.
+
+    :param multi_proxy:
+    :param object_to_remove: Object to unlink
+    :param ignore_error: If the object is not found, do nothing
+    :return:
+    """
+    inner_list = get_object_list(multi_proxy)
+
+    ids = tuple(map(id, inner_list))
+    try:
+        index = ids.index(id(object_to_remove))
+    except ValueError:
+        if ignore_error:
+            return object_to_remove
+        raise ValueError("The object to remove is not linked to this multi-proxy.\n"
+                         "You may pass ignore_error=True to do nothing instead of raising an error.")
+
+    return inner_list.pop(index)
+
+@_typecheck_multiprox
+def remove_all(multi_proxy: MultiProxy | Any):
+    """
+    Unlink all elements from a multi-proxy
+    :param multi_proxy:
+    :return:
+    """
+    inner_list = get_object_list(multi_proxy)
+    inner_list.clear()

{multiproxpy-0.0.1 → multiproxpy-0.2.0}/src/MultiProxPy/MultiProxyClass.py

@@ -2,19 +2,25 @@ from typing import TypeVar
 
 class MultiProxy:
 
-    _objects: tuple[object, ...]    # Objects to call the methods from
+    _objects: list[object]    # Objects to call the methods from
+    _type: type # Type of object in this element
 
     def __init__(
             self,
             *objects: object,
+            assume_type: type | None = None,
     ):
         """
         Do not call directly!
         Use group_objects instead!
         """
-        assert objects, "At least one object is required to create a grouped caller!"
+        assert objects, "At least one object is required to create a MultiProxy!"
 
-        super().__setattr__("_objects", objects)
+        if assume_type is None:
+            assume_type = type(objects[0])
+
+        super().__setattr__("_type", assume_type)
+        super().__setattr__("_objects", list(objects))
 
     def __getattribute__(self, item):
         objects = super().__getattribute__("_objects")
@@ -34,11 +40,11 @@ class MultiProxy:
 
     def __str__(self) -> str:
         objects = super().__getattribute__("_objects")
-        return f"<GroupedCaller {tuple(map(str, objects))}>"
+        return f"<MultiProxy {tuple(map(str, objects))}>"
 
     def __repr__(self):
         objects = super().__getattribute__("_objects")
-        return f"<GroupedCaller {id(self)} {tuple(map(repr, objects))}>"
+        return f"<MultiProxy {id(self)} {tuple(map(repr, objects))}>"
 
     def __await__(self):
         objects = super().__getattribute__("_objects")
@@ -102,6 +108,15 @@ def group_objects(
         primary: inner_type, *others: inner_type,
         check_type_mismatch: bool = True,
 ) -> inner_type:
+    """
+    Create a MultiProxy-object and fool the IDE about its type.
+    This is the proper way to create such an object.
+
+    :param primary: The "type" of the returned object
+    :param others: All the other elements inside that proxy
+    :param check_type_mismatch: False to go the dangerous route of mixing together types
+    :return:
+    """
 
     if check_type_mismatch:
         main_type = type(primary)
@@ -119,3 +134,5 @@ def group_objects(
 
     return my_caller
 
+
+

multiproxpy-0.2.0/src/MultiProxPy/__init__.py

@@ -0,0 +1,3 @@
+
+from .MultiProxyClass import MultiProxy, group_objects
+from .ModifyMultiProxy import get_inner_type, get_object_list, append_objects, remove_object_by_value, remove_index, remove_object, remove_all

multiproxpy-0.0.1/PKG-INFO

@@ -1,19 +0,0 @@
-Metadata-Version: 2.4
-Name: MultiProxPy
-Version: 0.0.1
-Summary: An easy way to combine multiple objects into one
-License-Expression: Apache-2.0
-License-File: LICENSE
-Author: Eric aka CheesecakeTV
-Author-email: eric@swiftgui.de
-Requires-Python: >=3.10
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Project-URL: Documentation, https://github.com/CheesecakeTV/MultiProxy
-Project-URL: Repository, https://github.com/CheesecakeTV/MultiProxy
-Description-Content-Type: text/markdown
-
-# MultiProxy
-
-
-

multiproxpy-0.0.1/README.md

@@ -1,3 +0,0 @@
-# MultiProxy
-
-

multiproxpy-0.0.1/src/MultiProxPy/__init__.py

@@ -1,3 +0,0 @@
-
-from .MultiProxyClass import MultiProxy, group_objects
-