polyapi-python 0.1.0.dev2__tar.gz → 0.1.0.dev3__tar.gz

{polyapi-python-0.1.0.dev2 → polyapi-python-0.1.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: polyapi-python
-Version: 0.1.0.dev2
+Version: 0.1.0.dev3
 Summary: The PolyAPI Python Client
 Author-email: Dan Fellin <dan@polyapi.io>
 License: MIT License
@@ -124,6 +124,11 @@ def bar(n: int) -> Foobar:
     return Foobar(count=n)
 ```
 
+## Pypi
+
+This library is hosted on Pypi. You can find the latest version on the [pypi polyapi-python](https://pypi.org/project/polyapi-python/) project.
+
+
 ## Upgrade
 
 To upgrade your library to the latest version, pass the upgrade flag.
@@ -147,3 +152,7 @@ To run this library's unit tests, please clone the repo then run:
 ```bash
 python -m unittest discover
 ```
+
+## Support
+
+If you run into any issues or want help getting started with this project, please contact support@polyapi.io

{polyapi-python-0.1.0.dev2 → polyapi-python-0.1.0.dev3}/README.md

@@ -88,6 +88,11 @@ def bar(n: int) -> Foobar:
     return Foobar(count=n)
 ```
 
+## Pypi
+
+This library is hosted on Pypi. You can find the latest version on the [pypi polyapi-python](https://pypi.org/project/polyapi-python/) project.
+
+
 ## Upgrade
 
 To upgrade your library to the latest version, pass the upgrade flag.
@@ -110,4 +115,8 @@ To run this library's unit tests, please clone the repo then run:
 
 ```bash
 python -m unittest discover
-```
+```
+
+## Support
+
+If you run into any issues or want help getting started with this project, please contact support@polyapi.io

{polyapi-python-0.1.0.dev2 → polyapi-python-0.1.0.dev3}/polyapi/api.py

@@ -1,10 +1,10 @@
 import os
 from typing import Any, Dict, List, Tuple
 
-from polyapi.constants import BASIC_PYTHON_TYPES, JSONSCHEMA_TO_PYTHON_TYPE_MAP
+from polyapi.constants import BASIC_PYTHON_TYPES
 from polyapi.typedefs import PropertySpecification, PropertyType
-from polyapi.utils import append_init, camelCase
-from polyapi.schema import generate_schema_types, clean_title
+from polyapi.utils import add_import_to_init, camelCase, init_the_init
+from polyapi.schema import generate_schema_types, clean_title, map_primitive_types
 
 # map the function type from the spec type to the function execute type
 TEMPLATE_FUNCTION_TYPE_MAP = {
@@ -47,21 +47,16 @@ def {function_name}(
 """
 
 
-def _map_primitive_types(type_: str) -> str:
-    # Define your mapping logic here
-    return JSONSCHEMA_TO_PYTHON_TYPE_MAP.get(type_, "Any")
-
-
 def _get_type(type_spec: PropertyType) -> Tuple[str, str]:
     if type_spec["kind"] == "plain":
         value = type_spec["value"]
         if value.endswith("[]"):
-            primitive = _map_primitive_types(value[:-2])
+            primitive = map_primitive_types(value[:-2])
             return f"List[{primitive}]", ""
         else:
-            return _map_primitive_types(value), ""
+            return map_primitive_types(value), ""
     elif type_spec["kind"] == "primitive":
-        return _map_primitive_types(type_spec["type"]), ""
+        return map_primitive_types(type_spec["type"]), ""
     elif type_spec["kind"] == "array":
         if type_spec.get("items"):
             items = type_spec["items"]
@@ -141,9 +136,10 @@ def _add_type_import_path(function_name: str, arg: str) -> str:
             return arg
         else:
             if '"' in sub:
-                return f'List[_{function_name}.{camelCase(sub)}]'
-            else:
+                sub = sub.replace('"', "")
                 return f'List["_{function_name}.{camelCase(sub)}"]'
+            else:
+                return f'List[_{function_name}.{camelCase(sub)}]'
 
     return f'_{function_name}.{camelCase(arg)}'
 
@@ -221,8 +217,7 @@ def add_function_file(
     return_type: Dict[str, Any],
 ):
     # first lets add the import to the __init__
-    init_path = os.path.join(full_path, "__init__.py")
-    _init_the_init(init_path)
+    init_the_init(full_path)
 
     func_str, func_type_defs = render_function(
         function_type,
@@ -233,6 +228,7 @@ def add_function_file(
         return_type,
     )
 
+    init_path = os.path.join(full_path, "__init__.py")
     with open(init_path, "a") as f:
         f.write(f"\n\nfrom . import _{function_name}\n\n{func_str}")
 
@@ -242,12 +238,6 @@ def add_function_file(
         f.write(func_type_defs)
 
 
-def _init_the_init(init_path: str) -> None:
-    if not os.path.exists(init_path):
-        with open(init_path, "w") as f:
-            f.write("from typing import List, Dict, Any, TypedDict\nfrom polyapi.execute import execute\nfrom polyapi.exceptions import PolyApiException\n")
-
-
 def create_function(
     function_type: str,
     path: str,
@@ -279,8 +269,8 @@ def create_function(
             # append to __init__.py file if nested folders
             next = folders[idx + 1] if idx + 2 < len(folders) else ""
             if next:
-                _init_the_init(os.path.join(full_path, "__init__.py"))
-                append_init(full_path, next)
+                init_the_init(full_path)
+                add_import_to_init(full_path, next)
 
 
 def generate_api(api_functions: List) -> None:

polyapi-python-0.1.0.dev3/polyapi/execute.py

@@ -0,0 +1,37 @@
+import requests
+from requests import Response
+from polyapi.config import get_api_key_and_url
+from polyapi.exceptions import PolyApiException
+
+
+def execute(function_type, function_id, data) -> Response:
+    api_key, api_url = get_api_key_and_url()
+    headers = {"Authorization": f"Bearer {api_key}"}
+    url = f"{api_url}/functions/{function_type}/{function_id}/execute"
+    resp = requests.post(url, json=data, headers=headers)
+    if resp.status_code != 200 and resp.status_code != 201:
+        error_content = resp.content.decode("utf-8", errors="ignore")
+        raise PolyApiException(f"{resp.status_code}: {error_content}")
+    return resp
+
+
+def variable_get(variable_id: str) -> Response:
+    api_key, base_url = get_api_key_and_url()
+    headers = {"Authorization": f"Bearer {api_key}"}
+    url = f"{base_url}/variables/{variable_id}/value"
+    resp = requests.get(url, headers=headers)
+    if resp.status_code != 200 and resp.status_code != 201:
+        error_content = resp.content.decode("utf-8", errors="ignore")
+        raise PolyApiException(f"{resp.status_code}: {error_content}")
+    return resp
+
+
+def variable_update(variable_id: str, value) -> Response:
+    api_key, base_url = get_api_key_and_url()
+    headers = {"Authorization": f"Bearer {api_key}"}
+    url = f"{base_url}/variables/{variable_id}/value"
+    resp = requests.patch(url, data={"value": value}, headers=headers)
+    if resp.status_code != 200 and resp.status_code != 201:
+        error_content = resp.content.decode("utf-8", errors="ignore")
+        raise PolyApiException(f"{resp.status_code}: {error_content}")
+    return resp

{polyapi-python-0.1.0.dev2 → polyapi-python-0.1.0.dev3}/polyapi/generate.py

@@ -4,7 +4,7 @@ import os
 import shutil
 from typing import Any, Dict, List, Tuple
 
-from .typedefs import PropertySpecification
+from .typedefs import PropertySpecification, VariableSpecDto
 from .utils import get_auth_headers
 from .api import generate_api
 from .variables import generate_variables
@@ -81,31 +81,19 @@ def get_functions_and_parse():
     return functions
 
 
-def get_variables_and_parse() -> List[Tuple[str, str, bool]]:
-    raw = get_variables()
-    variables = parse_variables(raw)
-    return variables
-
-
-def get_variables():
+def get_variables() -> List[VariableSpecDto]:
     api_key, api_url = get_api_key_and_url()
     headers = {"Authorization": f"Bearer {api_key}"}
-    url = f"{api_url}/variables"
+    # TODO do some caching so this and get_functions just do 1 function call
+    url = f"{api_url}/specs"
     resp = requests.get(url, headers=headers)
     if resp.status_code == 200:
-        return resp.json()
+        specs = resp.json()
+        return [spec for spec in specs if spec['type'] == "serverVariable"]
     else:
         raise NotImplementedError(resp.content)
 
 
-def parse_variables(variables: List) -> List[Tuple[str, str, bool]]:
-    rv = []
-    for v in variables:
-        path = f"vari.{v['context']}.{v['name']}"
-        rv.append((path, v["id"], v["secret"]))
-    return rv
-
-
 def remove_old_library():
     currdir = os.path.dirname(os.path.abspath(__file__))
     path = os.path.join(currdir, "poly")
@@ -131,7 +119,7 @@ def generate() -> None:
         )
         exit()
 
-    variables = get_variables_and_parse()
+    variables = get_variables()
     if variables:
         generate_variables(variables)
 

{polyapi-python-0.1.0.dev2 → polyapi-python-0.1.0.dev3}/polyapi/schema.py

@@ -5,6 +5,8 @@ from jsonschema_gentypes import configuration
 import tempfile
 import json
 
+from polyapi.constants import JSONSCHEMA_TO_PYTHON_TYPE_MAP
+
 
 def _cleanup_input_for_gentypes(input_data: Dict):
     """ cleanup input_data in place to make it more suitable for jsonschema_gentypes
@@ -83,4 +85,9 @@ def clean_title(title: str) -> str:
     # certain reserved words cant be titles, let's replace them
     if title == "List":
         title = "List_"
-    return title
+    return title
+
+
+def map_primitive_types(type_: str) -> str:
+    # Define your mapping logic here
+    return JSONSCHEMA_TO_PYTHON_TYPE_MAP.get(type_, "Any")

{polyapi-python-0.1.0.dev2 → polyapi-python-0.1.0.dev3}/polyapi/typedefs.py

@@ -32,6 +32,22 @@ class SpecificationDto(TypedDict):
     context: str
     name: str
     description: str
+    # function is none if this is actually VariableSpecDto
     function: FunctionSpecification | None
-    # variables have variable: {"secret": boolean} and NO function
-    type: Literal['apiFunction', 'customFunction', 'serverFunction', 'authFunction', 'webhookHandle', 'serverVariable']
+    type: Literal['apiFunction', 'customFunction', 'serverFunction', 'authFunction', 'webhookHandle', 'serverVariable']
+
+
+class VariableSpecification(TypedDict):
+    environmentId: str
+    value: Any
+    valueType: PropertyType
+    secret: bool
+
+
+class VariableSpecDto(TypedDict):
+    id: str
+    context: str
+    name: str
+    description: str
+    variable: VariableSpecification
+    type: Literal['serverVariable']

{polyapi-python-0.1.0.dev2 → polyapi-python-0.1.0.dev3}/polyapi/utils.py

@@ -2,7 +2,21 @@ import re
 import os
 
 
-def append_init(full_path: str, next: str) -> None:
+# this string should be in every __init__ file.
+# it contains all the imports needed for the function or variable code to run
+CODE_IMPORTS = "from typing import List, Dict, Any, TypedDict\nfrom polyapi.execute import execute, variable_get, variable_update\n\n"
+
+
+def init_the_init(full_path: str) -> None:
+    init_path = os.path.join(full_path, "__init__.py")
+    if not os.path.exists(init_path):
+        with open(init_path, "w") as f:
+            f.write(CODE_IMPORTS)
+
+
+def add_import_to_init(full_path: str, next: str) -> None:
+    init_the_init(full_path)
+
     init_path = os.path.join(full_path, "__init__.py")
     with open(init_path, "a+") as f:
         import_stmt = "from . import {}\n".format(next)

polyapi-python-0.1.0.dev3/polyapi/variables.py

@@ -0,0 +1,103 @@
+import os
+from typing import List
+
+from polyapi.schema import map_primitive_types
+from polyapi.typedefs import PropertyType, VariableSpecDto
+from polyapi.utils import add_import_to_init, init_the_init
+
+
+# GET is only included if the variable is not a secret
+GET_TEMPLATE = """
+    @staticmethod
+    def get() -> {variable_type}:
+        resp = variable_get("{variable_id}")
+        return resp.text
+"""
+
+
+TEMPLATE = """
+class {variable_name}:{get_method}
+    @staticmethod
+    def update(value: {variable_type}):
+        resp = variable_update("{variable_id}", value)
+        return resp.json()
+
+    @staticmethod
+    def inject(path=None) -> {variable_type}:
+        return {{
+            "type": "PolyVariable",
+            "id": "{variable_id}",
+            "path": path,
+        }}  # type: ignore"""
+
+
+def generate_variables(variables: List[VariableSpecDto]):
+    for variable in variables:
+        create_variable(variable)
+    print("Variables generated!")
+
+
+def render_variable(variable: VariableSpecDto):
+    variable_type = _get_variable_type(variable["variable"]["valueType"])
+    get_method = (
+        ""
+        if variable["variable"]["secret"]
+        else GET_TEMPLATE.format(
+            variable_id=variable["id"], variable_type=variable_type
+        )
+    )
+    return TEMPLATE.format(
+        variable_name=variable["name"],
+        variable_id=variable["id"],
+        variable_type=variable_type,
+        get_method=get_method,
+    )
+
+
+def _get_variable_type(type_spec: PropertyType) -> str:
+    # simplified version of _get_type from api.py
+    if type_spec["kind"] == "plain":
+        value = type_spec["value"]
+        if value.endswith("[]"):
+            primitive = map_primitive_types(value[:-2])
+            return f"List[{primitive}]"
+        else:
+            return map_primitive_types(value)
+    elif type_spec["kind"] == "primitive":
+        return map_primitive_types(type_spec["type"])
+    elif type_spec["kind"] == "array":
+        return "List"
+    elif type_spec["kind"] == "void":
+        return "None"
+    elif type_spec["kind"] == "object":
+        return "Dict"
+    elif type_spec["kind"] == "any":
+        return "Any"
+    else:
+        return "Any"
+
+
+def create_variable(variable: VariableSpecDto) -> None:
+    folders = ["vari"]
+    if variable["context"]:
+        folders += variable["context"].split(".")
+
+    # build up the full_path by adding all the folders
+    full_path = os.path.join(os.path.dirname(os.path.abspath(__file__)))
+
+    for idx, folder in enumerate(folders):
+        full_path = os.path.join(full_path, folder)
+        if not os.path.exists(full_path):
+            os.makedirs(full_path)
+        next = folders[idx + 1] if idx + 1 < len(folders) else None
+        if next:
+            add_import_to_init(full_path, next)
+
+    add_variable_to_init(full_path, variable)
+
+
+def add_variable_to_init(full_path: str, variable: VariableSpecDto):
+    init_the_init(full_path)
+    init_path = os.path.join(full_path, "__init__.py")
+    with open(init_path, "a") as f:
+        f.write(render_variable(variable) + "\n\n")

{polyapi-python-0.1.0.dev2 → polyapi-python-0.1.0.dev3}/polyapi_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: polyapi-python
-Version: 0.1.0.dev2
+Version: 0.1.0.dev3
 Summary: The PolyAPI Python Client
 Author-email: Dan Fellin <dan@polyapi.io>
 License: MIT License
@@ -124,6 +124,11 @@ def bar(n: int) -> Foobar:
     return Foobar(count=n)
 ```
 
+## Pypi
+
+This library is hosted on Pypi. You can find the latest version on the [pypi polyapi-python](https://pypi.org/project/polyapi-python/) project.
+
+
 ## Upgrade
 
 To upgrade your library to the latest version, pass the upgrade flag.
@@ -147,3 +152,7 @@ To run this library's unit tests, please clone the repo then run:
 ```bash
 python -m unittest discover
 ```
+
+## Support
+
+If you run into any issues or want help getting started with this project, please contact support@polyapi.io

{polyapi-python-0.1.0.dev2 → polyapi-python-0.1.0.dev3}/polyapi_python.egg-info/SOURCES.txt

@@ -23,4 +23,5 @@ polyapi_python.egg-info/requires.txt
 polyapi_python.egg-info/top_level.txt
 tests/test_function_cli.py
 tests/test_generate.py
-tests/test_utils.py
+tests/test_utils.py
+tests/test_variables.py

{polyapi-python-0.1.0.dev2 → polyapi-python-0.1.0.dev3}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=61.2", "wheel"]
 
 [project]
 name = "polyapi-python"
-version = "0.1.0.dev2"
+version = "0.1.0.dev3"
 description = "The PolyAPI Python Client"
 authors = [{ name = "Dan Fellin", email = "dan@polyapi.io" }]
 dependencies = ["requests", "typing_extensions", "jsonschema-gentypes", "pydantic>=2.5.3", "stdlib_list"]
@@ -19,4 +19,4 @@ packages = ["polyapi"]
 
 [tools.setuptools.packages.find]
 include = ["polyapi"]
-exclude = ["polyapi/poly*", "polyapi/vari*", "polyapi/.config.env"]  # exclude the generated libraries from builds
+exclude = ["polyapi/poly*", "polyapi/vari*", "polyapi/.config.env"]  # exclude the generated libraries from builds

{polyapi-python-0.1.0.dev2 → polyapi-python-0.1.0.dev3}/tests/test_generate.py

@@ -155,9 +155,10 @@ GET_PRODUCTS_COUNT = {
 
 class T(unittest.TestCase):
     def test_render_function_accuweather(self):
-        func_str = render_function(
+        name = ACCUWEATHER["name"]
+        func_str, _ = render_function(
             ACCUWEATHER["type"],
-            ACCUWEATHER["name"],
+            name,
             ACCUWEATHER["id"],
             ACCUWEATHER["description"],
             ACCUWEATHER["function"]["arguments"],
@@ -165,12 +166,13 @@ class T(unittest.TestCase):
         )
         self.assertIn(ACCUWEATHER["id"], func_str)
         self.assertIn("locationId: int,", func_str)
-        self.assertIn("-> ApiFunctionResponse", func_str)
+        self.assertIn(f"-> _{name}.{name}Response", func_str)
 
     def test_render_function_zillow(self):
-        func_str = render_function(
+        name = ZILLOW['name']
+        func_str, _ = render_function(
             ZILLOW["type"],
-            ZILLOW["name"],
+            name,
             ZILLOW["id"],
             ZILLOW["description"],
             ZILLOW["function"]["arguments"],
@@ -178,10 +180,11 @@ class T(unittest.TestCase):
         )
         self.assertIn(ZILLOW["id"], func_str)
         self.assertIn("locationId: int,", func_str)
-        self.assertIn("-> ApiFunctionResponse", func_str)
+        self.assertIn(f"-> _{name}.{name}Response", func_str)
 
     def test_render_function_twilio_api(self):
-        func_str = render_function(
+        name = TWILIO['name']
+        func_str, _ = render_function(
             TWILIO["type"],
             TWILIO["name"],
             TWILIO["id"],
@@ -192,11 +195,12 @@ class T(unittest.TestCase):
         self.assertIn(TWILIO["id"], func_str)
         self.assertIn("conversationSID: str", func_str)
         self.assertIn("authToken: str", func_str)
-        self.assertIn("-> ApiFunctionResponse", func_str)
+        self.assertIn(f"-> _{name}.{name}Response", func_str)
 
     def test_render_function_twilio_server(self):
         # same test but try it as a serverFunction rather than an apiFunction
-        func_str = render_function(
+        name = TWILIO['name']
+        func_str, _ = render_function(
             "serverFunction",
             TWILIO["name"],
             TWILIO["id"],
@@ -207,11 +211,11 @@ class T(unittest.TestCase):
         self.assertIn(TWILIO["id"], func_str)
         self.assertIn("conversationSID: str", func_str)
         self.assertIn("authToken: str", func_str)
-        self.assertIn("-> ResponseType", func_str)
+        self.assertIn(f"-> _{name}.ResponseType", func_str)
 
     def test_render_function_get_products_count(self):
         return_type = GET_PRODUCTS_COUNT["function"]["returnType"]
-        func_str = render_function(
+        func_str, _ = render_function(
             GET_PRODUCTS_COUNT["type"],
             GET_PRODUCTS_COUNT["name"],
             GET_PRODUCTS_COUNT["id"],

polyapi-python-0.1.0.dev3/tests/test_variables.py

@@ -0,0 +1,28 @@
+import unittest
+from polyapi.variables import render_variable
+
+EXAMPLE = {
+        "type": "serverVariable",
+        "id": "181238j18231j",
+        "name": "test",
+        "context": "my3",
+        "description": "a test variable",
+        "visibilityMetadata": {
+            "visibility": "ENVIRONMENT"
+        },
+        "variable": {
+            "environmentId": "123818231",
+            "secret": False,
+            "valueType": {
+                "kind": "primitive",
+                "type": "string"
+            },
+            "value": "some mock value"
+        }
+    }
+
+
+class T(unittest.TestCase):
+    def test_render_variable(self):
+        variable_str = render_variable(EXAMPLE)
+        self.assertIn("class test", variable_str)

polyapi-python-0.1.0.dev2/polyapi/execute.py

@@ -1,15 +0,0 @@
-import requests
-from requests import Response
-from polyapi.config import get_api_key_and_url
-from polyapi.exceptions import PolyApiException
-
-
-def execute(function_type, function_id, data) -> Response:
-    api_key, api_url = get_api_key_and_url()
-    headers = {"Authorization": f"Bearer {api_key}"}
-    url = f"{api_url}/functions/{function_type}/{function_id}/execute"
-    resp = requests.post(url, json=data, headers=headers)
-    if resp.status_code != 200 and resp.status_code != 201:
-        error_content = resp.content.decode("utf-8", errors="ignore")
-        raise PolyApiException(f"{resp.status_code}: {error_content}")
-    return resp

polyapi-python-0.1.0.dev2/polyapi/variables.py

@@ -1,86 +0,0 @@
-import os
-
-from polyapi.utils import append_init
-
-
-TEMPLATE = """
-import requests
-from polyapi.config import get_api_key_and_url
-from polyapi.exceptions import PolyApiException
-
-
-class {variable_name}:
-    @staticmethod
-    def get():
-        secret = {secret}
-        if secret:
-            raise ValueError('Cannot access secret variable from client. Use .inject() instead within Poly function.')
-        else:
-            api_key, base_url = get_api_key_and_url()
-            headers = {{"Authorization": f"Bearer {{api_key}}"}}
-            url = f"{{base_url}}/variables/{variable_id}/value"
-            resp = requests.get(url, headers=headers)
-            if resp.status_code != 200 and resp.status_code != 201:
-                raise PolyApiException(f"{{resp.status_code}}: {{resp.content}}")
-            return resp.text
-
-    @staticmethod
-    def update(value):
-        api_key, base_url = get_api_key_and_url()
-        headers = {{"Authorization": f"Bearer {{api_key}}"}}
-        url = f"{{base_url}}/variables/{variable_id}"
-        resp = requests.patch(url, data={{"value": value}}, headers=headers)
-        if resp.status_code != 200 and resp.status_code != 201:
-            raise PolyApiException(f"{{resp.status_code}}: {{resp.content}}")
-        return resp.json()
-
-    def inject(path=None):
-        return {{
-            "type": "PolyVariable",
-            "id": "{variable_id}",
-            "path": path,
-        }}
-"""
-
-
-def generate_variables(variables):
-    for variable in variables:
-        create_variable(*variable)
-    print("Variables generated!")
-
-
-def add_variable_file(full_path: str, variable_name: str, variable_id: str, secret: str):
-    # first lets add the import to the __init__
-    init_path = os.path.join(full_path, "__init__.py")
-    with open(init_path, "a") as f:
-        f.write(f"from ._{variable_name} import {variable_name}\n")
-
-    # now lets add the code!
-    file_path = os.path.join(full_path, f"_{variable_name}.py")
-    with open(file_path, "w") as f:
-        f.write(
-            TEMPLATE.format(
-                variable_name=variable_name,
-                variable_id=variable_id,
-                secret=secret,
-            )
-        )
-
-
-def create_variable(path: str, variable_id: str, secret: str) -> None:
-    full_path = os.path.dirname(os.path.abspath(__file__))
-
-    folders = path.split(".")
-    for idx, folder in enumerate(folders):
-        if idx + 1 == len(folders):
-            variable_name = folder
-            add_variable_file(full_path, variable_name, variable_id, secret)
-        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:
-                append_init(full_path, next)