synmax-api-python-client 4.0.0__py3-none-any.whl → 4.2.1__py3-none-any.whl

synmax/openapi/client.py

@@ -0,0 +1,199 @@
+import json
+import httpx
+import logging
+from pydantic import BaseModel
+from typing import Any, Dict, Optional, Type, Iterator
+from prance import ResolvingParser
+import time
+import importlib
+
+from itertools import islice
+import pandas as pd
+
+from synmax.openapi.utils import change_signature, get_annotation, get_body_model, get_param_model
+
+class OpenAPIClient:
+    def __init__(self,
+                 base_uri: str = "",
+                 headers: Optional[Dict[str, str]] = None,
+                 logger: Optional[logging.Logger] = None,
+                 timeout = 15.0,
+                 retries = 3,
+                 retry_sleep = 20,
+                 ):
+        self._base_uri = base_uri.rstrip('/')
+        self._retries = retries
+        self._retry_sleep = retry_sleep
+        self._timeout = timeout
+        accept_header = {"Accept": "application/x-ndjson"}
+        base_headers = headers or {}
+        self._client = httpx.Client(
+            headers=dict(base_headers, **accept_header),
+            timeout=timeout,
+        )
+        self._logger = logger or logging.getLogger(__name__)
+        parser = ResolvingParser(self._spec, backend = 'openapi-spec-validator')
+        self._openapi = parser.specification
+        self._paths = self._openapi.get("paths", {})
+        self._generate_methods()
+        self._logger.info(f"Initialized client for {self._base_uri}")
+
+
+    def _generate_methods(self):
+        for path, methods in self._paths.items():
+            for method, details in methods.items():
+                method_name = details.get("x-method-name", None)
+                if method_name is None:
+                    continue
+                param_model = get_param_model(details.get("parameters", []), method_name)
+                body_model = get_body_model(details.get("requestBody", {}), method_name)
+                full_url = f"{self._base_uri}{path}"
+                request_func = self._create_request_function(method, full_url, param_model, body_model)
+                request_func.__name__ = method_name
+                setattr(self, method_name, request_func.__get__(self))
+
+
+    @classmethod
+    def _dump_stub(cls) -> str:
+        if not hasattr(cls, '_spec'):
+            message = f"Class '{cls.__name__}' is missing required attribute: '_spec'"
+            raise AttributeError(message)
+        t = type(cls.__name__, (OpenAPIClient,), {"_spec": cls._spec})
+        return t()._get_annotations()
+
+
+    @classmethod
+    def _write_stub(cls):
+        module = cls.__module__
+        origin = importlib.util.find_spec(module).origin
+        outfile = f"{origin}i"
+        with open(outfile, "w") as file:
+            file.write(cls._dump_stub())
+        print(f"wrote class stub to {outfile}")
+
+
+    def _get_annotations(self) -> str:
+        lines = []
+        lines.append("from typing import Literal, Union")
+        lines.append("from synmax.openapi.client import Result")
+        lines.append("from datetime import date")
+        lines.append(f"class {self.__class__.__name__}:")
+
+        tab = "    "
+
+        for path, methods in self._paths.items():
+            for method, details in methods.items():
+                method_name = details.get("x-method-name", details.get("operationId", None))
+                if method_name is None:
+                    continue
+                param_model = get_param_model(details.get("parameters", []), method_name)
+                body_model = get_body_model(details.get("requestBody", {}), method_name)
+                annotation = get_annotation([param_model, body_model])
+                description = details.get("summary", None)
+                if description is None:
+                    description = " "
+                else:
+                    description = f"\n{tab}{tab}\"\"\"{description}\"\"\"\n{tab}{tab}"
+
+                lines.append(f"{tab}def {method_name}({annotation}) -> Result:{description}...")
+        return "\n".join(lines)
+
+
+    def _create_request_function(self, method: str, full_url: str, param_model: Optional[Type[BaseModel]], body_model: Optional[Type[BaseModel]]):
+        def request_func(self, **kwargs) -> Result:
+            def generator() -> Iterator[Dict[str, Any]]:
+                param_dict = None
+                if param_model:
+                    data = param_model(**kwargs).model_dump(mode='json')
+                    param_dict = {k: v for k, v in data.dict().items() if v is not None}
+                body_dict = None
+                if body_model:
+                    data = body_model(**kwargs).model_dump(mode='json')
+                    body_dict = {k: v for k, v in data.items() if v is not None}
+                self._logger.info(f"Making request to {full_url}")
+                retry_count = 0
+                can_retry = True
+                while can_retry:
+                    try:
+                        with self._client.stream(
+                                method.upper(),
+                                full_url,
+                                params=param_dict if param_model else None,
+                                json=body_dict if body_model else None,
+                                ) as response:
+                            if response.is_error:
+                                for chunk in response.iter_text():
+                                    self._logger.error(f"Error response fom api server. Status code: {response.status_code}")
+                                    self._logger.error(chunk)
+                            response.raise_for_status()
+                            total_bytes = 0
+                            total_records = 0
+                            last_message = time.time()
+                            buffer = ""
+                            for chunk in response.iter_bytes():
+                                total_bytes += len(chunk)
+                                buffer += chunk.decode("utf-8")
+                                while "\n" in buffer:
+                                    line, buffer = buffer.split("\n", 1)
+                                    if line.strip():
+                                        can_retry = False # if we get any response, interrupt retry logic
+                                        yield json.loads(line)
+                                        total_records += 1
+                                now = time.time()
+                                if now - last_message >= 1:
+                                    last_message = now
+                                    self._logger.debug(f"Got {total_records} total records, {total_bytes} total bytes")
+                            if buffer.strip():  # last record has no newline
+                                yield json.loads(buffer)
+                                total_records += 1
+                            self._logger.debug(f"Got {total_records} total records, {total_bytes} total bytes")
+                        break
+                    except httpx.ReadTimeout:
+                        retry_count += 1
+                        retry_text = ""
+                        can_retry = can_retry and retry_count <= self._retries
+                        if can_retry:
+                            retry_text = f"Retry {retry_count}/{self._retries}. Sleep {self._retry_sleep}s."
+                        self._logger.error(f"Request timed out ({self._timeout}s). {retry_text}")
+                        time.sleep(self._retry_sleep)
+
+            return Result(generator())
+
+        signature = {}
+        for model in (param_model, body_model):
+            if model:
+                for field_name, field in model.__annotations__.items():
+                    is_optional = model.__fields__[field_name].default is None
+                    signature[field_name] = Optional[field] if is_optional else field
+        return change_signature(request_func, signature)
+
+    def close(self):
+        self._client.close()
+
+
+
+class Result(Iterator[Dict[str, Any]]):
+    def __init__(self, generator):
+        self._generator = generator
+
+    def __iter__(self):
+        return self._generator
+
+    def __next__(self):
+        return next(self._generator)
+
+    def df(self, chunk_size = 100000) -> pd.DataFrame:
+        def batched():
+            it = iter(self)
+            while True:
+                batch = list(islice(it, chunk_size))
+                if not batch:
+                    break
+                yield batch
+        chunks = []
+        for batch in batched():
+            chunks.append(pd.DataFrame(batch))
+        df = pd.concat(chunks, ignore_index=True)
+        return df
+
+    # TODO: save_csv(self, path)

