polyapi-python 0.3.8.dev9__tar.gz → 0.3.9__tar.gz

{polyapi_python-0.3.8.dev9 → polyapi_python-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyapi-python
-Version: 0.3.8.dev9
+Version: 0.3.9
 Summary: The Python Client for PolyAPI, the IPaaS by Developers for Developers
 Author-email: Dan Fellin <dan@polyapi.io>
 License: MIT License
@@ -32,10 +32,10 @@ Requires-Dist: requests>=2.32.3
 Requires-Dist: typing_extensions>=4.12.2
 Requires-Dist: jsonschema-gentypes==2.6.0
 Requires-Dist: pydantic>=2.8.0
-Requires-Dist: stdlib_list==0.10.0
+Requires-Dist: stdlib_list>=0.10.0
 Requires-Dist: colorama==0.4.4
 Requires-Dist: python-socketio[asyncio_client]==5.11.1
-Requires-Dist: truststore==0.8.0
+Requires-Dist: truststore>=0.8.0
 Dynamic: license-file
 
 # PolyAPI Python Library
@@ -110,24 +110,6 @@ def bar():
     return "Hello World"
 ```
 
-## See Server Function Logs
-
-In order to see function logs, please first set `logsEnabled` to `true` in Canopy for the function.
-
-https://na1.polyapi.io/canopy/polyui/collections/server-functions
-
-Then in your code, get the poly logger and log with it like so:
-
-```python
-logger = logging.getLogger("poly")
-def bar():
-    logger.warning("I AM THE LOG")
-    return "Hello World"
-```
-
-Finally, click the "Show Logs" button to see your server function logs in Canopy!
-
-
 ## Complex Types In Server Functions
 
 You can define arbitrarily complex argument and return types using TypedDicts.
@@ -206,3 +188,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.dev9 → polyapi_python-0.3.9}/README.md

@@ -70,24 +70,6 @@ def bar():
     return "Hello World"
 ```
 
-## See Server Function Logs
-
-In order to see function logs, please first set `logsEnabled` to `true` in Canopy for the function.
-
-https://na1.polyapi.io/canopy/polyui/collections/server-functions
-
-Then in your code, get the poly logger and log with it like so:
-
-```python
-logger = logging.getLogger("poly")
-def bar():
-    logger.warning("I AM THE LOG")
-    return "Hello World"
-```
-
-Finally, click the "Show Logs" button to see your server function logs in Canopy!
-
-
 ## Complex Types In Server Functions
 
 You can define arbitrarily complex argument and return types using TypedDicts.
@@ -165,4 +147,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.8.dev9 → polyapi_python-0.3.9}/polyapi/auth.py

@@ -1,5 +1,4 @@
 from typing import List, Dict, Any, Tuple
-import uuid
 
 from polyapi.typedefs import PropertySpecification
 from polyapi.utils import parse_arguments, get_type_and_def
@@ -26,7 +25,8 @@ async def getToken(clientId: str, clientSecret: str, scopes: List[str], callback
 
     Function ID: {function_id}
     \"""
-    eventsClientId = "{client_id}"
+    from polyapi.poly.client_id import client_id
+    eventsClientId = client_id
     function_id = "{function_id}"
 
     options = options or {{}}
@@ -165,7 +165,7 @@ def render_auth_function(
     func_str = ""
 
     if function_name == "getToken":
-        func_str = GET_TOKEN_TEMPLATE.format(function_id=function_id, description=function_description, client_id=uuid.uuid4().hex)
+        func_str = GET_TOKEN_TEMPLATE.format(function_id=function_id, description=function_description)
     elif function_name == "introspectToken":
         func_str = INTROSPECT_TOKEN_TEMPLATE.format(function_id=function_id, description=function_description)
     elif function_name == "refreshToken":

{polyapi_python-0.3.8.dev9 → polyapi_python-0.3.9}/polyapi/deployables.py

@@ -1,4 +1,6 @@
 import os
+import string
+import random
 import subprocess
 import json
 import hashlib
@@ -65,20 +67,21 @@ class SyncDeployment(TypedDict, total=False):
     context: str
     name: str
     description: str
-    type: str
+    type: DeployableTypes
     fileRevision: str
     file: str
     types: DeployableFunctionTypes
-    typeSchemas: Dict[str, any]
+    typeSchemas: Dict[str, Any]
     dependencies: List[str]
-    config: Dict[str, any]
+    config: Dict[str, Any]
     instance: str
-    id: Optional[str] = None
-    deployed: Optional[str] = None
+    id: Optional[str]
+    deployed: Optional[str]
+
 
 DeployableTypeEntries: List[Tuple[DeployableTypeNames, DeployableTypes]] = [
-    ("PolyServerFunction", "server-function"),
-    ("PolyClientFunction", "client-function"),
+    ("PolyServerFunction", "server-function"),  # type: ignore
+    ("PolyClientFunction", "client-function"),  # type: ignore
 ]
 
 DeployableTypeToName: Dict[DeployableTypeNames, DeployableTypes] = {name: type for name, type in DeployableTypeEntries}
@@ -118,13 +121,13 @@ def get_all_deployable_files_windows(config: PolyDeployConfig) -> List[str]:
     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 /S /M /I /F:/ {pattern} *.*"
+    search_command = f" | findstr /M /I /F:/ {pattern}"
 
     result = []
     for dir_path in config["include_dirs"]:
         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"
+        dir_command = f"dir {include_pattern} /S /P /B"
         full_command = f"{dir_command}{exclude_command}{search_command}"
         try:
             output = subprocess.check_output(full_command, shell=True, text=True)
@@ -175,7 +178,7 @@ def get_git_revision(branch_or_tag: str = "HEAD") -> str:
         return check_output(["git", "rev-parse", "--short", branch_or_tag], text=True).strip()
     except CalledProcessError:
         # Return a random 7-character hash as a fallback
-        return "".join(format(ord(c), 'x') for c in os.urandom(4))[:7]
+        return "".join([random.choice(string.ascii_letters + string.digits) for _ in range(7)])
 
 def get_cache_deployments_revision() -> str:
     """Retrieve the cache deployments revision from a file."""

{polyapi_python-0.3.8.dev9 → polyapi_python-0.3.9}/polyapi/execute.py

@@ -1,9 +1,13 @@
 from typing import Dict, Optional
 import requests
+import os
+import logging
 from requests import Response
 from polyapi.config import get_api_key_and_url, get_mtls_config
 from polyapi.exceptions import PolyApiException
 
+logger = logging.getLogger("poly")
+
 def direct_execute(function_type, function_id, data) -> Response:
     """ execute a specific function id/type
     """
@@ -13,7 +17,11 @@ def direct_execute(function_type, function_id, data) -> Response:
     
     endpoint_info = requests.post(url, json=data, headers=headers)
     if endpoint_info.status_code < 200 or endpoint_info.status_code >= 300:
-        raise PolyApiException(f"{endpoint_info.status_code}: {endpoint_info.content.decode('utf-8', errors='ignore')}")
+        error_content = endpoint_info.content.decode("utf-8", errors="ignore")
+        if function_type == 'api' and os.getenv("LOGS_ENABLED"):
+            raise PolyApiException(f"Error executing api function with id: {function_id}. Status code: {endpoint_info.status_code}. Request data: {data}, Response: {error_content}")
+        elif function_type != 'api':
+            raise PolyApiException(f"{endpoint_info.status_code}: {error_content}")
     
     endpoint_info_data = endpoint_info.json()
     request_params = endpoint_info_data.copy()
@@ -38,9 +46,12 @@ def direct_execute(function_type, function_id, data) -> Response:
             **request_params
         )
 
-    if resp.status_code < 200 or resp.status_code >= 300:
+    if (resp.status_code < 200 or resp.status_code >= 300):
         error_content = resp.content.decode("utf-8", errors="ignore")
-        raise PolyApiException(f"{resp.status_code}: {error_content}")
+        if function_type == 'api' and os.getenv("LOGS_ENABLED"):
+            logger.error(f"Error executing api function with id: {function_id}. Status code: {resp.status_code}. Request data: {data}, Response: {error_content}")
+        elif function_type != 'api':   
+            raise PolyApiException(f"{resp.status_code}: {error_content}")    
     
     return resp
 
@@ -59,9 +70,12 @@ def execute(function_type, function_id, data) -> Response:
         headers=headers,
     )
 
-    if resp.status_code < 200 or resp.status_code >= 300:
+    if (resp.status_code < 200 or resp.status_code >= 300) and os.getenv("LOGS_ENABLED"):
         error_content = resp.content.decode("utf-8", errors="ignore")
-        raise PolyApiException(f"{resp.status_code}: {error_content}")
+        if function_type == 'api' and os.getenv("LOGS_ENABLED"):
+            logger.error(f"Error executing api function with id: {function_id}. Status code: {resp.status_code}. Request data: {data}, Response: {error_content}")
+        elif function_type != 'api':
+            raise PolyApiException(f"{resp.status_code}: {error_content}")
 
     return resp
 

{polyapi_python-0.3.8.dev9 → polyapi_python-0.3.9}/polyapi/generate.py

@@ -1,9 +1,12 @@
 import json
 import requests
 import os
+import uuid
 import shutil
 import logging
 import tempfile
+
+from copy import deepcopy
 from typing import Any, List, Optional, Tuple, cast
 
 from .auth import render_auth_function
@@ -11,11 +14,12 @@ from .client import render_client_function
 from .poly_schemas import generate_schemas
 from .webhook import render_webhook_handle
 
-from .typedefs import PropertySpecification, SchemaSpecDto, SpecificationDto, VariableSpecDto
+from .typedefs import PropertySpecification, SchemaSpecDto, SpecificationDto, VariableSpecDto, TableSpecDto
 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 .poly_tables import generate_tables
 from .config import get_api_key_and_url, get_direct_execute_config, get_cached_generate_args
 
 SUPPORTED_FUNCTION_TYPES = {
@@ -26,7 +30,7 @@ SUPPORTED_FUNCTION_TYPES = {
     "webhookHandle",
 }
 
-SUPPORTED_TYPES = SUPPORTED_FUNCTION_TYPES | {"serverVariable", "schema", "snippet"}
+SUPPORTED_TYPES = SUPPORTED_FUNCTION_TYPES | {"serverVariable", "schema", "snippet", "table"}
 
 
 X_POLY_REF_WARNING = '''"""
@@ -136,19 +140,22 @@ def parse_function_specs(
     limit_ids: List[str] | None = None,  # optional list of ids to limit to
 ) -> List[SpecificationDto]:
     functions = []
-    for spec in specs:
-        if not spec:
+    for raw_spec in specs:
+        if not raw_spec:
             continue
 
         # For no_types mode, we might not have function data, but we still want to include the spec
         # if it's a supported function type
-        if spec["type"] not in SUPPORTED_FUNCTION_TYPES:
+        if raw_spec["type"] not in SUPPORTED_FUNCTION_TYPES:
             continue
 
         # Skip if we have a limit and this spec is not in it
-        if limit_ids and spec.get("id") not in limit_ids:
+        if limit_ids and raw_spec.get("id") not in limit_ids:
             continue
 
+        # Should really be fixed in specs api, but for now handle json strings in arg schemas
+        spec = normalize_args_schema(raw_spec)
+
         # For customFunction, check language if we have function data
         if spec["type"] == "customFunction":
             if spec.get("language") and spec["language"] != "python":
@@ -190,16 +197,18 @@ def read_cached_specs() -> List[SpecificationDto]:
         return json.loads(f.read())
 
 
-def get_variables() -> List[VariableSpecDto]:
-    specs = read_cached_specs()
+def get_variables(specs: List[SpecificationDto]) -> List[VariableSpecDto]:
     return [cast(VariableSpecDto, spec) for spec in specs if spec["type"] == "serverVariable"]
 
 
-def get_schemas() -> List[SchemaSpecDto]:
-    specs = read_cached_specs()
+def get_schemas(specs: List[SpecificationDto]) -> List[SchemaSpecDto]:
     return [cast(SchemaSpecDto, spec) for spec in specs if spec["type"] == "schema"]
 
 
+def get_tables(specs: List[SpecificationDto]) -> List[TableSpecDto]:
+    return [cast(TableSpecDto, spec) for spec in specs if spec["type"] == "table"]
+
+
 def remove_old_library():
     currdir = os.path.dirname(os.path.abspath(__file__))
     path = os.path.join(currdir, "poly")
@@ -214,6 +223,10 @@ def remove_old_library():
     if os.path.exists(path):
         shutil.rmtree(path)
 
+    path = os.path.join(currdir, "tabi")
+    if os.path.exists(path):
+        shutil.rmtree(path)
+
 
 def create_empty_schemas_module():
     """Create an empty schemas module for no-types mode so user code can still import from polyapi.schemas"""
@@ -272,6 +285,14 @@ sys.modules[__name__] = _SchemaModule()
 ''')
 
 
+def _generate_client_id() -> None:
+    full_path = os.path.dirname(os.path.abspath(__file__))
+    full_path = os.path.join(full_path, "poly", "client_id.py")
+    with open(full_path, "w") as f:
+        f.write(f'client_id = "{uuid.uuid4().hex}"')
+
+
+
 def generate_from_cache() -> None:
     """
     Generate using cached values after non-explicit call.
@@ -286,6 +307,37 @@ def generate_from_cache() -> None:
     )
 
 
+def _parse_arg_schema(value: Any) -> Any:
+    if isinstance(value, str):
+        text = value.strip()
+        if text and text[0] in "{[":
+            try:
+                return json.loads(text)
+            except json.JSONDecodeError:
+                logging.warning("Could not parse function argument schema (leaving as str): %s", text[:200])
+    return value
+
+
+def normalize_args_schema(
+    raw_spec: SpecificationDto
+) -> SpecificationDto:
+    spec = deepcopy(raw_spec)
+
+    function_block = spec.get("function")
+    if not isinstance(function_block, dict):
+        return spec
+    arguments_block = function_block.get("arguments")
+    if not isinstance(arguments_block, list):
+        return spec
+
+    for argument in arguments_block:
+        arg_type = argument.get("type")
+        if isinstance(arg_type, dict) and "schema" in arg_type:
+            arg_type["schema"] = _parse_arg_schema(arg_type["schema"])
+
+    return spec
+
+
 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)
@@ -297,9 +349,11 @@ def generate(contexts: Optional[List[str]] = None, names: Optional[List[str]] =
     limit_ids: List[str] = []  # useful for narrowing down generation to a single function to debug
     functions = parse_function_specs(specs, limit_ids=limit_ids)
 
+    _generate_client_id()
+
     # Only process schemas if no_types is False
     if not no_types:
-        schemas = get_schemas()
+        schemas = get_schemas(specs)
         schema_index = build_schema_index(schemas)
         if schemas:
             schema_limit_ids: List[str] = []  # useful for narrowing down generation to a single function to debug
@@ -323,7 +377,11 @@ def generate(contexts: Optional[List[str]] = None, names: Optional[List[str]] =
         )
         exit()
 
-    variables = get_variables()
+    tables = get_tables(specs)
+    if tables:
+        generate_tables(tables)
+
+    variables = get_variables(specs)
     if variables:
         generate_variables(variables)
 
@@ -335,14 +393,7 @@ def generate(contexts: Optional[List[str]] = None, names: Optional[List[str]] =
 
 
 def clear() -> None:
-    base = os.path.dirname(os.path.abspath(__file__))
-    poly_path = os.path.join(base, "poly")
-    if os.path.exists(poly_path):
-        shutil.rmtree(poly_path)
-
-    vari_path = os.path.join(base, "vari")
-    if os.path.exists(vari_path):
-        shutil.rmtree(vari_path)
+    remove_old_library()
     print("Cleared!")
 
 

{polyapi_python-0.3.8.dev9 → polyapi_python-0.3.9}/polyapi/poly_schemas.py

@@ -25,11 +25,13 @@ 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:
                 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')
@@ -40,6 +42,7 @@ def generate_schemas(specs: List[SchemaSpecDto], limit_ids: List[str] = None):
         for spec in specs:
             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')
@@ -51,6 +54,37 @@ def generate_schemas(specs: List[SchemaSpecDto], limit_ids: List[str] = None):
         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(
@@ -75,9 +109,9 @@ def add_schema_file(
 
         schema_defs = render_poly_schema(spec)
 
-        if not schema_defs:
-            # If render_poly_schema failed and returned empty string, don't create any files
-            raise Exception("Schema rendering failed - empty schema content returned")
+        # 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)
@@ -87,7 +121,7 @@ def add_schema_file(
         # Read current __init__.py content if it exists
         init_content = ""
         if os.path.exists(init_path):
-            with open(init_path, "r") as f:
+            with open(init_path, "r", encoding='utf-8') as f:
                 init_content = f.read()
         
         # Prepare new content to append to __init__.py
@@ -95,12 +129,12 @@ def add_schema_file(
         
         # 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:
+        with tempfile.NamedTemporaryFile(mode="w", delete=False, dir=full_path, suffix=".tmp", encoding='utf-8') 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:
+        with tempfile.NamedTemporaryFile(mode="w", delete=False, dir=full_path, suffix=".tmp", encoding='utf-8') as temp_schema:
             temp_schema.write(schema_defs)
             temp_schema_path = temp_schema.name
         
@@ -171,7 +205,7 @@ def create_schema(
 def add_schema_to_init(full_path: str, spec: SchemaSpecDto):
     init_the_init(full_path, code_imports="")
     init_path = os.path.join(full_path, "__init__.py")
-    with open(init_path, "a") as f:
+    with open(init_path, "a", encoding='utf-8') as f:
         f.write(render_poly_schema(spec) + "\n\n")