snapline-api-adapters 0.1.10__tar.gz

snapline_api_adapters-0.1.10/.gitignore

@@ -0,0 +1,5 @@
+/*.iml
+.idea
+dist/
+build/
+*.egg-info/

snapline_api_adapters-0.1.10/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: snapline-api-adapters
+Version: 0.1.10
+Summary: REST, GraphQL, and SOAP API adapters for Snapline
+Project-URL: Homepage, https://github.com/vaagatech/snapline-python
+Project-URL: Repository, https://github.com/vaagatech/snapline-python
+Author-email: VaagaTech <info@vaagatech.com>
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: snapline-engine==0.1.10

snapline_api_adapters-0.1.10/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "snapline-api-adapters"
+version = "0.1.10"
+description = "REST, GraphQL, and SOAP API adapters for Snapline"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "VaagaTech", email = "info@vaagatech.com" }]
+dependencies = [
+    "snapline-engine==0.1.10",
+    "httpx>=0.27.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/vaagatech/snapline-python"
+Repository = "https://github.com/vaagatech/snapline-python"
+
+[tool.hatch.build.targets.wheel]
+packages = ["snapline"]

snapline_api_adapters-0.1.10/snapline/api_adapters/__init__.py

@@ -0,0 +1,29 @@
+from .api_factory import api
+from .execute_api import execute_api
+from .graphql.execute_graphql import execute_graphql
+from .resolve_url import resolve_url
+from .rest.execute_rest import execute_rest
+from .soap.execute_soap import execute_soap
+from .soap.xml_utils import build_soap_envelope, parse_soap_body
+from .types import (
+    ApiExecuteContext,
+    ApiExecuteResult,
+    ApiRequestConfig,
+    is_graphql_config,
+    is_rest_config,
+    is_soap_config,
+)
+
+__all__ = [
+    "api",
+    "build_soap_envelope",
+    "execute_api",
+    "execute_graphql",
+    "execute_rest",
+    "execute_soap",
+    "is_graphql_config",
+    "is_rest_config",
+    "is_soap_config",
+    "parse_soap_body",
+    "resolve_url",
+]

snapline_api_adapters-0.1.10/snapline/api_adapters/api_factory.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .types import GraphqlApiConfig, RestApiConfig, SoapApiConfig
+
+
+class ApiFactory:
+  @staticmethod
+  def rest(config: dict[str, Any]) -> RestApiConfig:
+    return {"protocol": "rest", **config}
+
+  @staticmethod
+  def soap(config: dict[str, Any]) -> SoapApiConfig:
+    return {"protocol": "soap", **config}
+
+  @staticmethod
+  def graphql(config: dict[str, Any]) -> GraphqlApiConfig:
+    return {"protocol": "graphql", **config}
+
+
+api = ApiFactory()

snapline_api_adapters-0.1.10/snapline/api_adapters/execute_api.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .graphql.execute_graphql import execute_graphql
+from .rest.execute_rest import execute_rest
+from .soap.execute_soap import execute_soap
+from .types import (
+    ApiExecuteContext,
+    ApiExecuteResult,
+    ApiRequestConfig,
+    is_graphql_config,
+    is_rest_config,
+    is_soap_config,
+)
+
+
+def execute_api(
+    config: ApiRequestConfig,
+    context: ApiExecuteContext | dict[str, Any] | None = None,
+) -> ApiExecuteResult:
+    if is_rest_config(config):
+        return execute_rest(config, context)
+    if is_soap_config(config):
+        return execute_soap(config, context)
+    if is_graphql_config(config):
+        return execute_graphql(config, context)
+    raise ValueError("Unsupported API protocol")

snapline_api_adapters-0.1.10/snapline/api_adapters/graphql/execute_graphql.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from snapline.engine import load_json_file
+
+from ..resolve_url import resolve_url
+from ..types import ApiExecuteContext, ApiExecuteResult, GraphqlApiConfig
+
+
+def _default_fetch(
+    url: str,
+    *,
+    method: str = "GET",
+    headers: dict[str, str] | None = None,
+    content: str | bytes | None = None,
+    data: str | bytes | None = None,
+) -> httpx.Response:
+    body = content if content is not None else data
+    return httpx.request(method, url, headers=headers, content=body)
+
+
+def _load_query(config: GraphqlApiConfig) -> str:
+    if config.get("query"):
+        return config["query"]
+
+    query_file = config.get("queryFile")
+    if not query_file:
+        return ""
+
+    raw = Path(query_file).read_text(encoding="utf-8").strip()
+    if raw.startswith("{"):
+        parsed = json.loads(raw)
+        return parsed.get("query", raw)
+    return raw
+
+
+def _get_by_path(obj: Any, path: str | None) -> Any:
+    if not path:
+        return obj
+
+    cursor = obj
+    for key in path.split("."):
+        if isinstance(cursor, dict) and key in cursor:
+            cursor = cursor[key]
+        else:
+            return None
+    return cursor
+
+
+def execute_graphql(
+    config: GraphqlApiConfig,
+    context: ApiExecuteContext | dict[str, Any] | None = None,
+) -> ApiExecuteResult:
+    ctx = context or {}
+    base_url = ctx.get("baseUrl")
+    auth_headers = ctx.get("authHeaders", {})
+    fetch_impl = ctx.get("fetchImpl") or _default_fetch
+    input_from_row = ctx.get("inputFromRow")
+
+    query = _load_query(config)
+    variables: dict[str, Any] = dict(config.get("variables") or {})
+
+    if config.get("variablesFile"):
+        variables = load_json_file(config["variablesFile"])
+    if config.get("inputFile"):
+        variables = load_json_file(config["inputFile"])
+    if input_from_row:
+        variables = {**variables, **input_from_row}
+
+    url = resolve_url(config["endpoint"], base_url)
+    response = fetch_impl(
+        url,
+        method="POST",
+        headers={
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            **auth_headers,
+            **(config.get("headers") or {}),
+        },
+        content=json.dumps({"query": query, "variables": variables}),
+    )
+
+    text = response.text
+    response_headers = dict(response.headers)
+
+    try:
+        parsed = json.loads(text) if text else None
+    except json.JSONDecodeError:
+        parsed = text
+
+    gql_data = parsed.get("data") if isinstance(parsed, dict) and "data" in parsed else parsed
+    data = _get_by_path(gql_data, config.get("dataPath"))
+
+    return {
+        "status": response.status_code,
+        "data": data,
+        "headers": response_headers,
+        "raw": text,
+    }

snapline_api_adapters-0.1.10/snapline/api_adapters/resolve_url.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from urllib.parse import urljoin, urlparse
+
+
+def resolve_url(endpoint: str, base_url: str | None = None) -> str:
+    if urlparse(endpoint).scheme:
+        return endpoint
+    if not base_url:
+        return endpoint
+    return urljoin(base_url.rstrip("/") + "/", endpoint.lstrip("/"))

snapline_api_adapters-0.1.10/snapline/api_adapters/rest/execute_rest.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+from urllib.parse import urlencode, urlparse, urlunparse, parse_qsl
+
+import httpx
+
+from snapline.engine import load_json_file
+
+from ..resolve_url import resolve_url
+from ..types import ApiExecuteContext, ApiExecuteResult, RestApiConfig
+
+
+def _default_fetch(
+    url: str,
+    *,
+    method: str = "GET",
+    headers: dict[str, str] | None = None,
+    content: str | bytes | None = None,
+    data: str | bytes | None = None,
+) -> httpx.Response:
+    body = content if content is not None else data
+    return httpx.request(method, url, headers=headers, content=body)
+
+
+def execute_rest(
+    config: RestApiConfig,
+    context: ApiExecuteContext | dict[str, Any] | None = None,
+) -> ApiExecuteResult:
+    ctx = context or {}
+    base_url = ctx.get("baseUrl")
+    auth_headers = ctx.get("authHeaders", {})
+    fetch_impl = ctx.get("fetchImpl") or _default_fetch
+    input_from_row = ctx.get("inputFromRow")
+
+    endpoint = config["endpoint"]
+    method = config.get("method") or "GET"
+    input_file = config.get("inputFile")
+    body = config.get("body")
+    headers = config.get("headers") or {}
+
+    url = resolve_url(endpoint, base_url)
+    payload: Any = body
+
+    if input_file:
+        payload = load_json_file(input_file)
+
+    if input_from_row:
+        if isinstance(payload, dict) and not isinstance(payload, list):
+            payload = {**payload, **input_from_row}
+        else:
+            payload = dict(input_from_row)
+
+    http_method = method.upper()
+    if input_from_row and http_method in {"GET", "HEAD"}:
+        parsed = urlparse(url)
+        query = dict(parse_qsl(parsed.query))
+        query.update({key: str(value) for key, value in input_from_row.items()})
+        url = urlunparse(parsed._replace(query=urlencode(query)))
+
+    request_headers = {
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        **auth_headers,
+        **headers,
+    }
+
+    request_body: str | None = None
+    if payload is not None and http_method not in {"GET", "HEAD"}:
+        request_body = json.dumps(payload)
+
+    response = fetch_impl(
+        url,
+        method=http_method,
+        headers=request_headers,
+        content=request_body,
+    )
+
+    text = response.text
+    response_headers = dict(response.headers)
+
+    try:
+        data = json.loads(text) if text else None
+    except json.JSONDecodeError:
+        data = text
+
+    return {
+        "status": response.status_code,
+        "data": data,
+        "headers": response_headers,
+        "raw": text,
+    }

snapline_api_adapters-0.1.10/snapline/api_adapters/soap/execute_soap.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from ..resolve_url import resolve_url
+from ..soap.xml_utils import build_soap_envelope, parse_soap_body
+from ..types import ApiExecuteContext, ApiExecuteResult, SoapApiConfig
+
+
+def _default_fetch(
+    url: str,
+    *,
+    method: str = "GET",
+    headers: dict[str, str] | None = None,
+    content: str | bytes | None = None,
+    data: str | bytes | None = None,
+) -> httpx.Response:
+    body = content if content is not None else data
+    return httpx.request(method, url, headers=headers, content=body)
+
+
+def _load_envelope(config: SoapApiConfig) -> str:
+    if config.get("envelope"):
+        return config["envelope"]
+
+    input_file = config.get("inputFile")
+    if input_file:
+        return Path(input_file).read_text(encoding="utf-8")
+
+    return build_soap_envelope(
+        "<GetUserRequest><email>unknown@example.com</email></GetUserRequest>"
+    )
+
+
+def execute_soap(
+    config: SoapApiConfig,
+    context: ApiExecuteContext | dict[str, Any] | None = None,
+) -> ApiExecuteResult:
+    ctx = context or {}
+    base_url = ctx.get("baseUrl")
+    auth_headers = ctx.get("authHeaders", {})
+    fetch_impl = ctx.get("fetchImpl") or _default_fetch
+    input_from_row = ctx.get("inputFromRow")
+
+    envelope = _load_envelope(config)
+
+    if input_from_row and input_from_row.get("email"):
+        import re
+
+        envelope = re.sub(
+            r"<email>[^<]*</email>",
+            f"<email>{input_from_row['email']}</email>",
+            envelope,
+            flags=re.IGNORECASE,
+        )
+
+    url = resolve_url(config["endpoint"], base_url)
+    headers: dict[str, str] = {
+        "Content-Type": "text/xml; charset=utf-8",
+        "Accept": "text/xml",
+        **auth_headers,
+        **(config.get("headers") or {}),
+    }
+
+    if config.get("soapAction"):
+        headers["SOAPAction"] = config["soapAction"]
+
+    response = fetch_impl(
+        url,
+        method="POST",
+        headers=headers,
+        content=envelope,
+    )
+
+    text = response.text
+    response_headers = dict(response.headers)
+    data = parse_soap_body(text)
+
+    return {
+        "status": response.status_code,
+        "data": data,
+        "headers": response_headers,
+        "raw": text,
+    }

snapline_api_adapters-0.1.10/snapline/api_adapters/soap/xml_utils.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+
+def parse_soap_body(xml: str) -> dict[str, Any]:
+    body_match = re.search(
+        r"<(?:[\w]+:)?Body[^>]*>([\s\S]*?)</(?:[\w]+:)?Body>",
+        xml,
+        flags=re.IGNORECASE,
+    )
+    inner = body_match.group(1) if body_match else xml
+    result: dict[str, Any] = {}
+
+    tag_pattern = re.compile(
+        r"<(?:[\w]+:)?(\w+)[^>]*>([^<]*)</(?:[\w]+:)?\1>",
+        flags=re.IGNORECASE,
+    )
+    for match in tag_pattern.finditer(inner):
+        key = match.group(1)
+        value = (match.group(2) or "").strip()
+        if key and value is not None:
+            result[key] = value
+
+    return result
+
+
+def build_soap_envelope(body_inner_xml: str) -> str:
+    return (
+        '<?xml version="1.0" encoding="UTF-8"?>'
+        '<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">'
+        "<soap:Body>"
+        f"{body_inner_xml}"
+        "</soap:Body>"
+        "</soap:Envelope>"
+    )

snapline_api_adapters-0.1.10/snapline/api_adapters/types.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any, Literal, Protocol, TypeAlias
+
+HttpMethod: TypeAlias = Literal["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]
+ApiProtocol: TypeAlias = Literal["rest", "soap", "graphql"]
+
+
+class FetchResponse(Protocol):
+    status_code: int
+    text: str
+    headers: dict[str, str]
+
+    def json(self) -> Any: ...
+
+
+class FetchImpl(Protocol):
+    def __call__(
+        self,
+        url: str,
+        *,
+        method: str = "GET",
+        headers: dict[str, str] | None = None,
+        content: str | bytes | None = None,
+        data: str | bytes | None = None,
+    ) -> FetchResponse: ...
+
+
+class ApiExecuteContext(dict):
+    baseUrl: str | None
+    authHeaders: dict[str, str]
+    fetchImpl: FetchImpl | None
+    inputFromRow: dict[str, Any] | None
+
+
+class ApiExecuteResult(dict):
+    status: int
+    data: Any
+    headers: dict[str, str]
+    raw: str
+
+
+class RestApiConfig(dict):
+    protocol: Literal["rest"]
+    endpoint: str
+    method: HttpMethod | None
+    inputFile: str | None
+    body: Any
+    headers: dict[str, str] | None
+
+
+class SoapApiConfig(dict):
+    protocol: Literal["soap"]
+    endpoint: str
+    soapAction: str | None
+    envelope: str | None
+    inputFile: str | None
+    headers: dict[str, str] | None
+
+
+class GraphqlApiConfig(dict):
+    protocol: Literal["graphql"]
+    endpoint: str
+    query: str | None
+    queryFile: str | None
+    variables: dict[str, Any] | None
+    variablesFile: str | None
+    inputFile: str | None
+    dataPath: str | None
+    headers: dict[str, str] | None
+
+
+ApiRequestConfig = RestApiConfig | SoapApiConfig | GraphqlApiConfig
+
+
+def is_rest_config(config: ApiRequestConfig) -> bool:
+    return config.get("protocol") == "rest"
+
+
+def is_soap_config(config: ApiRequestConfig) -> bool:
+    return config.get("protocol") == "soap"
+
+
+def is_graphql_config(config: ApiRequestConfig) -> bool:
+    return config.get("protocol") == "graphql"