kbasic 0.2.3__tar.gz → 0.3.1__tar.gz

{kbasic-0.2.3 → kbasic-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: kbasic
-Version: 0.2.3
+Version: 0.3.1
 Summary: Keyan's basic utility functions.
 Author: Keyan Gootkin
 Author-email: Keyan Gootkin <keyangootkin@gmail.com>

{kbasic-0.2.3 → kbasic-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kbasic"
-version = "0.2.3"
+version = "0.3.1"
 description = "Keyan's basic utility functions."
 readme = "README.md"
 authors = [

{kbasic-0.2.3 → kbasic-0.3.1}/src/kbasic/__init__.py

@@ -8,4 +8,4 @@ from kbasic.user_input import *
 from kbasic.Tex import *
 from kbasic.typing import *
 from kbasic.vectors import *
-from kbasic.parsing import *
+from kbasic.parsing import *

kbasic-0.3.1/src/kbasic/typing.py

@@ -0,0 +1,34 @@
+"""
+    Use ABCs to allow matching any number or array type, e.g. this will work:
+    match 1.:
+        case Number(): ...
+    
+    or:
+    match {1, 2, 3, 4}:
+        case Array(): ...
+"""
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Imports                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+from abc import ABC
+from collections.abc import Generator
+from numpy import int8, uint8, int16, uint16, int32, uint32, int64, uint64, \
+                  float16, float32, float64, longdouble, complex64, complex128, \
+                  clongdouble, ndarray
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                              Types                              <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+class Array(ABC):
+    types: list = [ndarray, list, set, tuple, Generator]
+    @classmethod
+    def __subclasshook__(cls, sub):
+        return sub in cls.types
+class Number(ABC):
+    types: list = [
+        int, int8, uint8, int16, uint16, int32, uint32, int64, uint64,
+        float, float16, float32, float64, longdouble,
+        complex, complex64, complex128, clongdouble
+    ]
+    @classmethod
+    def __subclasshook__(cls, sub):
+        return sub in cls.types

{kbasic-0.2.3 → kbasic-0.3.1}/src/kbasic/vectors.py

@@ -28,9 +28,9 @@ def hamilton_product(q1, q2):
 class VectorBase:
     def __init__(self, *components) -> None:
         match components[0]:
-            case x if type(x) in Number.types:
+            case Number():
                 self.components = components
-            case x if type(x) in Array.types:
+            case Array():
                 self.components = tuple(array(x) for x in components)
             case Generator():
                 self.components = tuple(components[0])
@@ -77,15 +77,15 @@ class VectorBase:
         match other:
             case VectorBase():
                 return Vector(xs+xo for xs, xo in zip(self.components, other.components))
-            case x if type(x) in Number.types:
+            case Number():
                 return Vector(xi+other for xi in self)
-            case x if type(x) in Array.types:
+            case Array():
                 return Vector(xs+xo for xs, xo in zip(self.components, other))
     def __sub__(self, other) -> Self:
         match other:
-            case x if type(x) in Number.types:
+            case Number():
                 return type(self)(x-other for x in self)
-            case x if type(x) in Array.types:
+            case Array():
                 return type(self)(xs-xo for xs, xo in zip(self.components, other))
             case VectorBase():
                 return type(self)(xs-xo for xs, xo in zip(self.components, other.components))
@@ -93,23 +93,23 @@ class VectorBase:
         match other:
             case VectorBase():
                 return sum(list(c1*c2 for c1,c2 in zip(self, other)), axis=0)
-            case x if type(x) in Number.types:
+            case Number():
                 return type(self)(c*other for c in self)
-            case x if type(x) in Array.types:
+            case Array():
                 return type(self)(c1*c2 for c1, c2 in zip(self, other))
     def __truediv__(self, other) -> Self:
         match other:
             case VectorBase():
                 return Vector(c1 / c2 for c1, c2 in zip(self, other))
-            case x if type(x) in Number.types:
+            case Number():
                 return type(self)(c / other for c in self)
-            case x if type(x) in Array.types:
+            case Array():
                 return type(self)(c1 / c2 for c1, c2 in zip(self, other))
     def __floordiv__(self, other) -> Self:
         match other:
-            case x if type(x) in Number.types:
+            case Number():
                 return type(self)(c//other for c in self)
-            case x if type(x) in Array.types:
+            case Array():
                 return type(self)(c1//c2 for c1, c2 in zip(self, other))
     def __radd__(self, other) -> Self:
         match other:
@@ -125,15 +125,15 @@ class VectorBase:
             case _: return self.__mul__(other)
     def __rtruediv__(self, other) -> Self:
         match other:
-            case x if type(x) in Number.types:
+            case Number():
                 return type(self)(other/c for c in self)
-            case x if type(x) in Array.types:
+            case Array():
                 return type(self)(c2/c1 for c1, c2 in zip(self, other))
     def __rfloordiv__(self, other) -> Self:
         match other:
-            case x if type(x) in Number.types:
+            case Number():
                 return type(self)(other//c for c in self)
-            case x if type(x) in Array.types:
+            case Array():
                 return type(self)(c2//c1 for c1, c2 in zip(self, other))
 class Vector(VectorBase):
     def __new__(cls, *components) -> Self: # the vector factory
@@ -145,7 +145,7 @@ class Vector(VectorBase):
             case (Generator(),):
                 return Vector(tuple(components[0]))
             # single array
-            case (x,) if type(x) in Array.types:
+            case (Array(),):
                 return Vector(*x)
             # 2D
             case (x, y):

kbasic-0.2.3/src/kbasic/typing.py

@@ -1,34 +0,0 @@
-"""
-    I don't like type checking in python, so the way i decided to do it is if i want
-    to see if something looks like a number (int, float, complex or numpy variants)
-    i would say ->
-    if type(x) in Number.types: do_something()
-    elif type(x) in Array.types: do_something_else()
-"""
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                             Imports                             <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-from numpy import int8, uint8, int16, uint16, int32, uint32, int64, uint64, \
-                  float16, float32, float64, longdouble, complex64, complex128, \
-                  clongdouble, ndarray
-from numpy.typing import NDArray, ArrayLike
-from collections.abc import Callable, Generator
-from typing import Any
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                              Types                              <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-class Array:
-    types: list = [NDArray, ndarray, list, set, tuple, Generator]
-class Number:
-    types: list = [
-        int, int8, uint8, int16, uint16, int32, uint32, int64, uint64, 
-        float, float16, float32, float64, longdouble, 
-        complex, complex64, complex128, clongdouble
-    ]
-    def __new__(cls, x):
-        match x:
-            case x if type(x) in Number.types: return x
-            case str() if x.isnumeric(): return int(x)
-            case str() if '.' in x and all([xi.isnumeric() for xi in x.split('.')]): 
-                return float(x)
-            case _: raise ValueError(f"Cannot parse argument: {x}\nof type: {type(x)}")