@seamapi/nextlove-sdk-generator 1.4.0

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

@@ -0,0 +1,147 @@
+import axios from "axios"
+import type { ObjSchema, OpenAPISchema, Route } from "lib/types.js"
+import { ClassFile } from "./class-file.js"
+import { pascalCase } from "change-case"
+import { flattenObjSchema } from "lib/openapi/index.js"
+import conftestPyTemplate from "./templates/conftest.py.template.js"
+import routesPyTemplate from "./templates/routes.py.template.js"
+import seamPyTemplate from "./templates/seam.py.template.js"
+import test_smokePyTemplate from "./templates/test_smoke.py.template.js"
+import pyprojectTomlTemplate from "./templates/pyproject.toml.template.js"
+import { mapPythonType } from "./map-python-type.js"
+import deep_attr_dictPyTemplate from "./templates/utils/deep_attr_dict.py.template.js"
+import abstractRoutesTemplate from "./templates/snippets/abstract-routes.template.js"
+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 { getParameterAndResponseSchema } from "lib/openapi/get-parameter-and-response-schema.js"
+
+export const generatePythonSDK = async () => {
+  const openapi: OpenAPISchema = await axios
+    .get("https://connect.getseam.com/openapi.json")
+    .then((res) => res.data)
+  const routes: Route[] = Object.entries(openapi.paths).map(([path, v]) => ({
+    path,
+    ...v,
+  }))
+
+  const fs: any = {}
+
+  fs["README.md"] = readmeMdTemplate()
+
+  const class_map: Record<string, ClassFile> = {}
+
+  const namespaces: string[][] = []
+
+  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 namespace = group_names.join("_")
+    group_names.reverse()
+    const class_name = pascalCase(group_names.join("_"))
+    if (!class_map[class_name]) {
+      namespaces.push(route.post["x-fern-sdk-group-name"])
+      class_map[class_name] = new ClassFile(class_name, namespace)
+    }
+    const cls = class_map[class_name]
+
+    if (!cls) {
+      console.warn(`No class for "${route.path}", skipping`)
+      continue
+    }
+
+    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
+    }
+
+    cls.addMethod({
+      method_name: route.post["x-fern-sdk-method-name"],
+      path: route.path,
+      parameters: Object.entries(parameter_schema.properties)
+        .filter(
+          ([_, param_val]) =>
+            param_val && typeof param_val === "object" && "type" in param_val
+        )
+        .map(([param_name, param_val]: any) => ({
+          name: param_name,
+          type: mapPythonType(param_val.type),
+          position:
+            route.post["x-fern-sdk-method-name"] === "get" &&
+            param_name === `${route.post["x-fern-sdk-return-value"]}_id`
+              ? 0
+              : undefined,
+        })),
+      return_path: [route.post["x-fern-sdk-return-value"]],
+      return_resource: response_obj_type
+        ? pascalCase(response_obj_type)
+        : `List[${pascalCase(response_arr_type)}]`,
+    })
+  }
+
+  const top_level_namespaces = namespaces
+    .map((ns) => (ns.length === 1 ? ns[0] : null))
+    .filter<string>(Boolean as any)
+
+  for (const [_, cls] of Object.entries(class_map)) {
+    fs[`seamapi/${cls.namespace}.py`] = cls.serializeToClass()
+  }
+
+  fs[`seamapi/types.py`] = [
+    `from typing import Any, Dict, List, Optional, Union`,
+    `import abc`,
+    `from dataclasses import dataclass`,
+    `from seamapi.utils.deep_attr_dict import DeepAttrDict`,
+    "",
+    "",
+    ...Object.entries(openapi.components.schemas)
+      .map(
+        ([schema_name, schema]) =>
+          [schema_name, flattenObjSchema(schema as any)] as [string, ObjSchema]
+      )
+      .map(([schema_name, schema]) =>
+        resourceDataclassTemplate(
+          pascalCase(schema_name),
+          Object.entries(schema.properties).map(([name, property_schema]) => ({
+            name,
+            type: mapPythonType(property_schema as any),
+          }))
+        )
+      ),
+    "",
+    "",
+    `class SeamAPIException(Exception):`,
+    `  pass`,
+    "",
+    "",
+    ...Object.entries(class_map).map(([_, cls]) =>
+      cls.serializeToAbstractClassWithoutImports()
+    ),
+    "",
+    "",
+    abstractRoutesTemplate(top_level_namespaces),
+    "",
+    abstractSeamTemplate(),
+  ].join("\n")
+
+  fs["seamapi/__init__.py"] = `from seamapi.seam import Seam`
+  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["tests/conftest.py"] = conftestPyTemplate()
+  fs["tests/test_smoke.py"] = test_smokePyTemplate()
+  fs["tests/__init__.py"] = ""
+
+  return fs
+}

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

