polyapi-python 0.3.7.dev7__py3-none-any.whl → 0.3.8__py3-none-any.whl

polyapi/cli.py

@@ -14,6 +14,16 @@ from .sync import sync_deployables
 CLI_COMMANDS = ["setup", "generate", "function", "clear", "help", "update_rendered_spec"]
 
 
+def _get_version_string():
+    """Get the version string for the package."""
+    try:
+        import importlib.metadata
+        version = importlib.metadata.version('polyapi-python')
+        return version
+    except Exception:
+        return "Unknown"
+
+
 def execute_from_cli():
     # First we setup all our argument parsing logic
     # Then we parse the arguments (waaay at the bottom)
@@ -22,6 +32,11 @@ def execute_from_cli():
         description="Manage your Poly API configurations and functions",
         formatter_class=argparse.RawTextHelpFormatter
     )
+    
+    # Add global --version/-v flag
+    parser.add_argument('-v', '--version', action='version', 
+                       version=_get_version_string(),
+                       help="Show version information")
 
     subparsers = parser.add_subparsers(help="Available commands")
 
@@ -36,6 +51,9 @@ def execute_from_cli():
             set_api_key_and_url(args.url, args.api_key)
         else:
             initialize_config(force=True)
+            # setup command should have default cache values
+            from .config import cache_generate_args
+            cache_generate_args(contexts=None, names=None, function_ids=None, no_types=False)
             generate()
 
     setup_parser.set_defaults(command=setup)
@@ -46,11 +64,34 @@ def execute_from_cli():
     generate_parser = subparsers.add_parser("generate", help="Generates Poly library")
     generate_parser.add_argument("--no-types", action="store_true", help="Generate SDK without type definitions")
     generate_parser.add_argument("--contexts", type=str, required=False, help="Contexts to generate")
+    generate_parser.add_argument("--names", type=str, required=False, help="Resource names to generate (comma-separated)")
+    generate_parser.add_argument("--function-ids", type=str, required=False, help="Function IDs to generate (comma-separated)")
 
     def generate_command(args):
+        from .config import cache_generate_args
+        
         initialize_config()
+        
         contexts = args.contexts.split(",") if args.contexts else None
-        generate(contexts=contexts, no_types=args.no_types)
+        names = args.names.split(",") if args.names else None
+        function_ids = args.function_ids.split(",") if args.function_ids else None
+        no_types = args.no_types
+        
+        # overwrite all cached values with the values passed in from the command line
+        final_contexts = contexts
+        final_names = names
+        final_function_ids = function_ids
+        final_no_types = no_types
+        
+        # cache the values used for this explicit generate command
+        cache_generate_args(
+            contexts=final_contexts,
+            names=final_names, 
+            function_ids=final_function_ids,
+            no_types=final_no_types
+        )
+        
+        generate(contexts=final_contexts, names=final_names, function_ids=final_function_ids, no_types=final_no_types)
 
     generate_parser.set_defaults(command=generate_command)
 

polyapi/client.py

@@ -10,7 +10,7 @@ from typing import List, Dict, Any, TypedDict
 """
 
 
-def _wrap_code_in_try_except(code: str) -> str:
+def _wrap_code_in_try_except(function_name: str, code: str) -> str:
     """ this is necessary because client functions with imports will blow up ALL server functions,
     even if they don't use them.
     because the server function will try to load all client functions when loading the library
@@ -18,8 +18,8 @@ def _wrap_code_in_try_except(code: str) -> str:
     prefix = """logger = logging.getLogger("poly")
 try:
     """
-    suffix = """except ImportError as e:
-    logger.debug(e)"""
+    suffix = f"""except ImportError as e:
+    logger.warning("Failed to import client function '{function_name}', function unavailable: " + str(e))"""
 
     lines = code.split("\n")
     code = "\n    ".join(lines)
@@ -39,6 +39,6 @@ def render_client_function(
         return_type_def=return_type_def,
     )
 
-    code = _wrap_code_in_try_except(code)
+    code = _wrap_code_in_try_except(function_name, code)
 
     return code + "\n\n", func_type_defs

polyapi/config.py

@@ -12,6 +12,10 @@ API_FUNCTION_DIRECT_EXECUTE = None
 MTLS_CERT_PATH = None
 MTLS_KEY_PATH = None
 MTLS_CA_PATH = None
+LAST_GENERATE_CONTEXTS = None
+LAST_GENERATE_NAMES = None
+LAST_GENERATE_FUNCTION_IDS = None
+LAST_GENERATE_NO_TYPES = None
 
 
 def get_config_file_path() -> str:
@@ -55,6 +59,16 @@ def get_api_key_and_url() -> Tuple[str | None, str | None]:
         MTLS_CERT_PATH = config.get("polyapi", "mtls_cert_path", fallback=None)
         MTLS_KEY_PATH = config.get("polyapi", "mtls_key_path", fallback=None)
         MTLS_CA_PATH = config.get("polyapi", "mtls_ca_path", fallback=None)
+        
+        # Read and cache generate command arguments
+        global LAST_GENERATE_CONTEXTS, LAST_GENERATE_NAMES, LAST_GENERATE_FUNCTION_IDS, LAST_GENERATE_NO_TYPES
+        contexts_str = config.get("polyapi", "last_generate_contexts_used", fallback=None)
+        LAST_GENERATE_CONTEXTS = contexts_str.split(",") if contexts_str else None
+        names_str = config.get("polyapi", "last_generate_names_used", fallback=None)
+        LAST_GENERATE_NAMES = names_str.split(",") if names_str else None
+        function_ids_str = config.get("polyapi", "last_generate_function_ids_used", fallback=None)
+        LAST_GENERATE_FUNCTION_IDS = function_ids_str.split(",") if function_ids_str else None
+        LAST_GENERATE_NO_TYPES = config.get("polyapi", "last_generate_no_types_used", fallback="false").lower() == "true"
 
     return key, url
 
@@ -133,4 +147,58 @@ def get_direct_execute_config() -> bool:
     if API_FUNCTION_DIRECT_EXECUTE is None:
         # Force a config read if value isn't cached
         get_api_key_and_url()