synmax/openapi/utils.py

@@ -0,0 +1,101 @@
+import inspect
+from pydantic import BaseModel, create_model, Extra
+from typing import Any, Dict, Optional, Type, Union, Literal
+from datetime import date
+
+
+def change_signature(func, signature: inspect.Signature):
+    """
+    Wraps a func in a new one with a different signature
+
+    :param func: function to wrap
+    :param signature: signature to assign
+    """
+    def wrapped(*args, **kwargs):
+        bound_arguments = inspect.signature(func).bind(*args, **kwargs)
+        bound_arguments.apply_defaults()
+        return func(*bound_arguments.args, **bound_arguments.kwargs)
+    sig = inspect.signature(func)
+    new_params = [
+            inspect.Parameter(
+                name,
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                annotation=signature.get(name)
+                )
+            for name in signature
+            ]
+    new_signature = sig.replace(parameters=new_params)
+    wrapped.__signature__ = new_signature
+    return wrapped
+
+
+def get_annotation(models: list[BaseModel]) -> str:
+    params = []
+    for model in models:
+        if model is None:
+            continue
+        fields = model.model_fields
+        for fname, field in fields.items():
+
+            annotation = repr(field.annotation)
+            if hasattr(field.annotation, "__name__"):
+                annotation = field.annotation.__name__
+            if hasattr(field.annotation, "__origin__"):
+                annotation = str(field.annotation).replace("typing.","")
+            default = " = ..." if field.is_required() is False else ""
+            params.append(f"{fname}: {annotation}{default}")
+    return ",".join(["self"] + params)
+
+
+def get_param_model(parameters: list, operation_id: str) -> Optional[Type[BaseModel]]:
+    param_fields = {}
+    for param in parameters:
+        name = param["name"]
+        schema = param.get("schema", {"type": "string"})
+        required = param.get("required", False)
+        param_fields[name] = (map_openapi_type(schema, name), ... if required else None)
+    return create_model(f"{operation_id}Params", **param_fields) if param_fields else None
+
+
+def get_body_model(request_body: dict, operation_id: str) -> Optional[Type[BaseModel]]:
+    body_fields = {}
+    body_extra = Extra.allow
+    if request_body:
+        content = request_body.get("content", {}).get("application/json", {})
+        schema = content.get("schema", {"type": "object", "properties": {}})
+        required_fields = schema.get("required", [])
+        for key, value in schema.get("properties", {}).items():
+            is_required = key in required_fields
+            body_fields[key] = (map_openapi_type(value, key), ... if is_required else None)
+        if schema.get("additionalProperties") is False:
+            body_extra = Extra.forbid
+    return create_model(f"{operation_id}Body", **body_fields, __config__=type("Config", (), {"extra": body_extra})) if body_fields else None
+
+
+def map_openapi_type(schema: Dict[str, Any], name: str) -> Type:
+    type_map = {
+        "string": str,
+        "integer": int,
+        "boolean": bool,
+        "number": float,
+        "array": list,
+        "object": dict
+    }
+
+    if "enum" in schema:
+        return Literal[tuple(schema["enum"])]
+
+    if "anyOf" in schema:
+        types = [map_openapi_type(sub_schema, name) for sub_schema in schema["anyOf"]]
+        return Union[tuple(types)]
+
+    if schema.get("type") == "array":
+        items_schema = schema.get("items", {})
+        item_type = map_openapi_type(items_schema, name)
+        return list[item_type]
+
+    if schema.get("type") == "string" and schema.get("format") == "date":
+        return date
+
+    return type_map.get(schema.get("type"), Any)
+

