polyapi-python 0.3.1.dev1__py3-none-any.whl → 0.3.1.dev3__py3-none-any.whl

polyapi/__init__.py

@@ -16,8 +16,8 @@ if len(sys.argv) > 1 and sys.argv[1] not in CLI_COMMANDS:
 
 
 polyCustom: Dict[str, Any] = {
-  "executionId": None,
-  "executionApiKey": None,
-  "responseStatusCode": 200,
-  "responseContentType": None,
+    "executionId": None,
+    "executionApiKey": None,
+    "responseStatusCode": 200,
+    "responseContentType": None,
 }

polyapi/cli.py

@@ -1,73 +1,186 @@
+import os
 import argparse
 
-from polyapi.utils import print_green
+from polyapi.utils import print_green, print_red
 
 from .config import initialize_config, set_api_key_and_url
 from .generate import generate, clear
 from .function_cli import function_add_or_update, function_execute
 from .rendered_spec import get_and_update_rendered_spec
+from .prepare import prepare_deployables
+from .sync import sync_deployables
 
 
 CLI_COMMANDS = ["setup", "generate", "function", "clear", "help", "update_rendered_spec"]
 
-CLIENT_DESC = """Commands
-  python -m polyapi setup                Setup your Poly connection
-  python -m polyapi generate             Generates Poly library
-  python -m polyapi function <command>   Manages functions
-  python -m polyapi clear                Clear current generated Poly library
-"""
-
-
-def execute_from_cli() -> None:
+def execute_from_cli():
+    # First we setup all our argument parsing logic
+    # Then we parse the arguments (waaay at the bottom)
     parser = argparse.ArgumentParser(
-        prog="python -m polyapi", description=CLIENT_DESC, formatter_class=argparse.RawTextHelpFormatter
+        prog="python -m polyapi",
+        description="Manage your Poly API configurations and functions",
+        formatter_class=argparse.RawTextHelpFormatter
     )
-    parser.add_argument("--context", required=False, default="")
-    parser.add_argument("--description", required=False, default="")
-    parser.add_argument("--client", action="store_true", help="Pass --client when adding function to add a client function.")
-    parser.add_argument("--server", action="store_true", help="Pass --server when adding function to add a server function.")
-    parser.add_argument("--logs", choices=["enabled", "disabled"], default="disabled", help="Enable or disable logs for the function.")
-    parser.add_argument("--skip-generate", action="store_true", help="Pass --skip-generate to skip generating the library after adding a function.")
-    parser.add_argument("--execution-api-key", required=False, default="", help="API key for execution (for server functions only).")
-    parser.add_argument("command", choices=CLI_COMMANDS)
-    parser.add_argument("subcommands", nargs="*")
-    args = parser.parse_args()
-    command = args.command
-
-    if command == "help":
-        parser.print_help()
-    elif command == "generate":
+    
+    subparsers = parser.add_subparsers(help="Available commands")
+
+    ###########################################################################
+    # Setup command
+    setup_parser = subparsers.add_parser("setup", help="Setup your Poly connection")
+    setup_parser.add_argument("api_key", nargs="?", help="API key for Poly API")
+    setup_parser.add_argument("url", nargs="?", help="URL for the Poly API")
+
+    def setup(args):
+        if args.api_key and args.url:
+            set_api_key_and_url(args.url, args.api_key)
+        else:
+            initialize_config(force=True)
+            generate()
+
+    setup_parser.set_defaults(command=setup)
+
+
+    ###########################################################################
+    # Generate command
+    generate_parser = subparsers.add_parser("generate", help="Generates Poly library")
+
+    def generate_command(args):
+        initialize_config()
         print("Generating Poly functions...", end="")
         generate()
         print_green("DONE")
