polyapi-python 0.3.20.dev4__tar.gz → 0.3.21__tar.gz

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.20.dev4
+Version: 0.3.21
 Summary: The Python SDK for the integration platform PolyAPI
 Author-email: PolyAPI <support@polyapi.io>
 License: MIT License
@@ -28,15 +28,23 @@ Project-URL: Homepage, https://github.com/polyapi/polyapi-python
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: requests==2.32.3
+Requires-Dist: requests==2.33.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
+Requires-Dist: python-socketio[asyncio_client]==5.16.2
 Requires-Dist: truststore==0.9.1
 Requires-Dist: httpx==0.28.1
+Provides-Extra: dev
+Requires-Dist: mock==5.2.0; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: flask==3.1.3; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: types-requests; extra == "dev"
+Requires-Dist: types-colorama; extra == "dev"
+Requires-Dist: pip-audit; extra == "dev"
 Dynamic: license-file
 
 # PolyAPI Python Library

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/polyapi/ai_function.py

@@ -75,8 +75,7 @@ def render_ai_function(
 
 
 def _normalize_return_type_for_annotation(function_name: str, return_type_name: str) -> str:
-    if return_type_name == "ReturnType":
-        return "ReturnType"
+    # "ReturnType" lives in a separate module, so it must be qualified (e.g. _SFX.ReturnType).
     return add_type_import_path(function_name, return_type_name)
 
 

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/polyapi/cli.py

@@ -9,7 +9,6 @@ from .cli_constants import CLI_COMMANDS
 from .config import initialize_config, set_api_key_and_url
 from .generate import generate, clear
 from .function_cli import function_add_or_update, function_execute
-from .rendered_spec import get_and_update_rendered_spec
 from .prepare import prepare_deployables
 from .sync import sync_deployables
 
@@ -196,22 +195,6 @@ def execute_from_cli():
     clear_parser.set_defaults(command=clear_command)
 
 
-    ###########################################################################
-    # Update rendered spec command
-    update_spec_parser = subparsers.add_parser("update_rendered_spec", help="Update the rendered spec file")
-    update_spec_parser.add_argument("spec", help="Specification file to update")
-
-    def update_rendered_spec(args):
-        updated = get_and_update_rendered_spec(args.spec)
-        if updated:
-            print("Updated rendered spec!")
-        else:
-            print("Failed to update rendered spec!")
-            exit(1)
-
-    update_spec_parser.set_defaults(command=update_rendered_spec)
-
-
     ###########################################################################
     # Prepare command
     prepare_parser = subparsers.add_parser('prepare', help="Find and prepare all Poly deployables")

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/polyapi/cli_constants.py

@@ -4,7 +4,6 @@ CLI_COMMANDS = (
     "function",
     "clear",
     "help",
-    "update_rendered_spec",
     "prepare",
     "sync",
 )

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/polyapi/deployables.py

@@ -51,7 +51,7 @@ class DeployableFunctionTypes(TypedDict):
     params: List[DeployableFunctionParam]
     returns: DeployableFunctionParamBase
 
-class DeployableRecord(ParsedDeployableConfig, total=False):
+class DeployableRecord(ParsedDeployableConfig):
     gitRevision: str
     fileRevision: str
     file: str
@@ -64,7 +64,7 @@ class DeployableRecord(ParsedDeployableConfig, total=False):
     docEndIndex: int
     dirty: Optional[bool]
 
-class SyncDeployment(TypedDict, total=False):
+class SyncDeployment(TypedDict):
     context: str
     name: str
     description: str
@@ -195,30 +195,12 @@ def write_cache_revision(git_revision: Optional[str] = None) -> None:
     with open(CACHE_VERSION_FILE, 'w', encoding='utf-8') as file:
         file.write(git_revision)
 
-def is_cache_up_to_date() -> bool:
-    if not Path(CACHE_VERSION_FILE).exists():
-        return False
-    with open(CACHE_VERSION_FILE, 'r', encoding='utf-8') as file:
-        cached_revision = file.read().strip()
-    git_revision = get_git_revision()
-    return cached_revision == git_revision
-
 def is_cache_up_to_date() -> bool:
     """Check if the cached revision matches the current Git revision."""
     cached_revision = get_cache_deployments_revision()
     git_revision = get_git_revision()  # This function needs to be defined or imported
     return cached_revision == git_revision
 
-def write_deploy_comments(deployments: List[Dict]) -> str:
-    """Generate a string of deployment comments for each deployment."""
-    canopy_path = 'polyui/collections' if 'localhost' in os.getenv('POLY_API_BASE_URL', '') else 'canopy/polyui/collections'
-    comments = []
-    for d in deployments:
-        instance_url = d['instance'].replace(':8000', ':3000') if d['instance'].endswith(':8000') else d['instance']
-        comment = f"# Poly deployed @ {d['deployed']} - {d['context']}.{d['name']} - {instance_url}/{canopy_path}/{d['type']}s/{d['id']} - {d['fileRevision']}"
-        comments.append(comment)
-    return '\n'.join(comments)
-
 def print_docstring_function_comment(description: str, args: list, returns: dict) -> str:
     docstring = f'"""{description}\n\n'
     if args:
@@ -243,7 +225,7 @@ def print_docstring_function_comment(description: str, args: list, returns: dict
     return docstring
 
 
-def update_deployment_comments(file_content: str, deployable: dict) -> str:
+def update_deployment_comments(file_content: str, deployable: DeployableRecord) -> str:
     """
     Remove old deployment comments based on the provided ranges and add new ones.
     """
@@ -255,7 +237,7 @@ def update_deployment_comments(file_content: str, deployable: dict) -> str:
         file_content = f"{deployment_comments}\n{file_content}"
     return file_content
 
-def update_deployable_function_comments(file_content: str, deployable: dict, disable_docs: bool = False) -> str:
+def update_deployable_function_comments(file_content: str, deployable: DeployableRecord, disable_docs: bool = False) -> str:
     """
     Update the docstring in the file content based on the deployable's documentation data.
     """
@@ -263,7 +245,7 @@ def update_deployable_function_comments(file_content: str, deployable: dict, dis
         docstring = print_docstring_function_comment(
             deployable['types']['description'],
             deployable['types']['params'],
-            deployable['types']['returns']
+            deployable['types']['returns'] # pyright: ignore[reportArgumentType]
         )
         if deployable["docStartIndex"] == deployable["docEndIndex"]:
             # Function doesn't yet have any docstrings so we need to add additional whitespace
@@ -272,7 +254,7 @@ def update_deployable_function_comments(file_content: str, deployable: dict, dis
         return f"{file_content[:deployable['docStartIndex']]}{docstring}{file_content[deployable['docEndIndex']:]}"
     return file_content
 
-def write_updated_deployable(deployable: dict, disable_docs: bool = False) -> dict:
+def write_updated_deployable(deployable: DeployableRecord, disable_docs: bool = False) -> DeployableRecord:
     """
     Read the deployable's file, update its comments and docstring, and write back to the file.
     """

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/polyapi/error_handler.py

@@ -42,7 +42,8 @@ async def unregister_all():
     _, base_url = get_api_key_and_url()
     # need to reconnect because maybe socketio client disconnected after Ctrl+C?
     try:
-        await client.connect(base_url, transports=["websocket"], namespaces=["/events"])
+        if client:
+            await client.connect(base_url, transports=["websocket"], namespaces=["/events"])
     except ConnectionError:
         pass
     await asyncio.gather(*[unregister(handler) for handler in active_handlers])
@@ -63,10 +64,11 @@ async def on(
     data["apiKey"] = api_key
 
     def registerCallback(id: int):
-        nonlocal handler_id
-        handler_id = id
-        client.on(f"handleError:{handler_id}", callback, namespace="/events")
-        active_handlers.append({"path": path, "id": handler_id, "apiKey": api_key})
+        if client:
+            nonlocal handler_id
+            handler_id = id
+            client.on(f"handleError:{handler_id}", callback, namespace="/events")
+            active_handlers.append({"path": path, "id": handler_id, "apiKey": api_key})
 
     await client.emit("registerErrorHandler", data, "/events", registerCallback)
 

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/polyapi/generate.py

@@ -7,7 +7,7 @@ import tempfile
 import stat
 
 from copy import deepcopy
-from typing import Any, List, Optional, Tuple, cast
+from typing import Any, Dict, List, Optional, Tuple, cast
 
 from .auth import render_auth_function
 from .client import render_client_function
@@ -104,7 +104,7 @@ def replace_poly_refs_in_functions(specs: List[SpecificationDto], schema_index):
             func = spec.get("function")
             if func:
                 try:
-                    spec["function"] = resolve_poly_refs(func, schema_index)
+                    spec["function"] = resolve_poly_refs(func, schema_index) # pyright: ignore[reportGeneralTypeIssues]
                 except Exception:
                     # print()
                     # print(f"{spec['context']}.{spec['name']} (id: {spec['id']}) failed to resolve poly refs, skipping!")
@@ -123,7 +123,7 @@ def replace_poly_refs_in_schemas(specs: List[SchemaSpecDto], schema_index):
     spec_idxs_to_remove = []
     for idx, spec in enumerate(specs):
         try:
-            spec["definition"] = resolve_poly_refs(spec["definition"], schema_index)
+            spec["definition"] = cast(Dict[str, Any], resolve_poly_refs(spec["definition"], schema_index))
         except Exception:
             # print()
             print(f"{spec['context']}.{spec['name']} (id: {spec['id']}) failed to resolve poly refs, skipping!")
@@ -445,16 +445,16 @@ def render_spec(spec: SpecificationDto) -> Tuple[str, str]:
     arguments: List[PropertySpecification] = []
     return_type: Any = {}
     if spec.get("function"):
-        assert spec["function"]
+        function_spec = cast(Dict[str, Any], spec["function"]) # pyright: ignore[reportTypedDictNotRequiredAccess]
         # Handle cases where arguments might be missing or None
-        if spec["function"].get("arguments"):
+        if function_spec.get("arguments"):
             arguments = [
-                arg for arg in spec["function"]["arguments"]
+                arg for arg in function_spec["arguments"]
             ]
-        
+
         # Handle cases where returnType might be missing or None
-        if spec["function"].get("returnType"):
-            return_type = spec["function"]["returnType"]
+        if function_spec.get("returnType"):
+            return_type = function_spec["returnType"]
         else:
             # Provide a fallback return type when missing
             return_type = {"kind": "any"}

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/polyapi/parser.py

@@ -5,13 +5,18 @@ import sys
 import re
 from typing import Dict, List, Mapping, Optional, Tuple, Any, Union
 from typing import _TypedDictMeta as BaseTypedDict  # type: ignore
-from typing_extensions import _TypedDictMeta, cast # type: ignore
+from typing_extensions import TypedDict, _TypedDictMeta, cast # type: ignore
 from stdlib_list import stdlib_list
 from pydantic import TypeAdapter
 from importlib.metadata import packages_distributions
 from polyapi.constants import PYTHON_TO_JSONSCHEMA_TYPE_MAP
 from polyapi.utils import print_red
-from polyapi.deployables import Deployment, DeployableRecord, get_deployable_file_revision
+from polyapi.deployables import (
+    Deployment,
+    DeployableRecord,
+    DeployableTypes,
+    get_deployable_file_revision,
+)
 
 
 # these libraries are already installed in the base docker image
@@ -116,15 +121,53 @@ def _parse_sphinx_docstring(docstring: str) -> Dict[str, Any]:
     }
 
 
-def _parse_google_docstring(docstring: str) -> Dict[str, Any]:
+class _GoogleParamState(TypedDict):
+    name: str
+    type: str
+    description: List[str]
+
+
+class _GoogleReturnsState(TypedDict):
+    type: str
+    description: List[str]
+
+
+class GoogleDocstringParam(TypedDict):
+    name: str
+    type: str
+    typeSchema: Optional[Dict[str, Any]]
+    description: str
+
+
+class GoogleDocstringReturns(TypedDict):
+    type: str
+    typeSchema: Optional[Dict[str, Any]]
+    description: str
+
+
+class GoogleDocstring(TypedDict):
+    description: str
+    params: List[GoogleDocstringParam]
+    returns: GoogleDocstringReturns
+    raises: Dict[str, str]
+
+
+class _GoogleDocstringState(TypedDict):
+    description: List[str]
+    params: Dict[str, _GoogleParamState]
+    returns: _GoogleReturnsState
+    raises: Dict[str, str]
+
+
+def _parse_google_docstring(docstring: str) -> GoogleDocstring:
     import re
     lines = docstring.split('\n')
     mode = None
-    params = {}
-    parsed = {
+    params: Dict[str, _GoogleParamState] = {}
+    parsed: _GoogleDocstringState = {
         'description': [],
-        'params': [],
-        'returns': {'description': []},
+        'params': params,
+        'returns': {'type': '', 'description': []},
         'raises': {}
     }
     current_key = None
@@ -169,12 +212,25 @@ def _parse_google_docstring(docstring: str) -> Dict[str, Any]:
         elif mode is None:
             parsed['description'].append(line.strip())
 
-    # Consolidate descriptions
-    parsed['description'] = ' '.join(parsed['description']).strip()
-    parsed['returns']['description'] = ' '.join(parsed['returns']['description']).strip()
-    parsed['params'] = [{ **v, 'description': ' '.join(v['description']).strip() } for v in params.values()]
+    parsed_result: GoogleDocstring = {
+        'description': ' '.join(parsed['description']).strip(),
+        'params': [
+            {
+                **value,
+                'typeSchema': None,
+                'description': ' '.join(value['description']).strip(),
+            }
+            for value in params.values()
+        ],
+        'returns': {
+            'type': parsed['returns']['type'],
+            'typeSchema': None,
+            'description': ' '.join(parsed['returns']['description']).strip(),
+        },
+        'raises': parsed['raises'],
+    }
 
-    return parsed
+    return parsed_result
 
 
 def _get_schemas(code: str) -> List[Dict]:
@@ -299,12 +355,12 @@ def _parse_deploy_comment(comment: str) -> Optional[Deployment]:
 
     # Local development puts canopy on a different port than the poly-server
     if instance.endswith("localhost:3000"):
-        instance = instance.replace(":3000', ':8000")
+        instance = instance.replace(":3000", ":8000")
 
     return {
         "name": name,
         "context": context,
-        "type": deploy_type,
+        "type": DeployableTypes(deploy_type),
         "id": id,
         "deployed": deployed,
         "fileRevision": file_revision,
@@ -398,9 +454,9 @@ def parse_function_code(code: str, name: Optional[str] = "", context: Optional[s
             ):
                 # We've found a polyConfig dictionary assignment
                 if node.annotation.id == "PolyServerFunction":
-                    deployable["type"] = "server-function"
+                    deployable["type"] = "server-function" # pyright: ignore[reportGeneralTypeIssues]
                 elif node.annotation.id == "PolyClientFunction":
-                    deployable["type"] = "client-function"
+                    deployable["type"] = "client-function" # pyright: ignore[reportGeneralTypeIssues]
                 else:
                     print_red("ERROR")
                     print(f"Unsupported polyConfig type '${node.annotation.id}'")
@@ -466,7 +522,7 @@ def parse_function_code(code: str, name: Optional[str] = "", context: Optional[s
                 if deployment:
                     start = self._line_offsets[i]
                     deployable["deployments"].append(deployment)
-                    deployable["deploymentCommentRanges"].append([start, start + len(line)])
+                    deployable["deploymentCommentRanges"].append((start, start + len(line)))
 
         def visit_Import(self, node: ast.Import):
             # TODO maybe handle `import foo.bar` case?
@@ -539,7 +595,7 @@ def parse_function_code(code: str, name: Optional[str] = "", context: Optional[s
 
         def generic_visit(self, node):
             if hasattr(node, 'lineno') and hasattr(node, 'col_offset'):
-                self._current_offset = self._line_offsets[node.lineno - 1] + node.col_offset
+                self._current_offset = self._line_offsets[node.lineno - 1] + node.col_offset # pyright: ignore[reportAttributeAccessIssue]
             super().generic_visit(node)
 
     tree = ast.parse(code)

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/polyapi/poly_tables.py

@@ -74,7 +74,12 @@ def scrub_keys(e: Exception) -> Dict[str, Any]:
 
 def execute_query(table_id, method, query):
     from polyapi import polyCustom
-    from polyapi.poly.client_id import client_id
+
+    client_id: Optional[str] = None
+    try:
+        from polyapi.poly.client_id import client_id  # pyright: ignore[reportMissingImports]
+    except ImportError:
+        pass
 
     try:
         api_key, base_url = get_api_key_and_url()
@@ -84,7 +89,9 @@ 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}"
+        url = f"{base_url.rstrip('/')}/tables/{table_id}/{method}"
+        if client_id:
+            url += f"?clientId={client_id}"
         headers = {"x-poly-execution-id": polyCustom.get("executionId") or ""}
         if auth_key:
             headers["Authorization"] = f"Bearer {auth_key}"

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/polyapi/prepare.py

@@ -1,7 +1,7 @@
 import os
 import sys
 import subprocess
-from typing import List, Tuple, Literal
+from typing import Any, Dict, List, Tuple, Literal, TypeGuard
 from polyapi import http_client
 from polyapi.utils import get_auth_headers
 from polyapi.config import get_api_key_and_url
@@ -10,7 +10,7 @@ from polyapi.deployables import (
     prepare_deployable_directory, write_cache_revision,
     save_deployable_records, get_all_deployable_files,
     is_cache_up_to_date, get_git_revision,
-    write_updated_deployable, DeployableRecord
+    write_updated_deployable, DeployableRecord, PolyDeployConfig
 )
 
 class FunctionArgumentDto:
@@ -19,7 +19,15 @@ class FunctionArgumentDto:
         self.type = type
         self.description = description
 
-def get_function_description(deploy_type: Literal["server-function", "client-function"], description: str, arguments, code: str) -> str:
+
+FunctionDeployType = Literal["server-function", "client-function"]
+
+
+def _is_function_deploy_type(deploy_type: str) -> TypeGuard[FunctionDeployType]:
+    return deploy_type in ("server-function", "client-function")
+
+
+def get_function_description(deploy_type: FunctionDeployType, description: str, arguments, code: str) -> Dict[str, Any]:
     if deploy_type == "server-function":
         return get_server_function_description(description, arguments, code)
     elif deploy_type == "client-function":
@@ -27,14 +35,14 @@ def get_function_description(deploy_type: Literal["server-function", "client-fun
     else:
         raise ValueError("Unsupported deployable type")
 
-def get_server_function_description(description: str, arguments, code: str) -> str:
+def get_server_function_description(description: str, arguments, code: str) -> Dict[str, Any]:
     api_key, api_url = get_api_key_and_url()
     headers = get_auth_headers(api_key)
     data = {"description": description, "arguments": arguments, "code": code}
     response = http_client.post(f"{api_url}/functions/server/description-generation", headers=headers, json=data)
     return response.json()
 
-def get_client_function_description(description: str, arguments, code: str) -> str:
+def get_client_function_description(description: str, arguments, code: str) -> Dict[str, Any]:
     api_key, api_url = get_api_key_and_url()
     headers = get_auth_headers(api_key)
     # Simulated API call to generate client function descriptions
@@ -50,8 +58,12 @@ def fill_in_missing_function_details(deployable: DeployableRecord, code: str) ->
     )
     if is_missing_descriptions:
         try:
+            deploy_type = deployable["type"]
+            if not _is_function_deploy_type(deploy_type):
+                raise ValueError(f'Unsupported deployable type: "{deploy_type}"')
+
             ai_generated = get_function_description(
-                deployable["type"],
+                deploy_type,
                 deployable["types"]["description"], 
                 [{"name": p["name"], "type": p["type"], "description": p.get("description")} for p in deployable["types"]["params"]],
                 code
@@ -84,7 +96,13 @@ def get_base_url() -> str:
 def get_all_deployables(disable_docs: bool, disable_ai: bool, git_revision: str) -> List[DeployableRecord]:
     print("Searching for poly deployables.")
     base_url = get_base_url() or "."
-    possible_deployables = get_all_deployable_files({"includeDirs": [base_url]})
+    deployable_search_config: PolyDeployConfig = {
+        "type_names": [],
+        "include_dirs": [base_url],
+        "include_files_or_extensions": [],
+        "exclude_dirs": [],
+    }
+    possible_deployables = get_all_deployable_files(deployable_search_config)
     print(f'Found {len(possible_deployables)} possible deployable file{"s" if len(possible_deployables) != 1 else ""}.')
 
     found = {}

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/polyapi/server.py

@@ -75,8 +75,7 @@ def render_server_function(
 
 
 def _normalize_return_type_for_annotation(function_name: str, return_type_name: str) -> str:
-    if return_type_name == "ReturnType":
-        return "ReturnType"
+    # "ReturnType" lives in a separate module, so it must be qualified (e.g. _SFX.ReturnType).
     return add_type_import_path(function_name, return_type_name)
 
 

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/polyapi/sync.py

@@ -22,7 +22,7 @@ def read_file(file_path: str) -> str:
     with open(file_path, 'r', encoding='utf-8') as file:
         return file.read()
 
-def group_by(items: List[Dict], key: str) -> Dict[str, List[Dict]]:
+def group_by(items: List[DeployableRecord], key: str) -> Dict[str, List[DeployableRecord]]:
     grouped = {}  # type: ignore
     for item in items:
         grouped.setdefault(item[key], []).append(item)
@@ -50,7 +50,7 @@ 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!")
+        raise Exception("Missing api key!")
     headers = get_auth_headers(api_key)
     url = f'{deployable["instance"]}/functions/{deployable["type"].replace("-function", "")}'
     payload = {

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/polyapi/utils.py

@@ -41,7 +41,9 @@ def add_import_to_init(full_path: str, next: str, code_imports: Optional[str] =
             f.write(import_stmt)
 
 
-def get_auth_headers(api_key: str):
+def get_auth_headers(api_key: Optional[str]) -> dict[str, str]:
+    if api_key is None:
+        raise ValueError("An API key is required to build authorization headers")
     return {"Authorization": f"Bearer {api_key}"}
 
 
@@ -102,7 +104,8 @@ def normalize_cross_language_type(type_name: str) -> str:
         normalized = [normalize_cross_language_type(part) for part in parts]
         return " | ".join(normalized) if normalized else "Any"
 
-    if value == "ReturnType" or value.startswith("ReturnType<") or "typeof" in value:
+    # Only TS's ReturnType<...>/typeof syntax falls back to Any, not our own "ReturnType" name.
+    if value.startswith("ReturnType<") or "typeof" in value:
         return "Any"
 
     return primitive_map.get(value, value)
@@ -220,8 +223,12 @@ def get_type_and_def(  # noqa: C901
                 return "List", ""
             elif title and title == "ReturnType" and schema.get("type"):
                 assert isinstance(title, str)
-                schema_type = schema.get("type", "Any")
-                root_type, generated_code = wrapped_generate_schema_types(schema, schema_type, "Dict")  # type: ignore
+                # Use `title` as the class name, not schema["type"] (e.g. "object" collides with dict).
+                root_type, generated_code = wrapped_generate_schema_types(schema, title, "Dict")  # type: ignore
+                if f"class {root_type}(" not in generated_code:
+                    # A property-less object schema (e.g. bare {"type": "object"}) generates no
+                    # class at all, so root_type would reference a name that doesn't exist.
+                    return "Dict", ""
                 return (map_primitive_types(root_type), "") if is_primitive(root_type) else (root_type, generated_code)  # type: ignore
             elif title:
                 assert isinstance(title, str)

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/polyapi/variables.py

@@ -118,14 +118,16 @@ def render_variable(variable: VariableSpecDto):
 def _get_variable_type(type_spec: PropertyType) -> str:
     # simplified version of _get_type from api.py
     if type_spec["kind"] == "plain":
-        value = type_spec["value"]
-        if value.endswith("[]"):
+        value = type_spec.get("value")
+        if value and value.endswith("[]"):
             primitive = map_primitive_types(value[:-2])
             return f"List[{primitive}]"
-        else:
+        elif value:
             return map_primitive_types(value)
+        else:
+            return "Any"
     elif type_spec["kind"] == "primitive":
-        return map_primitive_types(type_spec["type"])
+        return map_primitive_types(type_spec.get("type", "not gonna find this so it will fallback to any"))
     elif type_spec["kind"] == "array":
         return "List"
     elif type_spec["kind"] == "void":

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/polyapi/webhook.py

@@ -107,7 +107,8 @@ async def unregister_all():
     # maybe need to reconnect because maybe socketio client disconnected after Ctrl+C?
     # feels like Linux disconnects but Windows stays connected
     try:
-        await client.connect(base_url, transports=["websocket"], namespaces=["/events"])
+        if client:
+            await client.connect(base_url, transports=["websocket"], namespaces=["/events"])
     except ConnectionError:
         pass
     await asyncio.gather(*[unregister(handler) for handler in active_handlers])

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/polyapi_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.20.dev4
+Version: 0.3.21
 Summary: The Python SDK for the integration platform PolyAPI
 Author-email: PolyAPI <support@polyapi.io>
 License: MIT License
@@ -28,15 +28,23 @@ Project-URL: Homepage, https://github.com/polyapi/polyapi-python
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: requests==2.32.3
+Requires-Dist: requests==2.33.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
+Requires-Dist: python-socketio[asyncio_client]==5.16.2
 Requires-Dist: truststore==0.9.1
 Requires-Dist: httpx==0.28.1
+Provides-Extra: dev
+Requires-Dist: mock==5.2.0; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: flask==3.1.3; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: types-requests; extra == "dev"
+Requires-Dist: types-colorama; extra == "dev"
+Requires-Dist: pip-audit; extra == "dev"
 Dynamic: license-file
 
 # PolyAPI Python Library

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/polyapi_python.egg-info/SOURCES.txt

@@ -23,7 +23,6 @@ polyapi/poly_schemas.py
 polyapi/poly_tables.py
 polyapi/prepare.py
 polyapi/py.typed
-polyapi/rendered_spec.py
 polyapi/schema.py
 polyapi/server.py
 polyapi/sync.py
@@ -47,7 +46,6 @@ tests/test_generated_poly_boundary.py
 tests/test_parser.py
 tests/test_poly_custom.py
 tests/test_poly_schemas.py
-tests/test_rendered_spec.py
 tests/test_schema.py
 tests/test_server.py
 tests/test_tabi.py

polyapi_python-0.3.21/polyapi_python.egg-info/requires.txt

@@ -0,0 +1,18 @@
+requests==2.33.0
+typing_extensions==4.15.0
+jsonschema-gentypes==2.13.0
+pydantic==2.13.4
+stdlib_list==0.11.1
+colorama==0.4.4
+python-socketio[asyncio_client]==5.16.2
+truststore==0.9.1
+httpx==0.28.1
+
+[dev]
+mock==5.2.0
+pytest
+flask==3.1.3
+mypy
+types-requests
+types-colorama
+pip-audit

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/pyproject.toml

@@ -4,17 +4,17 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "polyapi-python"
-version = "0.3.20.dev4"
+version = "0.3.21"
 description = "The Python SDK for the integration platform PolyAPI"
 authors = [{ name = "PolyAPI", email = "support@polyapi.io" }]
 dependencies = [
-    "requests==2.32.3",
+    "requests==2.33.0",
     "typing_extensions==4.15.0",
     "jsonschema-gentypes==2.13.0",
     "pydantic==2.13.4",
     "stdlib_list==0.11.1",
     "colorama==0.4.4",
-    "python-socketio[asyncio_client]==5.11.1",
+    "python-socketio[asyncio_client]==5.16.2",
     "truststore==0.9.1",
     "httpx==0.28.1"
 ]
@@ -22,6 +22,17 @@ readme = "README.md"
 license = { file = "LICENSE" }
 requires-python = ">=3.10"
 
+[project.optional-dependencies]
+dev = [
+    "mock==5.2.0",
+    "pytest",
+    "flask==3.1.3",
+    "mypy",
+    "types-requests",
+    "types-colorama",
+    "pip-audit",
+]
+
 [project.urls]
 Homepage = "https://github.com/polyapi/polyapi-python"
 

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/tests/test_async_proof.py

@@ -23,6 +23,7 @@ import threading
 import time
 import unittest
 import warnings
+from typing import cast
 from unittest.mock import patch, MagicMock, AsyncMock
 
 import httpx
@@ -315,7 +316,7 @@ def _run_real_resource_soak():
 
 # 1. http_client sync / async client pairing
 
-class TestHttpClientPairing:
+class TestHttpClientPairing(unittest.TestCase):
     """Verify that the sync helpers call httpx.Client and the async helpers
     call httpx.AsyncClient."""
 
@@ -498,7 +499,7 @@ class TestHttpClientPairing:
                     raise AttributeError("close is read-only")
                 object.__setattr__(self, name, value)
 
-        loop = ReadOnlyCloseLoop()
+        loop = cast(asyncio.AbstractEventLoop, ReadOnlyCloseLoop())
         with self.assertLogs("poly", level=logging.WARNING) as captured:
             http_client._register_loop_close_hook(loop)
 
@@ -587,7 +588,7 @@ class TestHttpClientPairing:
             async def _run():
                 client = http_client._get_async_client()
                 proxy_pools = [
-                    type(transport._pool).__name__
+                    type(getattr(transport, "_pool", None)).__name__
                     for transport in client._mounts.values()
                     if transport is not None
                 ]

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/tests/test_dependency_pins.py

@@ -13,21 +13,13 @@ def _parse_requirement_version(requirement: str) -> tuple[int, ...]:
     return tuple(int(part) for part in match.groups())
 
 
-def test_truststore_pin_matches_between_dependency_surfaces():
-    requirements_lines = (REPO_ROOT / "requirements.txt").read_text(encoding="utf-8").splitlines()
-    requirements_pin = next(line for line in requirements_lines if line.startswith("truststore=="))
-
+def _truststore_pin() -> str:
     pyproject_text = (REPO_ROOT / "pyproject.toml").read_text(encoding="utf-8")
     pyproject_match = re.search(r'"(truststore==\d+\.\d+\.\d+)"', pyproject_text)
     assert pyproject_match is not None
-    pyproject_pin = pyproject_match.group(1)
-
-    assert requirements_pin == pyproject_pin
+    return pyproject_match.group(1)
 
 
 def test_truststore_pin_supports_python_313_ssl_chain_api():
-    requirements_lines = (REPO_ROOT / "requirements.txt").read_text(encoding="utf-8").splitlines()
-    requirements_pin = next(line for line in requirements_lines if line.startswith("truststore=="))
-
     if sys.version_info >= (3, 13):
-        assert _parse_requirement_version(requirements_pin) >= TRUSTSTORE_MINIMUM_PYTHON_313_VERSION
+        assert _parse_requirement_version(_truststore_pin()) >= TRUSTSTORE_MINIMUM_PYTHON_313_VERSION

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/tests/test_deployables.py

@@ -1,7 +1,12 @@
 import unittest
+from typing import cast
 
 from polyapi.parser import parse_function_code
-from polyapi.deployables import update_deployable_function_comments, update_deployment_comments
+from polyapi.deployables import (
+    DeployableRecord,
+    update_deployable_function_comments,
+    update_deployment_comments,
+)
 
 
 INITIAL_SERVER_FN_DEPLOYMENTS = """
@@ -110,7 +115,10 @@ class T(unittest.TestCase):
             ],
             "deploymentCommentRanges": [[0, 177]]
         }
-        updated_file_contents = update_deployment_comments(INITIAL_SERVER_FN_DEPLOYMENTS, test_deployable)
+        updated_file_contents = update_deployment_comments(
+            INITIAL_SERVER_FN_DEPLOYMENTS,
+            cast(DeployableRecord, test_deployable),
+        )
         self.assertEqual(updated_file_contents, EXPECTED_SERVER_FN_DEPLOYMENTS)
 
     def test_parse_and_write_deployable_docstring(self):

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/tests/test_generate.py

@@ -6,9 +6,14 @@ import importlib.util
 import subprocess
 import sys
 import tempfile
-from typing import cast
+from typing import List, cast
 from unittest.mock import patch, MagicMock
-from polyapi.typedefs import SpecificationDto
+from polyapi.typedefs import (
+    PropertyType,
+    SchemaSpecDto,
+    SpecificationDto,
+    VariableSpecDto,
+)
 from polyapi.utils import get_type_and_def, rewrite_reserved, to_type_module_alias
 from polyapi.generate import render_spec, create_empty_schemas_module, generate_functions, create_function, add_function_file, get_specs
 from polyapi.poly_schemas import generate_schemas, create_schema
@@ -268,7 +273,7 @@ class T(unittest.TestCase):
         self.assertEqual(params["contexts"], ",".join(contexts))
 
     def test_get_type_and_def(self):
-        arg_type, arg_def = get_type_and_def(OPENAPI_FUNCTION)
+        arg_type, arg_def = get_type_and_def(cast(PropertyType, OPENAPI_FUNCTION))
         self.assertEqual(arg_type, "Callable[[List[WebhookEventTypeElement], Dict, Dict, Dict], None]")
 
     def test_rewrite_reserved(self):
@@ -277,7 +282,7 @@ class T(unittest.TestCase):
 
     def test_render_spec_no_function_data(self):
         """Test that render_spec handles specs with no function data gracefully"""
-        func_str, func_type_defs = render_spec(NO_TYPES_SPEC)
+        func_str, func_type_defs = render_spec(cast(SpecificationDto, NO_TYPES_SPEC))
         
         # Should generate a function even without function data
         self.assertIsNotNone(func_str)
@@ -287,7 +292,7 @@ class T(unittest.TestCase):
 
     def test_render_spec_minimal_function_data(self):
         """Test that render_spec handles specs with minimal function data"""
-        func_str, func_type_defs = render_spec(MINIMAL_FUNCTION_SPEC)
+        func_str, func_type_defs = render_spec(cast(SpecificationDto, MINIMAL_FUNCTION_SPEC))
         
         # Should generate a function with fallback types
         self.assertIsNotNone(func_str)
@@ -482,7 +487,7 @@ def test_nested_function() -> schemas.api.v1.user.profile:
             
             # Capture logging output
             with patch('polyapi.generate.logging.warning') as mock_warning:
-                generate_functions(specs)
+                generate_functions(cast(List[SpecificationDto], specs))
                 
                 # Verify that create_function was called twice (once for each spec)
                 self.assertEqual(mock_create.call_count, 2)
@@ -522,7 +527,7 @@ def test_nested_function() -> schemas.api.v1.user.profile:
             
             # Capture logging output
             with patch('polyapi.poly_schemas.logging.warning') as mock_warning:
-                generate_schemas(specs)
+                generate_schemas(cast(List[SchemaSpecDto], specs))
                 
                 # Verify that create_schema was called twice (once for each spec)
                 self.assertEqual(mock_create.call_count, 2)
@@ -568,7 +573,7 @@ def test_nested_function() -> schemas.api.v1.user.profile:
             
             # Capture logging output
             with patch('polyapi.variables.logging.warning') as mock_warning:
-                generate_variables(specs)
+                generate_variables(cast(List[VariableSpecDto], specs))
                 
                 # Verify that create_variable was called twice (once for each spec)
                 self.assertEqual(mock_create.call_count, 2)
@@ -625,7 +630,11 @@ def test_nested_function() -> schemas.api.v1.user.profile:
                 
                 # Verify that the function generation fails
                 with self.assertRaises(Exception):
-                    add_function_file(temp_dir, "failingFunction", failing_spec)
+                    add_function_file(
+                        temp_dir,
+                        "failingFunction",
+                        cast(SpecificationDto, failing_spec),
+                    )
                 
                 # Verify no partial files were left behind
                 files_in_dir = os.listdir(temp_dir)
@@ -666,7 +675,10 @@ def test_nested_function() -> schemas.api.v1.user.profile:
                 
                 # Verify that the variable generation fails
                 with self.assertRaises(Exception):
-                    add_variable_to_init(temp_dir, failing_spec)
+                    add_variable_to_init(
+                        temp_dir,
+                        cast(VariableSpecDto, failing_spec),
+                    )
                 
                 # Verify no partial files were left behind and __init__.py wasn't corrupted
                 init_path = os.path.join(temp_dir, "__init__.py")
@@ -695,7 +707,7 @@ def test_nested_function() -> schemas.api.v1.user.profile:
                             "definition": {"type": "object", "properties": {"test": {"type": "string"}}}
                         }
                     ]
-                    generate_schemas(schemas)
+                    generate_schemas(cast(List[SchemaSpecDto], schemas))
                     
                     # Should have logged a warning about the failed schema
                     mock_warning.assert_called()
@@ -742,7 +754,7 @@ def test_nested_function() -> schemas.api.v1.user.profile:
                         
                         # This should fail gracefully 
                         try:
-                            generate.create_function(spec)
+                            generate.create_function(cast(SpecificationDto, spec))
                         except:
                             pass  # Expected to fail
                         
@@ -808,7 +820,7 @@ def test_nested_function() -> schemas.api.v1.user.profile:
                     
                     # This should fail but handle cleanup gracefully
                     try:
-                        generate.create_function(spec)
+                        generate.create_function(cast(SpecificationDto, spec))
                     except:
                         pass  # Expected to fail
                     

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/tests/test_parser.py

@@ -157,7 +157,8 @@ class T(unittest.TestCase):
         self.assertEqual(len(types["params"]), 1)
         self.assertEqual(types["params"][0], {"name": "n", "type": "int", "typeSchema": None, "description": ""})
         self.assertEqual(types["returns"]["type"], "Barbar")
-        self.assertEqual(types["returns"]["typeSchema"]['title'], "Barbar")
+        typeSchema = types["returns"].get("typeSchema") or {} 
+        self.assertEqual(typeSchema.get('title', "Barbar"), "Barbar")
 
     def test_complex_arg_type(self):
         deployable = parse_function_code(COMPLEX_ARG_TYPE, "foobar")
@@ -173,7 +174,7 @@ class T(unittest.TestCase):
         self.assertEqual(len(types["params"]), 1)
         self.assertEqual(types["params"][0], {"name": "n", "type": "int", "typeSchema": None, "description": ""})
         self.assertEqual(types["returns"]["type"], "List[Barbar]")
-        self.assertEqual(types["returns"]["typeSchema"]["items"]['title'], "Barbar")
+        self.assertEqual(types["returns"]["typeSchema"]["items"]['title'], "Barbar") # pyright: ignore[reportOptionalSubscript]
 
     def test_parse_import_basic(self):
         code = "import flask\n\n\ndef foobar(n: int) -> int:\n    return 9\n"
@@ -215,6 +216,7 @@ class T(unittest.TestCase):
         })
         self.assertEqual(deployable["types"]["returns"], {
             "type": "Any",
+            "typeSchema": None,
             "description": "import number please keep handy"
         })
 

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/tests/test_server.py

@@ -151,8 +151,9 @@ class T(unittest.TestCase):
 #         self.assertIn(expected_return_type, func_str)
 
 
-    def test_render_function_return_type_name_collision_does_not_reference_module_attr(self):
+    def test_render_function_return_type_name_collision_uses_qualified_reference(self):
         return_type = RETURN_TYPE_NAMED_RETURN_TYPE["function"]["returnType"]
+        name = RETURN_TYPE_NAMED_RETURN_TYPE["name"]
         func_str, func_type_defs = render_server_function(
             RETURN_TYPE_NAMED_RETURN_TYPE["type"],
             RETURN_TYPE_NAMED_RETURN_TYPE["name"],
@@ -161,9 +162,10 @@ class T(unittest.TestCase):
             RETURN_TYPE_NAMED_RETURN_TYPE["function"]["arguments"],
             return_type,
         )
-        self.assertIn("-> dict", func_str)
-        self.assertNotIn(".returnType", func_str)
-        self.assertNotIn(".ReturnType", func_str)
+        # The real "ReturnType" class must be generated and referenced via its
+        # qualified module alias, not collapsed to a generic "dict".
+        self.assertIn(f"-> {to_type_module_alias(name)}.ReturnType", func_str)
+        self.assertIn("class ReturnType(", func_type_defs)
 
     def test_render_function_string_union_returns_text(self):
         function_name = "getMaybeName"

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/tests/test_utils.py

@@ -1,4 +1,6 @@
 import unittest
+from typing import cast
+from polyapi.typedefs import PropertyType
 from polyapi.utils import add_type_import_path, get_type_and_def, rewrite_reserved
 
 OPENAPI_FUNCTION = {
@@ -75,7 +77,7 @@ OPENAPI_FUNCTION = {
 
 class T(unittest.TestCase):
     def test_get_type_and_def(self):
-        arg_type, arg_def = get_type_and_def(OPENAPI_FUNCTION)
+        arg_type, arg_def = get_type_and_def(cast(PropertyType, OPENAPI_FUNCTION))
         self.assertEqual(
             arg_type,
             "Callable[[List[WebhookEventTypeElement], Dict, Dict, Dict], None]",

{polyapi_python-0.3.20.dev4 → polyapi_python-0.3.21}/tests/test_variables.py

@@ -1,4 +1,6 @@
 import unittest
+from typing import cast
+from polyapi.typedefs import VariableSpecDto
 from polyapi.variables import render_variable
 
 EXAMPLE = {
@@ -24,5 +26,5 @@ EXAMPLE = {
 
 class T(unittest.TestCase):
     def test_render_variable(self):
-        variable_str = render_variable(EXAMPLE)
+        variable_str = render_variable(cast(VariableSpecDto, EXAMPLE))
         self.assertIn("class test", variable_str)

polyapi_python-0.3.20.dev4/polyapi/rendered_spec.py

@@ -1,69 +0,0 @@
-import os
-from typing import Optional
-
-from polyapi import http_client
-from polyapi.config import get_api_key_and_url
-from polyapi.generate import read_cached_specs, render_spec
-from polyapi.typedefs import SpecificationDto
-
-
-def update_rendered_spec(spec: SpecificationDto):
-    print("Updating rendered spec...")
-    func_str, type_defs = render_spec(spec)
-    data = {
-        "language": "python",
-        "signature": func_str,
-        "typedefs": type_defs,
-    }
-    if spec["type"] == "apiFunction":
-        data["apiFunctionId"] = spec["id"]
-    elif spec["type"] == "serverFunction":
-        data["customFunctionId"] = spec["id"]
-    elif spec["type"] == "clientFunction":
-        data["customFunctionId"] = spec["id"]
-    elif spec["type"] == "webhookHandle":
-        data["webhookHandleId"] = spec["id"]
-    else:
-        raise NotImplementedError("todo")
-
-    # use super key on develop-k8s here!
-    api_key, base_url = get_api_key_and_url()
-
-    url = f"{base_url}/functions/rendered-specs"
-    headers = {"Authorization": f"Bearer {api_key}"}
-    resp = http_client.post(url, json=data, headers=headers)
-    assert resp.status_code == 201, (resp.text, resp.status_code)
-
-
-def _get_spec(spec_id: str, no_types: bool = False) -> Optional[SpecificationDto]:
-    api_key, base_url = get_api_key_and_url()
-    url = f"{base_url}/specs"
-    headers = {"Authorization": f"Bearer {api_key}"}
-    params = {"noTypes": str(no_types).lower()}
-    resp = http_client.get(url, headers=headers, params=params)
-    if resp.status_code == 200:
-        specs = resp.json()
-        for spec in specs:
-            if spec['id'] == spec_id:
-                return spec
-        return None
-    else:
-        raise NotImplementedError(resp.content)
-
-
-def get_and_update_rendered_spec(spec_id: str) -> bool:
-    spec = _get_spec(spec_id)
-    if spec:
-        update_rendered_spec(spec)
-        return True
-    return False
-
-
-def save_rendered_specs() -> None:
-    specs = read_cached_specs()
-    # right now we just support rendered apiFunctions
-    api_specs = [spec for spec in specs if spec["type"] == "apiFunction"]
-    for spec in api_specs:
-        assert spec["function"]
-        print("adding", spec["context"], spec["name"])
-        update_rendered_spec(spec)

polyapi_python-0.3.20.dev4/polyapi_python.egg-info/requires.txt

@@ -1,9 +0,0 @@
-requests==2.32.3
-typing_extensions==4.15.0
-jsonschema-gentypes==2.13.0
-pydantic==2.13.4
-stdlib_list==0.11.1
-colorama==0.4.4
-python-socketio[asyncio_client]==5.11.1
-truststore==0.9.1
-httpx==0.28.1

polyapi_python-0.3.20.dev4/tests/test_rendered_spec.py

@@ -1,52 +0,0 @@
-import unittest
-from mock import patch, Mock
-
-from polyapi.rendered_spec import get_and_update_rendered_spec
-
-GET_PRODUCTS_COUNT = {
-    "id": "8f7d24b0-4a29-40c0-9091",
-    "type": "serverFunction",
-    "context": "test",
-    "name": "getProductsCount111",
-    "description": "An API call to retrieve the count of products in the product list.",
-    "requirements": ["snabbdom"],
-    "function": {
-        "arguments": [
-            {
-                "name": "products",
-                "required": False,
-                "type": {
-                    "kind": "array",
-                    "items": {"kind": "primitive", "type": "string"},
-                },
-            }
-        ],
-        "returnType": {"kind": "plain", "value": "number"},
-        "synchronous": True,
-    },
-    "code": "",
-    "language": "javascript",
-    "visibilityMetadata": {"visibility": "ENVIRONMENT"},
-}
-
-
-class T(unittest.TestCase):
-    @patch("polyapi.rendered_spec._get_spec")
-    def test_get_and_update_rendered_spec_fail(self, _get_spec):
-        """ pass in a bad id to update and make sure it returns False
-        """
-        _get_spec.return_value = None
-        updated = get_and_update_rendered_spec("123")
-        self.assertEqual(_get_spec.call_count, 1)
-        self.assertFalse(updated)
-
-    @patch("polyapi.http_client.post")
-    @patch("polyapi.rendered_spec._get_spec")
-    def test_get_and_update_rendered_spec_success(self, _get_spec, post):
-        """ pass in a bad id to update and make sure it returns False
-        """
-        _get_spec.return_value = GET_PRODUCTS_COUNT
-        post.return_value = Mock(status_code=201, text="Created")
-        updated = get_and_update_rendered_spec("123")
-        self.assertEqual(_get_spec.call_count, 1)
-        self.assertTrue(updated)