-    return bool(API_FUNCTION_DIRECT_EXECUTE)
+    return bool(API_FUNCTION_DIRECT_EXECUTE)
+
+
+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_FUNCTION_IDS, LAST_GENERATE_NO_TYPES
+    if LAST_GENERATE_CONTEXTS is None and LAST_GENERATE_NAMES is None and LAST_GENERATE_FUNCTION_IDS is None and LAST_GENERATE_NO_TYPES is None:
+        # Force a config read if values aren't cached
+        get_api_key_and_url()
+    return LAST_GENERATE_CONTEXTS, LAST_GENERATE_NAMES, LAST_GENERATE_FUNCTION_IDS, bool(LAST_GENERATE_NO_TYPES)
+
+
+def cache_generate_args(contexts: list | None = None, names: list | None = None, function_ids: list | None = None, no_types: bool = False):
+    """Cache generate command arguments to config file"""
+    from typing import List
+    
+    # Read existing config
+    path = get_config_file_path()
+    config = configparser.ConfigParser()
+    
+    if os.path.exists(path):
+        with open(path, "r") as f:
+            config.read_file(f)
+    
+    # Ensure polyapi section exists
+    if "polyapi" not in config:
+        config["polyapi"] = {}
+    
+    # Update cached values
+    global LAST_GENERATE_CONTEXTS, LAST_GENERATE_NAMES, LAST_GENERATE_FUNCTION_IDS, LAST_GENERATE_NO_TYPES
+    LAST_GENERATE_CONTEXTS = contexts
+    LAST_GENERATE_NAMES = names
+    LAST_GENERATE_FUNCTION_IDS = function_ids
+    LAST_GENERATE_NO_TYPES = no_types
+    
+    # Write values to config
+    if contexts is not None:
+        config.set("polyapi", "last_generate_contexts_used", ",".join(contexts))
+    elif config.has_option("polyapi", "last_generate_contexts_used"):
+        config.remove_option("polyapi", "last_generate_contexts_used")
+        
+    if names is not None:
+        config.set("polyapi", "last_generate_names_used", ",".join(names))
+    elif config.has_option("polyapi", "last_generate_names_used"):
+        config.remove_option("polyapi", "last_generate_names_used")
+        
+    if function_ids is not None:
+        config.set("polyapi", "last_generate_function_ids_used", ",".join(function_ids))
+    elif config.has_option("polyapi", "last_generate_function_ids_used"):
+        config.remove_option("polyapi", "last_generate_function_ids_used")
+        
+    config.set("polyapi", "last_generate_no_types_used", str(no_types).lower())
+    
+    with open(path, "w") as f:
+        config.write(f)

polyapi/deployables.py

@@ -31,6 +31,7 @@ class ParsedDeployableConfig(TypedDict):
     context: str
     name: str
     type: DeployableTypes
+    description: Optional[str]
     disableAi: Optional[bool]
     config: Dict[str, Any]
 
@@ -112,20 +113,22 @@ class PolyDeployConfig(TypedDict):
 
 def get_all_deployable_files_windows(config: PolyDeployConfig) -> List[str]:
     # Constructing the Windows command using dir and findstr
-    include_pattern = " ".join(f"*.{f}" if "." in f else f"*.{f}" for f in config["include_files_or_extensions"]) or "*"
-    exclude_pattern = '|'.join(config["exclude_dirs"])
-    pattern = '|'.join(f"polyConfig: {name}" for name in config["type_names"]) or 'polyConfig'
+    include_pattern = " ".join(f"*.{f}" for f in config["include_files_or_extensions"]) or "*"
+    exclude_pattern = ' '.join(f"\\{f}" for f in config["exclude_dirs"])
+    pattern = ' '.join(f"/C:\"polyConfig: {name}\"" for name in config["type_names"]) or '/C:"polyConfig"'
 
     exclude_command = f" | findstr /V /I \"{exclude_pattern}\"" if exclude_pattern else ''
-    search_command = f" | findstr /M /I /F:/ /C:\"{pattern}\""
+    search_command = f" | findstr /S /M /I /F:/ {pattern} *.*"
 
     result = []
     for dir_path in config["include_dirs"]:
-        dir_command = f"dir /S /P /B {include_pattern} {dir_path}"
+        if dir_path != '.':
+            include_pattern = " ".join(f"{dir_path}*.{f}" for f in config["include_files_or_extensions"]) or "*"
+        dir_command = f"dir {include_pattern} /S /P /B > NUL"
         full_command = f"{dir_command}{exclude_command}{search_command}"
         try:
             output = subprocess.check_output(full_command, shell=True, text=True)
-            result.extend(output.strip().split('\r\n'))
+            result.extend(output.strip().split('\n'))
         except subprocess.CalledProcessError:
             pass
     return result
@@ -154,7 +157,7 @@ def get_all_deployable_files(config: PolyDeployConfig) -> List[str]:
     if not config.get("include_files_or_extensions"):
         config["include_files_or_extensions"] = ["py"]
     if not config.get("exclude_dirs"):
-        config["exclude_dirs"] = ["poly", "node_modules", "dist", "build", "output", ".vscode", ".poly", ".github", ".husky", ".yarn"]
+        config["exclude_dirs"] = ["Lib", "node_modules", "dist", "build", "output", ".vscode", ".poly", ".github", ".husky", ".yarn", ".venv"]
 
     is_windows = os.name == "nt"
     if is_windows:

polyapi/function_cli.py

@@ -1,7 +1,7 @@
 import sys
 from typing import Any, List, Optional
 import requests
-from polyapi.generate import generate as generate_library
+
 from polyapi.config import get_api_key_and_url
 from polyapi.utils import get_auth_headers, print_green, print_red, print_yellow
 from polyapi.parser import parse_function_code, get_jsonschema_type
