polyapi-python 0.3.7.dev6__tar.gz → 0.3.8__tar.gz

{polyapi_python-0.3.7.dev6/polyapi_python.egg-info → polyapi_python-0.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.7.dev6
+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.7.dev6 → polyapi_python-0.3.8}/README.md

@@ -165,4 +165,5 @@ 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
+If you run into any issues or want help getting started with this project, please contact support@polyapi.io
+.

{polyapi_python-0.3.7.dev6 → polyapi_python-0.3.8}/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_python-0.3.7.dev6 → polyapi_python-0.3.8}/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_python-0.3.7.dev6 → polyapi_python-0.3.8}/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_python-0.3.7.dev6 → polyapi_python-0.3.8}/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_python-0.3.7.dev6 → polyapi_python-0.3.8}/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_python-0.3.7.dev6 → polyapi_python-0.3.8}/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_python-0.3.7.dev6 → polyapi_python-0.3.8}/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.")