polyapi-python 0.3.18.dev7__py3-none-any.whl → 0.3.19__py3-none-any.whl

polyapi/cli.py

@@ -45,8 +45,8 @@ def execute_from_cli():
     
     # Add global --version/-v flag
     parser.add_argument('-v', '--version', action='version', 
-                       version=_get_version_string(),
-                       help="Show version information")
+                        version=_get_version_string(),
+                        help="Show version information")
 
     subparsers = parser.add_subparsers(help="Available commands")
 
@@ -95,7 +95,7 @@ def execute_from_cli():
         # overwrite all cached values with the values passed in from the command line
         final_contexts = contexts
         final_names = names
-        final_ids = ids
+        # final_ids = ids
         final_no_types = no_types
         
         # cache the values used for this explicit generate command
@@ -127,6 +127,7 @@ def execute_from_cli():
     fn_add_parser.add_argument("--logs", choices=["enabled", "disabled"], default=None, help="Enable or disable logs for the function.")
     fn_add_parser.add_argument("--execution-api-key", required=False, default="", help="API key for execution (for server functions only).")
     fn_add_parser.add_argument("--skip-generate", action="store_true", help="Skip running generate after function add command, especially useful if you are deploying a bunch of functions at once. Run generate manually at the end!")
+    fn_add_parser.add_argument("--image", type=str, default=None, help="Docker image to use when deploying a server function")
     fn_add_parser.add_argument("--generate-contexts", type=str, help="Server function only – only include certain contexts to speed up function execution")
     fn_add_parser.add_argument("--visibility", type=str, default="environment", help="Specifies the visibility of a function. Options: PUBLIC, TENANT, ENVIRONMENT. Case insensitive")
 
@@ -141,6 +142,8 @@ def execute_from_cli():
             err = "You must specify `--server` or `--client`."
         elif logs_enabled and not args.server:
             err = "Option `logs` is only for server functions (--server)."
+        elif args.image and not args.server:
+            err = "Option `image` is only for server functions (--server)."
         elif args.generate_contexts and not args.server:
             err = "Option `generate-contexts` is only for server functions (--server)."
         elif visibility not in ["PUBLIC", "TENANT", "ENVIRONMENT"]:
@@ -162,7 +165,8 @@ def execute_from_cli():
             generate=not args.skip_generate,
             execution_api_key=args.execution_api_key,
             generate_contexts=args.generate_contexts,
-            visibility=visibility
+            visibility=visibility,
+            image=args.image,
         )
 
     fn_add_parser.set_defaults(command=add_function)

polyapi/config.py

@@ -135,7 +135,6 @@ def clear_config():
 
 def get_mtls_config() -> Tuple[bool, str | None, str | None, str | None]:
     """Return MTLS configuration settings"""
-    global MTLS_CERT_PATH, MTLS_KEY_PATH, MTLS_CA_PATH
     if MTLS_CERT_PATH is None or MTLS_KEY_PATH is None or MTLS_CA_PATH is None:
         # Force a config read if values aren't cached
         get_api_key_and_url()
@@ -144,7 +143,6 @@ def get_mtls_config() -> Tuple[bool, str | None, str | None, str | None]:
 
 def get_direct_execute_config() -> bool:
     """Return whether direct execute is enabled"""
-    global API_FUNCTION_DIRECT_EXECUTE
     if API_FUNCTION_DIRECT_EXECUTE is None:
         # Force a config read if value isn't cached
         get_api_key_and_url()
@@ -153,7 +151,6 @@ def get_direct_execute_config() -> bool:
 
 def get_cached_generate_args() -> Tuple[list | None, list | None, list | None, bool]:
     """Return cached generate command arguments"""
-    global LAST_GENERATE_CONTEXTS, LAST_GENERATE_NAMES, LAST_GENERATE_IDS, LAST_GENERATE_NO_TYPES
     if LAST_GENERATE_CONTEXTS is None and LAST_GENERATE_NAMES is None and LAST_GENERATE_IDS is None and LAST_GENERATE_NO_TYPES is None:
         # Force a config read if values aren't cached
         get_api_key_and_url()

polyapi/execute.py

@@ -1,6 +1,7 @@
 import httpx
 import os
 import logging
