MultiProxPy 0.1.0__tar.gz → 0.2.1__tar.gz

{multiproxpy-0.1.0 → multiproxpy-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MultiProxPy
-Version: 0.1.0
+Version: 0.2.1
 Summary: An easy way to combine multiple objects into one
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -36,7 +36,8 @@ 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](assets/images/SuggestionsOnProxyObject.png)
+![img.png](https://github.com/CheesecakeTV/MultiProxPy/blob/main/assets/images/SuggestionsOnProxyObject.png)\
+(The image might not show on PyPi. Here is the link: 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
 

{multiproxpy-0.1.0 → multiproxpy-0.2.1}/README.md

@@ -21,7 +21,8 @@ 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](assets/images/SuggestionsOnProxyObject.png)
+![img.png](https://github.com/CheesecakeTV/MultiProxPy/blob/main/assets/images/SuggestionsOnProxyObject.png)\
+(The image might not show on PyPi. Here is the link: 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
 

{multiproxpy-0.1.0 → multiproxpy-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "MultiProxPy"
-version = "0.1.0"
+version = "0.2.1"
 packages = [
     { include = "MultiProxPy", from = "src" }
 ]

multiproxpy-0.2.1/src/MultiProxPy/ModifyMultiProxy.py

@@ -0,0 +1,175 @@
+from typing import Any, Callable, Iterable, TypeVar
+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 is 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, *objects: object, assert_match: bool = True) -> 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
+
+T = TypeVar("T")
+@_typecheck_multiprox
+def append_object(multi_proxy: MultiProxy | Any, to_append: T, assert_type: bool = True) -> T:
+    """
+    Add a single object to a multi-proxy.
+    The added object is returned, so you can call this function inline
+
+    :param multi_proxy:
+    :param to_append:
+    :param assert_type:
+    :return:
+    """
+    _assert_type_match(multi_proxy, to_append, assert_match=assert_type)
+
+    inner_list = get_object_list(multi_proxy)
+    inner_list.append(to_append)
+    return to_append
+
+def extend_proxy(multi_proxy: MultiProxy | Any, iter_to_extend: Iterable[T], assert_type: bool = True) -> Iterable[T]:
+    """
+    Adds all elements from iter_to_extend to the passed multi_proxy.
+    The passed iterable is returned, so you can call this function inline.
+
+    Just remember that some iterables depleat. If the returned iterable is empty, convert it to a list first.
+
+    :param multi_proxy:
+    :param iter_to_extend:
+    :param assert_type:
+    :return:
+    """
+    iter_tuple = tuple(iter_to_extend)
+    _assert_type_match(multi_proxy, *iter_tuple, assert_match=assert_type)
+
+    inner_list = get_object_list(multi_proxy)
+    inner_list.extend(iter_tuple)
+
+    return iter_to_extend
+
+@_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, *objects, 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.1.0 → multiproxpy-0.2.1}/src/MultiProxPy/MultiProxyClass.py

@@ -2,19 +2,24 @@ 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 MultiProxy!"
+        if assume_type is None:
+            assert objects, "At least one object or a specific type is required to create a MultiProxy!"
+            assume_type = type(objects[0])
 
-        super().__setattr__("_objects", objects)
+        super().__setattr__("_type", assume_type)
+        super().__setattr__("_objects", list(objects))
 
     def __getattribute__(self, item):
         objects = super().__getattribute__("_objects")
@@ -111,7 +116,6 @@ def group_objects(
     :param check_type_mismatch: False to go the dangerous route of mixing together types
     :return:
     """
-
     if check_type_mismatch:
         main_type = type(primary)
         all_mismatching = tuple(filter(lambda a:not isinstance(a, main_type), others))
@@ -128,5 +132,18 @@ def group_objects(
 
     return my_caller
 
+def create_empty_proxy(object_type: type[inner_type]) -> inner_type:
+    """
+    Create an empty "group" of objects with the passed type.
+    This way, you may add the objects of that group later on.
+
+    :param object_type:
+    :return:
+    """
+    my_caller = MultiProxy(
+        assume_type=object_type,
+    )
+
+    return my_caller
 
 

multiproxpy-0.2.1/src/MultiProxPy/__init__.py

@@ -0,0 +1,15 @@
+
+from .MultiProxyClass import MultiProxy, group_objects, create_empty_proxy
+from .ModifyMultiProxy import (
+    get_inner_type,
+    get_object_list,
+    append_objects,
+    remove_object_by_value,
+    remove_index,
+    remove_object,
+    remove_all,
+    append_object,
+    extend_proxy,
+)
+
+create_proxy = group_objects    # Just an alias that might be easier for some people

multiproxpy-0.1.0/src/MultiProxPy/__init__.py

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