tinybird 0.0.1.dev26__py3-none-any.whl → 0.0.1.dev27__py3-none-any.whl

tinybird/config.py

@@ -83,7 +83,7 @@ async def get_config(host: str, token: Optional[str], semver: Optional[str] = No
         async with aiofiles.open(config_file) as file:
             res = await file.read()
             config = json.loads(res)
-    except IOError:
+    except OSError:
         pass
     except json.decoder.JSONDecodeError:
         click.echo(FeedbackManager.error_load_file_config(config_file=config_file))

tinybird/datatypes.py

@@ -2,6 +2,7 @@ import ast
 import decimal
 import re
 from decimal import Decimal
+from typing import Callable, Dict, List, Optional, Tuple
 
 datetime64_patterns = [
     r"\d\d\d\d.\d\d.\d\d(T|\s)\d\d:\d\d:\d\d.\d\d\d",
@@ -53,7 +54,7 @@ bool_allowed_values = {
 }
 
 
-def is_type_datetime64(type_to_check):
+def is_type_datetime64(type_to_check: str) -> bool:
     """
     >>> is_type_datetime64('DateTime64')
     True
@@ -73,7 +74,7 @@ def is_type_datetime64(type_to_check):
     return re.match(datetime64_type_pattern, type_to_check) is not None
 
 
-def is_type_datetime(type_to_check):
+def is_type_datetime(type_to_check: str) -> bool:
     """
     >>> is_type_datetime('DateTime')
     True
@@ -89,87 +90,87 @@ def is_type_datetime(type_to_check):
     return re.match(datetime_type_pattern, type_to_check) is not None
 
 
-def string_test(x):
+def string_test(x: str) -> bool:
     return True
 
 
-def date_test(x):
-    return re.match(r"\d\d\d\d-\d\d-\d\d$", x)
+def date_test(x: str) -> bool:
+    return re.match(r"\d\d\d\d-\d\d-\d\d$", x) is not None
 
 
-def datetime64_test(x):
+def datetime64_test(x: str) -> bool:
     return any([re.match(p, x) for p in datetime64_patterns])
 
 
-def datetime_test(x):
+def datetime_test(x: str) -> bool:
     return any([re.match(p, x) for p in datetime_patterns])
 
 
-def int_8_test(x):
-    return re.match(intx_re, x) and -int_8_max <= int(x) < int_8_max
+def int_8_test(x: str) -> bool:
+    return re.match(intx_re, x) is not None and -int_8_max <= int(x) < int_8_max
 
 
-def int16_test(x):
-    return re.match(intx_re, x) and -int16_max <= int(x) < int16_max
+def int16_test(x: str) -> bool:
+    return re.match(intx_re, x) is not None and -int16_max <= int(x) < int16_max
 
 
-def int32_test(x):
-    return re.match(intx_re, x) and -int32_max <= int(x) < int32_max
+def int32_test(x: str) -> bool:
+    return re.match(intx_re, x) is not None and -int32_max <= int(x) < int32_max
 
 
-def int64_test(x):
-    return re.match(intx_re, x) and -int64_max <= int(x) < int64_max
+def int64_test(x: str) -> bool:
+    return re.match(intx_re, x) is not None and -int64_max <= int(x) < int64_max
 
 
-def int128_test(x):
-    return re.match(intx_re, x) and -int128_max <= int(x) < int128_max
+def int128_test(x: str) -> bool:
+    return re.match(intx_re, x) is not None and -int128_max <= int(x) < int128_max
 
 
-def int256_test(x):
-    return re.match(intx_re, x) and -int256_max <= int(x) < int256_max
+def int256_test(x: str) -> bool:
+    return re.match(intx_re, x) is not None and -int256_max <= int(x) < int256_max
 
 
-def uint_8_test(x):
-    return re.match(uintx_re, x) and 0 <= int(x) < uint_8_max
+def uint_8_test(x: str) -> bool:
+    return re.match(uintx_re, x) is not None and 0 <= int(x) < uint_8_max
 
 
-def uint16_test(x):
-    return re.match(uintx_re, x) and 0 <= int(x) < uint16_max
+def uint16_test(x: str) -> bool:
+    return re.match(uintx_re, x) is not None and 0 <= int(x) < uint16_max
 
 
-def uint32_test(x):
-    return re.match(uintx_re, x) and 0 <= int(x) < uint32_max
+def uint32_test(x: str) -> bool:
+    return re.match(uintx_re, x) is not None and 0 <= int(x) < uint32_max
 
 
-def uint64_test(x):
-    return re.match(uintx_re, x) and 0 <= int(x) < uint64_max
+def uint64_test(x: str) -> bool:
+    return re.match(uintx_re, x) is not None and 0 <= int(x) < uint64_max
 
 
-def uint128_test(x):
-    return re.match(intx_re, x) and 0 <= int(x) < uint128_max
+def uint128_test(x: str) -> bool:
+    return re.match(intx_re, x) is not None and 0 <= int(x) < uint128_max
 
 
-def uint256_test(x):
-    return re.match(intx_re, x) and 0 <= int(x) < uint256_max
+def uint256_test(x: str) -> bool:
+    return re.match(intx_re, x) is not None and 0 <= int(x) < uint256_max
 
 
-def float_test(x):
+def float_test(x: str) -> bool:
     return "_" not in x and type_test(x, float)
 
 
-def float32_test(x):
+def float32_test(x: str) -> bool:
     return "_" not in x and type_test(x, float) and -float32_max <= float(x) < float32_max
 
 
-def float64_test(x):
+def float64_test(x: str) -> bool:
     return "_" not in x and type_test(x, float) and -float64_max < float(x) < float64_max
 
 
-def bool_test(x):
+def bool_test(x: str) -> bool:
     return x in bool_allowed_values
 
 
-def test_numeric_testers(fn, n):
+def test_numeric_testers(fn: Callable[[str], bool], n: int) -> bool:
     """
     >>> test_numeric_testers(int32_test, (2**31)-1)
     True
@@ -192,7 +193,7 @@ def test_numeric_testers(fn, n):
     return fn(str(n))
 
 
-def array_test(_type_test):
+def array_test(_type_test: type) -> Callable[[str], bool]:
     """
     >>> array_test(str)("['blabla']")
     True
@@ -220,7 +221,7 @@ def array_test(_type_test):
     False
     """
 
-    def _test(x):
+    def _test(x: str) -> bool:
         if x[0] != "[":
             return False
         try:
@@ -234,7 +235,7 @@ def array_test(_type_test):
     return _test
 
 
-numbers_types = (
+numbers_types: Tuple[str, ...] = (
     "Int8",
     "UInt8",
     "Int16",
@@ -253,7 +254,7 @@ numbers_types = (
 
 # Use guessers for discovering types
 # I.e., when you have to take into consideration things like float precision
-guessers = {
+guessers: Dict[str, Callable[[str], bool]] = {
     "DateTime64": datetime64_test,
     "DateTime": datetime_test,
     "Date": date_test,
@@ -274,7 +275,7 @@ guessers = {
 
 # Use testers validating a value against a type
 # I.e., you already know the type and you need to check if a value fits there
-testers = {
+testers: Dict[str, Callable[[str], bool]] = {
     "DateTime64": datetime64_test,
     "DateTime": datetime_test,
     "Date": date_test,
@@ -300,7 +301,7 @@ testers = {
 
 
 # Search for `canBeInsideNullable` under CH code and see which ones are true.
-nullable_types = [
+nullable_types: List[str] = [
     "Date",
     "Date32",
     "DateTime",
@@ -340,7 +341,7 @@ nullable_types = [
 ]
 
 
-def type_test(i, t):
+def type_test(i: str, t: type) -> bool:
     try:
         t(i)
         return True
@@ -348,7 +349,7 @@ def type_test(i, t):
         return False
 
 
-def parse_decimal_type(typ):
+def parse_decimal_type(typ: str) -> Optional[Tuple[int, int, int]]:
     """
     >>> parse_decimal_type("decimal")
 
@@ -407,19 +408,7 @@ def parse_decimal_type(typ):
     return b, p, s
 
 
-def is_type_decimal(type_to_check):
-    """
-    >>> is_type_decimal('Decimal')
-    True
-    >>> is_type_decimal("Decimal(10, 2)")
-    True
-    >>> is_type_decimal("decimal")
-    False
-    """
-    return parse_decimal_type(type_to_check) is not None
-
-
-def get_decimal_limits(p, s):
+def get_decimal_limits(p: int, s: int) -> Tuple[Decimal, Decimal]:
     """
     >>> get_decimal_limits(1, 0)
     (Decimal('-9'), Decimal('9'))

tinybird/git_settings.py

@@ -105,10 +105,10 @@ DEFAULT_INIT_FILES_DEPLOY = {
 
 
 class SemverVersions(Enum):
-    MAJOR: str = "major"
-    MINOR: str = "minor"
-    PATCH: str = "patch"
-    CURRENT: str = "current"
+    MAJOR = "major"
+    MINOR = "minor"
+    PATCH = "patch"
+    CURRENT = "current"
 
 
 def bump_version(version: str, next_version: Optional[str]) -> str: