manual patch

Author: jph00

fastcore/foundation.py

@@ -47,7 +47,8 @@ def patch(f=None, *, as_prop=False, cls_method=False):
 
 # Cell
 def patch_property(f):
-    "Decorator: add `f` as a property to the first parameter's class (based on f's type annotations)"
+    "Deprecated; use `patch(as_prop=True)` instead"
+    warnings.warn("`patch_property` is deprecated and will be removed; use `patch(as_prop=True)` instead")
     cls = next(iter(f.__annotations__.values()))
     return patch_to(cls, as_prop=True)(f)
 

fastcore/utils.py

@@ -113,12 +113,13 @@ class Inf(metaclass=_InfMeta):
     pass
 
 # Cell
-def _oper(op,a,b=float('nan')): return (lambda o:op(o,a)) if b!=b else op(a,b)
+_dumobj = object()
+def _oper(op,a,b=_dumobj): return (lambda o:op(o,a)) if b is _dumobj else op(a,b)
 
 def _mk_op(nm, mod):
     "Create an operator using `oper` and add to the caller's module"
     op = getattr(operator,nm)
-    def _inner(a,b=float('nan')): return _oper(op, a,b)
+    def _inner(a, b=_dumobj): return _oper(op, a,b)
     _inner.__name__ = _inner.__qualname__ = nm
     _inner.__doc__ = f'Same as `operator.{nm}`, or returns partial if 1 arg'
     mod[nm] = _inner

nbs/01_foundation.ipynb

@@ -357,57 +357,12 @@
    "source": [
     "#export\n",
     "def patch_property(f):\n",
-    "    \"Decorator: add `f` as a property to the first parameter's class (based on f's type annotations)\"\n",
+    "    \"Deprecated; use `patch(as_prop=True)` instead\"\n",
+    "    warnings.warn(\"`patch_property` is deprecated and will be removed; use `patch(as_prop=True)` instead\")\n",
     "    cls = next(iter(f.__annotations__.values()))\n",
     "    return patch_to(cls, as_prop=True)(f)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This is similar to using `patch_to` with the argument `as_prop=True`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class _T3(int): pass\n",
-    "\n",
-    "@patch_property\n",
-    "def prop(self:_T3): return self+1 #this will patch _T3 because of self's type annotation\n",
-    "\n",
-    "t = _T3(1)\n",
-    "test_eq(t.prop, 2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "You may also patch multiple classes at once by passing a tuple of objects as the type annotation for the first argument of your function:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class _T4(int): pass\n",
-    "\n",
-    "@patch_property\n",
-    "def newprop(self:(_T3, _T4)): return self+5\n",
-    "\n",
-    "t = _T3(1)\n",
-    "test_eq(t.newprop, 6)\n",
-    "t = _T4(1)\n",
-    "test_eq(t.newprop, 6)"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

nbs/02_utils.ipynb

@@ -294,7 +294,7 @@
     {
      "data": {
       "text/plain": [
-       "<__main__._t at 0x7fb0035b9be0>"
+       "<__main__._t at 0x7fb002551190>"
       ]
      },
      "execution_count": null,
@@ -608,12 +608,13 @@
    "outputs": [],
    "source": [
     "#export\n",
-    "def _oper(op,a,b=float('nan')): return (lambda o:op(o,a)) if b!=b else op(a,b)\n",
+    "_dumobj = object()\n",
+    "def _oper(op,a,b=_dumobj): return (lambda o:op(o,a)) if b is _dumobj else op(a,b)\n",
     "\n",
     "def _mk_op(nm, mod):\n",
     "    \"Create an operator using `oper` and add to the caller's module\"\n",
     "    op = getattr(operator,nm)\n",
-    "    def _inner(a,b=float('nan')): return _oper(op, a,b)\n",
+    "    def _inner(a, b=_dumobj): return _oper(op, a,b)\n",
     "    _inner.__name__ = _inner.__qualname__ = nm\n",
     "    _inner.__doc__ = f'Same as `operator.{nm}`, or returns partial if 1 arg'\n",
     "    mod[nm] = _inner"
@@ -1023,6 +1024,29 @@
     "test_eq(_f(1, '.', 3), (1,Path('.'),'3',0))"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1, Path('.'), '3', 0)"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "@with_cast\n",
+    "def _f(a, b:Path, c:str='', d=0)->bool: return (a,b,c,d)\n",
+    "\n",
+    "_f(1, '.', 3)"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,