@@ -0,0 +1 @@
+export * from "./generate-python-sdk.js"

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

@@ -0,0 +1,29 @@
+import type { PropertySchema } from "lib/types.js"
+
+// TODO literals?
+export const mapPythonType = (property_schema: PropertySchema) => {
+  if (typeof property_schema !== "object") {
+    return "Any"
+  }
+
+  if ("type" in property_schema && property_schema.type === "string") {
+    // TODO handle format="date-time"
+    // if (property_schema.enum)
+    //   return `Union[${property_schema.enum
+    //     .map((v) => `Literal["${v}"]`)
+    //     .join(",")}]`
+    return "str"
+  }
+  if ("type" in property_schema && property_schema.type === "integer")
+    return "int"
+  if ("type" in property_schema && property_schema.type === "boolean")
+    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 === "object")
+    return "Dict[str, Any]" // TODO, make more specific
+
+  return "Any"
+}

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

@@ -0,0 +1,11 @@
+export default () => `import pytest
+import random
+import string
+from seamapi import Seam
+
+
+@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`

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

@@ -0,0 +1,20 @@
+export default () => `[tool.poetry]
+name = "seamapi"
+version = "2.14.0"
+description = "A Python Library for Seam's API https://getseam.com"
+authors = ["Severin Ibarluzea <seveibar@gmail.com>"]
+license = "MIT"
+
+[tool.poetry.dependencies]
+python = "^3.7"
+requests = "^2.26.0"
+
+[tool.poetry.dev-dependencies]
+pytest = "^6.2.5"
+python-dotenv = "^0.19.2"
+black = "^21.12b0"
+responses = "^0.22.0"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"`

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

@@ -0,0 +1,47 @@
+export default () => `# Seam for Python
+
+Control locks, lights and other internet of things devices with Seam's simple API. Check out the [documentation](https://docs.getseam.com) or [some examples](examples)
+
+## Setup
+
+\`\`\`bash
+pip install seamapi
+\`\`\`
+
+## Usage
+
+\`\`\`python
+from seamapi import Seam
+
+# export SEAM_API_KEY=***
+seam = Seam()
+
+some_lock = seam.locks.get(
+  name="Front Door"
+)
+
+seam.locks.lock_door(some_lock)
+\`\`\`
+
+## Development
+
+This project uses [poetry](https://github.com/python-poetry/poetry)
+
+- To setup the project and install dependencies run \`poetry install\`
+- To run tests, run \`poetry run pytest -s\`
+- To build the project for publishing, run \`poetry build\`
+
+Commits to \`main\` following [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) will automatically be published to PyPI.
+
+Our tests use a seam sandbox environment given by the environment
+variables \`SEAM_SANDBOX_API_KEY\`. If you want to run the tests, you should
+first create a sandbox workspace [on your Developer Console](https://console.getseam.com)
+then create a sandbox workspace.
+
+> NOTE: For installation on m1 mac, you may need to export the following lines
+> prior to \`poetry install\`...
+>
+> \`export CPPFLAGS="-I/opt/homebrew/opt/openssl@1.1/include"\`
+>
+> \`export LDFLAGS="-L/opt/homebrew/opt/openssl@1.1/lib -L\${HOME}/.pyenv/versions/3.8.10/lib"\`
+`

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

@@ -0,0 +1,13 @@
+import { pascalCase } from "change-case"
+export default (namespaces: string[]) =>
+  [
+    `from .types import AbstractRoutes`,
+    ...namespaces.map((ns) => `from .${ns} import ${pascalCase(ns)}`),
+    ``,
+    `class Routes(AbstractRoutes):`,
+    `  def __init__(self):`,
+    ...namespaces.map((ns) => `    self.${ns} = ${pascalCase(ns)}(seam=self)`),
+    ``,
+    `  def make_request(self):`,
+    `    raise NotImplementedError()`,
+  ].join("\n")

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

