feat: Scalar things

cloudquery/sdk/scalar/__init__.py

@@ -1,8 +1,15 @@
 from .scalar import Scalar, ScalarInvalidTypeError, NULL_VALUE
 from .scalar_factory import ScalarFactory
+from .vector import Vector
+
 from .binary import Binary
 from .bool import Bool
 from .date32 import Date32
-from .float64 import Float64
-from .int64 import Int64
+from .date64 import Date64
+from .float import Float
+from .int import Int
+from .list import List
+from .string import String
+from .timestamp import Timestamp
+from .uint import Uint
 from .uuid import UUID

cloudquery/sdk/scalar/binary.py

@@ -3,33 +3,33 @@
 
 
 class Binary(Scalar):
-    def __init__(self, valid: bool = False, value: bytes = None):
-        self._valid = valid
-        self._value = value
-
     def __eq__(self, scalar: Scalar) -> bool:
         if scalar is None:
             return False
         if type(scalar) == Binary:
             return self._value == scalar._value and self._valid == scalar._valid
         return False
 
-    def __str__(self) -> str:
-        return str(self._value) if self._valid else NULL_VALUE
-
     @property
     def value(self):
         return self._value
 
-    def set(self, scalar):
-        if scalar is None:
+    def set(self, value: any):
+        if value is None:
+            return
+
+        if isinstance(value, Binary):
+            self._valid = value.is_valid
+            self._value = value.value
             return
 
-        if type(scalar) == bytes:
+        if type(value) == bytes:
             self._valid = True
-            self._value = scalar
-        elif type(scalar) == str:
+            self._value = value
+        elif type(value) == str:
             self._valid = True
-            self._value = scalar.encode()
+            self._value = value.encode()
         else:
-            raise ScalarInvalidTypeError("Invalid type for Binary scalar")
+            raise ScalarInvalidTypeError(
+                "Invalid type {} for Binary scalar".format(type(value))
+            )

cloudquery/sdk/scalar/bool.py

@@ -17,33 +17,34 @@ def parse_string_to_bool(input_string):
 
 
 class Bool(Scalar):
-    def __init__(self, valid: bool = False, value: bool = False) -> None:
-        self._valid = valid
-        self._value = value
-
     def __eq__(self, scalar: Scalar) -> bool:
         if scalar is None:
             return False
         if type(scalar) == Bool:
             return self._value == scalar._value and self._valid == scalar._valid
         return False
 
-    def __str__(self) -> str:
-        return str(self._value) if self._valid else NULL_VALUE
-
     @property
     def value(self):
         return self._value
 
     def set(self, value: Any):
         if value is None:
+            self._valid = False
+            return
+
+        if isinstance(value, Bool):
+            self._valid = value.is_valid
+            self._value = value.value
             return
 
         if type(value) == bool:
             self._value = value
         elif type(value) == str:
             self._value = parse_string_to_bool(value)
         else:
-            raise ScalarInvalidTypeError("Invalid type for Bool scalar")
+            raise ScalarInvalidTypeError(
+                "Invalid type {} for Bool scalar".format(type(value))
+            )
 
         self._valid = True

cloudquery/sdk/scalar/date32.py

@@ -4,26 +4,25 @@
 
 
 class Date32(Scalar):
-    def __init__(self, valid: bool = False, value: bool = False) -> None:
-        self._valid = valid
-        self._value = value
-
     def __eq__(self, scalar: Scalar) -> bool:
         if scalar is None:
             return False
         if type(scalar) == Date32:
             return self._value == scalar._value and self._valid == scalar._valid
         return False
 
-    def __str__(self) -> str:
-        return str(self._value) if self._valid else NULL_VALUE
-
     @property
     def value(self):
         return self._value
 
     def set(self, value: Any):
         if value is None:
+            self._valid = False
+            return
+
+        if isinstance(value, Date32):
+            self._valid = value.is_valid
+            self._value = value.value
             return
 
         if type(value) == datetime:
@@ -33,6 +32,8 @@ def set(self, value: Any):
         elif type(value) == time:
             self._value = datetime.combine(datetime.today(), value)
         else:
-            raise ScalarInvalidTypeError("Invalid type for Bool scalar")
+            raise ScalarInvalidTypeError(
+                "Invalid type {} for Date32 scalar".format(type(value))
+            )
 
         self._valid = True

cloudquery/sdk/scalar/date64.py

