@seamapi/nextlove-sdk-generator 1.5.3 → 1.5.4

package/src/lib/generate-python-sdk/class-file.ts

@@ -1,24 +1,47 @@
-export type ClassFileMethod = {
+export type ClassFileMethodBase = {
   method_name: string
   path: string
   parameters: Array<{
     name: string
     type: string
     position?: number | undefined
+    required?: boolean | undefined
+    default_value?: string
   }>
-  return_path: string[]
-  return_resource: string
+}
+
+export type ClassFileMethod = ClassFileMethodBase &
+  (
+    | {
+        return_path: string[]
+        return_resource: string
+      }
+    | {
+        return_path: string[]
+        return_resource: "void"
+      }
+  )
+
+type ChildClassIdentifier = {
+  class_name: string
+  namespace: string
 }
 
 export class ClassFile {
   name: string
   namespace: string | undefined
   methods: ClassFileMethod[]
+  child_class_identifiers: ChildClassIdentifier[]
 
-  constructor(name: string, namespace?: string | undefined) {
+  constructor(
+    name: string,
+    namespace: string | undefined,
+    child_class_identifiers: ChildClassIdentifier[]
+  ) {
     this.name = name
     this.namespace = namespace
     this.methods = []
+    this.child_class_identifiers = child_class_identifiers
   }
 
   addMethod(method: ClassFileMethod) {
@@ -26,89 +49,249 @@ export class ClassFile {
   }
 
   serializeToAbstractClassWithoutImports(): string {
+    const has_child_classes = this.child_class_identifiers.length > 0
+
     return [
       `class Abstract${this.name}(abc.ABC):`,
       this.methods.length === 0 ? `  pass` : "",
-      ...this.methods.map(({ method_name, parameters }) =>
-        [
-          "",
-          "",
-          `@abc.abstractmethod`,
-          `def ${method_name}(self, ${parameters
-            .sort((a, b) => (a.position ?? 9999) - (b.position ?? 9999))
-            .map(({ name, type, position }) =>
-              position !== undefined
-                ? `${name}: ${type}`
-                : `${name}: Optional[${type}] = None`
-            )
-            .join(", ")}):`,
-          `  raise NotImplementedError()`,
-        ]
-          .map((s) => `  ${s}`)
-          .join("\n")
-      ),
+      `${
+        has_child_classes
+          ? this.child_class_identifiers
+              .map((i) =>
+                [
+                  `  @property`,
+                  `  @abc.abstractmethod`,
+                  `  def ${i.namespace}(self) -> Abstract${i.class_name}:`,
+                  `    raise NotImplementedError()`,
+                ].join("\n")
+              )
+              .join("\n\n")
+          : ""
+      }`,
+      ...this.methods
+        .concat(
+          this.name === "ActionAttempts"
+            ? [
+                {
+                  method_name: "poll_until_ready",
+                  parameters: [
+                    { name: "action_attempt_id", type: "str", required: true },
+                    { name: "timeout", type: "float", default_value: "5.0" },
+                    {
+                      name: "polling_interval",
+                      type: "float",
+                      default_value: "0.5",
+                    },
+                  ],
+                  return_path: [],
+                  return_resource: "ActionAttempt",
+                  path: "",
+                },
+              ]
+            : []
+        )
+        .map(({ method_name, parameters }) =>
+          [
+            "",
+            "",
+            `@abc.abstractmethod`,
+            `def ${method_name}(self, ${parameters
+              .sort(
+                (a, b) =>
+                  (a.position ?? a.required ? 1000 : 9999) -
+                  (b.position ?? b.required ? 1000 : 9999)
+              )
+              .map(({ name, type, required, default_value }) =>
+                required
+                  ? `${name}: ${type}`
+                  : `${name}: Optional[${type}] = ${default_value ?? "None"}`
+              )
+              .join(", ")}):`,
+            `  raise NotImplementedError()`,
+          ]
+            .map((s) => `  ${s}`)
+            .join("\n")
+        ),
     ].join("\n")
   }
 
   serializeToClass(): string {
-    return [
-      `from seamapi.types import (${[
-        `Abstract${this.name}`,
-        `AbstractSeam as Seam`,
-        ...Array.from(
-          new Set(
-            this.methods.map((m) =>
-              m.return_resource.replace(/^List\[/, "").replace(/\]$/, "")
-            )
+    const validClasses = [
+      `Abstract${this.name}`,
+      `AbstractSeam as Seam`,
+      ...Array.from(
+        new Set(
+          this.methods.map((m) =>
+            m.return_resource.replace(/^List\[/, "").replace(/\]$/, "")
           )
-        ),
-      ].join(",")})`,
-      `from typing import (Optional, Any)`,
-      "",
+        )
+      ),
+    ].filter((classInstance) => classInstance !== "")
+    const has_child_classes = this.child_class_identifiers.length > 0
+
+    return [
+      `from seamapi.types import (${validClasses
+        .filter((cls) => cls !== "None")
+        .join(",")})`,
+      `from typing import Optional, Any, List, Dict, Union`,
+      `${
+        has_child_classes
+          ? this.child_class_identifiers
+              .map(
+                (i) =>
+                  `from seamapi.${this.namespace}_${i.namespace} import ${i.class_name}`
+              )
+              .join("\n")
+          : ""
+      }`,
+      `${this.name === "ActionAttempts" ? "import time\n" : ""}`,
+
       `class ${this.name}(Abstract${this.name}):`,
       // TODO DOCSTRING
       `  seam: Seam`,
       "",
       `  def __init__(self, seam: Seam):`,
       `    self.seam = seam`,
+      `${
+        has_child_classes
+          ? this.child_class_identifiers
+              .map(
+                (i) => `    self._${i.namespace} = ${i.class_name}(seam=seam)`
+              )
+              .join("\n")
+          : ""
+      }`,
       "",
+      `${
+        has_child_classes
+          ? this.child_class_identifiers
+              .map((i) =>
+                [
+                  `  @property`,
+                  `  def ${i.namespace}(self) -> ${i.class_name}:`,
+                  `    return self._${i.namespace}`,
+                ].join("\n")
+              )
+              .join("\n\n")
+          : ""
+      }`,
       ...this.methods.map(
         ({ method_name, path, return_resource, return_path, parameters }) => {
-          const is_return_resource_a_list = return_resource.startsWith("List[")
-          const list_item_type = return_resource.slice(5, -1)
+          let return_resource_item = return_resource
+          const is_return_resource_list =
+            return_resource_item.startsWith("List[")
+
+          if (is_return_resource_list) {
+            return_resource_item = return_resource.slice(5, -1)
+          }
+
+          const does_method_use_action_attempt =
+            return_resource === "ActionAttempt" && !is_return_resource_list
+          const is_none_return_type = return_resource_item === "None"
+
           return [
             "",
             "",
             `def ${method_name}(self, ${parameters
-              .sort((a, b) => (a.position ?? 9999) - (b.position ?? 9999))
-              .map(({ name, type, position }) =>
-                position !== undefined
+              .sort(
+                (a, b) =>
+                  (a.position ?? a.required ? 1000 : 9999) -
+                  (b.position ?? b.required ? 1000 : 9999)
+              )
+              .map(({ name, type, required }) =>
+                required
                   ? `${name}: ${type}`
                   : `${name}: Optional[${type}] = None`
               )
-              .join(", ")}):`,
+              .concat(
+                does_method_use_action_attempt
+                  ? [
+                      "wait_for_action_attempt: Union[bool, Dict[str, float]] = True",
+                    ]
+                  : []
+              )
+              .join(", ")}) -> ${return_resource}:`,
+
             `  json_payload = {}`,
+            "",
+
             ...parameters.map(
               ({ name }) =>
                 `  if ${name} is not None:\n      json_payload["${name}"] = ${name}`
             ),
-            `  res = self.seam.make_request(`,
+            "",
+
+            `  ${is_none_return_type ? "" : "res = "}self.seam.make_request(`,
             `    "POST",`,
             `    "${path}",`,
             `    json=json_payload`,
             `  )`,
-            is_return_resource_a_list
-              ? `  return [${list_item_type}.from_dict(item) for item in res["${return_path.join(
-                  '"]["'
-                )}"]]`
-              : `  return ${return_resource}.from_dict(res["${return_path.join(
-                  '"]["'
-                )}"])`,
+            "",
+
+            does_method_use_action_attempt
+              ? [
+                  "  if isinstance(wait_for_action_attempt, dict):",
+                  `      updated_action_attempt = self.seam.action_attempts.poll_until_ready(`,
+                  "        res['action_attempt']['action_attempt_id'],",
+                  "        timeout=wait_for_action_attempt.get('timeout', None),",
+                  "        polling_interval=wait_for_action_attempt.get('polling_interval', None),",
+                  "      )",
+                  "    elif wait_for_action_attempt is True:",
+                  `        updated_action_attempt = self.seam.action_attempts.poll_until_ready(`,
+                  "          res['action_attempt']['action_attempt_id']",
+                  "        )",
+                  "    else:",
+                  `        return ${return_resource}.from_dict(res["${return_path.join(
+                    '"]["'
+                  )}"])`,
+                  "",
+                  "    return updated_action_attempt",
+                ].join("\n")
+              : "",
+            "",
+
+            !does_method_use_action_attempt
+              ? is_none_return_type
+                ? `  return None`
+                : is_return_resource_list
+                ? `  return [${return_resource_item}.from_dict(item) for item in res["${return_path.join(
+                    '"]["'
+                  )}"]]`
+                : `  return ${return_resource}.from_dict(res["${return_path.join(
+                    '"]["'
+                  )}"])`
+              : "",
           ]
             .map((s) => `  ${s}`)
             .join("\n")
         }
       ),
+      this.name === "ActionAttempts"
+        ? [
+            "",
+            "  def poll_until_ready(self, action_attempt_id: str, timeout: Optional[float] = 5.0, polling_interval: Optional[float] = 0.5) -> ActionAttempt:",
+            "    seam = self.seam",
+            "    time_waiting = 0.0",
+            "",
+            "    action_attempt = seam.action_attempts.get(action_attempt_id, wait_for_action_attempt=False)",
+            "",
+            "    while action_attempt.status == 'pending':",
+            "      time.sleep(polling_interval)",
+            "      time_waiting += polling_interval",
+            "",
+            "      if time_waiting > timeout:",
+            "        raise Exception('Timed out waiting for action attempt to be ready')",
+            "",
+            "      action_attempt = seam.action_attempts.get(",
+            "        action_attempt.action_attempt_id, wait_for_action_attempt=False",
+            "      )",
+            "",
+            "    if action_attempt.status == 'failed':",
+            "      raise Exception(f'Action Attempt failed: {action_attempt.error.message}')",
+            "",
+            "    return action_attempt",
+          ].join("\n")
+        : "",
     ].join("\n")
   }
 }

