add repr

Author: Rens Dimmendaal

Diff for: fasttransform/_modidx.py

@@ -26,14 +26,17 @@
                                     'fasttransform.core.Transform.__init_subclass__': ( 'core.html#transform.__init_subclass__',
                                                                                         'fasttransform/core.py'),
                                     'fasttransform.core.Transform.__new__': ('core.html#transform.__new__', 'fasttransform/core.py'),
+                                    'fasttransform.core.Transform.__repr__': ('core.html#transform.__repr__', 'fasttransform/core.py'),
                                     'fasttransform.core.Transform._call': ('core.html#transform._call', 'fasttransform/core.py'),
                                     'fasttransform.core.Transform._do_call': ('core.html#transform._do_call', 'fasttransform/core.py'),
                                     'fasttransform.core.Transform.decode': ('core.html#transform.decode', 'fasttransform/core.py'),
+                                    'fasttransform.core.Transform.name': ('core.html#transform.name', 'fasttransform/core.py'),
                                     'fasttransform.core.Transform.setup': ('core.html#transform.setup', 'fasttransform/core.py'),
                                     'fasttransform.core._TfmDict': ('core.html#_tfmdict', 'fasttransform/core.py'),
                                     'fasttransform.core._TfmDict.__setitem__': ('core.html#_tfmdict.__setitem__', 'fasttransform/core.py'),
                                     'fasttransform.core._TfmMeta': ('core.html#_tfmmeta', 'fasttransform/core.py'),
                                     'fasttransform.core._TfmMeta.__prepare__': ('core.html#_tfmmeta.__prepare__', 'fasttransform/core.py'),
+                                    'fasttransform.core._get_name': ('core.html#_get_name', 'fasttransform/core.py'),
                                     'fasttransform.core._has_self_arg': ('core.html#_has_self_arg', 'fasttransform/core.py'),
                                     'fasttransform.core._is_tfm_method': ('core.html#_is_tfm_method', 'fasttransform/core.py'),
                                     'fasttransform.core._is_tuple': ('core.html#_is_tuple', 'fasttransform/core.py'),

Diff for: fasttransform/core.py

@@ -18,9 +18,15 @@
 from fastcore.dispatch import retain_type
 
 # %% ../nbs/00_core.ipynb 6
-def _is_tuple(o): return isinstance(o, tuple) and not hasattr(o, '_fields')
+def _get_name(o):
+    if hasattr(o,'__qualname__'): return o.__qualname__
+    if hasattr(o,'__name__'): return o.__name__
+    return o.__class__.__name__
 
 # %% ../nbs/00_core.ipynb 7
+def _is_tuple(o): return isinstance(o, tuple) and not hasattr(o, '_fields')
+
+# %% ../nbs/00_core.ipynb 8
 def retain_type(new, old, ret_type,as_copy=False):
     if new is None: return new
     if ret_type is NoneType: return new
@@ -34,7 +40,7 @@ def retain_type(new, old, ret_type,as_copy=False):
     return retain_meta(old, cast(new, ret_type), as_copy=as_copy)
 
 
-# %% ../nbs/00_core.ipynb 14
+# %% ../nbs/00_core.ipynb 15
 _tfm_methods = 'encodes','decodes','setups'
 
 def _is_tfm_method(n, f): return n in _tfm_methods and callable(f)
@@ -46,91 +52,78 @@ def __setitem__(self, k, v):
         self[k].dispatch(v)
 
 
-# %% ../nbs/00_core.ipynb 15
+# %% ../nbs/00_core.ipynb 16
 class _TfmMeta(type):
     @classmethod
     def __prepare__(cls, name, bases): 
         return _TfmDict()
 
-# %% ../nbs/00_core.ipynb 18
+# %% ../nbs/00_core.ipynb 20
 def _has_self_arg(f) -> bool:
     "Check if function `f` has 'self' as first parameter"
     try: return f.__code__.co_varnames[0] == 'self'
     # Attribute error if not callable
     # IndexError if no (kw)args
     except (AttributeError, IndexError): return False
 
-# %% ../nbs/00_core.ipynb 19
+# %% ../nbs/00_core.ipynb 21
 def _subclass_decorator(cls, f):
     nm = f.__name__
-    # needed for plum to register dispatch correctly
-    # f.__qualname__ = f"{cls.__name__}.{nm}"
     if not hasattr(cls, nm): setattr(cls, nm, Function(f).dispatch(f))
     else: getattr(cls,nm).dispatch(f)
     return cls
 
-# %% ../nbs/00_core.ipynb 20
+# %% ../nbs/00_core.ipynb 22
 class Transform(metaclass=_TfmMeta):
     "Delegates (`__call__`,`decode`,`setup`) to (<code>encodes</code>,<code>decodes</code>,<code>setups</code>) if `split_idx` matches"
     split_idx,init_enc,order,train_setup = None,None,0,None
-
+    
     def __init_subclass__(cls):
         orig_init = cls.__init__ if hasattr(cls,'__init__') else lambda o: None