@@ -91,7 +91,9 @@ def function_add_or_update(
         function_id = resp.json()["id"]
         print(f"Function ID: {function_id}")
         if generate:
-            generate_library()
+            # Use cached generate arguments when regenerating after function deployment
+            from polyapi.generate import generate_from_cache
+            generate_from_cache()
     else:
         print("Error adding function.")
         print(resp.status_code)

polyapi/generate.py

@@ -2,7 +2,9 @@ import json
 import requests
 import os
 import shutil
-from typing import List, Optional, Tuple, cast
+import logging
+import tempfile
+from typing import Any, List, Optional, Tuple, cast
 
 from .auth import render_auth_function
 from .client import render_client_function
@@ -14,7 +16,7 @@ from .api import render_api_function
 from .server import render_server_function
 from .utils import add_import_to_init, get_auth_headers, init_the_init, print_green, to_func_namespace
 from .variables import generate_variables
-from .config import get_api_key_and_url, get_direct_execute_config
+from .config import get_api_key_and_url, get_direct_execute_config, get_cached_generate_args
 
 SUPPORTED_FUNCTION_TYPES = {
     "apiFunction",
@@ -36,15 +38,21 @@ Unresolved schema, please add the following schema to complete it:
   path:'''
 
 
-def get_specs(contexts=Optional[List[str]], no_types: bool = False) -> List:
+def get_specs(contexts: Optional[List[str]] = None, names: Optional[List[str]] = None, function_ids: Optional[List[str]] = None, no_types: bool = False) -> List:
     api_key, api_url = get_api_key_and_url()
     assert api_key
     headers = get_auth_headers(api_key)
     url = f"{api_url}/specs"
-    params = {"noTypes": str(no_types).lower()}
+    params: Any = {"noTypes": str(no_types).lower()}
 
     if contexts:
         params["contexts"] = contexts
+    
+    if names:
+        params["names"] = names
+        
+    if function_ids:
+        params["functionIds"] = function_ids
 
     # Add apiFunctionDirectExecute parameter if direct execute is enabled
     if get_direct_execute_config():
@@ -149,7 +157,7 @@ def parse_function_specs(
 
         # Functions with serverSideAsync True will always return a Dict with execution ID
         if spec.get('serverSideAsync') and spec.get("function"):
-            spec['function']['returnType'] = {'kind': 'plain', 'value': 'object'}
+            spec['function']['returnType'] = {'kind': 'plain', 'value': 'object'}  # type: ignore
 
         functions.append(spec)
 
@@ -264,12 +272,26 @@ sys.modules[__name__] = _SchemaModule()
 ''')
 
 
-def generate(contexts: Optional[List[str]] = None, no_types: bool = False) -> None:
+def generate_from_cache() -> None:
+    """
+    Generate using cached values after non-explicit call.
+    """
+    cached_contexts, cached_names, cached_function_ids, cached_no_types = get_cached_generate_args()
+    
+    generate(
+        contexts=cached_contexts, 
+        names=cached_names, 
+        function_ids=cached_function_ids, 
+        no_types=cached_no_types
+    )
+
+
+def generate(contexts: Optional[List[str]] = None, names: Optional[List[str]] = None, function_ids: Optional[List[str]] = None, no_types: bool = False) -> None:
     generate_msg = f"Generating Poly Python SDK for contexts ${contexts}..." if contexts else "Generating Poly Python SDK..."
     print(generate_msg, end="", flush=True)
     remove_old_library()
 
-    specs = get_specs(no_types=no_types, contexts=contexts)
+    specs = get_specs(contexts=contexts, names=names, function_ids=function_ids, no_types=no_types)
     cache_specs(specs)
 
     limit_ids: List[str] = []  # useful for narrowing down generation to a single function to debug
@@ -301,11 +323,9 @@ def generate(contexts: Optional[List[str]] = None, no_types: bool = False) -> No
         )
         exit()
 
-    # Only process variables if no_types is False
-    if not no_types:
-        variables = get_variables()
-        if variables:
-            generate_variables(variables)
+    variables = get_variables()
+    if variables:
+        generate_variables(variables)
 
     # indicator to vscode extension that this is a polyapi-python project
     file_path = os.path.join(os.getcwd(), ".polyapi-python")
@@ -334,8 +354,9 @@ def render_spec(spec: SpecificationDto) -> Tuple[str, str]:
     function_id = spec["id"]
 
     arguments: List[PropertySpecification] = []
-    return_type = {}
+    return_type: Any = {}
     if spec.get("function"):
