implemented property handling for MultiConnection

Author: marian-code

ssh_utilities/multi_connection/_delegated.py

@@ -48,19 +48,28 @@ def __init__(self, method_name: str, parent_ref: "ABCs",
         self._method_name = method_name
         self._parent_ref = parent_ref
         self._inner_class = inner_class
+        self._property = False
+
+    def is_property(self):
+        """Set this callabel to behave like a property."""
+        self._property = True
 
     def __call__(self, *args, **kwargs):
-        """Call the appropriate method on all connections asynchronouslly."""
+        """Call the appropriate method on all connections asynchronously."""
         iterables = [(c, *args, *kwargs)
                      for c in self._parent_ref.mc.values()]
         return self._parent_ref.mc.pool.map(self._call, *zip(*iterables))
 
     def _call(self, c: "_CONN", *args, **kwargs):
         """Make method calls for each of the connections."""
         method = getattr(getattr(c, self._inner_class), self._method_name)
-        return method(*args, **kwargs)
+        if self._property:
+            return method
+        else:
+            return method(*args, **kwargs)
 
 
+# ! properties
 # TODO what about abstract properties delegation?
 # TODO mayybe this is too deep magic? still not sure if we are returning
 # TODO actual class or class instance, this can have dnagendous consequences!
@@ -77,7 +86,7 @@ def Inner(abc_parent: "ABCs", multi_connection: "MultiConnection"):  # NOSONAR
     >>> method1[Connection1, Connection2]
     >>> method2[Connection1, Connection2]
 
-    The methods became classes and each 'method' holds reference to all
+    The methods become classes and each one holds reference to all
     open connections
 
     Parameters
@@ -96,8 +105,15 @@ def Inner(abc_parent: "ABCs", multi_connection: "MultiConnection"):  # NOSONAR
     for name in abc_parent.__abstractmethods__:
         if hasattr(abc_parent, name):
             inner_class = abc_parent.__name__.replace("ABC", "").lower()
-            setattr(abc_parent, name, delegated(name, abc_parent,
-                                                inner_class))
+            attr = getattr(abc_parent, name)
+            new_method = delegated(name, abc_parent, inner_class)
+            if isinstance(attr, property):
+                new_method.is_property()
+                new_method = property(new_method.__call__,
+                                      attr.__set__, attr.__delattr__)
+
+            setattr(abc_parent, name, new_method)
+
             implemented.add(name)
     abc_parent.__abstractmethods__ = frozenset(
         abc_parent.__abstractmethods__ - implemented

ssh_utilities/multi_connection/_dict_interface.py

@@ -1,16 +1,17 @@
 """module providing dictionary interface for multi_connection."""
 
 import logging
+from copy import copy
 from typing import (TYPE_CHECKING, Dict, ItemsView, KeysView, Optional, Tuple,
-                    Union, ValuesView)
+                    Union, ValuesView, TypeVar)
 
 if TYPE_CHECKING:
     from ..local import LocalConnection
     from ..remote import SSHConnection
     from .multi_connection import MultiConnection
 
     _CONN = Union[SSHConnection, LocalConnection]
-
+    _DictInterface1 = TypeVar("_DictInterface1")
 
 log = logging.getLogger(__name__)
 
@@ -47,46 +48,151 @@ def __len__(self) -> int:
         return len(self._connections)
 
     def keys(self) -> KeysView[str]:
+        """Iterate over registered key same as `dict.keys` method.
+
+        Yields
+        ------
+        KeysView[str]
+            key
+        """
         return self._connections.keys()
 
     def values(self) -> ValuesView["_CONN"]:
+        """Iterate over registered Connections same as `dict.values` method.
+
+        Yields
+        ------
+        ValuesView[_CONN]
+            `SSHConnection`/`LocalConnection`
+        """
         return self._connections.values()
 
     def items(self) -> ItemsView[str, "_CONN"]:
+        """Iterate over key, Connection pairs same as `dict.items` method.
+
+        Yields
+        ------
+        ItemsView[str, _CONN]
+            key, `SSHConnection`/`LocalConnection`
+        """
         return self._connections.items()
 
     def pop(self, key: str, *args) -> "_CONN":
+        """Pop one connection from `MultiConnection` object based on key.
+
+        Parameters
+        ----------
+        key: str
+            key denoting the connection
+        default: Any, optional
+            optianal value returned if key is not pressent
+
+        Returns
+        -------
+        _CONN
+            `SSHConnection` or `LocalConnection` object
+
+        Raises
+        ------
+        AttributeError
+            if the input key is not present among the connections and default
+            is not defined.
+        """
         conn = self._connections.pop(key, *args)
         self._share_connection.pop(key, *args)
         return conn
 
     def popitem(self) -> Tuple[str, "_CONN"]:
+        """Pops one key, connection pair from `MultiConnection`.
+
+        Returns
+        -------
+        Tuple[str, _CONN]
+            key, `SSHConnection`/`LocalConnection`  pair
+        """
         key, conn = self._connections.popitem()
         self._share_connection.pop(key, None)
         return key, conn
 
     def update(self, other: "MultiConnection"):
+        """Updates `Multiconnection` with another `Multiconnection`.
+
+        This only merges underlying dictionaries holding connections
+
+        Parameters
+        ----------
+        other : `MultiConnection`
+            the added object of same type as self
+        """
         self._add_multi(other)
 
     def get(self, key: str, *args) -> Optional["_CONN"]:
+        """Get one connection from `MultiConnection` object based on key.
+
+        Parameters
+        ----------
+        key: str
+            key denoting the connection
+        default: Any, optional
+            optianal value returned if key is not pressent
+
+        Returns
+        -------
+        _CONN
+            `SSHConnection` or `LocalConnection` object shallow copy
+
+        Raises
+        ------
+        AttributeError
+            if the input key is not present among the connections and default
+            is not defined.
+        """
         return self._connections.get(key, *args)
 
-    def copy(self):
-        return self
+    def copy(self: "_DictInterface1") -> "_DictInterface1":
+        """Get a shallow copy of `MultiConnection`.
+
+        Returns
+        -------
+        `MultiConnection`
+            MultiConnection object shallow copy
+        """
+        return copy(self)
 
     def clear(self):
+        """Close and delete all underlying connections."""
         self.close()
         self._connections.clear()
         self._share_connection.clear()
         self.pool.shutdown()
 
     def _add_one(self, other: "_CONN",
                  key: Optional[str] = None):
-
+        """Add one connecction to the undelying dictionary.
+
+        Parameters
+        ----------
+        other: _CONN
+            `SSHConnection` or `LocalConnection`
+        key: Optional[str]
+            if used connection is added under this key, else key is extracted
+            from `connection.server_name` attribute
+
+        Raises
+        ------
+        AttributeError
+            if key is already pressent among registered connections
+        """
         if key is None:
             key = other.server_name.lower()
+
+        if key in self.keys():
+            raise KeyError(f"Cannot register new Connection under key: {key}, "
+                           f"change Connection.server_name attribute or pass "
+                           f"in another key")
         self._connections.update({key: other})
 
     def _add_multi(self, other: "MultiConnection"):
+        """Register multiple new connections."""
         self._share_connection.update(other._share_connection)
         self._connections.update(other._connections)

ssh_utilities/multi_connection/_persistence.py

@@ -46,13 +46,15 @@ def __repr__(self):
         self.__str__()
 
     def __deepcopy__(self, memodict: dict = {}):
+        """On deepcopy we create new instance as this is simpler and safer."""
         return MultiConnection.from_dict(self.to_dict())
 
     def __getstate__(self):
+        """Gets the state of object for pickling."""
         return self.to_dict()
 
     def __setstate__(self, state: dict):
-
+        """Initializes the object after load from pickle."""
         ssh_servers, share_connection, local, thread_safe = (
             self._parse_persistence_dict(state)
         )
@@ -63,6 +65,13 @@ def __setstate__(self, state: dict):
 
     def to_dict(self) -> Dict[int, Dict[str, Optional[Union[str, bool,
                                                             int, None]]]]:
+        """Saves all the importatnt info from object to dictonary.
+
+        Returns
+        -------
+        Dict[int, Dict[str, Optional[Union[str, bool, int, None]]]]
+            dictionary representing the object
+        """
         conns = {}
         for i, (v, sc) in enumerate(zip(self._connections.values(),
                                         self._share_connection.values())):
@@ -75,7 +84,18 @@ def to_dict(self) -> Dict[int, Dict[str, Optional[Union[str, bool,
     @staticmethod
     def _parse_persistence_dict(d: dict) -> Tuple[List[str], List[int],
                                                   List[bool], List[bool]]:
+        """Parses dictionary produced by `to_dict` method.
 
+        Parameters
+        ----------
+        d : dict
+            dictionary of values needed to reinitialize the class
+
+        Returns
+        -------
+        Tuple[List[str], List[int], List[bool], List[bool]]
+            Tuple of lists with parsed information
+        """
         share_connection = []
         ssh_servers = []
         local = []

tests/manual_test.py

@@ -5,9 +5,16 @@
 for out in mc.os.isfile("/home/rynik/hw_config_Kohn.log"):
     print(out)
 
+for n in mc.os.name:
+    print(n)
+
+for p in mc.os.path.realpath("/home/rynik"):
+    print(p)
+
 a = mc.to_dict()
 del mc
 
+
 with MultiConnection(["kohn"], quiet=True) as mc:
     for out in mc.os.isfile("/home/rynik/hw_config_Kohn.log"):
         print(out)