package/src/lib/generate-python-sdk/generate-python-sdk.ts

@@ -14,7 +14,16 @@ import abstractRoutesTemplate from "./templates/snippets/abstract-routes.templat
 import abstractSeamTemplate from "./templates/snippets/abstract-seam.template.js"
 import resourceDataclassTemplate from "./templates/snippets/resource-dataclass.template.js"
 import readmeMdTemplate from "./templates/readme.md.template.js"
+import initTemplate from "./templates/__init__.py.template.js"
+import gitignoreTemplate from "./templates/.gitignore.template.js"
+import prebuildTemplate from "./templates/prebuild.py.template.js"
+import reportErrorTemplate from "./templates/utils/report_error.py.template.js"
+import getSentryDsnTemplate from "./templates/utils/get_sentry_dsn.py.template.js"
+import SeamApiExceptionClassTemplate from "./templates/snippets/seam-api-exception-class.template.js"
 import { getParameterAndResponseSchema } from "lib/openapi/get-parameter-and-response-schema.js"
+import mapParentToChildrenResources from "lib/openapi/map-parent-to-children-resource.js"
+import { deepFlattenOneOfAndAllOfSchema } from "lib/generate-php-sdk/utils/deep-flatten-one-of-and-all-of-schema.js"
+import endpoints_returning_deprecated_action_attempt from "lib/endpoints-returning-deprecated-action-attempt.js"
 
 export const generatePythonSDK = async () => {
   const openapi: OpenAPISchema = await axios
@@ -26,24 +35,51 @@ export const generatePythonSDK = async () => {
   }))
 
   const fs: any = {}