-
         def __init__(self,*args,**kwargs):
             orig_init(self, *args, **kwargs)
             for nm in _tfm_methods:
                 if hasattr(self.__class__, nm):
                     setattr(self, nm, MethodType(getattr(self.__class__, nm), self))
-    
         cls.__init__ = __init__
 
     def __new__(cls, enc=None, dec=None):
-        # subclass of Transform decorator usage
+        "Catch use of subclasses of Transform as decorator."
         if (
             issubclass(cls,Transform) and   
             _has_self_arg(enc) and
             enc.__name__ in _tfm_methods and
             dec is None
         ): return _subclass_decorator(cls, enc)
-        # default usecase
         return super().__new__(cls)
 
     def __init__(self,enc=None,dec=None, split_idx=None, order=None):
         self.split_idx = ifnone(split_idx, self.split_idx)
-        if order is not None: self.order=order
-            
+        if order is not None: self.order=order 
         enc = L(enc)
         if enc: self.encodes = Function(enc[0])
         for e in enc: self.encodes.dispatch(e)
-
         dec = L(dec)
         if dec: self.decodes = Function(dec[0])
         for d in dec: self.decodes.dispatch(d)
 
-    def __call__(self,*args,split_idx=None, **kwargs):
-        return self._call('encodes', split_idx, *args,**kwargs)
-    
-    def decode(self, *args,split_idx=None, **kwargs):
-        return self._call('decodes', split_idx, *args, **kwargs)
-    
+    def __call__(self,*args,split_idx=None, **kwargs): return self._call('encodes', split_idx, *args,**kwargs)
+    def decode(self, *args,split_idx=None, **kwargs): return self._call('decodes', split_idx, *args, **kwargs)
     def setup(self, items=None, train_setup=False):
         train_setup = train_setup if self.train_setup is None else self.train_setup
-        # fastcore could initalize a TypeDispatch without implementation, always returning input
         setups = self.setups if hasattr(self,'setups') else lambda o:o
         return setups(getattr(items, 'train', items) if train_setup else items)
 
     def _call(self, nm, split_idx=None, *args, **kwargs):
         if split_idx!=self.split_idx and self.split_idx is not None: return args[0]
         return self._do_call(nm, *args, **kwargs)
-    
+
     def _do_call(self, nm, *args, **kwargs): 
         x = args[0]
         if not hasattr(self, nm): return x
         if _is_tuple(x):
             res = tuple(self._do_call(nm, x_, *args[1:], **kwargs) for x_ in x)
             return retain_type(res, x, Any)
-        
         f_args = args if type(self) is Transform else (self,)+args
         try:
             method, ret_type = getattr(self,nm)._resolve_method_with_cache(f_args)
@@ -139,9 +132,13 @@ def _do_call(self, nm, *args, **kwargs):
         res = method(*f_args,**kwargs)
         return retain_type(res, x, ret_type)
 
+    @property
+    def name(self): return getattr(self, '_name', _get_name(self))
+    def __repr__(self): return f'{self.name}:\nencodes: {self.encodes}decodes: {self.decodes}'
+
 add_docs(Transform, decode="Delegate to decodes to undo transform", setup="Delegate to setups to set up transform")
 
-# %% ../nbs/00_core.ipynb 116
+# %% ../nbs/00_core.ipynb 117
 def compose_tfms(x, tfms, is_enc=True, reverse=False, **kwargs):
     "Apply all `func_nm` attribute of `tfms` on `x`, maybe in `reverse` order"
     if reverse: tfms = reversed(tfms)
@@ -151,13 +148,13 @@ def compose_tfms(x, tfms, is_enc=True, reverse=False, **kwargs):
     return x
 
 
-# %% ../nbs/00_core.ipynb 121
+# %% ../nbs/00_core.ipynb 122
 def mk_transform(f):
     "Convert function `f` to `Transform` if it isn't already one"
     f = instantiate(f)
     return f if isinstance(f,(Transform,Pipeline)) else Transform(f)
 
-# %% ../nbs/00_core.ipynb 122
+# %% ../nbs/00_core.ipynb 123
 def gather_attrs(o, k, nm):
     "Used in __getattr__ to collect all attrs `k` from `self.{nm}`"
     if k.startswith('_') or k==nm: raise AttributeError(k)
@@ -166,12 +163,12 @@ def gather_attrs(o, k, nm):
     if not res: raise AttributeError(k)
     return res[0] if len(res)==1 else L(res)
 
-# %% ../nbs/00_core.ipynb 123
+# %% ../nbs/00_core.ipynb 124
 def gather_attr_names(o, nm):
     "Used in __dir__ to collect all attrs `k` from `self.{nm}`"
     return L(getattr(o,nm)).map(dir).concat().unique()
 
-# %% ../nbs/00_core.ipynb 124
+# %% ../nbs/00_core.ipynb 125
 class Pipeline:
     "A pipeline of composed (for encode/decode) transforms, setup with types"
     def __init__(self, funcs=None, split_idx=None):