-    elif command == "setup" and len(args.subcommands) == 2:
-        set_api_key_and_url(args.subcommands[1], args.subcommands[0])
-    elif command == "setup":
-        initialize_config(force=True)
-        generate()
-    elif command == "update_rendered_spec":
-        assert len(args.subcommands) == 1
-        updated = get_and_update_rendered_spec(args.subcommands[0])
+
+    generate_parser.set_defaults(command=generate_command)
+
+
+    ###########################################################################
+    # Function commands
+    fn_parser = subparsers.add_parser("function", help="Manage and execute functions")
+    fn_subparsers = fn_parser.add_subparsers(help="Available commands")
+
+    # Function - Add command
+    fn_add_parser = fn_subparsers.add_parser("add", help="Add or update the function")
+    fn_add_parser.add_argument("name", help="Name of the function")
+    fn_add_parser.add_argument("file", help="Path to the function file")
+    fn_add_parser.add_argument("--context", required=False, default="", help="Context of the function")
+    fn_add_parser.add_argument("--description", required=False, default="", help="Description of the function")
+    fn_add_parser.add_argument("--server", action="store_true", help="Marks the function as a server function")
+    fn_add_parser.add_argument("--client", action="store_true", help="Marks the function as a client function")
+    fn_add_parser.add_argument("--logs", choices=["enabled", "disabled"], default="disabled", help="Enable or disable logs for the function.")
+    fn_add_parser.add_argument("--execution-api-key", required=False, default="", help="API key for execution (for server functions only).")
+    fn_add_parser.add_argument("--disable-ai", "--skip-generate", action="store_true", help="Pass --disable-ai skip AI generation of missing descriptions")
+
+    def add_function(args):
+        initialize_config()
+        logs_enabled = args.logs == "enabled"
+        err = ""
+        if args.server and args.client:
+            err = "Specify either `--server` or `--client`. Found both."
+        elif not args.server and not args.client:
+            err = "You must specify `--server` or `--client`."
+        elif logs_enabled and not args.server:
+            err = "Option `logs` is only for server functions (--server)."
+
+        if err:
+            print_red("ERROR")
+            print(err)
+            exit(1)
+
+        function_add_or_update(
+            context=args.context,
+            description=args.description,
+            client=args.client,
+            server=args.server,
+            logs_enabled=logs_enabled,
+            generate=not args.disable_ai,
+            execution_api_key=args.execution_api_key
+        )
+
+    fn_add_parser.set_defaults(command=add_function)
+
+
+    # Function - Execute command
+    fn_exec_parser = fn_subparsers.add_parser("execute", help="Execute a function with the provided arguments")
+    fn_exec_parser.add_argument("name", help="Name of the function")
+    fn_exec_parser.add_argument("args", nargs="*", help="Arguments for the function")
+    fn_exec_parser.add_argument("--context", required=False, default="", help="Context of the function")
+
+    def execute_function(args):
+        initialize_config()
+        print(function_execute(args.context, args.name, args.args))
+
+    fn_exec_parser.set_defaults(command=execute_function)
+
+
+    ###########################################################################
+    # Clear command
+    clear_parser = subparsers.add_parser("clear", help="Clear current generated Poly library")
+
+    def clear_command(_):
+        print("Clearing the generated library...")
+        clear()
+
+    clear_parser.set_defaults(command=clear_command)
+
+
+    ###########################################################################
+    # Update rendered spec command
+    update_spec_parser = subparsers.add_parser("update_rendered_spec", help="Update the rendered spec file")
+    update_spec_parser.add_argument("spec", help="Specification file to update")
+
+    def update_rendered_spec(args):
+        updated = get_and_update_rendered_spec(args.spec)
         if updated:
             print("Updated rendered spec!")
         else:
             print("Failed to update rendered spec!")
             exit(1)