-
-  fs["README.md"] = readmeMdTemplate()
-
   const class_map: Record<string, ClassFile> = {}
-
   const namespaces: string[][] = []
+  const parent_to_children_resources_map = mapParentToChildrenResources(routes)
+
+  const processClass = (resource_name: string) => {
+    const child_class_identifiers = (
+      parent_to_children_resources_map[resource_name] ?? []
+    ).map((child_resource) => ({
+      class_name: pascalCase(`${resource_name} ${child_resource}`),
+      namespace: child_resource,
+    }))
+    const pascal_resource_name = pascalCase(resource_name)
+
+    class_map[pascal_resource_name] = new ClassFile(
+      pascal_resource_name,
+      resource_name,
+      child_class_identifiers
+    )
+  }
 
   for (const route of routes) {
     if (!route.post) continue
     if (!route.post["x-fern-sdk-group-name"]) continue
     const group_names = [...route.post["x-fern-sdk-group-name"]]
+    const [base_resource] = group_names
     const namespace = group_names.join("_")
     group_names.reverse()
-    const class_name = pascalCase(group_names.join("_"))
+    const class_name = pascalCase(namespace)
+
     if (!class_map[class_name]) {
       namespaces.push(route.post["x-fern-sdk-group-name"])
-      class_map[class_name] = new ClassFile(class_name, namespace)
+
+      processClass(namespace)
     }
+
+    /*
+      special case when we don't have routes for a base resource
+      and thus a respective x-fern-sdk-group-name for ex. /noise_sensors
+    */
+    if (base_resource && !class_map[pascalCase(base_resource)]) {
+      namespaces.push([base_resource])
+
+      processClass(base_resource)
+    }
+
     const cls = class_map[class_name]
 
     if (!cls) {
@@ -54,11 +90,6 @@ export const generatePythonSDK = async () => {
     const { parameter_schema, response_obj_type, response_arr_type } =
       getParameterAndResponseSchema(route)
 
-    if (!response_obj_type && !response_arr_type) {
-      console.warn(`No response object/array ref for "${route.path}", skipping`)
-      continue
-    }
-
     if (!parameter_schema) {
       console.warn(`No parameter schema for "${route.path}", skipping`)
       continue
@@ -70,21 +101,29 @@ export const generatePythonSDK = async () => {
       parameters: Object.entries(parameter_schema.properties)
         .filter(
           ([_, param_val]) =>
-            param_val && typeof param_val === "object" && "type" in param_val
+            "type" in param_val ||
+            ("oneOf" in param_val && "type" in (param_val.oneOf[0] ?? {}))
         )
         .map(([param_name, param_val]: any) => ({
           name: param_name,
-          type: mapPythonType(param_val.type),
+          type: mapPythonType(
+            "type" in param_val
+              ? param_val
+              : deepFlattenOneOfAndAllOfSchema(param_val)
+          ),
           position:
             route.post["x-fern-sdk-method-name"] === "get" &&
             param_name === `${route.post["x-fern-sdk-return-value"]}_id`
               ? 0
               : undefined,
+          required: parameter_schema.required?.includes(param_name),
         })),
       return_path: [route.post["x-fern-sdk-return-value"]],
-      return_resource: response_obj_type
-        ? pascalCase(response_obj_type)
-        : `List[${pascalCase(response_arr_type)}]`,
+      return_resource: determineReturnResource({
+        route_path: route.path,
+        response_obj_type,
+        response_arr_type,
+      }),
     })
   }
 
@@ -119,13 +158,16 @@ export const generatePythonSDK = async () => {
       ),
     "",
     "",
-    `class SeamAPIException(Exception):`,
-    `  pass`,
+    SeamApiExceptionClassTemplate(),
     "",
     "",
-    ...Object.entries(class_map).map(([_, cls]) =>
-      cls.serializeToAbstractClassWithoutImports()
-    ),
+    ...Object.entries(class_map)
+      .sort(
+        // define classes without children first for parent-child referencing
+        ([, a], [, b]) =>
+          a.child_class_identifiers.length - b.child_class_identifiers.length
+      )
+      .map(([_, cls]) => cls.serializeToAbstractClassWithoutImports()),
     "",
     "",
     abstractRoutesTemplate(top_level_namespaces),
@@ -133,11 +175,18 @@ export const generatePythonSDK = async () => {
     abstractSeamTemplate(),
   ].join("\n")
 
-  fs["seamapi/__init__.py"] = `from seamapi.seam import Seam`
+  fs["README.md"] = readmeMdTemplate()
+  fs["pyproject.toml"] = pyprojectTomlTemplate()
+  fs[".gitignore"] = gitignoreTemplate()
+  fs["scripts/prebuild.py"] = prebuildTemplate()
+
+  fs["seamapi/__init__.py"] = initTemplate()
   fs["seamapi/routes.py"] = routesPyTemplate(top_level_namespaces)
   fs["seamapi/seam.py"] = seamPyTemplate()
   fs["seamapi/utils/deep_attr_dict.py"] = deep_attr_dictPyTemplate()
-  fs["pyproject.toml"] = pyprojectTomlTemplate()
+
+  fs["seamapi/utils/report_error.py"] = reportErrorTemplate()
+  fs["seamapi/utils/get_sentry_dsn.py"] = getSentryDsnTemplate()
 
   fs["tests/conftest.py"] = conftestPyTemplate()
   fs["tests/test_smoke.py"] = test_smokePyTemplate()
@@ -145,3 +194,27 @@ export const generatePythonSDK = async () => {
 
   return fs
 }
+
+function determineReturnResource({
+  route_path,
+  response_arr_type,
+  response_obj_type,
+}: {
+  route_path: string
+  response_obj_type?: string
+  response_arr_type?: string
+}) {
+  if (endpoints_returning_deprecated_action_attempt.includes(route_path)) {
+    return "None"
+  }
+
+  if (response_obj_type) {
+    return pascalCase(response_obj_type)
+  }
+
+  if (response_arr_type) {
+    return `List[${pascalCase(response_arr_type)}]`
+  }
+
+  return "None"
+}

package/src/lib/generate-python-sdk/map-python-type.ts

@@ -1,4 +1,4 @@
-import type { PropertySchema } from "lib/types.js"
+import type { PrimitiveSchema, PropertySchema } from "lib/types.js"
 
 // TODO literals?
 export const mapPythonType = (property_schema: PropertySchema) => {
@@ -20,8 +20,14 @@ export const mapPythonType = (property_schema: PropertySchema) => {
     return "bool"
   if ("type" in property_schema && property_schema.type === "number")
     return "float"
-  if ("type" in property_schema && property_schema.type === "array")
-    return "List[Any]" // TODO, make more specific
+  if ("type" in property_schema && property_schema.type === "array") {
+    const array_item_type: string =
+      "type" in property_schema.items
+        ? mapPythonType({ type: property_schema.items.type } as PrimitiveSchema)
+        : "Any"
+
+    return `List[${array_item_type}]`
+  } // TODO, make more specific
   if ("type" in property_schema && property_schema.type === "object")
     return "Dict[str, Any]" // TODO, make more specific
 

package/src/lib/generate-python-sdk/templates/.gitignore.template.ts

@@ -0,0 +1,11 @@
+export default () => `dist
+seamapi/utils/get_sentry_dsn.py
+.env
+__pycache__
+*/__pycache__
+node_modules
+
+.deeper
+.yalc
+yalc.lock
+`

package/src/lib/generate-python-sdk/templates/__init__.py.template.ts

@@ -0,0 +1,6 @@
+export default () => `# flake8: noqa
+# type: ignore
+
+from seamapi.seam import Seam
+from seamapi.seam import SeamApiException
+`

package/src/lib/generate-python-sdk/templates/conftest.py.template.ts

@@ -1,11 +1,80 @@
-export default () => `import pytest
-import random
+export default () => `import random
 import string
+import pytest
 from seamapi import Seam
+from dotenv import load_dotenv
+from typing import Any
+from dataclasses import dataclass
 
 
+@pytest.fixture(autouse=True)
+def dotenv_fixture():
+    load_dotenv()
+
+
+@dataclass
+class SeamBackend:
+    url: str
+    sandbox_api_key: str
+
+
+# TODO this should use scope="session", but there's some issue, this would
+# dramatically reduce test time to switch
 @pytest.fixture(scope="function")
-def seam():
-    r = ''.join(random.choices(string.ascii_uppercase + string.digits, k=10))
-    seam = Seam(api_url=f"https://{r}.fakeseamconnect.seam.vc", api_key="seam_apikey1_token")
-    yield seam`
+def seam_backend():
+    random_string = ''.join(random.choices(string.ascii_uppercase + string.digits, k=10))
+    yield SeamBackend(
+        url=f"https://{random_string}.fakeseamconnect.seam.vc",
+        sandbox_api_key="seam_apikey1_token",
+    )
+
+
+@pytest.fixture
+def seam(seam_backend: Any):
+    seam = Seam(api_url=seam_backend.url, api_key=seam_backend.sandbox_api_key)
+    # seam.make_request("POST", "/workspaces/reset_sandbox")
+    yield seam
+
+
+@pytest.fixture
+def fake_sentry(monkeypatch):
+    sentry_dsn = "https://key@sentry.io/123"
+
+    monkeypatch.setenv("SENTRY_DSN", sentry_dsn)
+
+    sentry_init_args = {}
+    sentry_capture_exception_calls = []
+    sentry_add_breadcrumb_calls = []
+
+    class TestSentryClient(object):
+        def __init__(self, *args, **kwargs):
+            sentry_init_args.update(kwargs)
+
+        def set_context(self, *args, **kwargs):
+            pass
+
+    monkeypatch.setattr("sentry_sdk.Client", TestSentryClient)
+
+    class TestSentryScope(object):
+        def set_context(self, *args, **kwargs):
+            pass
+
+    class TestSentryHub(object):
+        def __init__(self, *args, **kwargs):
+            self.scope = TestSentryScope()
+
+        def capture_exception(self, *args, **kwargs):
+            sentry_capture_exception_calls.append((args, kwargs))
+
+        def add_breadcrumb(self, *args, **kwargs):
+            sentry_add_breadcrumb_calls.append((args, kwargs))
+
+    monkeypatch.setattr("sentry_sdk.Hub", TestSentryHub)
+
+    yield {
+        "sentry_init_args": sentry_init_args,
+        "sentry_capture_exception_calls": sentry_capture_exception_calls,
+        "sentry_add_breadcrumb_calls": sentry_add_breadcrumb_calls,
+        "sentry_dsn": sentry_dsn,
+    }
+`

package/src/lib/generate-python-sdk/templates/prebuild.py.template.ts

@@ -0,0 +1,12 @@
+export default () => `import os
+
+value = os.environ.get("SENTRY_DSN", "None")
+if value != "None":
+  value = f'"{value}"'
+
+f = open("seamapi/utils/get_sentry_dsn.py", "w")
+f.write(f"""
+def get_sentry_dsn():
+  return {value}
+""")
+`