@@ -0,0 +1,73 @@
+export default () => `import os
+
+from .routes import Routes
+import requests
+from importlib.metadata import version
+from typing import Optional, cast
+from .types import AbstractSeam, SeamAPIException
+
+
+class Seam(AbstractSeam):
+    api_key: str
+    api_url: str = "https://connect.getseam.com"
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        api_url: Optional[str] = None,
+        should_report_exceptions: Optional[bool] = False,
+    ):
+        """
+        Parameters
+        ----------
+        api_key : str, optional
+          API key
+        api_url : str, optional
+          API url
+        """
+        Routes.__init__(self)
+
+        if api_key is None:
+            api_key = os.environ.get("SEAM_API_KEY", None)
+        if api_key is None:
+            raise Exception(
+                "SEAM_API_KEY not found in environment, and api_key not provided"
+            )
+        if api_url is None:
+            api_url = os.environ.get("SEAM_API_URL", self.api_url)
+        self.api_key = api_key
+        self.api_url = cast(str, api_url)
+
+    def make_request(self, method: str, path: str, **kwargs):
+        """
+        Makes a request to the API
+
+        Parameters
+        ----------
+        method : str
+          Request method
+        path : str
+          Request path
+        **kwargs
+          Keyword arguments passed to requests.request
+        """
+
+        url = self.api_url + path
+        headers = {
+            "Authorization": "Bearer " + self.api_key,
+            "Content-Type": "application/json",
+            "User-Agent": "Python SDK v" + version("seamapi") + " (https://github.com/seamapi/python)",
+        }
+        response = requests.request(method, url, headers=headers, **kwargs)
+
+        parsed_response = response.json()
+
+        if response.status_code != 200:
+            raise SeamAPIException(
+                response.status_code,
+                response.headers.get("seam-request-id", None),
+                parsed_response["error"],
+            )
+        ## TODO automatically paginate if kwargs["auto_paginate"] is True
+
+        return parsed_response`

package/src/lib/generate-python-sdk/templates/snippets/abstract-routes.template.ts

@@ -0,0 +1,9 @@
+import { pascalCase } from "change-case"
+
+export default (namespaces: string[]) => `@dataclass
+class AbstractRoutes(abc.ABC):
+${namespaces.map((ns) => `  ${ns}: Abstract${pascalCase(ns)}`).join("\n")}
+
+  @abc.abstractmethod
+  def make_request(self, method: str, path: str, **kwargs) -> Any:
+    raise NotImplementedError`

package/src/lib/generate-python-sdk/templates/snippets/abstract-seam.template.ts

@@ -0,0 +1,8 @@
+export default () => `@dataclass
+class AbstractSeam(AbstractRoutes):
+  api_key: str
+  api_url: str
+
+  @abc.abstractmethod
+  def __init__(self, api_key: Optional[str] = None):
+    raise NotImplementedError`

package/src/lib/generate-python-sdk/templates/snippets/resource-dataclass.template.ts

@@ -0,0 +1,15 @@
+export default (
+  name: string,
+  parameters: Array<{
+    name: string
+    type: string
+  }>
+) => `@dataclass
+class ${name}:
+${parameters.map((p) => `  ${p.name}: ${p.type}`).join("\n")}
+
+  @staticmethod
+  def from_dict(d: Dict[str, Any]):
+    return ${name}(
+${parameters.map((p) => `      ${p.name}=d.get("${p.name}", None),`).join("\n")}
+      )`

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

@@ -0,0 +1,12 @@
+export default () => `from seamapi import Seam
+
+
+def test_get_devices(seam: Seam):
+    devices_response = seam.devices.list()
+    assert devices_response[0].device_id
+
+
+def test_create_access_code(seam: Seam):
+    access_code = seam.access_codes.create(device_id="august_device_1", code="1234")
+    assert access_code.status == "setting"
+    assert access_code.code == "1234"`

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

@@ -0,0 +1,27 @@
+export default () => `# https://stackoverflow.com/a/3031270/559475
+class DeepAttrDict(dict):
+    MARKER = object()
+
+    def __init__(self, value=None):
+        if value is None:
+            pass
+        elif isinstance(value, dict):
+            for key in value:
+                self.__setitem__(key, value[key])
+        else:
+            raise TypeError("expected dict")
+
+    def __setitem__(self, key, value):
+        if isinstance(value, dict) and not isinstance(value, DeepAttrDict):
+            value = DeepAttrDict(value)
+        super(DeepAttrDict, self).__setitem__(key, value)
+
+    def __getitem__(self, key):
+        found = self.get(key, DeepAttrDict.MARKER)
+        if found is DeepAttrDict.MARKER:
+            found = DeepAttrDict()
+            super(DeepAttrDict, self).__setitem__(key, found)
+        return found
+
+    __setattr__, __getattr__ = __setitem__, __getitem__
+`

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