+        assert spec["function"]
         # Handle cases where arguments might be missing or None
         if spec["function"].get("arguments"):
             arguments = [
@@ -407,48 +428,124 @@ def add_function_file(
     function_name: str,
     spec: SpecificationDto,
 ):
-    # first lets add the import to the __init__
-    init_the_init(full_path)
+    """
+    Atomically add a function file to prevent partial corruption during generation failures.
+    
+    This function generates all content first, then writes files atomically using temporary files
+    to ensure that either the entire operation succeeds or no changes are made to the filesystem.
+    """
+    try:
+        # first lets add the import to the __init__
+        init_the_init(full_path)
 
-    func_str, func_type_defs = render_spec(spec)
+        func_str, func_type_defs = render_spec(spec)
 
-    if func_str:
-        # add function to init
-        init_path = os.path.join(full_path, "__init__.py")
-        with open(init_path, "a") as f:
-            f.write(f"\n\nfrom . import {to_func_namespace(function_name)}\n\n{func_str}")
+        if not func_str:
+            # If render_spec failed and returned empty string, don't create any files
+            raise Exception("Function rendering failed - empty function string returned")
 
-        # add type_defs to underscore file
-        file_path = os.path.join(full_path, f"{to_func_namespace(function_name)}.py")
-        with open(file_path, "w") as f:
-            f.write(func_type_defs)
+        # Prepare all content first before writing any files
+        func_namespace = to_func_namespace(function_name)
+        init_path = os.path.join(full_path, "__init__.py")
+        func_file_path = os.path.join(full_path, f"{func_namespace}.py")
+        
+        # Read current __init__.py content if it exists
+        init_content = ""
+        if os.path.exists(init_path):
+            with open(init_path, "r") as f:
+                init_content = f.read()
+        
+        # Prepare new content to append to __init__.py
+        new_init_content = init_content + f"\n\nfrom . import {func_namespace}\n\n{func_str}"
+        
+        # Use temporary files for atomic writes
+        # Write to __init__.py atomically
+        with tempfile.NamedTemporaryFile(mode="w", delete=False, dir=full_path, suffix=".tmp") as temp_init:
+            temp_init.write(new_init_content)
+            temp_init_path = temp_init.name
+        
+        # Write to function file atomically  
+        with tempfile.NamedTemporaryFile(mode="w", delete=False, dir=full_path, suffix=".tmp") as temp_func:
+            temp_func.write(func_type_defs)
+            temp_func_path = temp_func.name
+        
+        # Atomic operations: move temp files to final locations
+        shutil.move(temp_init_path, init_path)
+        shutil.move(temp_func_path, func_file_path)
+        
+    except Exception as e:
+        # Clean up any temporary files that might have been created
+        try:
+            if 'temp_init_path' in locals() and os.path.exists(temp_init_path):
+                os.unlink(temp_init_path)
+            if 'temp_func_path' in locals() and os.path.exists(temp_func_path):
+                os.unlink(temp_func_path)
+        except:
+            pass  # Best effort cleanup
+        
+        # Re-raise the original exception
+        raise e
 
 
 def create_function(
     spec: SpecificationDto
 ) -> None:
+    """
+    Create a function with atomic directory and file operations.
+    
+    Tracks directory creation to enable cleanup on failure.
+    """
     full_path = os.path.dirname(os.path.abspath(__file__))
     folders = f"poly.{spec['context']}.{spec['name']}".split(".")
-    for idx, folder in enumerate(folders):
-        if idx + 1 == len(folders):
-            # special handling for final level
-            add_function_file(
-                full_path,
-                folder,
-                spec,
-            )
-        else:
-            full_path = os.path.join(full_path, folder)
-            if not os.path.exists(full_path):
-                os.makedirs(full_path)
-
-            # append to __init__.py file if nested folders
-            next = folders[idx + 1] if idx + 2 < len(folders) else ""
-            if next:
-                init_the_init(full_path)
-                add_import_to_init(full_path, next)
+    created_dirs = []  # Track directories we create for cleanup on failure
+    
+    try:
+        for idx, folder in enumerate(folders):
+            if idx + 1 == len(folders):
+                # special handling for final level
+                add_function_file(
+                    full_path,
+                    folder,
+                    spec,
+                )
+            else:
+                full_path = os.path.join(full_path, folder)
+                if not os.path.exists(full_path):
+                    os.makedirs(full_path)
+                    created_dirs.append(full_path)  # Track for cleanup
+
+                # append to __init__.py file if nested folders
+                next = folders[idx + 1] if idx + 2 < len(folders) else ""
+                if next:
+                    init_the_init(full_path)
+                    add_import_to_init(full_path, next)
+                    
+    except Exception as e:
+        # Clean up directories we created (in reverse order)
+        for dir_path in reversed(created_dirs):
+            try:
+                if os.path.exists(dir_path) and not os.listdir(dir_path):  # Only remove if empty
+                    os.rmdir(dir_path)
+            except:
+                pass  # Best effort cleanup
+        
+        # Re-raise the original exception
+        raise e
 
 
 def generate_functions(functions: List[SpecificationDto]) -> None:
+    failed_functions = []
     for func in functions:
-        create_function(func)
+        try:
+            create_function(func)
+        except Exception as e:
+            function_path = f"{func.get('context', 'unknown')}.{func.get('name', 'unknown')}"
+            function_id = func.get('id', 'unknown')
+            failed_functions.append(f"{function_path} (id: {function_id})")
+            logging.warning(f"WARNING: Failed to generate function {function_path} (id: {function_id}): {str(e)}")
+            continue
+    
+    if failed_functions:
+        logging.warning(f"WARNING: {len(failed_functions)} function(s) failed to generate:")
+        for failed_func in failed_functions:
+            logging.warning(f"  - {failed_func}")

polyapi/parser.py

@@ -513,7 +513,13 @@ def parse_function_code(code: str, name: Optional[str] = "", context: Optional[s
     deployable["context"] = context or deployable["config"].get("context", "")
     deployable["name"] = name or deployable["config"].get("name", "")
     deployable["disableAi"] = deployable["config"].get("disableAi", False)
-    deployable["description"] = deployable["types"].get("description", "")
+    deployable["description"] = deployable["config"].get("description", "")
+    if deployable["description"]:
+        if deployable["description"] != deployable["types"].get("description", ""):
+            deployable["types"]["description"] = deployable["description"]
+            deployable["dirty"] = True
+    else:
+        deployable["description"] = deployable["types"].get("description", "")
     if not deployable["name"]:
         print_red("ERROR")
         print("Function config is missing a name.")

polyapi/poly_schemas.py

@@ -1,4 +1,7 @@
 import os
+import logging
+import tempfile
+import shutil
 from typing import Any, Dict, List, Tuple
 
 from polyapi.schema import wrapped_generate_schema_types
@@ -21,13 +24,67 @@ FALLBACK_SPEC_TEMPLATE = """class {name}(TypedDict, total=False):
 
 
 def generate_schemas(specs: List[SchemaSpecDto], limit_ids: List[str] = None):
+    failed_schemas = []
+    successful_schemas = []
     if limit_ids:
         for spec in specs:
             if spec["id"] in limit_ids:
-                create_schema(spec)
+                try:
+                    create_schema(spec)
+                    successful_schemas.append(f"{spec.get('context', 'unknown')}.{spec.get('name', 'unknown')}")
+                except Exception as e:
+                    schema_path = f"{spec.get('context', 'unknown')}.{spec.get('name', 'unknown')}"
+                    schema_id = spec.get('id', 'unknown')
+                    failed_schemas.append(f"{schema_path} (id: {schema_id})")
+                    logging.warning(f"WARNING: Failed to generate schema {schema_path} (id: {schema_id}): {str(e)}")
+                    continue
     else:
         for spec in specs:
-            create_schema(spec)
+            try:
+                create_schema(spec)
+                successful_schemas.append(f"{spec.get('context', 'unknown')}.{spec.get('name', 'unknown')}")
+            except Exception as e:
+                schema_path = f"{spec.get('context', 'unknown')}.{spec.get('name', 'unknown')}"
+                schema_id = spec.get('id', 'unknown')
+                failed_schemas.append(f"{schema_path} (id: {schema_id})")
+                logging.warning(f"WARNING: Failed to generate schema {schema_path} (id: {schema_id}): {str(e)}")
+                continue
+    
+    if failed_schemas:
+        logging.warning(f"WARNING: {len(failed_schemas)} schema(s) failed to generate:")
+        for failed_schema in failed_schemas:
+            logging.warning(f"  - {failed_schema}")
+        logging.warning(f"Successfully generated {len(successful_schemas)} schema(s)")
+
+
+def validate_schema_content(schema_content: str, schema_name: str) -> bool:
+    """
+    Validate that the schema content is meaningful and not just imports.
+    Returns True if the schema is valid, False otherwise.
+    """
+    if not schema_content or not schema_content.strip():
+        logging.debug(f"Schema {schema_name} failed validation: Empty content")
+        return False
+    
+    lines = schema_content.strip().split('\n')
+    
+    # Check if the content has any actual class definitions or type aliases
+    has_class_definition = any(line.strip().startswith('class ') for line in lines)
+    has_type_alias = any(schema_name in line and '=' in line and not line.strip().startswith('#') for line in lines)
+    
+    # Check if it's essentially just imports (less than 5 lines and no meaningful definitions)
+    meaningful_lines = [line for line in lines if line.strip() and not line.strip().startswith('from ') and not line.strip().startswith('import ') and not line.strip().startswith('#')]
+    
+    # Enhanced logging for debugging
+    if not (has_class_definition or has_type_alias) or len(meaningful_lines) < 1:
+        # Determine the specific reason for failure
+        if len(meaningful_lines) == 0:
+            logging.debug(f"Schema {schema_name} failed validation: No meaningful content (only imports) - likely empty object or unresolved reference")
+        elif not has_class_definition and not has_type_alias:
+            logging.debug(f"Schema {schema_name} failed validation: No class definition or type alias found")
+        return False
+    
+    return True
 
 
 def add_schema_file(
@@ -35,51 +92,114 @@ def add_schema_file(
     schema_name: str,
     spec: SchemaSpecDto,
 ):
-    # first lets add the import to the __init__
-    init_the_init(full_path, SCHEMA_CODE_IMPORTS)
-
-    if not spec["definition"].get("title"):
-        # very empty schemas like mews.Unit are possible
-        # add a title here to be sure they render
-        spec["definition"]["title"] = schema_name
-
-    schema_defs = render_poly_schema(spec)
-
-    if schema_defs:
-        # add function to init
+    """
+    Atomically add a schema file to prevent partial corruption during generation failures.
+    
+    This function generates all content first, then writes files atomically using temporary files
+    to ensure that either the entire operation succeeds or no changes are made to the filesystem.
+    """
+    try:
+        # first lets add the import to the __init__
+        init_the_init(full_path, SCHEMA_CODE_IMPORTS)
+
+        if not spec["definition"].get("title"):
+            # very empty schemas like mews.Unit are possible
+            # add a title here to be sure they render
+            spec["definition"]["title"] = schema_name
+
+        schema_defs = render_poly_schema(spec)
+
+        # Validate schema content before proceeding
+        if not validate_schema_content(schema_defs, schema_name):
+            raise Exception(f"Schema rendering failed or produced invalid content for {schema_name}")
+
+        # Prepare all content first before writing any files
+        schema_namespace = to_func_namespace(schema_name)
         init_path = os.path.join(full_path, "__init__.py")
-        with open(init_path, "a") as f:
-            f.write(f"\n\nfrom ._{to_func_namespace(schema_name)} import {schema_name}\n__all__.append('{schema_name}')\n")
-
-        # add type_defs to underscore file
-        file_path = os.path.join(full_path, f"_{to_func_namespace(schema_name)}.py")
-        with open(file_path, "w") as f:
-            f.write(schema_defs)
+        schema_file_path = os.path.join(full_path, f"_{schema_namespace}.py")
+        
+        # Read current __init__.py content if it exists
+        init_content = ""
+        if os.path.exists(init_path):
+            with open(init_path, "r") as f:
+                init_content = f.read()
+        
+        # Prepare new content to append to __init__.py
+        new_init_content = init_content + f"\n\nfrom ._{schema_namespace} import {schema_name}\n__all__.append('{schema_name}')\n"
+        
+        # Use temporary files for atomic writes
+        # Write to __init__.py atomically
+        with tempfile.NamedTemporaryFile(mode="w", delete=False, dir=full_path, suffix=".tmp") as temp_init:
+            temp_init.write(new_init_content)
+            temp_init_path = temp_init.name
+        
+        # Write to schema file atomically  
+        with tempfile.NamedTemporaryFile(mode="w", delete=False, dir=full_path, suffix=".tmp") as temp_schema:
+            temp_schema.write(schema_defs)
+            temp_schema_path = temp_schema.name
+        
+        # Atomic operations: move temp files to final locations
+        shutil.move(temp_init_path, init_path)
+        shutil.move(temp_schema_path, schema_file_path)
+        
+    except Exception as e:
+        # Clean up any temporary files that might have been created
+        try:
+            if 'temp_init_path' in locals() and os.path.exists(temp_init_path):
+                os.unlink(temp_init_path)
+            if 'temp_schema_path' in locals() and os.path.exists(temp_schema_path):
+                os.unlink(temp_schema_path)
+        except:
+            pass  # Best effort cleanup
+        
+        # Re-raise the original exception
+        raise e
 
 
 def create_schema(
     spec: SchemaSpecDto
 ) -> None:
+    """
+    Create a schema with atomic directory and file operations.
+    
+    Tracks directory creation to enable cleanup on failure.
+    """
     full_path = os.path.dirname(os.path.abspath(__file__))
     folders = f"schemas.{spec['context']}.{spec['name']}".split(".")
-    for idx, folder in enumerate(folders):
-        if idx + 1 == len(folders):
-            # special handling for final level
-            add_schema_file(
-                full_path,
-                folder,
-                spec,
-            )
-        else:
-            full_path = os.path.join(full_path, folder)
-            if not os.path.exists(full_path):
-                os.makedirs(full_path)
-
-            # append to __init__.py file if nested folders
-            next = folders[idx + 1] if idx + 2 < len(folders) else ""
-            if next:
-                init_the_init(full_path, SCHEMA_CODE_IMPORTS)
-                add_import_to_init(full_path, next)
+    created_dirs = []  # Track directories we create for cleanup on failure
+    
+    try:
+        for idx, folder in enumerate(folders):
+            if idx + 1 == len(folders):
+                # special handling for final level
+                add_schema_file(
+                    full_path,
+                    folder,
+                    spec,
+                )
+            else:
+                full_path = os.path.join(full_path, folder)
+                if not os.path.exists(full_path):
+                    os.makedirs(full_path)
+                    created_dirs.append(full_path)  # Track for cleanup
+
+                # append to __init__.py file if nested folders
+                next = folders[idx + 1] if idx + 2 < len(folders) else ""
+                if next:
+                    init_the_init(full_path, SCHEMA_CODE_IMPORTS)
+                    add_import_to_init(full_path, next)
+                    
+    except Exception as e:
+        # Clean up directories we created (in reverse order)
+        for dir_path in reversed(created_dirs):
+            try:
+                if os.path.exists(dir_path) and not os.listdir(dir_path):  # Only remove if empty
+                    os.rmdir(dir_path)
+            except:
+                pass  # Best effort cleanup
+        
+        # Re-raise the original exception
+        raise e
 
 
 def add_schema_to_init(full_path: str, spec: SchemaSpecDto):

polyapi/prepare.py

@@ -1,5 +1,6 @@
 import os
 import sys
+import subprocess
 from typing import List, Tuple, Literal
 import requests
 
@@ -31,7 +32,7 @@ def get_server_function_description(description: str, arguments, code: str) -> s
     api_key, api_url = get_api_key_and_url()
     headers = get_auth_headers(api_key)
     data = {"description": description, "arguments": arguments, "code": code}
-    response = requests.post(f"{api_url}/server-function-description", headers=headers, json=data)
+    response = requests.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:
@@ -39,7 +40,7 @@ def get_client_function_description(description: str, arguments, code: str) -> s
     headers = get_auth_headers(api_key)
     # Simulated API call to generate client function descriptions
     data = {"description": description, "arguments": arguments, "code": code}
-    response = requests.post(f"{api_url}/client-function-description", headers=headers, json=data)
+    response = requests.post(f"{api_url}/functions/client/description-generation", headers=headers, json=data)
     return response.json()
 
 def fill_in_missing_function_details(deployable: DeployableRecord, code: str) -> DeployableRecord:
@@ -135,6 +136,16 @@ def prepare_deployables(lazy: bool = False, disable_docs: bool = False, disable_
         # NOTE: write_updated_deployable has side effects that update deployable.fileRevision which is in both this list and parsed_deployables
         for deployable in dirty_deployables:
             write_updated_deployable(deployable, disable_docs)
+        # Re-stage any updated staged files.
+        staged = subprocess.check_output('git diff --name-only --cached', shell=True, text=True, ).split('\n')
+        for deployable in dirty_deployables:
+            try:
+                if deployable["file"] in staged:
+                    print(f'Staging {deployable["file"]}')
+                    subprocess.run(['git', 'add', deployable["file"]])
+            except:
+                print('Warning: File staging failed, check that all files are staged properly.')
+
 
     print("Poly deployments are prepared.")
     save_deployable_records(parsed_deployables)

polyapi/schema.py

@@ -64,7 +64,7 @@ def wrapped_generate_schema_types(type_spec: dict, root, fallback_type):
         # {'$ref': '#/definitions/FinanceAccountListModel'}
         return fallback_type, ""
     except:
-        logging.error(f"Error when generating schema type: {type_spec}\nusing fallback type '{fallback_type}'")
+        logging.warning(f"WARNING parsing jsonschema failed: {type_spec}\nusing fallback type '{fallback_type}'")
         return fallback_type, ""
 
 
@@ -104,12 +104,26 @@ def generate_schema_types(input_data: Dict, root=None):
 # Regex to match everything between "# example: {\n" and "^}$"
 MALFORMED_EXAMPLES_PATTERN = re.compile(r"# example: \{\n.*?^\}$", flags=re.DOTALL | re.MULTILINE)
 
+# Regex to fix invalid escape sequences in docstrings
+INVALID_ESCAPE_PATTERNS = [
+    # Fix "\ " (backslash space) which is not a valid escape sequence
+    (re.compile(r'\\(\s)', re.DOTALL), r'\1'),
+    # Fix other common invalid escape sequences in docstrings
+    (re.compile(r'\\([^nrtbfav"\'\\])', re.DOTALL), r'\\\\\1'),
+]
+
 
 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,
-    it will break the code because the object won't be properly commented out
+    it will break the code because the object won't be properly commented out. Also fixes invalid escape sequences.
     """
+    # Remove malformed examples
     cleaned_example = MALFORMED_EXAMPLES_PATTERN.sub("", example)
+    
+    # Fix invalid escape sequences in docstrings
+    for pattern, replacement in INVALID_ESCAPE_PATTERNS:
+        cleaned_example = pattern.sub(replacement, cleaned_example)
+    
     return cleaned_example
 
 

polyapi/typedefs.py

@@ -78,6 +78,7 @@ Visibility = Union[Literal['PUBLIC'], Literal['TENANT'], Literal['ENVIRONMENT']]
 class PolyDeployable(TypedDict, total=False):
     context: str
     name: str
+    description: NotRequired[str]
     disable_ai: NotRequired[bool]  # Optional field to disable AI
 
 

polyapi/variables.py

@@ -1,4 +1,7 @@
 import os
+import logging
+import tempfile
+import shutil
 from typing import List
 
 from polyapi.schema import map_primitive_types
@@ -70,8 +73,21 @@ class {variable_name}:{get_method}
 
 
 def generate_variables(variables: List[VariableSpecDto]):
+    failed_variables = []
     for variable in variables:
-        create_variable(variable)
+        try:
+            create_variable(variable)
+        except Exception as e:
+            variable_path = f"{variable.get('context', 'unknown')}.{variable.get('name', 'unknown')}"
+            variable_id = variable.get('id', 'unknown')
+            failed_variables.append(f"{variable_path} (id: {variable_id})")
+            logging.warning(f"WARNING: Failed to generate variable {variable_path} (id: {variable_id}): {str(e)}")
+            continue
+    
+    if failed_variables:
+        logging.warning(f"WARNING: {len(failed_variables)} variable(s) failed to generate:")
+        for failed_var in failed_variables:
+            logging.warning(f"  - {failed_var}")
 
 
 def render_variable(variable: VariableSpecDto):
@@ -116,26 +132,84 @@ def _get_variable_type(type_spec: PropertyType) -> str:
 
 
 def create_variable(variable: VariableSpecDto) -> None:
+    """
+    Create a variable with atomic directory and file operations.
+    
+    Tracks directory creation to enable cleanup on failure.
+    """
     folders = ["vari"]
     if variable["context"]:
         folders += variable["context"].split(".")
 
     # build up the full_path by adding all the folders
     full_path = os.path.join(os.path.dirname(os.path.abspath(__file__)))
-
-    for idx, folder in enumerate(folders):
-        full_path = os.path.join(full_path, folder)
-        if not os.path.exists(full_path):
-            os.makedirs(full_path)
-        next = folders[idx + 1] if idx + 1 < len(folders) else None
-        if next:
-            add_import_to_init(full_path, next)
-
-    add_variable_to_init(full_path, variable)
+    created_dirs = []  # Track directories we create for cleanup on failure
+
+    try:
+        for idx, folder in enumerate(folders):
+            full_path = os.path.join(full_path, folder)
+            if not os.path.exists(full_path):
+                os.makedirs(full_path)
+                created_dirs.append(full_path)  # Track for cleanup
+            next = folders[idx + 1] if idx + 1 < len(folders) else None
+            if next:
+                add_import_to_init(full_path, next)
+
+        add_variable_to_init(full_path, variable)
+        
+    except Exception as e:
+        # Clean up directories we created (in reverse order)
+        for dir_path in reversed(created_dirs):
+            try:
+                if os.path.exists(dir_path) and not os.listdir(dir_path):  # Only remove if empty
+                    os.rmdir(dir_path)
+            except:
+                pass  # Best effort cleanup
+        
+        # Re-raise the original exception
+        raise e
 
 
 def add_variable_to_init(full_path: str, variable: VariableSpecDto):
-    init_the_init(full_path)
-    init_path = os.path.join(full_path, "__init__.py")
-    with open(init_path, "a") as f:
-        f.write(render_variable(variable) + "\n\n")
+    """
+    Atomically add a variable to __init__.py to prevent partial corruption during generation failures.
+    
+    This function generates all content first, then writes the file atomically using temporary files
+    to ensure that either the entire operation succeeds or no changes are made to the filesystem.
+    """
+    try:
+        init_the_init(full_path)
+        init_path = os.path.join(full_path, "__init__.py")
+        
+        # Generate variable content first
+        variable_content = render_variable(variable)
+        if not variable_content:
+            raise Exception("Variable rendering failed - empty content returned")
+        
+        # Read current __init__.py content if it exists
+        init_content = ""
+        if os.path.exists(init_path):
+            with open(init_path, "r") as f:
+                init_content = f.read()
+        
+        # Prepare new content to append
+        new_init_content = init_content + variable_content + "\n\n"
+        
+        # Write to temporary file first, then atomic move
+        with tempfile.NamedTemporaryFile(mode="w", delete=False, dir=full_path, suffix=".tmp") as temp_file:
+            temp_file.write(new_init_content)
+            temp_file_path = temp_file.name
+        
+        # Atomic operation: move temp file to final location
+        shutil.move(temp_file_path, init_path)
+        
+    except Exception as e:
+        # Clean up temporary file if it exists
+        try:
+            if 'temp_file_path' in locals() and os.path.exists(temp_file_path):
+                os.unlink(temp_file_path)
+        except:
+            pass  # Best effort cleanup
+        
+        # Re-raise the original exception
+        raise e

polyapi/webhook.py

@@ -2,6 +2,7 @@ import asyncio
 import socketio  # type: ignore
 from socketio.exceptions import ConnectionError  # type: ignore
 import uuid
+import logging
 from typing import Any, Dict, List, Tuple
 
 from polyapi.config import get_api_key_and_url
@@ -121,22 +122,27 @@ def render_webhook_handle(
     arguments: List[PropertySpecification],
     return_type: Dict[str, Any],
 ) -> Tuple[str, str]:
-    function_args, function_args_def = parse_arguments(function_name, arguments)
-
-    if "WebhookEventType" in function_args:
-        # let's add the function name import!
-        function_args = function_args.replace("WebhookEventType", f"{to_func_namespace(function_name)}.WebhookEventType")
-
-    func_str = WEBHOOK_TEMPLATE.format(
-        description=function_description,
-        client_id=uuid.uuid4().hex,
-        function_id=function_id,
-        function_name=function_name,
-        function_args=function_args,
-        function_path=poly_full_path(function_context, function_name),
-    )
-    func_defs = WEBHOOK_DEFS_TEMPLATE.format(function_args_def=function_args_def)
-    return func_str, func_defs
+    try:
+        function_args, function_args_def = parse_arguments(function_name, arguments)
+
+        if "WebhookEventType" in function_args:
+            # let's add the function name import!
+            function_args = function_args.replace("WebhookEventType", f"{to_func_namespace(function_name)}.WebhookEventType")
+
+        func_str = WEBHOOK_TEMPLATE.format(
+            description=function_description,
+            client_id=uuid.uuid4().hex,
+            function_id=function_id,
+            function_name=function_name,
+            function_args=function_args,
+            function_path=poly_full_path(function_context, function_name),
+        )
+        func_defs = WEBHOOK_DEFS_TEMPLATE.format(function_args_def=function_args_def)
+        return func_str, func_defs
+    except Exception as e:
+        logging.warning(f"Failed to render webhook handle {function_context}.{function_name} (id: {function_id}): {str(e)}")
+        # Return empty strings to indicate generation failure - this will be caught by generate_functions error handling
+        return "", ""
 
 
 def start(*args):

{polyapi_python-0.3.7.dev7.dist-info → polyapi_python-0.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.7.dev7
+Version: 0.3.8
 Summary: The Python Client for PolyAPI, the IPaaS by Developers for Developers
 Author-email: Dan Fellin <dan@polyapi.io>
 License: MIT License
@@ -31,7 +31,7 @@ License-File: LICENSE
 Requires-Dist: requests>=2.32.3
 Requires-Dist: typing_extensions>=4.12.2
 Requires-Dist: jsonschema-gentypes==2.6.0
-Requires-Dist: pydantic==2.6.4
+Requires-Dist: pydantic>=2.8.0
 Requires-Dist: stdlib_list==0.10.0
 Requires-Dist: colorama==0.4.4
 Requires-Dist: python-socketio[asyncio_client]==5.11.1
@@ -206,3 +206,4 @@ Please ignore \[name-defined\] errors for now. This is a known bug we are workin
 ## Support
 
 If you run into any issues or want help getting started with this project, please contact support@polyapi.io
+.

polyapi_python-0.3.8.dist-info/RECORD

@@ -0,0 +1,31 @@
+polyapi/__init__.py,sha256=hw7x4j9JNJfPdkIOZqV0X9pbYcw3_5AH1iQFdSogH-c,3235
+polyapi/__main__.py,sha256=V4zhAh_YGxno5f_KSrlkELxcuDh9bR3WSd0n-2r-qQQ,93
+polyapi/api.py,sha256=2nds6ZdNe9OHvCba4IjOPga0CAYIsib2SbhEyDDCmd8,2188
+polyapi/auth.py,sha256=zrIGatjba5GwUTNjKj1GHQWTEDP9B-HrSzCKbLFoqvc,5336
+polyapi/cli.py,sha256=unKqAoZ1hTGAeyYRfNQ6jO15Um7N4F95k__1qFue5bI,10659
+polyapi/client.py,sha256=DW6ljG_xCwAo2yz23A9QfLooE6ZUDvSpdA4e_dCQjiQ,1418
+polyapi/config.py,sha256=cAMv2n9tGN_BTvqt7V32o5F86qRhxAKyey_PoId2D8s,7638
+polyapi/constants.py,sha256=sc-FnS0SngBLvSu1ZWMs0UCf9EYD1u1Yhfr-sZXGLns,607
+polyapi/deployables.py,sha256=8x-Y7MlpWnTqsWhidmO6yVZe2nTChzma6hJNVsfg94s,12113
+polyapi/error_handler.py,sha256=I_e0iz6VM23FLVQWJljxs2NGcl_OODbi43OcbnqBlp8,2398
+polyapi/exceptions.py,sha256=Zh7i7eCUhDuXEdUYjatkLFTeZkrx1BJ1P5ePgbJ9eIY,89
+polyapi/execute.py,sha256=sjI6BMBYPSCD6UngV9DzpJIRSU6p02aShNaTXhDExtY,3457
+polyapi/function_cli.py,sha256=H0sVrbvRBXw_xeApe2MvQw8p_xE7jVTTOU-07Dg041A,4220
+polyapi/generate.py,sha256=slCw9AOvQHQ8UtEaumFI1NoRvjH2Dj3Y33u7imQqi8c,19521
+polyapi/parser.py,sha256=20ZE7kSXx3UL7QVSIYYxzsnJlygVbsaDAg9q7c41WxQ,20695
+polyapi/poly_schemas.py,sha256=760g-rBou-XT0y7N0THHHJBHlqIrOhVsAj500T6Qp0Q,8994
+polyapi/prepare.py,sha256=pRWBhpgqMtKP04P9F6PIA3eCkOpCxQSv9TZdR3qR34I,7216
+polyapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+polyapi/rendered_spec.py,sha256=nJEj2vRgG3N20fU4s-ThRtOIwAuTzXwXuOBIkXljDVc,2240
+polyapi/schema.py,sha256=zMN0zr_dku-NzmL8e0C6lbym8I0SrzXxtU5I8-YwHkM,5291
+polyapi/server.py,sha256=YXWxhYBx-hluwDQ8Jvfpy2s8ogz0GsNTMcZVNcP5ca8,2147
+polyapi/sync.py,sha256=PGdC0feBBjEVrF3d9EluW_OAxbWuzSrfh84czma8kWg,6476
+polyapi/typedefs.py,sha256=vJLZYBNmR3i8yQEDYlu1UfvtJyg6E1R1QyGlgFUm2rU,2362
+polyapi/utils.py,sha256=1F7Dwst_PbPuUBUSxx5r8d2DHDgqHtu07QW92T_YSdw,12454
+polyapi/variables.py,sha256=VAp2d5I-4WLYHCPF1w3pqU4-z8_XRQpYW-ddOw6G5S4,7268
+polyapi/webhook.py,sha256=gWYXHz0PnB_uY_lnHeUlg3EIHfTGwF-Tc6UaatldZBw,5333
+polyapi_python-0.3.8.dist-info/licenses/LICENSE,sha256=6b_I7aPVp8JXhqQwdw7_B84Ca0S4JGjHj0sr_1VOdB4,1068
+polyapi_python-0.3.8.dist-info/METADATA,sha256=lGwPvkCNQgjTRTVpdJ9hjfUgpVhQ8RLJx7rVuOfLk-M,5779
+polyapi_python-0.3.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+polyapi_python-0.3.8.dist-info/top_level.txt,sha256=CEFllOnzowci_50RYJac-M54KD2IdAptFsayVVF_f04,8
+polyapi_python-0.3.8.dist-info/RECORD,,

polyapi_python-0.3.7.dev7.dist-info/RECORD

@@ -1,31 +0,0 @@
-polyapi/__init__.py,sha256=hw7x4j9JNJfPdkIOZqV0X9pbYcw3_5AH1iQFdSogH-c,3235
-polyapi/__main__.py,sha256=V4zhAh_YGxno5f_KSrlkELxcuDh9bR3WSd0n-2r-qQQ,93
-polyapi/api.py,sha256=2nds6ZdNe9OHvCba4IjOPga0CAYIsib2SbhEyDDCmd8,2188
-polyapi/auth.py,sha256=zrIGatjba5GwUTNjKj1GHQWTEDP9B-HrSzCKbLFoqvc,5336
-polyapi/cli.py,sha256=jtKXARbT9AOgYTR6nf3OiwiPvsyUlLVbyynEA84PDzw,8924
-polyapi/client.py,sha256=CoFDYvyKsqL4wPQbUDIr0Qb8Q5eD92xN4OEEcJEVuGQ,1296
-polyapi/config.py,sha256=QQxRZ9nMUykItUMAdw97dad0DPEV1luRwkeqOyrEKf8,4316
-polyapi/constants.py,sha256=sc-FnS0SngBLvSu1ZWMs0UCf9EYD1u1Yhfr-sZXGLns,607
-polyapi/deployables.py,sha256=WVcNNB6W5ZW_-ukf_kK3moRcnwIkC-O4te6vLepjcco,11936
-polyapi/error_handler.py,sha256=I_e0iz6VM23FLVQWJljxs2NGcl_OODbi43OcbnqBlp8,2398
-polyapi/exceptions.py,sha256=Zh7i7eCUhDuXEdUYjatkLFTeZkrx1BJ1P5ePgbJ9eIY,89
-polyapi/execute.py,sha256=sjI6BMBYPSCD6UngV9DzpJIRSU6p02aShNaTXhDExtY,3457
-polyapi/function_cli.py,sha256=hv5K5niegqitT6VwbS7M5ec3nEMyqwVtE6tcpwHoxIk,4125
-polyapi/generate.py,sha256=1ZwcUEfhYLc64Wh5aYhvU6P594HOL2LYycPKkH39frc,15394
-polyapi/parser.py,sha256=mdoh4pNq8pyiHE0-i6Coqj8frEXfBLRk6itpAXMrrgI,20373
-polyapi/poly_schemas.py,sha256=T4kfZyfgVLiqLD28GmYNiHnrNx77J_HO4uzk8LUAhlo,3137
-polyapi/prepare.py,sha256=Q8CWV4kmZ2dbXYVsud34AgJkj5ymcQ_IcYhLuikc9yk,6659
-polyapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-polyapi/rendered_spec.py,sha256=nJEj2vRgG3N20fU4s-ThRtOIwAuTzXwXuOBIkXljDVc,2240
-polyapi/schema.py,sha256=K5oAELfyAU3kuo1wSkTvNiA_Ppt2JCJwyg8F8XtLDU4,4707
-polyapi/server.py,sha256=YXWxhYBx-hluwDQ8Jvfpy2s8ogz0GsNTMcZVNcP5ca8,2147
-polyapi/sync.py,sha256=PGdC0feBBjEVrF3d9EluW_OAxbWuzSrfh84czma8kWg,6476
-polyapi/typedefs.py,sha256=MGDwWaijLNqokXF9UCHGAP-yKixOzztrH4Lsj800AJs,2328
-polyapi/utils.py,sha256=1F7Dwst_PbPuUBUSxx5r8d2DHDgqHtu07QW92T_YSdw,12454
-polyapi/variables.py,sha256=j7WWrGLr2O5SkWGxnsusnnfl25kVL3b6SQYcVGEoC8c,4277
-polyapi/webhook.py,sha256=NTSXYOl_QqsFekWRepPyVTsV9SVkgUu0HfG1SJJDHOE,4958
-polyapi_python-0.3.7.dev7.dist-info/licenses/LICENSE,sha256=6b_I7aPVp8JXhqQwdw7_B84Ca0S4JGjHj0sr_1VOdB4,1068
-polyapi_python-0.3.7.dev7.dist-info/METADATA,sha256=EeHNEwtPyswzeR1PoEXRKCgj0lEPA6Ak--1_pxmJjUo,5782
-polyapi_python-0.3.7.dev7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-polyapi_python-0.3.7.dev7.dist-info/top_level.txt,sha256=CEFllOnzowci_50RYJac-M54KD2IdAptFsayVVF_f04,8
-polyapi_python-0.3.7.dev7.dist-info/RECORD,,