-    elif command == "clear":
-        print("Clearing the generated library...")
-        clear()
-    elif command == "function":
-        logs_enabled = args.logs == "enabled"
-        if args.subcommands[0] == "execute":
-            print(function_execute(args.context, args.subcommands))
-        else:
-            function_add_or_update(
-                context=args.context,
-                description=args.description,
-                client=args.client,
-                server=args.server,
-                logs_enabled=logs_enabled,
-                subcommands=args.subcommands,
-                generate=not args.skip_generate,
-                execution_api_key=args.execution_api_key
-            )
+
+    update_spec_parser.set_defaults(command=update_rendered_spec)
+
+
+    ###########################################################################
+    # Prepare command
+    prepare_parser = subparsers.add_parser('prepare', help="Find and prepare all Poly deployables")
+    prepare_parser.add_argument("--lazy", action="store_true", help="Skip prepare work if the cache is up to date. (Relies on `git`)")
+    prepare_parser.add_argument("--disable-docs", action="store_true", help="Don't write any docstrings into the deployable files.")
+    prepare_parser.add_argument("--disable-ai", action="store_true", help="Don't use AI to fill in any missing descriptions.")
+
+    def prepare(args):
+        initialize_config()
+        disable_ai = args.disable_ai or bool(os.getenv("DISABLE_AI"))
+        prepare_deployables(lazy=args.lazy, disable_docs=args.disable_docs, disable_ai=disable_ai)
+
+    prepare_parser.set_defaults(command=prepare)
+
+
+    ###########################################################################
+    # Sync command
+    sync_parser = subparsers.add_parser("sync", help="Find and sync all Poly deployables")
+    sync_parser.add_argument("--dry-run", action="store_true", help="Run through sync steps with logging but don't make any changes.")
+
+    def sync(args):
+        initialize_config()
+        prepare_deployables(lazy=True, disable_docs=True, disable_ai=True)
+        if args.dry_run:
+            print("Running dry-run of sync...")
+        sync_deployables(dry_run=args.dry_run)
+        print("Poly deployments synced.")
+
+    sync_parser.set_defaults(command=sync)
+
+    ###########################################################################
+    #         _------.                                                        #
+    #        /  ,     \_             __         __ _          ________        #
+    #      /   /  /{}\ |o\_         / /   ___  / /( )_____   / ____/ /_  __   #
+    #     /    \  `--' /-' \       / /   / _ \/ __/// ___/  / /_  / / / / /   #
+    #    |      \     \     |     / /___/  __/ /_  (__  )  / __/ / / /_/ /    #
+    #   |              |`-, |    /_____/\___/\__/ /____/  /_/   /_/\__, /     #
+    #  /               /__/)/                                     /____/      #
+    # /               |                                                       #
+    ###########################################################################
+    parsed_args = parser.parse_args()
+    if hasattr(parsed_args, "command"):
+        parsed_args.command(parsed_args)
+    else:
+        parser.print_help()

polyapi/deployables.py