@@ -0,0 +1,153 @@
+import axios from "axios"
+import { flattenObjSchema } from "lib/index.js"
+import type { ObjSchema, OpenAPISchema, Route } from "lib/types.js"
+import resourceRbTemplate from "./templates/snippets/resource.rb.template.js"
+import { pascalCase } from "change-case"
+import { RubyClient } from "./ruby-client.js"
+import { getParameterAndResponseSchema } from "lib/openapi/get-parameter-and-response-schema.js"
+import base_clientRbTemplate from "./templates/base_client.rb.template.js"
+import readmeMdTemplate from "./templates/readme.md.template.js"
+import rakefileTemplate from "./templates/rakefile.template.js"
+import versionRbTemplate from "./templates/version.rb.template.js"
+import requestRbTemplate from "./templates/request.rb.template.js"
+import loggerRbTemplate from "./templates/logger.rb.template.js"
+import clientRbTemplate from "./templates/client.rb.template.js"
+import gemfileTemplate from "./templates/gemfile.template.js"
+import seamapiGemspecTemplate from "./templates/seamapi.gemspec.template.js"
+import base_resourceRbTemplate from "./templates/base_resource.rb.template.js"
+import resource_errorRbTemplate from "./templates/resource_error.rb.template.js"
+import resource_warningRbTemplate from "./templates/resource_warning.rb.template.js"
+import resource_errors_supportRbTemplate from "./templates/resource_errors_support.rb.template.js"
+import resource_warnings_supportRbTemplate from "./templates/resource_warnings_support.rb.template.js"
+
+export const generateRubySDK = async () => {
+  const openapi: OpenAPISchema = await axios
+    .get("https://connect.getseam.com/openapi.json")
+    .then((res) => res.data)
+  const routes: Route[] = Object.entries(openapi.paths).map(([path, v]) => ({
+    path,
+    ...v,
+  }))
+
+  const fs: any = {}
+
+  fs["README.md"] = readmeMdTemplate()
+  fs["Rakefile"] = rakefileTemplate()
+  fs["spec/spec_helper.rb"] = ""
+  fs["spec/smoketest.rb"] = ""
+  fs["Gemfile"] = gemfileTemplate()
+  fs["seamapi.gemspec"] = seamapiGemspecTemplate()
+  fs["lib/seam/version.rb"] = versionRbTemplate()
+  fs["lib/seam/request.rb"] = requestRbTemplate()
+  fs["lib/seam/logger.rb"] = loggerRbTemplate()
+  fs["lib/seam/client.rb"] = clientRbTemplate()
+  fs["lib/seam/clients/base_client.rb"] = base_clientRbTemplate()
+  fs["lib/seam/resources/base_resource.rb"] = base_resourceRbTemplate()
+  fs["lib/seam/resources/resource_error.rb"] = resource_errorRbTemplate()
+  fs["lib/seam/resources/resource_warning.rb"] = resource_warningRbTemplate()
+  fs["lib/seam/resources/resource_errors_support.rb"] =
+    resource_errors_supportRbTemplate()
+  fs["lib/seam/resources/resource_warnings_support.rb"] =
+    resource_warnings_supportRbTemplate()
+
+  const seamapi_rb_requires = [
+    "seam/version",
+    "seam/request",
+    "seam/logger",
+    "seam/client",
+    "seam/clients/base_client",
+    "seam/resources/base_resource",
+    "seam/resources/resource_error",
+    "seam/resources/resource_warning",
+    "seam/resources/resource_errors_support",
+    "seam/resources/resource_warnings_support",
+  ]
+
+  const resources = Object.entries(openapi.components.schemas).map(
+    ([schema_name, schema]) =>
+      [schema_name, flattenObjSchema(schema as any)] as [string, ObjSchema]
+  )
+  for (const [snake_name, schema] of resources) {
+    const params = Object.entries(schema.properties).map(
+      ([name, property_schema]) => ({
+        name,
+        is_date_time:
+          "format" in property_schema && property_schema.format === "date-time",
+      })
+    )
+
+    fs[`lib/seam/resources/${snake_name}.rb`] = resourceRbTemplate({
+      pascal_name: pascalCase(snake_name),
+      attrs: params.filter((p) => !p.is_date_time).map((p) => p.name),
+      date_attrs: params.filter((p) => p.is_date_time).map((p) => p.name),
+    })
+    seamapi_rb_requires.push(`seam/resources/${snake_name}`)
+  }
+
+  const clients: Record<string, RubyClient> = {}
+  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 namespace = group_names.join("_")
+    group_names.reverse()
+    const class_name = pascalCase(group_names.join("_"))
+    if (!clients[class_name]) {
+      // namespaces.push(route.post["x-fern-sdk-group-name"])
+      clients[class_name] = new RubyClient(class_name, namespace)
+    }
+    const client = clients[class_name]
+
+    if (!client) {
+      console.warn(`No client for "${class_name}", skipping`)
+      continue
+    }
+
+    const { parameter_schema, response_obj_type, response_arr_type } =
+      getParameterAndResponseSchema(route)
+
+    if (!parameter_schema) {
+      console.warn(`No parameter schema for "${route.path}", skipping`)
+      continue
+    }
+
+    if (!response_obj_type && !response_arr_type) {
+      console.warn(`No response object/array ref for "${route.path}", skipping`)
+      continue
+    }
+
+    client.addMethod({
+      method_name: route.post["x-fern-sdk-method-name"],
+      path: route.path,
+      parameters: Object.entries(parameter_schema.properties)
+        .filter(([_, param_val]) => "type" in param_val)
+        .map(([param_name, _]: any) => ({
+          name: param_name,
+          required: parameter_schema.required?.includes(param_name),
+          position:
+            route.post["x-fern-sdk-method-name"] === "get" &&
+            param_name === `${route.post["x-fern-sdk-return-value"]}_id`
+              ? 0
+              : undefined,
+        })),
+      return_path: route.post["x-fern-sdk-return-value"],
+      return_resource: pascalCase(response_obj_type ?? response_arr_type),
+    })
+  }
+
+  for (const client of Object.values(clients)) {
+    fs[`lib/seam/clients/${client.snake_name}.rb`] = client.serialize()
+    seamapi_rb_requires.push(`seam/clients/${client.snake_name}`)
+  }
+
+  fs["lib/seamapi.rb"] = [
+    `# frozen_string_literal: true`,
+    "",
+    ...seamapi_rb_requires.map((r) => `require_relative "${r}"`),
+    "",
+    `module Seam`,
+    `end`,
+  ].join("\n")
+
+  return fs
+}