{synmax_api_python_client-4.0.0.dist-info → synmax_api_python_client-4.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: synmax-api-python-client
-Version: 4.0.0
+Version: 4.2.1
 Summary: Synmax API client
 Home-page: https://github.com/SynMaxDev/synmax-api-python-client.git
 Author: Eric Anderson and Deepa Aswathaiah

{synmax_api_python_client-4.0.0.dist-info → synmax_api_python_client-4.2.1.dist-info}/RECORD

@@ -15,14 +15,16 @@ synmax/hyperion/process_api.py,sha256=y3sNiM2X_h-QVRRsrW4VmkABfGKxPqqZGMiYNrpRrK
 synmax/hyperion/process_inputs.py,sha256=Dij1FTzdyv0yGvwQNYZ9yJTJ6vBf-9B4P2zmJeCo6UU,10796
 synmax/hyperion/v4/__init__.py,sha256=VpXU-_FP836dXUDcUFYr-0y0-ZrSM8aCtGE97Z2qbS4,55
 synmax/hyperion/v4/hyperion_client.py,sha256=Yo6HVmekIH3L-G6ABjlwdxXhcmCG0pV1HDl5p8O1shM,833
+synmax/openapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synmax/openapi/client.py,sha256=fe6npo842Z_9ar2SX7wTFz9Y7Jv9vN03zTumpnb1y64,8600
+synmax/openapi/utils.py,sha256=q6PsmUT0D58_AdOCM0ZNw1CrveiYVF4IQN4J6ticZ4Q,3689
 synmax/theia/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-test/ip_rate_example.py,sha256=UQCrYDYH7mtFCet9xCJJNfT-3G5v_LKdeioEovSwVM4,1634
 test/test_api_client.py,sha256=HFWCu_xBgqQXc9p6k6YmP2gVrdCFwuhoDVqlxpN1Yoc,4713
 test/test_hyperion_client.py,sha256=aCb4bMBXWofa82MInXoU9tJ5wWsg5sBRv7B_CHvkrcg,1380
 test/test_hyperion_e2e.py,sha256=BPhZH7eVQZSsFcvPdonKjmLahnfsLy37Z2DHp0LGeHc,6247
 test/test_hyperion_helpers.py,sha256=R0G7oqKaoz6jLRACODJ1Cf2gA0gaMPQhOZRjKp4a6-s,2006
-synmax_api_python_client-4.0.0.dist-info/METADATA,sha256=3QD863d4OisG4eU47kl64hxVPNIivPS6XG9PaMrljHU,4860
-synmax_api_python_client-4.0.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-synmax_api_python_client-4.0.0.dist-info/top_level.txt,sha256=SAjmDfHlJzUmjoGCT1SnS4qGSLN_ZF-p58UN1yW5kB0,17
-synmax_api_python_client-4.0.0.dist-info/RECORD,,
+synmax_api_python_client-4.2.1.dist-info/METADATA,sha256=ffdQduj69sIu9qe9PJ9SgfDwp9mJVf03-qMjoGUcbew,4860
+synmax_api_python_client-4.2.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+synmax_api_python_client-4.2.1.dist-info/top_level.txt,sha256=SAjmDfHlJzUmjoGCT1SnS4qGSLN_ZF-p58UN1yW5kB0,17
+synmax_api_python_client-4.2.1.dist-info/RECORD,,

test/ip_rate_example.py

@@ -1,61 +0,0 @@
-import plotly.express as px
-import plotly.figure_factory as ff
-
-from synmax.hyperion import HyperionApiClient, ApiPayload, add_daily, get_fips
-
-"""Install SynMax Python Client"""
-
-# pip install --upgrade synmax-api-python-client
-
-"""Install other Dependencies"""
-
-# pip install plotly-geo plotly geopandas==0.8.1 pyshp shapely
-
-"""Query the production data"""
-
-access_token = "************************************"
-client = HyperionApiClient(access_token=access_token)
-
-payload = ApiPayload(
-    start_date="2021-01-01", end_date="2022-09-01", state_code="TX", production_month=2
-)
-df = client.production_by_well(payload)
-# df.to_csv(r'C:\Users\eric\Desktop\TEMP\prod_ip.csv', index=False)
-# df = pd.read_csv(r'C:\Users\eric\Desktop\TEMP\prod_ip.csv')
-
-"""convert to mcf/d"""
-df = add_daily(df)
-
-"""examine county-level histograms"""
-
-fig = px.histogram(df[df.county == "Midland"], x="gas_daily")
-fig.show()
-
-"""calculate average per county"""
-
-county_df = (
-    df[["state_ab", "county", "gas_daily"]]
-    .groupby(["state_ab", "county"], as_index=False)
-    .mean()
-)
-
-"""Get FIPS code Lookup Table"""
-
-fips_df = get_fips()
-
-"""merge fips_df with county_df"""
-county_df = county_df.merge(
-    fips_df[fips_df.state_ab == "TX"], how="right", on=["state_ab", "county"]
-)
-county_df["gas_daily"] = county_df["gas_daily"].fillna(0)
-
-"""Create county map"""
-
-fig = ff.create_choropleth(
-    fips=county_df.fips.tolist(),
-    values=county_df.gas_daily.tolist(),
-    county_outline={"color": "rgb(255,255,255)", "width": 0.5},
-    scope=["TX"],
-    binning_endpoints=[75, 125, 250, 500, 1000, 2000, 4000, 8000, 16000, 32000],
-)
-fig.show()