polyapi-python 0.3.1.dev1__tar.gz → 0.3.1.dev3__tar.gz

{polyapi_python-0.3.1.dev1/polyapi_python.egg-info → polyapi_python-0.3.1.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: polyapi-python
-Version: 0.3.1.dev1
+Version: 0.3.1.dev3
 Summary: The Python Client for PolyAPI, the IPaaS by Developers for Developers
 Author-email: Dan Fellin <dan@polyapi.io>
 License: MIT License

{polyapi_python-0.3.1.dev1 → polyapi_python-0.3.1.dev3}/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_python-0.3.1.dev3/polyapi/cli.py

@@ -0,0 +1,186 @@
+import os
+import argparse
+
+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"]
+
+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="Manage your Poly API configurations and functions",
+        formatter_class=argparse.RawTextHelpFormatter
+    )
+    
+    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")
+
+    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)
+
+    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_python-0.3.1.dev3/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)

polyapi_python-0.3.1.dev3/polyapi/function_cli.py

@@ -0,0 +1,123 @@
+import sys
+from typing import Any, List
+import requests
+from polyapi.generate import get_functions_and_parse, generate_functions
+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
+import importlib
+
+
+def _func_already_exists(context: str, function_name: str) -> bool:
+    try:
+        module = importlib.import_module(f"polyapi.poly.{context}")
+        return bool(getattr(module, function_name, False))
+    except ModuleNotFoundError:
+        return False
+
+
+def function_add_or_update(
+    name: str,
+    file: str,
+    context: str,
+    description: str,
+    client: bool,
+    server: bool,
+    logs_enabled: bool,
+    generate: bool = True,
+    execution_api_key: str = ""
+):
+    verb = "Updating" if _func_already_exists(context, name) else "Adding"
+    ftype = "server" if server else "client"
+    print(f"{verb} custom {ftype} function...", end="")
+
+    with open(file, "r") as f:
+        code = f.read()
+
+    # OK! let's parse the code and generate the arguments
+    parsed = parse_function_code(code, name, context)
+    return_type = parsed["types"]["returns"]["type"]
+
+    if not return_type:
+        print_red("ERROR")
+        print(
+            f"Function {name} not found as top-level function in {name}"
+        )
+        sys.exit(1)
+
+    data = {
+        "context": context or parsed["context"],
+        "name": name,
+        "description": description or parsed["types"]["description"],
+        "code": code,
+        "language": "python",
+        "returnType": return_type,
+        "returnTypeSchema": parsed["types"]["returns"]["typeSchema"],
+        "arguments": [{**p, "type": get_jsonschema_type(p["type"])  } for p in parsed["types"]["params"]],
+        "logsEnabled": logs_enabled or parsed["config"].get("logs_enabled", False),
+    }
+
+    if server and parsed["dependencies"]:
+        print_yellow(
+            "\nPlease note that deploying your functions will take a few minutes because it makes use of libraries other than polyapi."
+        )
+        data["requirements"] = parsed["dependencies"]
+
+    api_key, api_url = get_api_key_and_url()
+    assert api_key
+    if server:
+        url = f"{api_url}/functions/server"
+
+        if execution_api_key:
+            data["executionApiKey"] = execution_api_key
+
+    elif client:
+        url = f"{api_url}/functions/client"
+    else:
+        print_red("ERROR")
+        print("Please specify type of function with --client or --server")
+        sys.exit(1)
+
+    headers = get_auth_headers(api_key)
+    resp = requests.post(url, headers=headers, json=data)
+    if resp.status_code == 201:
+        print_green("DEPLOYED")
+        function_id = resp.json()["id"]
+        print(f"Function ID: {function_id}")
+        if generate:
+            print("Generating new custom function...", end="")
+            functions = get_functions_and_parse(limit_ids=[function_id])
+            generate_functions(functions)
+            print_green("DONE")
+    else:
+        print("Error adding function.")
+        print(resp.status_code)
+        print(resp.content)
+        sys.exit(1)
+
+
+def function_execute(context: str, name: str, args: List) -> Any:
+    context_code = importlib.import_module(f"polyapi.poly.{context}")
+    print(f"Executing poly.{context}.{name}... ")
+    fn = getattr(context_code, name)
+    return fn(*args)
+
+
+def spec_delete(function_type: str, function_id: str):
+    api_key, api_url = get_api_key_and_url()
+    assert api_key
+    if function_type == "api":
+        url = f"{api_url}/functions/api/{function_id}"
+    elif function_type == "serverFunction":
+        url = f"{api_url}/functions/server/{function_id}"
+    elif function_type == "customFunction":
+        url = f"{api_url}/functions/client/{function_id}"
+    elif function_type == "webhookHandle":
+        url = f"{api_url}/webhooks/{function_id}"
+    else:
+        print_red("ERROR")
+        print(f"Unknown function type: {function_type}")
+        sys.exit(1)
+    headers = get_auth_headers(api_key)
+    resp = requests.delete(url, headers=headers)
+    return resp

{polyapi_python-0.3.1.dev1 → polyapi_python-0.3.1.dev3}/polyapi/generate.py

@@ -13,7 +13,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, to_func_namespace
 from .variables import generate_variables
-from .config import get_api_key_and_url, initialize_config
+from .config import get_api_key_and_url
 
 SUPPORTED_FUNCTION_TYPES = {
     "apiFunction",
@@ -122,7 +122,6 @@ def remove_old_library():
 
 
 def generate() -> None:
-    initialize_config()
 
     remove_old_library()