polyapi-python 0.3.9.dev8__tar.gz → 0.3.9.dev10__tar.gz

{polyapi_python-0.3.9.dev8 → polyapi_python-0.3.9.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.9.dev8
+Version: 0.3.9.dev10
 Summary: The Python Client for PolyAPI, the IPaaS by Developers for Developers
 Author-email: Dan Fellin <dan@polyapi.io>
 License: MIT License

{polyapi_python-0.3.9.dev8 → polyapi_python-0.3.9.dev10}/polyapi/auth.py

@@ -1,5 +1,4 @@
 from typing import List, Dict, Any, Tuple
-import uuid
 
 from polyapi.typedefs import PropertySpecification
 from polyapi.utils import parse_arguments, get_type_and_def
@@ -26,7 +25,8 @@ async def getToken(clientId: str, clientSecret: str, scopes: List[str], callback
 
     Function ID: {function_id}
     \"""
-    eventsClientId = "{client_id}"
+    from polyapi.poly.client_id import client_id
+    eventsClientId = client_id
     function_id = "{function_id}"
 
     options = options or {{}}
@@ -165,7 +165,7 @@ def render_auth_function(
     func_str = ""
 
     if function_name == "getToken":
-        func_str = GET_TOKEN_TEMPLATE.format(function_id=function_id, description=function_description, client_id=uuid.uuid4().hex)
+        func_str = GET_TOKEN_TEMPLATE.format(function_id=function_id, description=function_description)
     elif function_name == "introspectToken":
         func_str = INTROSPECT_TOKEN_TEMPLATE.format(function_id=function_id, description=function_description)
     elif function_name == "refreshToken":

{polyapi_python-0.3.9.dev8 → polyapi_python-0.3.9.dev10}/polyapi/deployables.py

@@ -65,20 +65,20 @@ class SyncDeployment(TypedDict, total=False):
     context: str
     name: str
     description: str
-    type: str
+    type: DeployableTypes
     fileRevision: str
     file: str
     types: DeployableFunctionTypes
-    typeSchemas: Dict[str, any]
+    typeSchemas: Dict[str, Any]
     dependencies: List[str]
-    config: Dict[str, any]
+    config: Dict[str, Any]
     instance: str
-    id: Optional[str] = None
-    deployed: Optional[str] = None
+    id: Optional[str]
+    deployed: Optional[str]
 
 DeployableTypeEntries: List[Tuple[DeployableTypeNames, DeployableTypes]] = [
-    ("PolyServerFunction", "server-function"),
-    ("PolyClientFunction", "client-function"),
+    ("PolyServerFunction", "server-function"), # type: ignore
+    ("PolyClientFunction", "client-function"), # type: ignore
 ]
 
 DeployableTypeToName: Dict[DeployableTypeNames, DeployableTypes] = {name: type for name, type in DeployableTypeEntries}
@@ -175,7 +175,7 @@ def get_git_revision(branch_or_tag: str = "HEAD") -> str:
         return check_output(["git", "rev-parse", "--short", branch_or_tag], text=True).strip()
     except CalledProcessError:
         # Return a random 7-character hash as a fallback
-        return "".join(format(ord(c), 'x') for c in os.urandom(4))[:7]
+        return "".join(format(ord(str(c)), 'x') for c in os.urandom(4))[:7]
 
 def get_cache_deployments_revision() -> str:
     """Retrieve the cache deployments revision from a file."""

{polyapi_python-0.3.9.dev8 → polyapi_python-0.3.9.dev10}/polyapi/generate.py

@@ -1,6 +1,7 @@
 import json
 import requests
 import os
+import uuid
 import shutil
 import logging
 import tempfile
@@ -13,11 +14,12 @@ from .client import render_client_function
 from .poly_schemas import generate_schemas
 from .webhook import render_webhook_handle
 
-from .typedefs import PropertySpecification, SchemaSpecDto, SpecificationDto, VariableSpecDto
+from .typedefs import PropertySpecification, SchemaSpecDto, SpecificationDto, VariableSpecDto, TableSpecDto
 from .api import render_api_function
 from .server import render_server_function
 from .utils import add_import_to_init, get_auth_headers, init_the_init, print_green, to_func_namespace
 from .variables import generate_variables
+from .poly_tables import generate_tables
 from .config import get_api_key_and_url, get_direct_execute_config, get_cached_generate_args
 
 SUPPORTED_FUNCTION_TYPES = {
@@ -28,7 +30,7 @@ SUPPORTED_FUNCTION_TYPES = {
     "webhookHandle",
 }
 
-SUPPORTED_TYPES = SUPPORTED_FUNCTION_TYPES | {"serverVariable", "schema", "snippet"}
+SUPPORTED_TYPES = SUPPORTED_FUNCTION_TYPES | {"serverVariable", "schema", "snippet", "table"}
 
 
 X_POLY_REF_WARNING = '''"""
@@ -195,16 +197,18 @@ def read_cached_specs() -> List[SpecificationDto]:
         return json.loads(f.read())
 
 
-def get_variables() -> List[VariableSpecDto]:
-    specs = read_cached_specs()
+def get_variables(specs: List[SpecificationDto]) -> List[VariableSpecDto]:
     return [cast(VariableSpecDto, spec) for spec in specs if spec["type"] == "serverVariable"]
 
 
-def get_schemas() -> List[SchemaSpecDto]:
-    specs = read_cached_specs()
+def get_schemas(specs: List[SpecificationDto]) -> List[SchemaSpecDto]:
     return [cast(SchemaSpecDto, spec) for spec in specs if spec["type"] == "schema"]
 
 
+def get_tables(specs: List[SpecificationDto]) -> List[TableSpecDto]:
+    return [cast(TableSpecDto, spec) for spec in specs if spec["type"] == "table"]
+
+
 def remove_old_library():
     currdir = os.path.dirname(os.path.abspath(__file__))
     path = os.path.join(currdir, "poly")
@@ -219,6 +223,10 @@ def remove_old_library():
     if os.path.exists(path):
         shutil.rmtree(path)
 
+    path = os.path.join(currdir, "tabi")
+    if os.path.exists(path):
+        shutil.rmtree(path)
+
 
 def create_empty_schemas_module():
     """Create an empty schemas module for no-types mode so user code can still import from polyapi.schemas"""
@@ -277,6 +285,14 @@ sys.modules[__name__] = _SchemaModule()
 ''')
 
 
+def _generate_client_id() -> None:
+    full_path = os.path.dirname(os.path.abspath(__file__))
+    full_path = os.path.join(full_path, "poly", "client_id.py")
+    with open(full_path, "w") as f:
+        f.write(f'client_id = "{uuid.uuid4().hex}"')
+
+
+
 def generate_from_cache() -> None:
     """
     Generate using cached values after non-explicit call.
@@ -333,9 +349,11 @@ def generate(contexts: Optional[List[str]] = None, names: Optional[List[str]] =
     limit_ids: List[str] = []  # useful for narrowing down generation to a single function to debug
     functions = parse_function_specs(specs, limit_ids=limit_ids)
 
+    _generate_client_id()
+
     # Only process schemas if no_types is False
     if not no_types:
-        schemas = get_schemas()
+        schemas = get_schemas(specs)
         schema_index = build_schema_index(schemas)
         if schemas:
             schema_limit_ids: List[str] = []  # useful for narrowing down generation to a single function to debug
@@ -359,7 +377,11 @@ def generate(contexts: Optional[List[str]] = None, names: Optional[List[str]] =
         )
         exit()
 
-    variables = get_variables()
+    tables = get_tables(specs)
+    if tables:
+        generate_tables(tables)
+
+    variables = get_variables(specs)
     if variables:
         generate_variables(variables)
 
@@ -371,14 +393,7 @@ def generate(contexts: Optional[List[str]] = None, names: Optional[List[str]] =
 
 
 def clear() -> None:
-    base = os.path.dirname(os.path.abspath(__file__))
-    poly_path = os.path.join(base, "poly")
-    if os.path.exists(poly_path):
-        shutil.rmtree(poly_path)
-
-    vari_path = os.path.join(base, "vari")
-    if os.path.exists(vari_path):
-        shutil.rmtree(vari_path)
+    remove_old_library()
     print("Cleared!")
 
 

polyapi_python-0.3.9.dev10/polyapi/poly_tables.py

@@ -0,0 +1,443 @@
+import os
+import requests
+from typing_extensions import NotRequired, TypedDict
+from typing import List, Union, Type, Dict, Any, Literal, Tuple, Optional, get_args, get_origin
+from polyapi.utils import add_import_to_init, init_the_init
+from polyapi.typedefs import TableSpecDto
+from polyapi.constants import JSONSCHEMA_TO_PYTHON_TYPE_MAP
+
+
+def execute_query(table_id, method, query):
+    from polyapi import polyCustom
+    from polyapi.poly.client_id import client_id
+    try:
+        url = f"/tables/{table_id}/{method}?clientId={client_id}"
+        headers = {{
+            'x-poly-execution-id': polyCustom.get('executionId')
+        }}
+        response = requests.post(url, json=query, headers=headers)
+        response.raise_for_status()
+        return response.json()
+    except Exception as e:
+        return scrub_keys(e)
+
+
+def first_result(rsp):
+    if isinstance(rsp, dict) and isinstance(rsp.get('results'), list):
+        return rsp['results'][0] if rsp['results'] else None
+    return rsp
+
+
+_key_transform_map = {
+    "not_": "not",
+    "in": "in",
+    "starts_with": "startsWith",
+    "ends_with": "startsWith",
+    "not_in": "notIn",
+}
+
+
+def _transform_keys(obj: Any) -> Any:
+    if isinstance(obj, dict):
+        return {
+            _key_transform_map.get(k, k): _transform_keys(v)
+            for k, v in obj.items()
+        }
+
+    elif isinstance(obj, list):
+        return [_transform_keys(v) for v in obj]
+
+    else:
+        return obj
+
+
+def transform_query(query: dict) -> dict:
+    if query["where"] or query["order_by"]:
+        return {
+            **query,
+            "where": _transform_keys(query["where"]) if query["where"] else None,
+            "orderBy": query["order_by"] if query["order_by"] else None
+        }
+
+    return query
+
+
+TABI_TABLE_TEMPLATE = '''
+{table_name}Columns = Literal[{table_columns}]
+
+
+
+{table_row_classes}
+
+
+
+{table_row_subset_class}
+
+
+
+{table_where_class}
+
+
+
+class {table_name}SelectManyQuery(TypedDict):
+    where: NotRequired[{table_name}WhereFilter]
+    order_by: NotRequired[Dict[{table_name}Columns, SortOrder]]
+    limit: NotRequired[int]
+    offset: NotRequired[int]
+
+
+
+class {table_name}SelectOneQuery(TypedDict):
+    where: NotRequired[{table_name}WhereFilter]
+    order_by: NotRequired[Dict[{table_name}Columns, SortOrder]]
+
+
+
+class {table_name}InsertOneQuery(TypedDict):
+    data: {table_name}Subset
+
+
+
+class {table_name}InsertManyQuery(TypedDict):
+    data: List[{table_name}Subset]
+
+
+
+class {table_name}UpdateManyQuery(TypedDict):
+    where: NotRequired[{table_name}WhereFilter]
+    data: {table_name}Subset
+
+
+
+class {table_name}DeleteQuery(TypedDict):
+    where: NotRequired[{table_name}WhereFilter]
+
+
+
+class {table_name}QueryResults(TypedDict):
+    results: List[{table_name}Row]
+    pagination: None # Pagination not yet supported
+
+
+
+class {table_name}CountQuery(TypedDict):
+    where: NotRequired[{table_name}WhereFilter]
+
+
+
+class {table_name}:{table_description}
+    table_id = "{table_id}"
+
+    @overload
+    @staticmethod
+    def count(query: {table_name}CountQuery) -> PolyCountResult: ...
+    @overload
+    @staticmethod
+    def count(*, where: Optional[{table_name}WhereFilter]) -> PolyCountResult: ...
+
+    @staticmethod
+    def count(*args, **kwargs) -> PolyCountResult:
+        if args:
+            if len(args) != 1 or not isinstance(args[0], dict):
+                raise TypeError("Expected query as a single argument or as kwargs")
+            query = args[0]
+        else:
+            query = kwargs
+        return execute_query({table_name}.table_id, "count", transform_query(query))
+
+    @overload
+    @staticmethod
+    def select_many(query: {table_name}SelectManyQuery) -> {table_name}QueryResults: ...
+    @overload
+    @staticmethod
+    def select_many(*, where: Optional[{table_name}WhereFilter], order_by: Optional[Dict[{table_name}Columns, SortOrder]], limit: Optional[int], offset: Optional[int]) -> {table_name}QueryResults: ...
+
+    @staticmethod
+    def select_many(*args, **kwargs) -> {table_name}QueryResults:
+        if args:
+            if len(args) != 1 or not isinstance(args[0], dict):
+                raise TypeError("Expected query as a single argument or as kwargs")
+            query = args[0]
+        else:
+            query = kwargs
+        if query.get('limit') is None:
+            query['limit'] = 1000
+        if query['limit'] > 1000:
+            raise ValueError("Cannot select more than 1000 rows at a time.")
+        return execute_query({table_name}.table_id, "select", transform_query(query))
+
+    @overload
+    @staticmethod
+    def select_one(query: {table_name}SelectOneQuery) -> {table_name}Row: ...
+    @overload
+    @staticmethod
+    def select_one(*, where: Optional[{table_name}WhereFilter], order_by: Optional[Dict[{table_name}Columns, SortOrder]]) -> {table_name}Row: ...
+
+    @staticmethod
+    def select_one(*args, **kwargs) -> {table_name}Row:
+        if args:
+            if len(args) != 1 or not isinstance(args[0], dict):
+                raise TypeError("Expected query as a single argument or as kwargs")
+            query = args[0]
+        else:
+            query = kwargs
+        query['limit'] = 1
+        return first_result(execute_query({table_name}.table_id, "select", transform_query(query)))
+
+    @overload
+    @staticmethod
+    def insert_many(query: {table_name}InsertManyQuery) -> {table_name}QueryResults: ...
+    @overload
+    @staticmethod
+    def insert_many(*, data: List[{table_name}Subset]) -> {table_name}QueryResults: ...
+
+    @staticmethod
+    def insert_many(*args, **kwargs) -> {table_name}QueryResults:
+        if args:
+            if len(args) != 1 or not isinstance(args[0], dict):
+                raise TypeError("Expected query as a single argument or as kwargs")
+            query = args[0]
+        else:
+            query = kwargs
+        if len(query['data']) > 1000:
+            raise ValueError("Cannot insert more than 1000 rows at a time.")
+        return execute_query({table_name}.table_id, "insert", query)
+
+    @overload
+    @staticmethod
+    def insert_one(query: {table_name}InsertOneQuery) -> {table_name}Row: ...
+    @overload
+    @staticmethod
+    def insert_one(*, data: {table_name}Subset) -> {table_name}Row: ...
+
+    @staticmethod
+    def insert_one(*args, **kwargs) -> {table_name}Row:
+        if args:
+            if len(args) != 1 or not isinstance(args[0], dict):
+                raise TypeError("Expected query as a single argument or as kwargs")
+            query = args[0]
+        else:
+            query = kwargs
+        return first_result(execute_query({table_name}.table_id, "insert", {{ 'data': [query['data']] }}))
+
+    @overload
+    @staticmethod
+    def upsert_many(query: {table_name}InsertManyQuery) -> {table_name}QueryResults: ...
+    @overload
+    @staticmethod
+    def upsert_many(*, data: List[{table_name}Subset]) -> {table_name}QueryResults: ...
+
+    @staticmethod
+    def upsert_many(*args, **kwargs) -> {table_name}QueryResults:
+        if args:
+            if len(args) != 1 or not isinstance(args[0], dict):
+                raise TypeError("Expected query as a single argument or as kwargs")
+            query = args[0]
+        else:
+            query = kwargs
+        if len(data) > 1000:
+            raise ValueError("Cannot upsert more than 1000 rows at a time.")
+        return execute_query({table_name}.table_id, "upsert", query)
+
+    @overload
+    @staticmethod
+    def upsert_one(query: {table_name}InsertOneQuery) -> {table_name}Row: ...
+    @overload
+    @staticmethod
+    def upsert_one(*, data: {table_name}Subset) -> {table_name}Row: ...
+
+    @staticmethod
+    def upsert_one(*args, **kwargs) -> {table_name}Row:
+        if args:
+            if len(args) != 1 or not isinstance(args[0], dict):
+                raise TypeError("Expected query as a single argument or as kwargs")
+            query = args[0]
+        else:
+            query = kwargs
+        return first_result(execute_query({table_name}.table_id, "upsert", {{ 'data': [query['data']] }}))
+
+    @overload
+    @staticmethod
+    def update_many(query: {table_name}UpdateManyQuery) -> {table_name}QueryResults: ...
+    @overload
+    @staticmethod
+    def update_many(*, where: Optional[{table_name}WhereFilter], data: {table_name}Subset) -> {table_name}QueryResults: ...
+
+    @staticmethod
+    def update_many(*args, **kwargs) -> {table_name}QueryResults:
+        if args:
+            if len(args) != 1 or not isinstance(args[0], dict):
+                raise TypeError("Expected query as a single argument or as kwargs")
+            query = args[0]
+        else:
+            query = kwargs
+        return execute_query({table_name}.table_id, "update", transform_query(query))
+
+    @overload
+    @staticmethod
+    def delete_many(query: {table_name}DeleteQuery) -> PolyDeleteResults: ...
+    @overload
+    @staticmethod
+    def delete_many(*, where: Optional[{table_name}WhereFilter]) -> PolyDeleteResults: ...
+
+    @staticmethod
+    def delete_many(*args, **kwargs) -> PolyDeleteResults:
+        if args:
+            if len(args) != 1 or not isinstance(args[0], dict):
+                raise TypeError("Expected query as a single argument or as kwargs")
+            query = args[0]
+        else:
+            query = kwargs
+        return execute_query({table_name}.table_id, "delete", query)
+'''
+
+
+def _get_column_type_str(name: str, schema: Dict[str, Any], is_required: bool) -> str:
+    result = ""
+
+    col_type = schema.get("type", "object")
+    if isinstance(col_type, list):
+        subtypes = [_get_column_type_str(name, { **schema, "type": t }, is_required) for t in col_type]
+        result = f"Union[{", ".join(subtypes)}]"
+    elif col_type == "array":
+        if isinstance(schema["items"], list):
+            subtypes = [_get_column_type_str(f"{name}{i}", s, True) for i, s in enumerate(schema["items"])]
+            result = f"Tuple[{", ".join(subtypes)}]"
+        elif isinstance(schema["items"], dict):
+            result = f"List[{_get_column_type_str(name, schema["items"], True)}]"
+        else:
+            result = "List[Any]"
+    elif col_type == "object":
+        if isinstance(schema.get("patternProperties"), dict):
+            # TODO: Handle multiple pattern properties
+            result = f"Dict[str, {_get_column_type_str(f"{name}_", schema["patternProperties"], True)}]"
+        elif isinstance(schema.get("properties"), dict) and len(schema["properties"].values()) > 0:
+            # TODO: Handle x-poly-refs
+            result = f'"{name}"'
+        else:
+            result = "Dict[str, Any]"
+    else:
+        result = JSONSCHEMA_TO_PYTHON_TYPE_MAP.get(schema["type"], "")
+
+    if result:
+        return result if is_required else f"Optional[{result}]"
+
+    return "Any"
+
+
+def _render_table_row_classes(table_name: str, schema: Dict[str, Any]) -> str:
+    from polyapi.schema import wrapped_generate_schema_types
+
+    output = wrapped_generate_schema_types(schema, f"{table_name}Row", "Dict")
+
+    return output[1].split("\n", 1)[1].strip()
+
+
+def _render_table_subset_class(table_name: str, columns: List[Tuple[str, Dict[str, Any]]], required: List[str]) -> str:
+    # Generate class which can match any subset of a table row
+    lines = [f"class {table_name}Subset(TypedDict):"]
+
+    for name, schema in columns:
+        type_str = _get_column_type_str(f"_{table_name}Row{name}", schema, name in required)
+        lines.append(f"    {name}: NotRequired[{type_str}]")
+
+    return "\n".join(lines)
+
+
+def _render_table_where_class(table_name: str, columns: List[Tuple[str, Dict[str, Any]]], required: List[str]) -> str:
+    # Generate class for the 'where' part of the query
+    lines = [f"class {table_name}WhereFilter(TypedDict):"]
+
+    for name, schema in columns:
+        ftype_str = ""
+        type_str = _get_column_type_str(f"_{table_name}Row{name}", schema, True) # force required to avoid wrapping type in Optional[]
+        is_required = name in required
+        if type_str == "bool":
+            ftype_str = "BooleanFilter" if is_required else "NullableBooleanFilter"
+        elif type_str == "str":
+            ftype_str = "StringFilter" if is_required else "NullableStringFilter"
+        elif type_str in ["int", "float"]:
+            ftype_str = "NumberFilter" if is_required else "NullableNumberFilter"
+        elif is_required == False:
+            type_str = "None"
+            ftype_str = "NullableObjectFilter"
+
+        if ftype_str:
+            lines.append(f"    {name}: NotRequired[Union[{type_str}, {ftype_str}]]")
+
+    lines.append(f'    AND: NotRequired[Union["{table_name}WhereFilter", List["{table_name}WhereFilter"]]]')
+    lines.append(f'    OR: NotRequired[List["{table_name}WhereFilter"]]')
+    lines.append(f'    NOT: NotRequired[Union["{table_name}WhereFilter", List["{table_name}WhereFilter"]]]')
+
+    return "\n".join(lines)
+
+
+def _render_table(table: TableSpecDto) -> str:
+    columns = list(table["schema"]["properties"].items())
+    required_colunms = table["schema"].get("required", [])
+
+    table_columns = ",".join([ f'"{k}"' for k,_ in columns])
+    table_row_classes = _render_table_row_classes(table["name"], table["schema"])
+    table_row_subset_class = _render_table_subset_class(table["name"], columns, required_colunms)
+    table_where_class = _render_table_where_class(table["name"], columns, required_colunms)
+    if table.get("description", ""):
+        table_description =  '\n    """'
+        table_description += '\n       '.join(table["description"].replace('"', "'").split("\n"))
+        table_description += '\n    """'
+    else:
+        table_description = ""
+
+    return TABI_TABLE_TEMPLATE.format(
+        table_name=table["name"],
+        table_id=table["id"],
+        table_description=table_description,
+        table_columns=table_columns,
+        table_row_classes=table_row_classes,
+        table_row_subset_class=table_row_subset_class,
+        table_where_class=table_where_class,
+    )
+
+
+def generate_tables(tables: List[TableSpecDto]):
+    for table in tables:
+        _create_table(table)
+
+
+def _create_table(table: TableSpecDto) -> None:
+    folders = ["tabi"]
+    if table["context"]:
+        folders += table["context"].split(".")
+
+    # build up the full_path by adding all the folders
+    base_path = os.path.join(os.path.dirname(os.path.abspath(__file__)))
+    full_path = base_path
+
+    for idx, folder in enumerate(folders):
+        full_path = os.path.join(full_path, folder)
+        if not os.path.exists(full_path):
+            os.makedirs(full_path)
+        next = folders[idx + 1] if idx + 1 < len(folders) else None
+        if next:
+            add_import_to_init(full_path, next, "")
+
+    init_path = os.path.join(full_path, "__init__.py")
+
+    imports = "\n".join([
+        "from typing_extensions import NotRequired, TypedDict",
+        "from typing import Union, List, Dict, Any, Literal, Optional, Required, overload",
+        "from polyapi.poly_tables import execute_query, first_result, transform_query",
+        "from polyapi.typedefs import Table, PolyCountResult, PolyDeleteResults, SortOrder, StringFilter, NullableStringFilter, NumberFilter, NullableNumberFilter, BooleanFilter, NullableBooleanFilter, NullableObjectFilter",
+    ])
+    table_contents = _render_table(table)
+
+    file_contents = ""
+    if os.path.exists(init_path):
+        with open(init_path, "r") as f:
+            file_contents = f.read()
+
+    with open(init_path, "w") as f:
+        if not file_contents.startswith(imports):
+            f.write(imports + "\n\n\n")
+        if file_contents:
+            f.write(file_contents + "\n\n\n")
+        f.write(table_contents)

{polyapi_python-0.3.9.dev8 → polyapi_python-0.3.9.dev10}/polyapi/sync.py

@@ -1,6 +1,7 @@
 import os
 from datetime import datetime
 from typing import List, Dict
+from typing_extensions import cast # type: ignore
 import requests
 
 from polyapi.utils import get_auth_headers
@@ -30,12 +31,14 @@ def group_by(items: List[Dict], key: str) -> Dict[str, List[Dict]]:
 
 def remove_deployable_function(deployable: SyncDeployment) -> bool:
     api_key, _ = get_api_key_and_url()
+    if not api_key:
+        raise Error("Missing api key!")
     headers = get_auth_headers(api_key)
     url = f'{deployable["instance"]}/functions/{deployable["type"].replace("-function", "")}/{deployable["id"]}'
     response = requests.get(url, headers=headers)
     if response.status_code != 200:
         return False
-    requests.delete(url, headers)
+    requests.delete(url, headers=headers)
     return True
 
 def remove_deployable(deployable: SyncDeployment) -> bool:
@@ -47,6 +50,8 @@ def remove_deployable(deployable: SyncDeployment) -> bool:
 
 def sync_function_and_get_id(deployable: SyncDeployment, code: str) -> str:
     api_key, _ = get_api_key_and_url()
+    if not api_key:
+        raise Error("Missing api key!")
     headers = get_auth_headers(api_key)
     url = f'{deployable["instance"]}/functions/{deployable["type"].replace("-function", "")}'
     payload = {
@@ -129,15 +134,15 @@ def sync_deployables(dry_run: bool, instance: str | None = None):
                 else:
                     sync_deployment = { **deployable, "instance": instance }
                 if git_revision == deployable['gitRevision']:
-                    deployment = sync_deployable(sync_deployment)
+                    deployment = sync_deployable(cast(SyncDeployment, sync_deployment))
                     if previous_deployment:
                         previous_deployment.update(deployment)
                     else:
                         deployable['deployments'].insert(0, deployment)
                 else:
-                    found = remove_deployable(sync_deployment)
+                    found = remove_deployable(cast(SyncDeployment, sync_deployment))
                     action = 'NOT FOUND' if not found else action
-                    remove_index = all_deployables.index(deployable)
+                    remove_index = all_deployables.index(cast(DeployableRecord, deployable))
                     to_remove.append(all_deployables.pop(remove_index))
 
             print(f"{'Would sync' if dry_run else 'Synced'} {deployable['type'].replace('-', ' ')} {deployable['context']}.{deployable['name']}: {'TO BE ' if dry_run else ''}{action}")