+from typing import Any
 from polyapi.config import get_api_key_and_url, get_mtls_config
 from polyapi.exceptions import PolyApiException
 from polyapi import http_client
@@ -49,14 +50,10 @@ def _sync_direct_execute(function_type, function_id, data) -> httpx.Response:
     # Direct-execute hits URL that may need custom TLS
     # settings (mTLS certs or disabled verification). httpx Client.request()
     # doesn't accept per-request transport kwargs, so use one-off calls.
-    if has_mtls:
-        resp = httpx.request(
-            url=endpoint_info_data["url"],
-            cert=(cert_path, key_path),
-            verify=ca_path,
-            timeout=None,
-            **request_params
-        )
+    if has_mtls and cert_path and key_path:
+        verify_value: bool | str = ca_path if ca_path else True
+        with httpx.Client(cert=(cert_path, key_path), verify=verify_value, timeout=None) as client:
+            resp = client.request(url=endpoint_info_data["url"], **request_params)
     else:
         resp = httpx.request(
             url=endpoint_info_data["url"],
@@ -83,9 +80,10 @@ async def _async_direct_execute(function_type, function_id, data) -> httpx.Respo
     has_mtls, cert_path, key_path, ca_path = get_mtls_config()
 
     # One-off async client for custom TLS settings on external URLs.
-    if has_mtls:
+    if has_mtls and cert_path and key_path:
+        verify_value: bool | str = ca_path if ca_path else True
         async with httpx.AsyncClient(
-            cert=(cert_path, key_path), verify=ca_path, timeout=None
+            cert=(cert_path, key_path), verify=verify_value, timeout=None
         ) as client:
             resp = await client.request(
                 url=endpoint_info_data["url"], **request_params

polyapi/function_cli.py

@@ -25,8 +25,9 @@ def function_add_or_update(
     logs_enabled: Optional[bool],
     generate_contexts: Optional[str],
     visibility: Optional[str],
+    image: Optional[str],
     generate: bool = True,
-    execution_api_key: str = ""
+    execution_api_key: str = "",
 ):
     verb = "Updating" if _func_already_exists(context, name) else "Adding"
     ftype = "server" if server else "client"
@@ -39,11 +40,12 @@ def function_add_or_update(
     parsed = parse_function_code(code, name, context)
     return_type = parsed["types"]["returns"]["type"]
 
+    if "dependencies" not in parsed:
+        parsed["dependencies"] = []
+
     if not return_type:
         print_red("ERROR")
-        print(
-            f"Function {name} not found as top-level function in {name}"
-        )
+        print(f"Function {name} not found as top-level function in {name}")
         sys.exit(1)
 
     if logs_enabled is None:
@@ -57,13 +59,19 @@ def function_add_or_update(
         "language": "python",
         "visibility": visibility or "ENVIRONMENT",
         "returnType": get_jsonschema_type(return_type),
-        "arguments": [{**p, "key": p["name"], "type": get_jsonschema_type(p["type"])} for p in parsed["types"]["params"]],
-        "logsEnabled": logs_enabled,
+        "arguments": [
+            {**p, "key": p["name"], "type": get_jsonschema_type(p["type"])}
+            for p in parsed["types"]["params"]
+        ],
+        "logsEnabled": logs_enabled
     }
 
     if generate_contexts:
         data["generateContexts"] = generate_contexts.split(",")
 
+    if server and image:
+        data["image"] = image
+
     if server and parsed["dependencies"]:
         print_yellow(
             "\nPlease note that deploying your functions will take a few minutes because it makes use of libraries other than polyapi."
@@ -94,6 +102,7 @@ def function_add_or_update(
         if generate:
             # Use cached generate arguments when regenerating after function deployment
             from polyapi.generate import generate_from_cache
+
             generate_from_cache()
     else:
         print("Error adding function.")
@@ -126,4 +135,4 @@ def spec_delete(function_type: str, function_id: str):
         sys.exit(1)
     headers = get_auth_headers(api_key)
     resp = http_client.delete(url, headers=headers)
-    return resp
+    return resp

polyapi/generate.py

@@ -241,6 +241,9 @@ def remove_old_library():
 
 def create_empty_schemas_module():
     """Create an empty schemas module for no-types mode so user code can still import from polyapi.schemas"""
+    import importlib
+    import sys
+
     currdir = os.path.dirname(os.path.abspath(__file__))
     schemas_path = os.path.join(currdir, "schemas")
     
@@ -251,50 +254,57 @@ def create_empty_schemas_module():
     # Create an __init__.py file with dynamic schema resolution
     init_path = os.path.join(schemas_path, "__init__.py")
     with open(init_path, "w") as f:
-        f.write('''"""Empty schemas module for no-types mode"""
+        f.write('''"""Empty schemas module for no-types mode."""
 from typing import Any, Dict
 
 class _GenericSchema(Dict[str, Any]):
     """Generic schema type that acts like a Dict for no-types mode"""
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
 class _SchemaModule:
-    """Dynamic module that returns itself for attribute access, allowing infinite nesting"""
-    
+    """Compatibility shim retained for tests that assert this symbol exists."""
+
     def __getattr__(self, name: str):
-        # For callable access (like schemas.Response()), return the generic schema class
-        # For further attribute access (like schemas.random.random2), return self to allow nesting
+        # For callable access (like schemas.Response()), return nested access.
         return _NestedSchemaAccess()
-    
+
     def __call__(self, *args, **kwargs):
-        # If someone tries to call the module itself, return a generic schema
         return _GenericSchema(*args, **kwargs)
-    
+
     def __dir__(self):
-        # Return common schema names for introspection
-        return ['Response', 'Request', 'Error', 'Data', 'Result']
+        return ["Response", "Request", "Error", "Data", "Result"]
 
 class _NestedSchemaAccess:
     """Handles nested attribute access and final callable resolution"""
-    
+
     def __getattr__(self, name: str):
-        # Continue allowing nested access
         return _NestedSchemaAccess()
-    
+
     def __call__(self, *args, **kwargs):
-        # When finally called, return a generic schema instance
         return _GenericSchema(*args, **kwargs)
-    
+
     def __class_getitem__(cls, item):
-        # Support type annotations like schemas.Response[str]
         return _GenericSchema
 
-# Replace this module with our dynamic module
-import sys
-sys.modules[__name__] = _SchemaModule()
+def __getattr__(name: str):
+    if name.startswith("__") or name == "load_tests":
+        raise AttributeError(name)
+    return _NestedSchemaAccess()
+
+
+def __dir__():
+    return ["Response", "Request", "Error", "Data", "Result"]
 ''')
 
+    # Ensure subsequent imports pick up the newly generated no-types module.
+    sys.modules.pop("polyapi.schemas", None)
+    parent_module = sys.modules.get("polyapi")
+    if parent_module is not None and hasattr(parent_module, "schemas"):
+        delattr(parent_module, "schemas")
+    importlib.invalidate_caches()
+
 
 def _generate_client_id() -> None:
     full_path = os.path.dirname(os.path.abspath(__file__))
@@ -411,6 +421,7 @@ def clear() -> None:
 def render_spec(spec: SpecificationDto) -> Tuple[str, str]:
     function_type = spec["type"]
     raw_description = spec.get("description", "")
+
     def _flatten_description(value: Any) -> List[str]:
         if value is None:
             return []

polyapi/http_client.py

@@ -69,7 +69,7 @@ def close():
         _sync_client = None
 
 async def close_async():
-    global _sync_client, _async_client, _async_client_loop
+    global _async_client, _async_client_loop
     close()
     client = _async_client
     client_loop = _async_client_loop

polyapi/parser.py

@@ -22,9 +22,27 @@ BASE_REQUIREMENTS = {
     "typing_extensions",
     "jsonschema-gentypes",
     "pydantic",
+    
     "cloudevents",
 }
-all_stdlib_symbols = stdlib_list(".".join([str(v) for v in sys.version_info[0:2]]))
+
+
+def _safe_stdlib_symbols() -> List[str]:
+    major = sys.version_info[0]
+    minor = sys.version_info[1]
+
+    # `stdlib_list` may lag behind the newest Python minor; fall back to the
+    # nearest supported version so importing this module never crashes.
+    while minor >= 0:
+        try:
+            return stdlib_list(f"{major}.{minor}")
+        except ValueError:
+            minor -= 1
+
+    return []
+
+
+all_stdlib_symbols = _safe_stdlib_symbols()
 BASE_REQUIREMENTS.update(
     all_stdlib_symbols
 )  # dont need to pip install stuff in the python standard library
@@ -397,13 +415,16 @@ def parse_function_code(code: str, name: Optional[str] = "", context: Optional[s
             deployable["docStartIndex"] = start_offset
             deployable["docEndIndex"] = end_offset
 
-            try:
-                docstring = ast.get_docstring(node)
-            finally:
-                # Handle case where there is no doc string
-                # Also handle case where docstring exists but is empty
-                if type(docstring) is None or (not docstring and '"""' not in self._lines[start_lineno] and "'''" not in self._lines[start_lineno]):
-                    return None
+            docstring = ast.get_docstring(node)
+
+            # Handle case where there is no doc string.
+            # Also handle case where docstring exists but is empty.
+            if docstring is None or (
+                not docstring
+                and '"""' not in self._lines[start_lineno]
+                and "'''" not in self._lines[start_lineno]
+            ):
+                return None
 
             docstring = cast(str, docstring)
 

polyapi/poly_tables.py

@@ -85,7 +85,7 @@ def execute_query(table_id, method, query):
 
         auth_key = polyCustom.get("executionApiKey") or api_key
         url = f"{base_url.rstrip('/')}/tables/{table_id}/{method}?clientId={client_id}"
-        headers = {"x-poly-execution-id": polyCustom.get("executionId")}
+        headers = {"x-poly-execution-id": polyCustom.get("executionId") or ""}
         if auth_key:
             headers["Authorization"] = f"Bearer {auth_key}"
         response = http_client.post(url, json=query, headers=headers)
@@ -130,11 +130,11 @@ def _transform_keys(obj: Any) -> Any:
 
 
 def transform_query(query: dict) -> dict:
-    if query["where"] or query["order_by"]:
+    if query.get("where") or query.get("order_by"):
         return {
             **query,
-            "where": _transform_keys(query["where"]) if query["where"] else None,
-            "orderBy": query["order_by"] if query["order_by"] else None,
+            "where": _transform_keys(query["where"]) if query.get("where") else None,
+            "orderBy": query["order_by"] if query.get("order_by") else None,
         }
 
     return query

polyapi/schema.py

@@ -2,6 +2,7 @@
 """
 import logging
 import contextlib
+import os
 import re
 from typing import Dict
 from jsonschema_gentypes.cli import process_config
@@ -79,9 +80,10 @@ def generate_schema_types(input_data: Dict, root=None):
     """takes in a Dict representing a schema as input then appends the resulting python code to the output file"""
     _cleanup_input_for_gentypes(input_data)
     tmp_input = _temp_store_input_data(input_data)
-    tmp_output = tempfile.NamedTemporaryFile(
+    with tempfile.NamedTemporaryFile(
         mode="w", delete=False, prefix="polyapi_", suffix=".py"
-    ).name
+    ) as tmp_output_file:
+        tmp_output = tmp_output_file.name
 
     config: configuration.Configuration = {
         "python_version": None,  # type: ignore
@@ -95,17 +97,23 @@ def generate_schema_types(input_data: Dict, root=None):
         ],
     }
 
-    # jsonschema_gentypes prints source to stdout
-    # no option to surpress so we do this
-    with contextlib.redirect_stdout(None):
-        process_config(config, [tmp_input])
-
-    with open(tmp_output, encoding='utf-8') as f:
-        output = f.read()
+    try:
+        # jsonschema_gentypes prints source to stdout
+        # no option to surpress so we do this
+        with contextlib.redirect_stdout(None):
+            process_config(config, [tmp_input])
 
-    output = clean_malformed_examples(output)
+        with open(tmp_output, encoding='utf-8') as f:
+            output = f.read()
 
-    return output
+        output = clean_malformed_examples(output)
+        return output
+    finally:
+        for temp_path in (tmp_input, tmp_output):
+            try:
+                os.unlink(temp_path)
+            except OSError:
+                pass
 
 
 # Matches commented example headers emitted by jsonschema-gentypes before a raw
@@ -122,6 +130,10 @@ INVALID_ESCAPE_PATTERNS = [
     (re.compile(r'\\([^nrtbfav"\'\\])', re.DOTALL), r'\\\\\1'),
 ]
 
+# jsonschema_gentypes may emit raw triple-quoted docstrings (r"""...""").
+# Normalize these to plain docstrings to keep generated output stable.
+RAW_TRIPLE_QUOTE_PATTERN = re.compile(r'(^\s*)r(["\']{3})', re.MULTILINE)
+
 
 def clean_malformed_examples(example: str) -> str:
     """ there is a bug in the `jsonschmea_gentypes` library where if an example from a jsonchema is an object,
@@ -149,6 +161,8 @@ def clean_malformed_examples(example: str) -> str:
     # Fix invalid escape sequences in docstrings
     for pattern, replacement in INVALID_ESCAPE_PATTERNS:
         cleaned_example = pattern.sub(replacement, cleaned_example)
+
+    cleaned_example = RAW_TRIPLE_QUOTE_PATTERN.sub(r'\1\2', cleaned_example)
     
     return cleaned_example
 

polyapi/utils.py

@@ -2,7 +2,7 @@ import keyword
 import re
 import os
 from urllib.parse import urlparse
-from typing import Tuple, List, Optional
+from typing import Tuple, List, Optional, cast
 from colorama import Fore, Style
 from polyapi.constants import BASIC_PYTHON_TYPES
 from polyapi.typedefs import PropertySpecification, PropertyType
@@ -115,9 +115,9 @@ def to_type_module_alias(function_name: str) -> str:
 
 def add_type_import_path(function_name: str, arg: str) -> str:
     """if not basic type, coerce to camelCase and add the import path"""
-    # from now, we start qualifying non-basic types :)) 
+    # from now, we start qualifying non-basic types :))
     # e.g. Callable[[EmailAddress, Dict, Dict, Dict], None]
-        # becomes Callable[[Set_profile_email.EmailAddress, Dict, Dict, Dict], None]
+    # becomes Callable[[Set_profile_email.EmailAddress, Dict, Dict, Dict], None]
     arg = normalize_cross_language_type(arg)
 
     if "|" in arg:
@@ -158,7 +158,7 @@ def add_type_import_path(function_name: str, arg: str) -> str:
     return f"{type_module_alias}.{camelCase(arg)}"
 
 
-def get_type_and_def(
+def get_type_and_def(  # noqa: C901
     type_spec: PropertyType, title_fallback: str = ""
 ) -> Tuple[str, str]:
     """ returns type and type definition for a given PropertyType
@@ -190,7 +190,7 @@ def get_type_and_def(
             return primitive, ""
         return map_primitive_types(primitive), ""
     elif type_spec["kind"] == "array":
-        if type_spec.get("items"):
+        if "items" in type_spec and isinstance(type_spec["items"], dict):
             items = type_spec["items"]
             if items.get("$ref"):
                 # For no-types mode, avoid complex schema generation
@@ -208,9 +208,12 @@ def get_type_and_def(
     elif type_spec["kind"] == "void":
         return "None", ""
     elif type_spec["kind"] == "object":
-        if type_spec.get("schema"):
+        if "schema" in type_spec and isinstance(type_spec["schema"], dict):
             schema = type_spec["schema"]
-            title = schema.get("title", schema.get("name", title_fallback))
+            title = cast(str, schema.get("title", schema.get("name", title_fallback)))
+            if not isinstance(title, str):
+                raise ValueError("Title must be a string, this should never happen due to the fallback, but got: {}".format(title))
+
             if title and schema.get("type") == "array":
                 # TODO fix me
                 # we don't use ReturnType as name for the list type here, we use _ReturnTypeItem

{polyapi_python-0.3.18.dev7.dist-info → polyapi_python-0.3.19.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.18.dev7
-Summary: The Python Client for PolyAPI, the IPaaS by Developers for Developers
+Version: 0.3.19
+Summary: The Python SDK for the integration platform PolyAPI
 Author-email: PolyAPI <support@polyapi.io>
 License: MIT License
         
@@ -29,9 +29,9 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests==2.32.3
-Requires-Dist: typing_extensions==4.12.2
-Requires-Dist: jsonschema-gentypes==2.10.0
-Requires-Dist: pydantic==2.8.0
+Requires-Dist: typing_extensions==4.15.0
+Requires-Dist: jsonschema-gentypes==2.13.0
+Requires-Dist: pydantic==2.13.4
 Requires-Dist: stdlib_list==0.11.1
 Requires-Dist: colorama==0.4.4
 Requires-Dist: python-socketio[asyncio_client]==5.11.1
@@ -99,7 +99,7 @@ print(poly.polyapi.function.api.list(my_server, my_api_key))
 To add a new server function, please follow the quickstart. Then you can add a server function like so:
 
 ```bash
-python -m polyapi --context mycontext --description mydesc --server function add <function_name> foo.py
+python -m polyapi function add <function_name> foo.py --server --context mycontext --description mydesc
 ```
 
 The code in `foo.py` should contain a single defined function named the same as your `<function_name>` variable.

{polyapi_python-0.3.18.dev7.dist-info → polyapi_python-0.3.19.dist-info}/RECORD

@@ -2,33 +2,33 @@ polyapi/__init__.py,sha256=vV1N9xtIMtpi4o-2jAI3775LkzRbC9JUo87MAnW9zgo,5201
 polyapi/__main__.py,sha256=V4zhAh_YGxno5f_KSrlkELxcuDh9bR3WSd0n-2r-qQQ,93
 polyapi/api.py,sha256=CzqX99GekhQJVqAAWlL03hUenIi_5iTln9cWgQzz6Ko,2784
 polyapi/auth.py,sha256=l0pGAoYvEWqa2TMsrM9GS8imXu3GsWvpn4eFPy1vksI,6195
-polyapi/cli.py,sha256=wrBmpyieCqXnKPfpX2asL_0ApSYWze9p3wlCwJrtfRM,11635
+polyapi/cli.py,sha256=V3586ElV1927u2AhQZAo_4UYKoJPqE8lz6b3_gJfMj0,11918
 polyapi/cli_constants.py,sha256=eZnAqAo8HLxHH3cdAoGWbrsALAtEWJFXRdSS2lvQvzE,144
 polyapi/client.py,sha256=DW6ljG_xCwAo2yz23A9QfLooE6ZUDvSpdA4e_dCQjiQ,1418
-polyapi/config.py,sha256=dnowfPKEau5sA4zwBzLK_dYAHA-Wi3AOnMtDNsYwUmM,7520
+polyapi/config.py,sha256=HArQg9BtZQxUCbi4OHLqvkwvjnnnDTJsuJW7niLo_5k,7328
 polyapi/constants.py,sha256=i3j0-ptd7XEs6ovnYegEhiP0BRs1JSKAq1oE5CWbDVo,707
 polyapi/deployables.py,sha256=njmqTU0W7d3JdDWhjjjr2UOghEv4bTKUN-3ztJvcC7o,12233
 polyapi/error_handler.py,sha256=I_e0iz6VM23FLVQWJljxs2NGcl_OODbi43OcbnqBlp8,2398
 polyapi/exceptions.py,sha256=Zh7i7eCUhDuXEdUYjatkLFTeZkrx1BJ1P5ePgbJ9eIY,89
-polyapi/execute.py,sha256=MeAmc5qsMQfnQPiHJK9Khkn_wrBxMoyMYYqmuFFPsRg,8779
-polyapi/function_cli.py,sha256=kKrecKCDNMmYtcOOCVF2KKOGjFUfWD2TbiVsyYQ84y8,4323
-polyapi/generate.py,sha256=3AtJcqZj2oybZmQVzrQ8XQyvwEz51PztWvSNKXdNre0,22008
-polyapi/http_client.py,sha256=Pd6FYHGB6plWlBbwZD9LPP6FEicdp0wyLWHd_9jxsaY,2273
-polyapi/parser.py,sha256=pAkeuwp1Kn6bHXiIoj-DuXQ518PztQThIa8vztgsKLQ,21525
+polyapi/execute.py,sha256=4jLkQely6cM7pNN9pYpGZTbEis-DfwENi5Fl07xSiig,8966
+polyapi/function_cli.py,sha256=gJE72lRvuWnGl6CG9GpqL78TOnUzxVe4kJMvg0PQixw,4493
+polyapi/generate.py,sha256=9B6DbrkBAPWpMVD92ifFYV2JaKNCduMQhqJ4Gm48qq0,22051
+polyapi/http_client.py,sha256=TcoFsIvRcNB9wWJT4YePPWFFY6lX90cdqi7C4jKbqqk,2259
+polyapi/parser.py,sha256=t3jJI6g5F7Qg_tirPOzSkQ02VLkSVhnqs9YGapyHx2k,21901
 polyapi/poly_schemas.py,sha256=JGMQbELPFw4V_0nA0o71WJKFTdxjCGoKqJvIid_Y-a4,10759
-polyapi/poly_tables.py,sha256=xFxR69dZNmePT9mUz3DvsoreQK7huIa07evEmOSixA0,20271
+polyapi/poly_tables.py,sha256=SlP7ZwqS3nIji2uGR2VJQH6IdddZ832rRItcmoYdIBc,20293
 polyapi/prepare.py,sha256=DBlrQu_A0PqdaQ3KlMs-C6PkV3qncatkAiBlC7j2hnk,7441
 polyapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 polyapi/rendered_spec.py,sha256=J2Num7MXnW_mKAe2MSVIL1coWopNYZ-6nNNwQRfseV0,2262
-polyapi/schema.py,sha256=PuLvu29rWWyN_DV6QLWHR5PNopfW2vpRsJ6mOTx7wao,6396
+polyapi/schema.py,sha256=SPO5GDvIE1BjRfJR89vJMEGCXERfEbhNXQm2A05UAOc,6959
 polyapi/server.py,sha256=_14lP4_BmRYMBXwaqXVWmiSTHH3h7ecCHxSalM9UiSc,3049
 polyapi/sync.py,sha256=t0Khh8B5GylxB7KWRP_xvkrvkuyVarSLCOvtmaz7lcc,6766
 polyapi/typedefs.py,sha256=mfll-KrngOW0wzbvDNiIDaDkFMwbsT-MY5y5hzWj9RE,5642
-polyapi/utils.py,sha256=SfzK86nhg1wuGzbI53DEFKJ3JkxZ0yU-CZBd_caKbrQ,15313
+polyapi/utils.py,sha256=dIkuIlGNsg1USiXNNkUnOtLVzie4mxBCBlTc0YsaXao,15594
 polyapi/variables.py,sha256=hfSDPGQK6YphNCa9MqE0W88WIFfqCQWgpBDWkExMq-A,7582
 polyapi/webhook.py,sha256=0ceLwHNjNd2Yx_8MX5jOIxiQ5Lwhy2pe81ProAuKon0,5108
-polyapi_python-0.3.18.dev7.dist-info/licenses/LICENSE,sha256=6b_I7aPVp8JXhqQwdw7_B84Ca0S4JGjHj0sr_1VOdB4,1068
-polyapi_python-0.3.18.dev7.dist-info/METADATA,sha256=21prqjvBznI3fTuIF25CWg4DWLJCva7ZUa7FTlQ1nfI,5915
-polyapi_python-0.3.18.dev7.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-polyapi_python-0.3.18.dev7.dist-info/top_level.txt,sha256=CEFllOnzowci_50RYJac-M54KD2IdAptFsayVVF_f04,8
-polyapi_python-0.3.18.dev7.dist-info/RECORD,,
+polyapi_python-0.3.19.dist-info/licenses/LICENSE,sha256=6b_I7aPVp8JXhqQwdw7_B84Ca0S4JGjHj0sr_1VOdB4,1068
+polyapi_python-0.3.19.dist-info/METADATA,sha256=69EIA_IEpETapdFInvMckQBDdcQiIu5N9EXc529-ODI,5893
+polyapi_python-0.3.19.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+polyapi_python-0.3.19.dist-info/top_level.txt,sha256=CEFllOnzowci_50RYJac-M54KD2IdAptFsayVVF_f04,8
+polyapi_python-0.3.19.dist-info/RECORD,,

{polyapi_python-0.3.18.dev7.dist-info → polyapi_python-0.3.19.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.1)
+Generator: setuptools (83.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any