chore: self reference without quotations marks

Author: samedii

lantern/numpy.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import numpy as np
 import torch
 
@@ -19,7 +20,7 @@ def validate(cls, data) -> np.ndarray:
             return np.array(data)
 
     @classmethod
-    def ndim(cls, ndim) -> "Numpy":
+    def ndim(cls, ndim) -> Numpy:
         class InheritNumpy(cls):
             @classmethod
             def validate(cls, data):
@@ -31,7 +32,7 @@ def validate(cls, data):
         return InheritNumpy
 
     @classmethod
-    def dims(cls, dims) -> "Numpy":
+    def dims(cls, dims) -> Numpy:
         class InheritNumpy(cls):
             @classmethod
             def validate(cls, data):
@@ -45,7 +46,7 @@ def validate(cls, data):
         return InheritNumpy
 
     @classmethod
-    def shape(cls, *sizes) -> "Numpy":
+    def shape(cls, *sizes) -> Numpy:
         class InheritNumpy(cls):
             @classmethod
             def validate(cls, data):
@@ -58,7 +59,7 @@ def validate(cls, data):
         return InheritNumpy
 
     @classmethod
-    def between(cls, ge, le) -> "Numpy":
+    def between(cls, ge, le) -> Numpy:
         class InheritNumpy(cls):
             @classmethod
             def validate(cls, data):
@@ -78,7 +79,7 @@ def validate(cls, data):
         return InheritNumpy
 
     @classmethod
-    def ge(cls, ge) -> "Numpy":
+    def ge(cls, ge) -> Numpy:
         class InheritTensor(cls):
             @classmethod
             def validate(cls, data):
@@ -91,7 +92,7 @@ def validate(cls, data):
         return InheritTensor
 
     @classmethod
-    def le(cls, le) -> "Numpy":
+    def le(cls, le) -> Numpy:
         class InheritTensor(cls):
             @classmethod
             def validate(cls, data):
@@ -106,7 +107,7 @@ def validate(cls, data):
         return InheritTensor
 
     @classmethod
-    def gt(cls, gt) -> "Numpy":
+    def gt(cls, gt) -> Numpy:
         class InheritTensor(cls):
             @classmethod
             def validate(cls, data):
@@ -118,7 +119,7 @@ def validate(cls, data):
         return InheritTensor
 
     @classmethod
-    def lt(cls, lt) -> "Numpy":
+    def lt(cls, lt) -> Numpy:
         class InheritTensor(cls):
             @classmethod
             def validate(cls, data):
@@ -131,7 +132,7 @@ def validate(cls, data):
         return InheritTensor
 
     @classmethod
-    def ne(cls, ne) -> "Numpy":
+    def ne(cls, ne) -> Numpy:
         class InheritTensor(cls):
             @classmethod
             def validate(cls, data):
@@ -144,7 +145,7 @@ def validate(cls, data):
         return InheritTensor
 
     @classmethod
-    def dtype(cls, dtype) -> "Numpy":
+    def dtype(cls, dtype) -> Numpy:
         class InheritNumpy(cls):
             @classmethod
             def validate(cls, data):
@@ -157,63 +158,63 @@ def validate(cls, data):
         return InheritNumpy
 
     @classmethod
-    def float(cls) -> "Numpy":
+    def float(cls) -> Numpy:
         return cls.dtype(np.float32)
 
     @classmethod
-    def float32(cls) -> "Numpy":
+    def float32(cls) -> Numpy:
         return cls.dtype(np.float32)
 
     @classmethod
-    def half(cls) -> "Numpy":
+    def half(cls) -> Numpy:
         return cls.dtype(np.float16)
 
     @classmethod
     def float16(cls):
         return cls.dtype(np.float16)
 
     @classmethod
-    def double(cls) -> "Numpy":
+    def double(cls) -> Numpy:
         return cls.dtype(np.float64)
 
     @classmethod
-    def float64(cls) -> "Numpy":
+    def float64(cls) -> Numpy:
         return cls.dtype(np.float64)
 
     @classmethod
-    def int(cls) -> "Numpy":
+    def int(cls) -> Numpy:
         return cls.dtype(np.int32)
 
     @classmethod
-    def int32(cls) -> "Numpy":
+    def int32(cls) -> Numpy:
         return cls.dtype(np.int32)
 
     @classmethod
-    def long(cls) -> "Numpy":
+    def long(cls) -> Numpy:
         return cls.dtype(np.int64)
 
     @classmethod
-    def int64(cls) -> "Numpy":
+    def int64(cls) -> Numpy:
         return cls.dtype(np.int64)
 
     @classmethod
-    def short(cls) -> "Numpy":
+    def short(cls) -> Numpy:
         return cls.dtype(np.int16)
 
     @classmethod
-    def int16(cls) -> "Numpy":
+    def int16(cls) -> Numpy:
         return cls.dtype(np.int16)
 
     @classmethod
-    def byte(cls) -> "Numpy":
+    def byte(cls) -> Numpy:
         return cls.dtype(np.uint8)
 
     @classmethod
-    def uint8(cls) -> "Numpy":
+    def uint8(cls) -> Numpy:
         return cls.dtype(np.uint8)
 
     @classmethod
-    def bool(cls) -> "Numpy":
+    def bool(cls) -> Numpy:
         return cls.dtype(bool)
 
 

lantern/tensor.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import numpy as np
 import torch
 
@@ -19,7 +20,7 @@ def validate(cls, data) -> torch.Tensor:
             return torch.as_tensor(data)
 
     @classmethod