package/src/lib/generate-ruby-sdk/index.ts

@@ -0,0 +1 @@
+export * from "./generate-ruby-sdk.js"

package/src/lib/generate-ruby-sdk/ruby-client.ts

@@ -0,0 +1,81 @@
+export type RubyClientMethodParameter = {
+  name: string
+  required?: boolean | undefined
+  position?: number | undefined
+}
+
+export type RubyClientMethod = {
+  method_name: string
+  path: string
+  parameters: RubyClientMethodParameter[]
+  return_resource: string
+  return_path: string
+}
+
+export class RubyClient {
+  methods: RubyClientMethod[] = []
+
+  constructor(
+    public pascal_name: string,
+    public snake_name: string
+  ) {
+    this.methods = []
+  }
+
+  addMethod(method: RubyClientMethod) {
+    this.methods.push(method)
+  }
+
+  /**
+   * Example:
+   *
+   * ```
+   * def create(device_id: nil, name: nil, code: nil, starts_at: nil, ends_at: nil)
+   *   request_seam_object(
+   *     :post,
+   *     "/access_codes/create",
+   *     Seam::AccessCode,
+   *     "action_attempt",
+   *     body: {device_id: device_id, code: code, starts_at: starts_at, ends_at: ends_at, name: name}.compact
+   *   )
+   * end
+   * ```
+   */
+  serialize() {
+    return [
+      `module Seam`,
+      `  module Clients`,
+      `    class ${this.pascal_name} < BaseClient`,
+      ...this.methods.map(
+        ({ method_name, path, parameters, return_resource, return_path }) => {
+          return [
+            " ",
+            `def ${method_name}(${parameters
+              .sort(
+                (a, b) =>
+                  (a.position ?? a.required ? 1000 : 9999) -
+                  (b.position ?? b.required ? 1000 : 9999)
+              )
+              .map((p) => `${p.name}${p.required ? "" : ": nil"}`)
+              .join(", ")})`,
+            `  request_seam_object(`,
+            `    :post,`,
+            `    "${path}",`,
+            `    ${return_resource},`,
+            `    '${return_path}',`,
+            `    body: {${parameters
+              .map((p) => `${p.name}: ${p.name}`)
+              .join(", ")}}.compact`,
+            `  )`,
+            `end`,
+          ]
+            .map((s) => `        ${s}`)
+            .join("\n")
+        }
+      ),
+      `    end`,
+      `  end`,
+      `end`,
+    ].join("\n")
+  }
+}