define subkey, vkey, vdict interface

Author: rushk014

vflow/subkey.py

@@ -66,6 +66,11 @@ def mismatches(self, other: object):
             cond2 = self.origin == other.origin and self.value != other.value
             return (cond0 or cond1) and cond2
         return True
+    
+    def __copy__(self):
+        """Return a copy of this Subkey
+        """
+        pass
 
     def __eq__(self, other: object):
         """Mainly used for testing purposes.

vflow/vdict.py

@@ -0,0 +1,25 @@
+"""Vdict key tuple wrapper class
+"""
+from typing import Tuple, Union
+
+class Vdict:
+
+    def __init__(self):
+        pass
+
+    def to_pandas(self, copy=False):
+        """Return a pandas.DataFrame representation of the Vdict.
+        """
+        pass
+
+    def __getitem__(self, *subkeys: Union[str, Tuple[str, str]], copy=False):
+        """Return a new Vdict with a subset of the items in self by filtering keys
+        based on subkey values. If copy=True, then make a deep copy of Vkeys and values.
+
+        Examples:
+            preds[`preproc_0`, `RF`] => Vdict with all items that have subkey
+                                        with value `preproc_0` and another with `RF`
+            `preproc_0` in preds => bool
+            (`model`, `RF`) in preds => bool
+        """
+        pass

vflow/vkey.py

@@ -0,0 +1,68 @@
+"""Vdict key tuple wrapper class
+"""
+from typing import Tuple, Union
+
+class Vkey:
+
+    def __init__(self, subkeys, origin: str, method: str):
+        """
+        Parameters
+        ----------
+        subkeys: tuple
+            tuple of subkeys to associate with this Vkey
+        origin: str
+            string attribute that identifies the Vset that created this Vkey
+        method: str
+            String attribute that identifies the Vset method that was called to create
+            this Vkey
+        """
+        self._subkeys = subkeys
+        self.origin = origin
+        self.method = method
+
+    def subkeys(self):
+        """Return a tuple of the Subkeys in this Vkey.
+        """
+        return self._subkeys
+    
+    def get_origins(self):
+        """Return a tuple of strings with the origins of the Subkeys in this Vkey.
+        """
+        return (sk.origin for sk in self.subkeys())
+    
+    def get_values(self):
+        """Return a tuple of strings with the values of the Subkeys in this Vkey.
+        """
+        return (sk.value for sk in self.subkeys())
+    
+    def __contains__(self, *subkeys: Union[str, Tuple[str, str]]):
+        """Returns True if subkeys that are strings overlap with self.get_values()
+        and if subkeys that are string tuples like (`origin`, `value`) have 
+        corresponding matches in both self.get_origins() and self.get_values().
+
+        Examples:
+            `preproc_0` in vkey => bool
+            (`model`, `RF`) in vkey => bool
+        """
+        pass
+
+    def __add__(self, other: 'Vkey'):
+        """Return a new Vkey by combining this Vkey with other, following Subkey
+        matching rules. Returns an empty Vkey if there are any Subkey mismatches.
+        """
+        pass
+
+    def __copy__(self):
+        """Return a copy of this Vkey (but not its Subkeys).
+        """
+        pass
+
+    def __deepcopy__(self):
+        """Return a copy of this Vkey and its Subkeys.
+        """
+        pass
+
+    def __len__(self):
+        """Return the number of Subkeys in this Vkey.
+        """
+        return len(self.subkeys())