-    def ndim(cls, ndim) -> "Tensor":
+    def ndim(cls, ndim) -> Tensor:
         class InheritTensor(cls):
             @classmethod
             def validate(cls, data):
@@ -31,7 +32,7 @@ def validate(cls, data):
         return InheritTensor
 
     @classmethod
-    def dims(cls, dims) -> "Tensor":
+    def dims(cls, dims) -> Tensor:
         class InheritTensor(cls):
             @classmethod
             def validate(cls, data):
@@ -45,7 +46,7 @@ def validate(cls, data):
         return InheritTensor
 
     @classmethod
-    def shape(cls, *sizes) -> "Tensor":
+    def shape(cls, *sizes) -> Tensor:
         class InheritTensor(cls):
             @classmethod
             def validate(cls, data):
@@ -58,7 +59,7 @@ def validate(cls, data):
         return InheritTensor
 
     @classmethod
-    def between(cls, ge, le) -> "Tensor":
+    def between(cls, ge, le) -> Tensor:
         class InheritTensor(cls):
             @classmethod
             def validate(cls, data):
@@ -77,7 +78,7 @@ def validate(cls, data):
         return InheritTensor
 
     @classmethod
-    def ge(cls, ge) -> "Tensor":
+    def ge(cls, ge) -> Tensor:
         class InheritTensor(cls):
             @classmethod
             def validate(cls, data):
@@ -90,7 +91,7 @@ def validate(cls, data):
         return InheritTensor
 
     @classmethod
-    def le(cls, le) -> "Tensor":
+    def le(cls, le) -> Tensor:
         class InheritTensor(cls):
             @classmethod
             def validate(cls, data):
@@ -105,7 +106,7 @@ def validate(cls, data):
         return InheritTensor
 
     @classmethod
-    def gt(cls, gt) -> "Tensor":
+    def gt(cls, gt) -> Tensor:
         class InheritTensor(cls):
             @classmethod
             def validate(cls, data):
@@ -117,7 +118,7 @@ def validate(cls, data):
         return InheritTensor
 
     @classmethod
-    def lt(cls, lt) -> "Tensor":
+    def lt(cls, lt) -> Tensor:
         class InheritTensor(cls):
             @classmethod
             def validate(cls, data):
@@ -130,7 +131,7 @@ def validate(cls, data):
         return InheritTensor
 
     @classmethod
-    def ne(cls, ne) -> "Tensor":
+    def ne(cls, ne) -> Tensor:
         class InheritTensor(cls):
             @classmethod
             def validate(cls, data):
@@ -143,7 +144,7 @@ def validate(cls, data):
         return InheritTensor
 
     @classmethod
-    def device(cls, device) -> "Tensor":
+    def device(cls, device) -> Tensor:
         class InheritTensor(cls):
             @classmethod
             def validate(cls, data):
@@ -152,15 +153,15 @@ def validate(cls, data):
         return InheritTensor
 
     @classmethod
-    def cpu(cls) -> "Tensor":
+    def cpu(cls) -> Tensor:
         return cls.device(torch.device("cpu"))
 
     @classmethod
-    def cuda(cls) -> "Tensor":
+    def cuda(cls) -> Tensor:
         return cls.device(torch.device("cuda"))
 
     @classmethod
-    def dtype(cls, dtype) -> "Tensor":
+    def dtype(cls, dtype) -> Tensor:
         class InheritTensor(cls):
             @classmethod
             def validate(cls, data):
@@ -173,63 +174,63 @@ def validate(cls, data):
         return InheritTensor
 
     @classmethod
-    def float(cls) -> "Tensor":
+    def float(cls) -> Tensor:
         return cls.dtype(torch.float32)
 
     @classmethod
-    def float32(cls) -> "Tensor":
+    def float32(cls) -> Tensor:
         return cls.dtype(torch.float32)
 
     @classmethod
-    def half(cls) -> "Tensor":
+    def half(cls) -> Tensor:
         return cls.dtype(torch.float16)
 
     @classmethod
     def float16(cls):
         return cls.dtype(torch.float16)
 
     @classmethod
-    def double(cls) -> "Tensor":
+    def double(cls) -> Tensor:
         return cls.dtype(torch.float64)
 
     @classmethod
-    def float64(cls) -> "Tensor":
+    def float64(cls) -> Tensor:
         return cls.dtype(torch.float64)
 
     @classmethod
-    def int(cls) -> "Tensor":
+    def int(cls) -> Tensor:
         return cls.dtype(torch.int32)
 
     @classmethod
-    def int32(cls) -> "Tensor":
+    def int32(cls) -> Tensor:
         return cls.dtype(torch.int32)
 
     @classmethod
-    def long(cls) -> "Tensor":
+    def long(cls) -> Tensor:
         return cls.dtype(torch.int64)
 
     @classmethod
-    def int64(cls) -> "Tensor":
+    def int64(cls) -> Tensor:
         return cls.dtype(torch.int64)
 
     @classmethod
-    def short(cls) -> "Tensor":
+    def short(cls) -> Tensor:
         return cls.dtype(torch.int16)
 
     @classmethod
-    def int16(cls) -> "Tensor":
+    def int16(cls) -> Tensor:
         return cls.dtype(torch.int16)
 
     @classmethod
-    def byte(cls) -> "Tensor":
+    def byte(cls) -> Tensor:
         return cls.dtype(torch.uint8)
 
     @classmethod
-    def uint8(cls) -> "Tensor":
+    def uint8(cls) -> Tensor:
         return cls.dtype(torch.uint8)
 
     @classmethod
-    def bool(cls) -> "Tensor":
+    def bool(cls) -> Tensor:
         return cls.dtype(torch.bool)