{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#default_exp transform"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "from fastcore.imports import *\n",
    "from fastcore.foundation import *\n",
    "from fastcore.utils import *\n",
    "from fastcore.dispatch import *\n",
    "import inspect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nbdev.showdoc import *\n",
    "from fastcore.test import *\n",
    "from fastcore.nb_imports import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Transforms\n",
    "\n",
    "> Definition of `Transform` and `Pipeline`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The classes here provide functionality for creating a composition of *partially reversible functions*. By \"partially reversible\" we mean that a transform can be `decode`d, creating a form suitable for display. This is not necessarily identical to the original form (e.g. a transform that changes a byte tensor to a float tensor does not recreate a byte tensor when decoded, since that may lose precision, and a float tensor can be displayed already).\n",
    "\n",
    "Classes are also provided and for composing transforms, and mapping them over collections. `Pipeline` is a transform which composes several `Transform`, knowing how to decode them or show an encoded item."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transform -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "_tfm_methods = 'encodes','decodes','setups'\n",
    "\n",
    "class _TfmDict(dict):\n",
    "    def __setitem__(self,k,v):\n",
    "        if k not in _tfm_methods or not callable(v): return super().__setitem__(k,v)\n",
    "        if k not in self: super().__setitem__(k,TypeDispatch())\n",
    "        self[k].add(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class _TfmMeta(type):\n",
    "    def __new__(cls, name, bases, dict):\n",
    "        res = super().__new__(cls, name, bases, dict)\n",
    "        for nm in _tfm_methods:\n",
    "            base_td = [getattr(b,nm,None) for b in bases]\n",
    "            if nm in res.__dict__: getattr(res,nm).bases = base_td\n",
    "            else: setattr(res, nm, TypeDispatch(bases=base_td))\n",
    "        res.__signature__ = inspect.signature(res.__init__)\n",
    "        return res\n",
    "\n",
    "    def __call__(cls, *args, **kwargs):\n",
    "        f = args[0] if args else None\n",
    "        n = getattr(f,'__name__',None)\n",
    "        if callable(f) and n in _tfm_methods:\n",
    "            getattr(cls,n).add(f)\n",
    "            return f\n",
    "        return super().__call__(*args, **kwargs)\n",
    "\n",
    "    @classmethod\n",
    "    def __prepare__(cls, name, bases): return _TfmDict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def _get_name(o):\n",
    "    if hasattr(o,'__qualname__'): return o.__qualname__\n",
    "    if hasattr(o,'__name__'): return o.__name__\n",
    "    return o.__class__.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def _is_tuple(o): return isinstance(o, tuple) and not hasattr(o, '_fields')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class Transform(metaclass=_TfmMeta):\n",
    "    \"Delegates (`__call__`,`decode`,`setup`) to (<code>encodes</code>,<code>decodes</code>,<code>setups</code>) if `split_idx` matches\"\n",
    "    split_idx,init_enc,order,train_setup = None,None,0,None\n",
    "    def __init__(self, enc=None, dec=None, split_idx=None, order=None):\n",
    "        self.split_idx = ifnone(split_idx, self.split_idx)\n",
    "        if order is not None: self.order=order\n",
    "        self.init_enc = enc or dec\n",
    "        if not self.init_enc: return\n",
    "\n",
    "        self.encodes,self.decodes,self.setups = TypeDispatch(),TypeDispatch(),TypeDispatch()\n",
    "        if enc:\n",
    "            self.encodes.add(enc)\n",
    "            self.order = getattr(enc,'order',self.order)\n",
    "            if len(type_hints(enc)) > 0: self.input_types = first(type_hints(enc).values())\n",
    "            self._name = _get_name(enc)\n",
    "        if dec: self.decodes.add(dec)\n",
    "\n",
    "    @property\n",
    "    def name(self): return getattr(self, '_name', _get_name(self))\n",
    "    def __call__(self, x, **kwargs): return self._call('encodes', x, **kwargs)\n",
    "    def decode  (self, x, **kwargs): return self._call('decodes', x, **kwargs)\n",
    "    def __repr__(self): return f'{self.name}:\\nencodes: {self.encodes}decodes: {self.decodes}'\n",
    "\n",
    "    def setup(self, items=None, train_setup=False):\n",
    "        train_setup = train_setup if self.train_setup is None else self.train_setup\n",
    "        return self.setups(getattr(items, 'train', items) if train_setup else items)\n",
    "\n",
    "    def _call(self, fn, x, split_idx=None, **kwargs):\n",
    "        if split_idx!=self.split_idx and self.split_idx is not None: return x\n",
    "        return self._do_call(getattr(self, fn), x, **kwargs)\n",
    "\n",
    "    def _do_call(self, f, x, **kwargs):\n",
    "        if not _is_tuple(x):\n",
    "            if f is None: return x\n",
    "            ret = f.returns_none(x) if hasattr(f,'returns_none') else None\n",
    "            return retain_type(f(x, **kwargs), x, ret)\n",
    "        res = tuple(self._do_call(f, x_, **kwargs) for x_ in x)\n",
    "        return retain_type(res, x)\n",
    "\n",
    "add_docs(Transform, decode=\"Delegate to <code>decodes</code> to undo transform\", setup=\"Delegate to <code>setups</code> to set up transform\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h2 id=\"Transform\" class=\"doc_header\"><code>class</code> <code>Transform</code><a href=\"\" class=\"source_link\" style=\"float:right\">[source]</a></h2>\n",
       "\n",
       "> <code>Transform</code>(**`enc`**=*`None`*, **`dec`**=*`None`*, **`split_idx`**=*`None`*, **`order`**=*`None`*)\n",
       "\n",
       "Delegates (`__call__`,`decode`,`setup`) to (<code>encodes</code>,<code>decodes</code>,<code>setups</code>) if `split_idx` matches"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(Transform)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A `Transform` is the main building block of the fastai data pipelines. In the most general terms a transform can be any function you want to apply to your data, however the `Transform` class provides several mechanisms that make the process of building them easy and flexible."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The main `Transform` features:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Type dispatch** - Type annotations are used to determine if a transform should be applied to the given argument. It also gives an option to provide several implementations and it choses the one to run based on the type. This is useful for example when running both independent and dependent variables through the pipeline where some transforms only make sense for one and not the other. Another usecase is designing a transform that handles different data formats. Note that if a transform takes multiple arguments only the type of the first one is used for dispatch. \n",
    "- **Handling of tuples** - When a tuple (or a subclass of tuple) of data is passed to a transform it will get applied to each element separately. You can opt out of this behavior by passing a list or an `L`, as only tuples gets this specific behavior. An alternative is to use `ItemTransform` defined below, which will always take the input as a whole.\n",
    "- **Reversability** - A transform can be made reversible by implementing the <code>decodes</code> method. This is mainly used to turn something like a category which is encoded as a number back into a label understandable by humans for showing purposes. Like the regular call method, the `decode` method that is used to decode will be applied over each element of a tuple separately.\n",
    "- **Type propagation** - Whenever possible a transform tries to return data of the same type it received. Mainly used to maintain semantics of things like `ArrayImage` which is a thin wrapper of pytorch's `Tensor`. You can opt out of this behavior by adding `->None` return type annotation.\n",
    "- **Preprocessing** - The `setup` method can be used to perform any one-time calculations to be later used by the transform, for example generating a vocabulary to encode categorical data.\n",
    "- **Filtering based on the dataset type** - By setting the `split_idx` flag you can make the transform be used only in a specific `DataSource` subset like in training, but not validation.\n",
    "- **Ordering** - You can set the `order` attribute which the `Pipeline` uses when it needs to merge two lists of transforms.\n",
    "- **Appending new behavior with decorators** - You can easily extend an existing `Transform` by creating <code>encodes</code> or <code>decodes</code> methods for new data types. You can put those new methods outside the original transform definition and decorate them with the class you wish them patched into. This can be used by the fastai library users to add their own behavior, or multiple modules contributing to the same transform."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining a `Transform`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a few ways to create a transform with different ratios of simplicity to flexibility.\n",
    "- **Extending the `Transform` class** - Use inheritence to implement the methods you want.\n",
    "- **Passing methods to the constructor** - Instantiate the `Transform` class and pass your functions as `enc` and `dec` arguments.\n",
    "- **@Transform decorator** - Turn any function into a `Transform` by just adding a decorator - very straightforward if all you need is a single <code>encodes</code> implementation.\n",
    "- **Passing a function to fastai APIs** - Same as above, but when passing a function to other transform aware classes like `Pipeline` or `TfmdDS` you don't even need a decorator. Your function will get converted to a `Transform` automatically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A(Transform): pass\n",
    "@A\n",
    "def encodes(self, x): return x+1\n",
    "f1 = A()\n",
    "test_eq(f1(1), 2)\n",
    "\n",
    "class B(A): pass\n",
    "@B\n",
    "def decodes(self, x): return x-1\n",
    "f2 = B()\n",
    "test_eq(f2(1), 2)\n",
    "test_eq(f2.decode(2), 1)\n",
    "test_eq(f1.decode(2), 2)\n",
    "\n",
    "class A(Transform): pass\n",
    "f3 = A()\n",
    "test_eq_type(f3(2), 2)\n",
    "test_eq_type(f3.decode(2.0), 2.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Transform` can be used as a decorator, to turn a function into a `Transform`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = Transform(lambda o:o//2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq_type(f(2), 1)\n",
    "test_eq_type(f.decode(2.0), 2.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@Transform\n",
    "def f(x): return x//2\n",
    "test_eq_type(f(2), 1)\n",
    "test_eq_type(f.decode(2.0), 2.0)\n",
    "\n",
    "@Transform\n",
    "def f(x): return x*2\n",
    "test_eq_type(f(2), 4)\n",
    "test_eq_type(f.decode(2.0), 2.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can derive from `Transform` and use <code>encodes</code> for your encoding function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ArrayImage(ndarray):\n",
    "    _show_args = {'cmap':'viridis'}\n",
    "    def __new__(cls, x, *args, **kwargs):\n",
    "        if isinstance(x,tuple): super().__new__(cls, x, *args, **kwargs)\n",
    "        if args or kwargs: raise RuntimeError('Unknown array init args')\n",
    "        if not isinstance(x,ndarray): x = array(x)\n",
    "        return x.view(cls)\n",
    "    \n",
    "    def show(self, ctx=None, figsize=None, **kwargs):\n",
    "        if ctx is None: _,ctx = plt.subplots(figsize=figsize)\n",
    "        ctx.imshow(im, **{**self._show_args, **kwargs})\n",
    "        ctx.axis('off')\n",
    "        return ctx\n",
    "    \n",
    "im = Image.open(TEST_IMAGE)\n",
    "im_t = ArrayImage(im)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A:\n",
       "encodes: (ArrayImage,object) -> encodes\n",
       "decodes: (ArrayImage,object) -> decodes"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class A(Transform):\n",
    "    def encodes(self, x:ArrayImage): return -x\n",
    "    def decodes(self, x:ArrayImage): return x+1\n",
    "    def setups (self, x:ArrayImage): x.foo = 'a'\n",
    "f = A()\n",
    "t = f(im_t)\n",
    "test_eq(t, -im_t)\n",
    "test_eq(f(1), 1)\n",
    "test_eq(type(t), ArrayImage)\n",
    "test_eq(f.decode(t), -im_t+1)\n",
    "test_eq(f.decode(1), 1)\n",
    "f.setup(im_t)\n",
    "test_eq(im_t.foo, 'a')\n",
    "t2 = array(1)\n",
    "f.setup(t2)\n",
    "assert not hasattr(f2,'foo')\n",
    "f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Without return annotation we get an `Int` back since that's what was passed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A(Transform): pass\n",
    "@A\n",
    "def encodes(self, x:Int): return x//2\n",
    "@A\n",
    "def encodes(self, x:float): return x+1\n",
    "\n",
    "f = A()\n",
    "test_eq_type(f(Int(2)), Int(1))\n",
    "test_eq_type(f(2), 2)\n",
    "test_eq_type(f(2.), 3.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Without return annotation we don't cast if we're not a subclass of the input type. If the annotation is a tuple, then any type in the tuple will match."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A(Transform):\n",
    "    def encodes(self, x:(Int,float)): return x/2\n",
    "    def encodes(self, x:(str,list)): return str(x)+'1'\n",
    "\n",
    "f = A()\n",
    "test_eq_type(f(Int(2)), 1.)\n",
    "test_eq_type(f(2), 2)\n",
    "test_eq_type(f(Float(2.)), Float(1.))\n",
    "test_eq_type(f('a'), 'a1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With return annotation `None` we get back whatever Python creates usually."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(x)->None: return x/2\n",
    "f = Transform(func)\n",
    "test_eq_type(f(2), 1.)\n",
    "test_eq_type(f(2.), 1.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since <code>decodes</code> has no return annotation, but <code>encodes</code> created an `Int` and we pass that result here to `decode`, we end up with an `Int`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(x): return Int(x+1)\n",
    "def dec (x): return x-1\n",
    "f = Transform(func,dec)\n",
    "t = f(1)\n",
    "test_eq_type(t, Int(2))\n",
    "test_eq_type(f.decode(t), Int(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the transform has `split_idx` then it's only applied if `split_idx` param matches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f.split_idx = 1\n",
    "test_eq(f(1, split_idx=1),2)\n",
    "test_eq_type(f(1, split_idx=0), 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transform takes lists as a whole and is applied to them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A(Transform): \n",
    "    def encodes(self, xy): x,y=xy; return [x+y,y]\n",
    "    def decodes(self, xy): x,y=xy; return [x-y,y]\n",
    "\n",
    "f = A()\n",
    "t = f([1,2])\n",
    "test_eq(t, [3,2])\n",
    "test_eq(f.decode(t), [1,2])\n",
    "f.split_idx = 1\n",
    "test_eq(f([1,2], split_idx=1), [3,2])\n",
    "test_eq(f([1,2], split_idx=0), [1,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AL(Transform): pass\n",
    "@AL\n",
    "def encodes(self, x): return L(x_+1 for x_ in x)\n",
    "@AL\n",
    "def decodes(self, x): return L(x_-1 for x_ in x)\n",
    "\n",
    "f = AL()\n",
    "t = f([1,2])\n",
    "test_eq(t, [2,3])\n",
    "test_eq(f.decode(t), [1,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transforms are applied to each element of a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def neg_int(x:numbers.Integral): return -x\n",
    "\n",
    "f = Transform(neg_int)\n",
    "test_eq(f((1,)), (-1,))\n",
    "test_eq(f((1.,)), (1.,))\n",
    "test_eq(f((1.,2,3.)), (1.,-2,3.))\n",
    "test_eq(f.decode((1,2)), (1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "test_eq(f.input_types, numbers.Integral)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class InplaceTransform(Transform):\n",
    "    \"A `Transform` that modifies in-place and just returns whatever it's passed\"\n",
    "    def _call(self, fn, x, split_idx=None, **kwargs):\n",
    "        super()._call(fn,x,split_idx,**kwargs)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A(InplaceTransform): pass\n",
    "@A\n",
    "def encodes(self, x:pd.Series): x.fillna(10, inplace=True)\n",
    "f = A()\n",
    "test_eq_type(f(pd.Series([1,2,None])),pd.Series([1,2,10]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class B(Transform): pass\n",
    "\n",
    "@B\n",
    "def encodes(self, x:int): return x+1\n",
    "@B\n",
    "def encodes(self, x:str): return x+'1'\n",
    "@B\n",
    "def encodes(self, x)->None: return str(x)+'!'\n",
    "\n",
    "b = B()\n",
    "test_eq(b([1]), '[1]!')\n",
    "test_eq(b((1,)), (2,))\n",
    "test_eq(b(('1',)), ('11',))\n",
    "test_eq(b([1.0]), '[1.0]!')\n",
    "test_eq(b.decode([2]), [2])\n",
    "assert pickle.loads(pickle.dumps(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@B\n",
    "def decodes(self, x:int): return x-1\n",
    "test_eq(b.decode((2,)), (1,))\n",
    "test_eq(b.decode(('2',)), ('2',))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Non-type-constrained functions are applied to all elements of a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A(Transform): pass\n",
    "@A\n",
    "def encodes(self, x): return x+1\n",
    "@A\n",
    "def decodes(self, x): return x-1\n",
    "\n",
    "f = A()\n",
    "t = f((1,2.0))\n",
    "test_eq_type(t, (2,3.0))\n",
    "test_eq_type(f.decode(t), (1,2.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Type-constrained functions are applied to only matching elements of a tuple, and return annotations are only applied where matching."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class B(Transform):\n",
    "    def encodes(self, x:int): return Int(x+1)\n",
    "    def encodes(self, x:str): return x+'1'\n",
    "    def decodes(self, x:Int): return x//2\n",
    "\n",
    "f = B()\n",
    "start = (1.,2,'3')\n",
    "t = f(start)\n",
    "test_eq_type(t, (1.,Int(3),'31'))\n",
    "test_eq(f.decode(t), (1.,Int(1),'31'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dispatching over tuples works recursively, by the way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = B()\n",
    "start = (1.,(2,'3'))\n",
    "t = f(start)\n",
    "test_eq_type(t, (1.,(Int(3),'31')))\n",
    "test_eq(f.decode(t), (1.,(Int(1),'31')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same behavior also works with `typing` module type classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A(Transform): pass\n",
    "@A\n",
    "def encodes(self, x:numbers.Integral): return x+1\n",
    "@A\n",
    "def encodes(self, x:float): return x*3\n",
    "@A\n",
    "def decodes(self, x:int): return x-1\n",
    "\n",
    "f = A()\n",
    "start = 1.0\n",
    "t = f(start)\n",
    "test_eq(t, 3.)\n",
    "test_eq(f.decode(t), 3)\n",
    "\n",
    "start = (1.,2,3.)\n",
    "t = f(start)\n",
    "test_eq(t, (3.,3,9.))\n",
    "test_eq(f.decode(t), (3.,2,9.))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "class DisplayedTransform(Transform):\n",
    "    \"A transform with a `__repr__` that shows its attrs\"\n",
    "\n",
    "    @property\n",
    "    def name(self): return f\"{super().name} -- {getattr(self,'__stored_args__',{})}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transforms normally are represented by just their class name and a list of encodes and decodes implementations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A:\n",
       "encodes: (object,object) -> noop\n",
       "decodes: (object,object) -> noop"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class A(Transform): encodes,decodes = noop,noop\n",
    "f = A()\n",
    "f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A `DisplayedTransform` will in addition show the contents of all attributes listed in the comma-delimited string `self.store_attrs`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A -- {'a': 1, 'b': 2}:\n",
       "encodes: (object,object) -> noop\n",
       "decodes: "
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class A(DisplayedTransform):\n",
    "    encodes = noop\n",
    "    def __init__(self, a, b=2):\n",
    "        super().__init__()\n",
    "        store_attr()\n",
    "    \n",
    "A(a=1,b=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ItemTransform -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class ItemTransform(Transform):\n",
    "    \"A transform that always take tuples as items\"\n",
    "    _retain = True\n",
    "    def __call__(self, x, **kwargs): return self._call1(x, '__call__', **kwargs)\n",
    "    def decode(self, x, **kwargs):   return self._call1(x, 'decode', **kwargs)\n",
    "    def _call1(self, x, name, **kwargs):\n",
    "        if not _is_tuple(x): return getattr(super(), name)(x, **kwargs)\n",
    "        y = getattr(super(), name)(list(x), **kwargs)\n",
    "        if not self._retain: return y\n",
    "        if is_listy(y) and not isinstance(y, tuple): y = tuple(y)\n",
    "        return retain_type(y, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`ItemTransform` is the class to use to opt out of the default behavior of `Transform`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AIT(ItemTransform): \n",
    "    def encodes(self, xy): x,y=xy; return (x+y,y)\n",
    "    def decodes(self, xy): x,y=xy; return (x-y,y)\n",
    "    \n",
    "f = AIT()\n",
    "test_eq(f((1,2)), (3,2))\n",
    "test_eq(f.decode((3,2)), (1,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you pass a special tuple subclass, the usual retain type behavior of `Transform` will keep it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class _T(tuple): pass\n",
    "x = _T((1,2))\n",
    "test_eq_type(f(x), _T((3,2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "f.split_idx = 0\n",
    "test_eq_type(f((1,2)), (1,2))\n",
    "test_eq_type(f((1,2), split_idx=0), (3,2))\n",
    "test_eq_type(f.decode((1,2)), (1,2))\n",
    "test_eq_type(f.decode((3,2), split_idx=0), (1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "class Get(ItemTransform):\n",
    "    _retain = False\n",
    "    def encodes(self, x): return x[0]\n",
    "    \n",
    "g = Get()\n",
    "test_eq(g([1,2,3]), 1)\n",
    "test_eq(g(L(1,2,3)), 1)\n",
    "test_eq(g(np.array([1,2,3])), 1)\n",
    "test_eq_type(g((['a'], ['b', 'c'])), ['a'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "class A(ItemTransform): \n",
    "    def encodes(self, x): return _T((x,x))\n",
    "    def decodes(self, x): return _T(x)\n",
    "    \n",
    "f = A()\n",
    "test_eq(type(f.decode((1,1))), _T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Func -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def get_func(t, name, *args, **kwargs):\n",
    "    \"Get the `t.name` (potentially partial-ized with `args` and `kwargs`) or `noop` if not defined\"\n",
    "    f = getattr(t, name, noop)\n",
    "    return f if not (args or kwargs) else partial(f, *args, **kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This works for any kind of `t` supporting `getattr`, so a class or a module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(get_func(operator, 'neg', 2)(), -2)\n",
    "test_eq(get_func(operator.neg, '__call__')(2), -2)\n",
    "test_eq(get_func(list, 'foobar')([2]), [2])\n",
    "a = [2,1]\n",
    "get_func(list, 'sort')(a)\n",
    "test_eq(a, [1,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transforms are built with multiple-dispatch: a given function can have several methods depending on the type of the object received. This is done directly with the `TypeDispatch` module and type-annotation in `Transform`, but you can also use the following class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class Func():\n",
    "    \"Basic wrapper around a `name` with `args` and `kwargs` to call on a given type\"\n",
    "    def __init__(self, name, *args, **kwargs): self.name,self.args,self.kwargs = name,args,kwargs\n",
    "    def __repr__(self): return f'sig: {self.name}({self.args}, {self.kwargs})'\n",
    "    def _get(self, t): return get_func(t, self.name, *self.args, **self.kwargs)\n",
    "    def __call__(self,t): return mapped(self._get, t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can call the `Func` object on any module name or type, even a list of types. It will return the corresponding function (with a default to `noop` if nothing is found) or list of functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(Func('sqrt')(math), math.sqrt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class _Sig():\n",
    "    def __getattr__(self,k):\n",
    "        def _inner(*args, **kwargs): return Func(k, *args, **kwargs)\n",
    "        return _inner\n",
    "\n",
    "Sig = _Sig()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"Sig\" class=\"doc_header\"><code>Sig</code><a href=\"__main__.py#L4\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>Sig</code>(**\\*`args`**, **\\*\\*`kwargs`**)\n",
       "\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(Sig, name=\"Sig\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Sig` is just sugar-syntax to create a `Func` object more easily with the syntax `Sig.name(*args, **kwargs)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = Sig.sqrt()\n",
    "test_eq(f(math), math.sqrt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pipeline -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def compose_tfms(x, tfms, is_enc=True, reverse=False, **kwargs):\n",
    "    \"Apply all `func_nm` attribute of `tfms` on `x`, maybe in `reverse` order\"\n",
    "    if reverse: tfms = reversed(tfms)\n",
    "    for f in tfms:\n",
    "        if not is_enc: f = f.decode\n",
    "        x = f(x, **kwargs)\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_int  (x):   return Int(x)\n",
    "def to_float(x):   return Float(x)\n",
    "def double  (x):   return x*2\n",
    "def half(x)->None: return x/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_compose(a, b, *fs): test_eq_type(compose_tfms(a, tfms=map(Transform,fs)), b)\n",
    "\n",
    "test_compose(1,   Int(1),   to_int)\n",
    "test_compose(1,   Float(1), to_int,to_float)\n",
    "test_compose(1,   Float(2), to_int,to_float,double)\n",
    "test_compose(2.0, 2.0,      to_int,double,half)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A(Transform):\n",
    "    def encodes(self, x:float):  return Float(x+1)\n",
    "    def decodes(self, x): return x-1\n",
    "    \n",
    "tfms = [A(), Transform(math.sqrt)]\n",
    "t = compose_tfms(3., tfms=tfms)\n",
    "test_eq_type(t, Float(2.))\n",
    "test_eq(compose_tfms(t, tfms=tfms, is_enc=False), 1.)\n",
    "test_eq(compose_tfms(4., tfms=tfms, reverse=True), 3.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfms = [A(), Transform(math.sqrt)]\n",
    "test_eq(compose_tfms((9,3.), tfms=tfms), (3,2.))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def mk_transform(f):\n",
    "    \"Convert function `f` to `Transform` if it isn't already one\"\n",
    "    f = instantiate(f)\n",
    "    return f if isinstance(f,(Transform,Pipeline)) else Transform(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def gather_attrs(o, k, nm):\n",
    "    \"Used in __getattr__ to collect all attrs `k` from `self.{nm}`\"\n",
    "    if k.startswith('_') or k==nm: raise AttributeError(k)\n",
    "    att = getattr(o,nm)\n",
    "    res = [t for t in att.attrgot(k) if t is not None]\n",
    "    if not res: raise AttributeError(k)\n",
    "    return res[0] if len(res)==1 else L(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def gather_attr_names(o, nm):\n",
    "    \"Used in __dir__ to collect all attrs `k` from `self.{nm}`\"\n",
    "    return L(getattr(o,nm)).map(dir).concat().unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class Pipeline:\n",
    "    \"A pipeline of composed (for encode/decode) transforms, setup with types\"\n",
    "    def __init__(self, funcs=None, split_idx=None):\n",
    "        self.split_idx,self.default = split_idx,None\n",
    "        if funcs is None: funcs = []\n",
    "        if isinstance(funcs, Pipeline): self.fs = funcs.fs\n",
    "        else:\n",
    "            if isinstance(funcs, Transform): funcs = [funcs]\n",
    "            self.fs = L(ifnone(funcs,[noop])).map(mk_transform).sorted(key='order')\n",
    "        for f in self.fs:\n",
    "            name = camel2snake(type(f).__name__)\n",
    "            a = getattr(self,name,None)\n",
    "            if a is not None: f = L(a)+f\n",
    "            setattr(self, name, f)\n",
    "\n",
    "    def setup(self, items=None, train_setup=False):\n",
    "        tfms = self.fs[:]\n",
    "        self.fs.clear()\n",
    "        for t in tfms: self.add(t,items, train_setup)\n",
    "\n",
    "    def add(self,t, items=None, train_setup=False):\n",
    "        t.setup(items, train_setup)\n",
    "        self.fs.append(t)\n",
    "\n",
    "    def __call__(self, o): return compose_tfms(o, tfms=self.fs, split_idx=self.split_idx)\n",
    "    def __repr__(self): return f\"Pipeline: {' -> '.join([f.name for f in self.fs if f.name != 'noop'])}\"\n",
    "    def __getitem__(self,i): return self.fs[i]\n",
    "    def __setstate__(self,data): self.__dict__.update(data)\n",
    "    def __getattr__(self,k): return gather_attrs(self, k, 'fs')\n",
    "    def __dir__(self): return super().__dir__() + gather_attr_names(self, 'fs')\n",
    "\n",
    "    def decode  (self, o, full=True):\n",
    "        if full: return compose_tfms(o, tfms=self.fs, is_enc=False, reverse=True, split_idx=self.split_idx)\n",
    "        #Not full means we decode up to the point the item knows how to show itself.\n",
    "        for f in reversed(self.fs):\n",
    "            if self._is_showable(o): return o\n",
    "            o = f.decode(o, split_idx=self.split_idx)\n",
    "        return o\n",
    "\n",
    "    def show(self, o, ctx=None, **kwargs):\n",
    "        o = self.decode(o, full=False)\n",
    "        o1 = (o,) if not _is_tuple(o) else o\n",
    "        if hasattr(o, 'show'): ctx = o.show(ctx=ctx, **kwargs)\n",
    "        else:\n",
    "            for o_ in o1:\n",
    "                if hasattr(o_, 'show'): ctx = o_.show(ctx=ctx, **kwargs)\n",
    "        return ctx\n",
    "\n",
    "    def _is_showable(self, o):\n",
    "        if hasattr(o, 'show'): return True\n",
    "        if _is_tuple(o): return all(hasattr(o_, 'show') for o_ in o)\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "add_docs(Pipeline,\n",
    "         __call__=\"Compose `__call__` of all `fs` on `o`\",\n",
    "         decode=\"Compose `decode` of all `fs` on `o`\",\n",
    "         show=\"Show `o`, a single item from a tuple, decoding as needed\",\n",
    "         add=\"Add transform `t`\",\n",
    "         setup=\"Call each tfm's `setup` in order\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Pipeline` is a wrapper for `compose_tfm`. You can pass instances of `Transform` or regular functions in `funcs`, the `Pipeline` will wrap them all in `Transform` (and instantiate them if needed) during the initialization. It handles the transform `setup` by adding them one at a time and calling setup on each, goes through them in order in `__call__` or `decode` and can `show` an object by applying decoding the transforms up until the point it gets an object that knows how to show itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Empty pipeline is noop\n",
    "pipe = Pipeline()\n",
    "test_eq(pipe(1), 1)\n",
    "test_eq(pipe((1,)), (1,))\n",
    "# Check pickle works\n",
    "assert pickle.loads(pickle.dumps(pipe))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class IntFloatTfm(Transform):\n",
    "    def encodes(self, x):  return Int(x)\n",
    "    def decodes(self, x):  return Float(x)\n",
    "    foo=1\n",
    "\n",
    "int_tfm=IntFloatTfm()\n",
    "\n",
    "def neg(x): return -x\n",
    "neg_tfm = Transform(neg, neg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipe = Pipeline([neg_tfm, int_tfm])\n",
    "\n",
    "start = 2.0\n",
    "t = pipe(start)\n",
    "test_eq_type(t, Int(-2))\n",
    "test_eq_type(pipe.decode(t), Float(start))\n",
    "test_stdout(lambda:pipe.show(t), '-2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipe = Pipeline([neg_tfm, int_tfm])\n",
    "t = pipe(start)\n",
    "test_stdout(lambda:pipe.show(pipe((1.,2.))), '-1\\n-2')\n",
    "test_eq(pipe.foo, 1)\n",
    "assert 'foo' in dir(pipe)\n",
    "assert 'int_float_tfm' in dir(pipe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transforms are available as attributes named with the snake_case version of the names of their types. Attributes in transforms can be directly accessed as attributes of the pipeline."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(pipe.int_float_tfm, int_tfm)\n",
    "test_eq(pipe.foo, 1)\n",
    "\n",
    "pipe = Pipeline([int_tfm, int_tfm])\n",
    "pipe.int_float_tfm\n",
    "test_eq(pipe.int_float_tfm[0], int_tfm)\n",
    "test_eq(pipe.foo, [1,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check opposite order\n",
    "pipe = Pipeline([int_tfm,neg_tfm])\n",
    "t = pipe(start)\n",
    "test_eq(t, -2)\n",
    "test_stdout(lambda:pipe.show(t), '-2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A(Transform):\n",
    "    def encodes(self, x):  return int(x)\n",
    "    def decodes(self, x):  return Float(x)\n",
    "\n",
    "pipe = Pipeline([neg_tfm, A])\n",
    "t = pipe(start)\n",
    "test_eq_type(t, -2)\n",
    "test_eq_type(pipe.decode(t), Float(start))\n",
    "test_stdout(lambda:pipe.show(t), '-2.0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s2 = (1,2)\n",
    "pipe = Pipeline([neg_tfm, A])\n",
    "t = pipe(s2)\n",
    "test_eq_type(t, (-1,-2))\n",
    "test_eq_type(pipe.decode(t), (Float(1.),Float(2.)))\n",
    "test_stdout(lambda:pipe.show(t), '-1.0\\n-2.0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class B(Transform):\n",
    "    def encodes(self, x): return x+1\n",
    "    def decodes(self, x): return x-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f1(x:ArrayImage): return -x\n",
    "def f2(x): return Image.open(x).resize((128,128))\n",
    "def f3(x:Image.Image): return(ArrayImage(array(x)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipe = Pipeline([f2,f3,f1])\n",
    "t = pipe(TEST_IMAGE)\n",
    "test_eq(type(t), ArrayImage)\n",
    "test_eq(t, -array(f3(f2(TEST_IMAGE))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pipe = Pipeline([f2,f3])\n",
    "t = pipe(TEST_IMAGE)\n",
    "ax = pipe.show(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_fig_exists(ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Check filtering is properly applied\n",
    "add1 = B()\n",
    "add1.split_idx = 1\n",
    "pipe = Pipeline([neg_tfm, A(), add1])\n",
    "test_eq(pipe(start), -2)\n",
    "pipe.split_idx=1\n",
    "test_eq(pipe(start), -1)\n",
    "pipe.split_idx=0\n",
    "test_eq(pipe(start), -2)\n",
    "for t in [None, 0, 1]:\n",
    "    pipe.split_idx=t\n",
    "    test_eq(pipe.decode(pipe(start)), start)\n",
    "    test_stdout(lambda: pipe.show(pipe(start)), \"-2.0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def neg(x): return -x\n",
    "test_eq(type(mk_transform(neg)), Transform)\n",
    "test_eq(type(mk_transform(math.sqrt)), Transform)\n",
    "test_eq(type(mk_transform(lambda a:a*2)), Transform)\n",
    "test_eq(type(mk_transform(Pipeline([neg]))), Pipeline)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TODO: method examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"Pipeline.__call__\" class=\"doc_header\"><code>Pipeline.__call__</code><a href=\"__main__.py#L26\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>Pipeline.__call__</code>(**`o`**)\n",
       "\n",
       "Compose `__call__` of all `fs` on `o`"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(Pipeline.__call__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"Pipeline.decode\" class=\"doc_header\"><code>Pipeline.decode</code><a href=\"__main__.py#L33\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>Pipeline.decode</code>(**`o`**, **`full`**=*`True`*)\n",
       "\n",
       "Compose `decode` of all `fs` on `o`"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(Pipeline.decode)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"Pipeline.setup\" class=\"doc_header\"><code>Pipeline.setup</code><a href=\"__main__.py#L17\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>Pipeline.setup</code>(**`items`**=*`None`*, **`train_setup`**=*`False`*)\n",
       "\n",
       "Call each tfm's `setup` in order"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(Pipeline.setup)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "During the setup, the `Pipeline` starts with no transform and adds them one at a time, so that during its setup, each transform gets the items processed up to its point and not after."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "#Test is with TfmdList"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Export -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted 00_test.ipynb.\n",
      "Converted 01_foundation.ipynb.\n",
      "Converted 02_utils.ipynb.\n",
      "Converted 03_dispatch.ipynb.\n",
      "Converted 04_transform.ipynb.\n",
      "Converted index.ipynb.\n"
     ]
    }
   ],
   "source": [
    "#hide\n",
    "from nbdev.export import notebook2script\n",
    "notebook2script()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "jupytext": {
   "split_at_heading": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}