@@ -0,0 +1,39 @@
+from cloudquery.sdk.scalar import Scalar, ScalarInvalidTypeError, NULL_VALUE
+from datetime import datetime, time
+from typing import Any
+
+
+class Date64(Scalar):
+    def __eq__(self, scalar: Scalar) -> bool:
+        if scalar is None:
+            return False
+        if type(scalar) == Date64:
+            return self._value == scalar._value and self._valid == scalar._valid
+        return False
+
+    @property
+    def value(self):
+        return self._value
+
+    def set(self, value: Any):
+        if value is None:
+            self._valid = False
+            return
+
+        if isinstance(value, Date64):
+            self._valid = value.is_valid
+            self._value = value.value
+            return
+
+        if type(value) == datetime:
+            self._value = value
+        elif type(value) == str:
+            self._value = datetime.strptime(value, "%Y-%m-%d")
+        elif type(value) == time:
+            self._value = datetime.combine(datetime.today(), value)
+        else:
+            raise ScalarInvalidTypeError(
+                "Invalid type {} for Date64 scalar".format(type(value))
+            )
+
+        self._valid = True

cloudquery/sdk/scalar/float.py

@@ -0,0 +1,49 @@
+from cloudquery.sdk.scalar import Scalar, ScalarInvalidTypeError
+
+
+class Float(Scalar):
+    def __init__(self, valid: bool = False, value: any = None, bitwidth: int = 64):
+        super().__init__(valid, value)
+        self._bitwidth = bitwidth
+
+    def __eq__(self, scalar: Scalar) -> bool:
+        if scalar is None:
+            return False
+        if type(scalar) == Float and self._bitwidth == scalar.bitwidth:
+            return self._value == scalar._value and self._valid == scalar._valid
+        return False
+
+    @property
+    def bitwidth(self):
+        return self._bitwidth
+
+    @property
+    def value(self):
+        return self._value
+
+    def set(self, value: any):
+        if value is None:
+            self._valid = False
+            return
+
+        if isinstance(value, Float) and value.bitwidth == self._bitwidth:
+            self._valid = value.is_valid
+            self._value = value.value
+            return
+
+        if type(value) == int:
+            self._value = float(value)
+        elif type(value) == float:
+            self._value = value
+        elif type(value) == str:
+            try:
+                self._value = float(value)
+            except ValueError:
+                raise ScalarInvalidTypeError(
+                    "Invalid value for Float{} scalar".format(self._bitwidth)
+                )
+        else:
+            raise ScalarInvalidTypeError(
+                "Invalid type {} for Float{} scalar".format(type(value), self._bitwidth)
+            )
+        self._valid = True

cloudquery/sdk/scalar/int.py

@@ -0,0 +1,56 @@
+from cloudquery.sdk.scalar import Scalar, ScalarInvalidTypeError
+
+
+class Int(Scalar):
+    def __init__(self, valid: bool = False, value: any = None, bitwidth: int = 64):
+        self._bitwidth = bitwidth
+        self._min = -(2 ** (bitwidth - 1))
+        self._max = 2 ** (bitwidth - 1)
+        super().__init__(valid, value)
+
+    def __eq__(self, scalar: Scalar) -> bool:
+        if scalar is None:
+            return False
+        if type(scalar) == Int and self._bitwidth == scalar.bitwidth:
+            return self._value == scalar._value and self._valid == scalar._valid
+        return False
+
+    @property
+    def bitwidth(self):
+        return self._bitwidth
+
+    @property
+    def value(self):
+        return self._value
+
+    def set(self, value: any):
+        if value is None:
+            self._valid = False
+            return
+
+        if isinstance(value, Int) and value.bitwidth == self._bitwidth:
+            self._valid = value.is_valid
+            self._value = value.value
+            return
+
+        if type(value) == int:
+            val = value
+        elif type(value) == float:
+            val = int(value)
+        elif type(value) == str:
+            try:
+                val = int(value)
+            except ValueError as e:
+                raise ScalarInvalidTypeError(
+                    "Invalid type for Int{} scalar".format(self._bitwidth)
+                ) from e
+        else:
+            raise ScalarInvalidTypeError(
+                "Invalid type {} for Int{} scalar".format(type(value), self._bitwidth)
+            )
+        if val < self._min or val >= self._max:
+            raise ScalarInvalidTypeError(
+                "Invalid Int{} scalar with value {}".format(self._bitwidth, val)
+            )
+        self._value = val
+        self._valid = True