Add check for legacy default=None optional input

Author: nevillelyh

python/coglet/check.py

@@ -0,0 +1,46 @@
+import ast
+import sys
+from typing import Optional, Type, TypeVar
+
+T = TypeVar('T', covariant=True)
+
+
+def find(nodes: list, tpe: Type[T], attr: str, name: str) -> Optional[T]:
+    for n in nodes:
+        if type(n) is tpe and getattr(n, attr) == name:
+            return n
+    return None
+
+
+def check(file: str, predictor: str) -> None:
+    with open(file, 'r') as f:
+        root = ast.parse(f.read())
+
+    p = find(root.body, ast.ClassDef, 'name', predictor)
+    if p is None:
+        return
+    fn = find(p.body, ast.FunctionDef, 'name', 'predict')
+    if fn is None:
+        fn = find(p.body, ast.AsyncFunctionDef, 'name', 'predict')  # type: ignore
+    args_and_defauts = zip(fn.args.args[-len(fn.args.defaults) :], fn.args.defaults)  # type: ignore
+    for a, d in args_and_defauts:
+        if type(a.annotation) is not ast.Name:
+            continue
+        if type(d) is not ast.Call or d.func.id != 'Input':  # type: ignore
+            continue
+        v = find(d.keywords, ast.keyword, 'arg', 'default')
+        if v is None or type(v.value) is not ast.Constant:
+            continue
+        if v.value.value is None:
+            pos = f'{file}:{a.lineno}:{a.col_offset}'
+            print(
+                f'{pos}: Input(default=None, ...) without Optional type hint is ambiguous and deprecated'
+            )
+            src = f'{ast.unparse(a)} = {ast.unparse(d)}'
+            d.keywords = [k for k in d.keywords if k.arg != 'default']
+            dst = f'{a.arg}: Optional[{a.annotation.id}] = {ast.unparse(d)}'
+            print(f'- {src}')
+            print(f'+ {dst}')
+
+
+check(sys.argv[1], sys.argv[2])

python/tests/cases/legacy_optional.py

@@ -0,0 +1,16 @@
+from typing import Optional
+
+from cog import BasePredictor, Input
+
+
+class Predictor(BasePredictor):
+    def predict(
+        self,
+        s1: str,
+        s2: Optional[str],
+        s3: str = Input(),
+        s4: Optional[str] = Input(),
+        s5: str = Input(default=None, description='x'),
+        s6: Optional[str] = Input(default=None),
+    ) -> str:
+        return f'{s1}:{s2}:{s3}:{s4}:{s5}:{s6}'