api-foundry-query-engine 0.8.1__tar.gz → 0.8.2__tar.gz

{api_foundry_query_engine-0.8.1 → api_foundry_query_engine-0.8.2}/.gitignore

@@ -9,3 +9,5 @@ htmlcov/
 .coverage.*
 .coverage
 .vscode/
+temp/
+volume/

{api_foundry_query_engine-0.8.1 → api_foundry_query_engine-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: api-foundry-query-engine
-Version: 0.8.1
+Version: 0.8.2
 Summary: The AWS lambda service handler use by the `api_foundry` project is a powerful tool designed to automate the deployment of REST APIs on AWS using Lambda services to access and interact with relational databases (RDBMS). This project leverages the OpenAPI specification to define and manage the APIs
 Project-URL: Documentation, https://github.com/DanRepik/api-foundry
 Project-URL: Source, https://github.com/DanRepik/api-foundry

api_foundry_query_engine-0.8.2/api_foundry_query_engine/.pre-commit-config.yaml

@@ -0,0 +1,22 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.4.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+
+  - repo: https://github.com/psf/black
+    rev: 23.12.1
+    hooks:
+    -   id: black
+        language_version: python3.11
+
+  - repo: https://github.com/PyCQA/flake8
+    rev: 7.0.0
+    hooks:
+      - id: flake8
+        args: [--max-line-length=120]
+
+exclude: '^$'

{api_foundry_query_engine-0.8.1 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/adapters/adapter.py

@@ -10,7 +10,6 @@ log = logger(__name__)
 
 
 class Adapter(metaclass=abc.ABCMeta):
-
     service: Service
     config: Mapping[str, str]
 
@@ -23,9 +22,13 @@ class Adapter(metaclass=abc.ABCMeta):
             and callable(__subclass.unmarshal)
         )
 
-    def __init__(self, config: Mapping[str, str] = {}, service: Optional[Service] = None) -> None:
+    def __init__(
+        self, config: Mapping[str, str] = {}, service: Optional[Service] = None
+    ) -> None:
         self.config = config
-        self.service = service if service is not None else TransactionalService(config=self.config)
+        self.service = (
+            service if service is not None else TransactionalService(config=self.config)
+        )
 
     def unmarshal(self, event) -> Operation:
         """

{api_foundry_query_engine-0.8.1 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/connectors/connection_factory.py

@@ -1,7 +1,6 @@
 from typing import Mapping
 import boto3
 import json
-import os
 
 from api_foundry_query_engine.connectors.connection import Connection
 from api_foundry_query_engine.utils.app_exception import ApplicationException

{api_foundry_query_engine-0.8.1 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/dao/operation_dao.py

@@ -20,7 +20,10 @@ from api_foundry_query_engine.utils.app_exception import ApplicationException
 from api_foundry_query_engine.dao.dao import DAO
 from api_foundry_query_engine.connectors.connection import Cursor
 from api_foundry_query_engine.operation import Operation
-from api_foundry_query_engine.utils.api_model import get_path_operation, get_schema_object
+from api_foundry_query_engine.utils.api_model import (
+    get_path_operation,
+    get_schema_object,
+)
 from api_foundry_query_engine.dao.sql_query_handler import SQLQueryHandler
 
 
@@ -83,9 +86,7 @@ class OperationDAO(DAO):
                 )
         return self._query_handler
 
-    def execute(
-        self, connector, operation=None
-    ) -> Union[list[dict], dict]:
+    def execute(self, connector, operation=None) -> Union[list[dict], dict]:
         """
         Execute the database operation based on the provided connector.
 

{api_foundry_query_engine-0.8.1 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/dao/sql_insert_query_handler.py

@@ -73,10 +73,15 @@ class SQLInsertSchemaQueryHandler(SQLSchemaQueryHandler):
         allowed_property_names = self.check_permissions(
             "write", self.schema_object.permissions, self.schema_object.properties
         )
-        allowed_properties = {k: v for k, v in self.schema_object.properties.items() if k in allowed_property_names}
+        allowed_properties = {
+            k: v
+            for k, v in self.schema_object.properties.items()
+            if k in allowed_property_names
+        }
         log.info(f"allowed properties: {allowed_properties}")
 
         import json
+
         for name, value in self.operation.store_params.items():
             parts = name.split(".")
 
@@ -98,13 +103,17 @@ class SQLInsertSchemaQueryHandler(SQLSchemaQueryHandler):
 
             columns.append(property.column_name)
             if property.api_name is None:
-                raise ApplicationException(400, f"Property '{name}' does not have a valid api_name.")
+                raise ApplicationException(
+                    400, f"Property '{name}' does not have a valid api_name."
+                )
             placeholders.append(self.placeholder(property, property.api_name))
             # Serialize embedded objects to JSON
             if property.api_type == "object":
                 self.store_placeholders[property.api_name] = json.dumps(value)
             else:
-                self.store_placeholders[property.api_name] = property.convert_to_db_value(value)
+                self.store_placeholders[
+                    property.api_name
+                ] = property.convert_to_db_value(value)
 
         if self.key_property:
             if self.key_property.key_type == "sequence":

{api_foundry_query_engine-0.8.1 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/dao/sql_select_query_handler.py

@@ -70,7 +70,7 @@ class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
                     if self.schema_object.api_name is None:
                         raise ApplicationException(
                             500,
-                            "schema_object.api_name is None, cannot use as key in prefix_map"
+                            "schema_object.api_name is None, cannot use as key in prefix_map",
                         )
                     prefix = self.prefix_map[self.schema_object.api_name]
             except KeyError:
@@ -80,7 +80,7 @@ class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
                     + "schema object: "
                     + str(self.schema_object.api_name)
                     + ", property: "
-                    + name
+                    + name,
                 )
 
             assignment, holders = self.search_value_assignment(property, value, prefix)

{api_foundry_query_engine-0.8.1 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/dao/sql_update_query_handler.py

@@ -42,29 +42,36 @@ class SQLUpdateSchemaQueryHandler(SQLSchemaQueryHandler):
         allowed_property_names = self.check_permissions(
             "write", self.schema_object.permissions, self.schema_object.properties
         )
-        allowed_properties = {k: v for k, v in self.schema_object.properties.items() if k in allowed_property_names}
+        allowed_properties = {
+            k: v
+            for k, v in self.schema_object.properties.items()
+            if k in allowed_property_names
+        }
         self.store_placeholders = {}
         columns = []
         invalid_columns = []
 
         import json
+
         for name, value in self.operation.store_params.items():
             property = allowed_properties.get(name, None)
             if property is None:
                 invalid_columns.append(name)
                 continue
 
-            placeholder = str(property.api_name) if property.api_name is not None else name
+            placeholder = (
+                str(property.api_name) if property.api_name is not None else name
+            )
             column_name = property.column_name
 
-            columns.append(
-                f"{column_name} = {self.placeholder(property, placeholder)}"
-            )
+            columns.append(f"{column_name} = {self.placeholder(property, placeholder)}")
             # Serialize embedded objects to JSON
             if property.api_type == "object":
                 self.store_placeholders[placeholder] = json.dumps(value)
             else:
-                self.store_placeholders[placeholder] = property.convert_to_db_value(value)
+                self.store_placeholders[placeholder] = property.convert_to_db_value(
+                    value
+                )
 
         if invalid_columns:
             raise ApplicationException(

{api_foundry_query_engine-0.8.1 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/lambda_handler.py

@@ -1,21 +1,18 @@
-from fileinput import filename
 import json
 import logging
 import os
 from typing import Optional, Mapping
-import yaml
 
 from api_foundry_query_engine.utils.app_exception import ApplicationException
 from api_foundry_query_engine.adapters.gateway_adapter import GatewayAdapter
-from api_foundry_query_engine.utils.api_model import APIModel
 
 log = logging.getLogger(__name__)
 
 engine_config: Optional[Mapping[str, str]] = None
 adapter: Optional[GatewayAdapter] = None
 
-class QueryEngine:
 
+class QueryEngine:
     def __init__(self, config: Mapping[str, str]):
         self.adapter = GatewayAdapter(config)
 

{api_foundry_query_engine-0.8.1 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/services/service.py

@@ -1,6 +1,5 @@
 import hashlib
 import json
-import os
 
 from api_foundry_query_engine.utils.logger import logger
 from api_foundry_query_engine.operation import Operation
@@ -8,7 +7,6 @@ from api_foundry_query_engine.operation import Operation
 log = logger(__name__)
 
 
-
 class Service:
     def __init__(self, config: dict = {}):
         self.config = config
@@ -17,7 +15,6 @@ class Service:
         raise NotImplementedError
 
 
-
 class ServiceAdapter(Service):
     def __init__(self, config: dict = {}):
         super().__init__(config)
@@ -26,7 +23,6 @@ class ServiceAdapter(Service):
         return super().execute(operation)
 
 
-
 class MutationPublisher(ServiceAdapter):
     def __init__(self, config: dict = {}):
         super().__init__(config)
@@ -65,6 +61,7 @@ class MutationPublisher(ServiceAdapter):
 
     def __client(self, client_type):
         import boto3
+
         region = self.config.get("AWS_REGION", "us-east-1")
         session = boto3.Session()
         if session:

{api_foundry_query_engine-0.8.1 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/services/transactional_service.py

@@ -1,5 +1,5 @@
 import traceback
-from typing import Optional, Mapping
+from typing import Mapping
 
 from api_foundry_query_engine.utils.logger import logger
 from api_foundry_query_engine.utils.app_exception import ApplicationException
@@ -19,7 +19,7 @@ class TransactionalService(ServiceAdapter):
     def __init__(self, config: Mapping[str, str]):
         super().__init__()
         self.config = config
-        self.connection_factory = ConnectionFactory(config) 
+        self.connection_factory = ConnectionFactory(config)
 
     def execute(self, operation: Operation) -> list[dict]:
         path_operation = get_path_operation(operation.entity, operation.action)

{api_foundry_query_engine-0.8.1 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/utils/api_model.py

@@ -4,25 +4,27 @@ import yaml
 from datetime import datetime
 from typing import Any, Dict, Mapping, Optional
 
-from api_foundry_query_engine.operation import Operation
 from api_foundry_query_engine.utils.logger import logger
 
 log = logger(__name__)
 
 api_model = None
 
+
 def get_schema_object(name: str) -> Optional["SchemaObject"]:
     global api_model
     if api_model is None:
         return None
     return api_model.schema_objects.get(name)
 
+
 def get_path_operation(path: str, method: str) -> Optional["PathOperation"]:
     global api_model
     if api_model is None:
         return None
     return api_model.path_operations.get(f"{path}_{method}")
 
+
 class SchemaObjectProperty:
     """Represents a property of a schema object."""
 
@@ -57,7 +59,9 @@ class SchemaObjectProperty:
             "date-time": lambda x: datetime.fromisoformat(x) if x else None,
             "time": lambda x: datetime.strptime(x, "%H:%M:%S").time() if x else None,
         }
-        conversion_func = conversion_mapping.get(self.column_type if self.column_type is not None else "string", lambda x: x)
+        conversion_func = conversion_mapping.get(
+            self.column_type if self.column_type is not None else "string", lambda x: x
+        )
         return conversion_func(value)
 
     def convert_to_api_value(self, value) -> Optional[Any]:
@@ -73,7 +77,9 @@ class SchemaObjectProperty:
             "date-time": lambda x: x.isoformat() if x else None,
             "time": lambda x: x.time().isoformat() if x else None,
         }
-        conversion_func = conversion_mapping.get(self.api_type if self.api_type is not None else "string", lambda x: x)
+        conversion_func = conversion_mapping.get(
+            self.api_type if self.api_type is not None else "string", lambda x: x
+        )
         return conversion_func(value)
 
 
@@ -101,7 +107,9 @@ class SchemaObjectAssociation:
             raise ValueError(f"Primary key not defined for schema '{self.schema_name}'")
         column_name = getattr(child_schema.primary_key, "column_name", None)
         if column_name is None:
-            raise ValueError(f"Primary key property does not have 'column_name' for schema '{self.schema_name}'")
+            raise ValueError(
+                f"Primary key property does not have 'column_name' for schema '{self.schema_name}'"
+            )
         return column_name
 
     @property
@@ -112,10 +120,14 @@ class SchemaObjectAssociation:
         if not parent_schema_obj:
             raise ValueError(f"SchemaObject '{self.parent_schema}' not found")
         if not parent_schema_obj.primary_key:
-            raise ValueError(f"Primary key not defined for schema '{self.parent_schema}'")
+            raise ValueError(
+                f"Primary key not defined for schema '{self.parent_schema}'"
+            )
         column_name = getattr(parent_schema_obj.primary_key, "column_name", None)
         if column_name is None:
-            raise ValueError(f"Primary key property does not have 'column_name' for schema '{self.parent_schema}'")
+            raise ValueError(
+                f"Primary key property does not have 'column_name' for schema '{self.parent_schema}'"
+            )
         return column_name
 
     def __repr__(self):
@@ -147,7 +159,9 @@ class SchemaObject:
             for name, prop_data in data.get("properties", {}).items()
         }
         self.relations = {
-            name: SchemaObjectAssociation(self.api_name if self.api_name is not None else "", assoc_data)
+            name: SchemaObjectAssociation(
+                self.api_name if self.api_name is not None else "", assoc_data
+            )
             for name, assoc_data in data.get("relations", {}).items()
         }
         self.concurrency_property = (
@@ -208,18 +222,20 @@ class APIModel:
             return None
         return self.path_operations.get(f"{path}_{method}")
 
-
     def __repr__(self):
         return (
             f"APIModel(schema_objects={list(self.schema_objects.keys())}, "
             + f"path_operations={list(self.path_operations.keys())})"
         )
 
+
 def set_api_model(engine_config: Mapping[str, str]):
     global api_model
     if api_model is None:
         if engine_config.get("API_SPEC"):
             api_model = APIModel(yaml.safe_load(engine_config["API_SPEC"]))
         else:
-            with open(os.environ.get("API_SPEC", "/var/task/api_spec.yaml"), "r") as file:
+            with open(
+                os.environ.get("API_SPEC", "/var/task/api_spec.yaml"), "r"
+            ) as file:
                 api_model = APIModel(yaml.safe_load(file))

{api_foundry_query_engine-0.8.1 → api_foundry_query_engine-0.8.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "api-foundry-query-engine"
-version = "0.8.1"
+version = "0.8.2"
 authors = [
     { name="Daniel Repik", email="danrepik@icloud.com" },
 ]