@@ -0,0 +1,296 @@
+import os
+import subprocess
+import json
+import hashlib
+from pathlib import Path
+from typing import TypedDict, List, Dict, Tuple, Optional, Any, Union
+from subprocess import check_output, CalledProcessError
+
+
+# Constants
+CACHE_VERSION_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "poly/deployments_revision")
+CACHE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "poly/deployables")
+
+
+class DeployableTypes(str):
+    pass
+
+class DeployableTypeNames(str):
+    pass
+
+class Deployment(TypedDict):
+    context: str
+    name: str
+    type: DeployableTypes
+    instance: str
+    id: str
+    deployed: str
+    fileRevision: str
+
+class ParsedDeployableConfig(TypedDict):
+    context: str
+    name: str
+    type: DeployableTypes
+    disableAi: Optional[bool]
+    config: Dict[str, Any]
+
+class DeployableFunctionParamBase(TypedDict):
+    type: str
+    typeSchema: Optional[Dict[str, Any]]
+    description: str
+
+class DeployableFunctionParam(DeployableFunctionParamBase):
+    name: str
+
+class DeployableFunctionTypes(TypedDict):
+    description: str
+    params: List[DeployableFunctionParam]
+    returns: DeployableFunctionParamBase
+
+class DeployableRecord(ParsedDeployableConfig, total=False):
+    gitRevision: str
+    fileRevision: str
+    file: str
+    types: DeployableFunctionTypes
+    typeSchemas: Dict[str, Any]
+    dependencies: List[str]
+    deployments: List[Deployment]
+    deploymentCommentRanges: List[Tuple[int, int]]
+    docStartIndex: int
+    docEndIndex: int
+    dirty: Optional[bool]
+
+class SyncDeployment(TypedDict, total=False):
+    context: str
+    name: str
+    description: str
+    type: str  # This should be an enumeration or a predefined set of strings if you have known types.
+    fileRevision: str
+    file: str
+    typeSchemas: Dict[str, any]
+    dependencies: List[str]
+    config: Dict[str, any]
+    instance: str
+    id: Optional[str] = None
+    deployed: Optional[str] = None
+
+DeployableTypeEntries: List[Tuple[DeployableTypeNames, DeployableTypes]] = [
+    ("PolyServerFunction", "server-function"),
+    ("PolyClientFunction", "client-function"),
+]
+
+DeployableTypeToName: Dict[DeployableTypeNames, DeployableTypes] = {name: type for name, type in DeployableTypeEntries}
+
+def prepare_deployable_directory() -> None:
+    Path(CACHE_DIR).mkdir(parents=True, exist_ok=True)
+
+def load_deployable_records() -> List[DeployableRecord]:
+    return [read_json_file(os.path.join(CACHE_DIR, name)) for name in os.listdir(CACHE_DIR) if name.endswith(".json")]
+
+def save_deployable_records(records: List[DeployableRecord]) -> None:
+    for record in records:
+        write_json_file(os.path.join(CACHE_DIR, f'{record["context"]}.{record["name"]}.json'), record)
+
+def remove_deployable_records(records: List[DeployableRecord]) -> None:
+    for record in records:
+        os.remove(os.path.join(CACHE_DIR, f'{record["context"]}.{record["name"]}.json'))
+
+def read_json_file(path: Union[str, Path]) -> Any:
+    with open(path, "r", encoding="utf-8") as file:
+        return json.load(file)
+
+def write_json_file(path: Union[str, Path], contents: Any) -> None:
+    with open(path, "w", encoding="utf-8") as file:
+        json.dump(contents, file, indent=2)
+
+class PolyDeployConfig(TypedDict):
+    type_names: List[str]
+    include_dirs: List[str]
+    include_files_or_extensions: List[str]
+    exclude_dirs: List[str]
+
+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'
+
+    exclude_command = f" | findstr /V /I \"{exclude_pattern}\"" if exclude_pattern else ''
+    search_command = f" | findstr /M /I /F:/ /C:\"{pattern}\""
+
+    result = []
+    for dir_path in config["include_dirs"]:
+        dir_command = f"dir /S /P /B {include_pattern} {dir_path}"
+        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'))
+        except subprocess.CalledProcessError:
+            pass
+    return result
+
+def get_all_deployable_files_linux(config: PolyDeployConfig) -> List[str]:
+    # Constructing the Linux grep command
+    include = " ".join(f'--include={f if "." in f else f"*.{f}"}' for f in config["include_files_or_extensions"])
+    exclude_dir = " ".join(f"--exclude-dir={dir}" for dir in config["exclude_dirs"])
+
+    search_path = " ".join(config["include_dirs"]) or "."
+    patterns = " ".join(f"-e 'polyConfig: {name}'" for name in config["type_names"]) or "-e 'polyConfig'"
+    grep_command = f'grep {include} {exclude_dir} -Rl {patterns} {search_path}'
+
+    try:
+        output = subprocess.check_output(grep_command, shell=True, text=True)
+        return output.strip().split('\n')
+    except subprocess.CalledProcessError:
+        return []
+
+def get_all_deployable_files(config: PolyDeployConfig) -> List[str]:
+    # Setting default values if not provided
+    if not config.get("type_names"):
+        config["type_names"] = [entry[0] for entry in DeployableTypeEntries]  # Assuming DeployableTypeEntries is defined elsewhere
+    if not config.get("include_dirs"):
+        config["include_dirs"] = ["."]
+    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"]
+
+    is_windows = os.name == "nt"
+    if is_windows:
+        return get_all_deployable_files_windows(config)
+    else:
+        return get_all_deployable_files_linux(config)
+
+def get_deployable_file_revision(file_contents: str) -> str:
+    # Remove leading single-line comments and hash the remaining contents
+    file_contents = "\n".join(line for line in file_contents.split("\n") if not line.strip().startswith("#"))
+    return hashlib.sha256(file_contents.encode('utf-8')).hexdigest()[:7]
+
+def get_git_revision(branch_or_tag: str = "HEAD") -> str:
+    try:
+        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]
+
+def get_cache_deployments_revision() -> str:
+    """Retrieve the cache deployments revision from a file."""
+    try:
+        with open(CACHE_VERSION_FILE, 'r', encoding='utf-8') as file:
+            return file.read().strip()
+    except FileNotFoundError:
+        return ''
+
+def write_cache_revision(git_revision: Optional[str] = None) -> None:
+    if git_revision is None:
+        git_revision = get_git_revision()
+    with open(CACHE_VERSION_FILE, 'w', encoding='utf-8') as file:
+        file.write(git_revision)
+
+def is_cache_up_to_date() -> bool:
+    if not Path(CACHE_VERSION_FILE).exists():
+        return False
+    with open(CACHE_VERSION_FILE, 'r', encoding='utf-8') as file:
+        cached_revision = file.read().strip()
+    git_revision = get_git_revision()
+    return cached_revision == git_revision
+
+def is_cache_up_to_date() -> bool:
+    """Check if the cached revision matches the current Git revision."""
+    cached_revision = get_cache_deployments_revision()
+    git_revision = get_git_revision()  # This function needs to be defined or imported
+    return cached_revision == git_revision
+
+def write_deploy_comments(deployments: List[Dict]) -> str:
+    """Generate a string of deployment comments for each deployment."""
+    canopy_path = 'polyui/collections' if 'localhost' in os.getenv('POLY_API_BASE_URL', '') else 'canopy/polyui/collections'
+    comments = []
+    for d in deployments:
+        instance_url = d['instance'].replace(':8000', ':3000') if d['instance'].endswith(':8000') else d['instance']
+        comment = f"# Poly deployed @ {d['deployed']} - {d['context']}.{d['name']} - {instance_url}/{canopy_path}/{d['type']}s/{d['id']} - {d['fileRevision']}"
+        comments.append(comment)
+    return '\n'.join(comments)
+
+def print_docstring_function_comment(description: str, args: list, returns: dict) -> str:
+    docstring = f'"""{description}\n\n'
+    if args:
+        docstring += '    Args:\n'
+        for arg in args:
+            name = arg.get('name')
+            arg_type = arg.get('type', '')
+            desc = arg.get('description', '')
+            if arg_type:
+                docstring += f'        {name} ({arg_type}): {desc}\n'
+            else:
+                docstring += f'        {name}: {desc}\n'
+
+    return_type = returns.get('type', '')
+    return_description = returns.get('description', '')
+    if return_type:
+        docstring += f'\n    Returns:\n        {return_type}: {return_description}\n'
+    else:
+        docstring += f'\n    Returns:\n        {return_description}\n'
+
+    docstring += '    """'
+    return docstring
+
+
+def update_deployment_comments(file_content: str, deployable: dict) -> str:
+    """
+    Remove old deployment comments based on the provided ranges and add new ones.
+    """
+    for range in reversed(deployable['deploymentCommentRanges']):
+        file_content = file_content[:range[0]] + file_content[range[1]:]
+    if deployable['deployments']:
+        deployment_comments = write_deploy_comments(deployable['deployments'])
+        deployable['deploymentCommentRanges'] = [(0, len(deployment_comments) + 1)]
+        file_content = f"{deployment_comments}\n{file_content}"
+    return file_content
+
+def update_deployable_function_comments(file_content: str, deployable: dict, disable_docs: bool = False) -> str:
+    """
+    Update the docstring in the file content based on the deployable's documentation data.
+    """
+    if not disable_docs:
+        docstring = print_docstring_function_comment(
+            deployable['types']['description'],
+            deployable['types']['params'],
+            deployable['types']['returns']
+        )
+        if deployable["docStartIndex"] == deployable["docEndIndex"]:
+            # Function doesn't yet have any docstrings so we need to add additional whitespace
+            docstring = "    " + docstring + "\n"
+        
+        return f"{file_content[:deployable['docStartIndex']]}{docstring}{file_content[deployable['docEndIndex']:]}"
+    return file_content
+
+def write_updated_deployable(deployable: dict, disable_docs: bool = False) -> dict:
+    """
+    Read the deployable's file, update its comments and docstring, and write back to the file.
+    """
+    with open(deployable['file'], 'r', encoding='utf-8') as file:
+        file_contents = file.read()
+    
+    if deployable['type'] in ['client-function', 'server-function']:
+        file_contents = update_deployable_function_comments(file_contents, deployable, disable_docs)
+    else:
+        raise ValueError(f"Unsupported deployable type: '{deployable['type']}'")
+
+    file_contents = update_deployment_comments(file_contents, deployable)
+    
+    with open(deployable['file'], 'w', encoding='utf-8') as file:
+        file.write(file_contents)
+    
+    deployable['fileRevision'] = get_deployable_file_revision(file_contents)
+    return deployable
+
+def write_deploy_comments(deployments: list) -> str:
+    """
+    Generate deployment comments for each deployment record.
+    """
+    canopy_path = 'polyui/collections' if 'localhost' in os.getenv('POLY_API_BASE_URL', '') else 'canopy/polyui/collections'
+    comments = []
+    for d in deployments:
+        instance_url = d['instance'].replace(':8000', ':3000') if d['instance'].endswith(':8000') else d['instance']
+        comments.append(f"# Poly deployed @ {d['deployed']} - {d['context']}.{d['name']} - {instance_url}/{canopy_path}/{d['type']}s/{d['id']} - {d['fileRevision']}")
+    return "\n".join(comments)