geniespec 0.1.1.dev2__tar.gz → 0.1.1.dev3__tar.gz

{geniespec-0.1.1.dev2 → geniespec-0.1.1.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geniespec
-Version: 0.1.1.dev2
+Version: 0.1.1.dev3
 Summary: Generate API code from an api.yaml spec
 License-Expression: MIT
 Requires-Dist: jinja2>=3.1.6
@@ -14,17 +14,17 @@ Description-Content-Type: text/markdown
 
 # Genie
 
-Genie (`geniespec` on PyPI) generates API code from an `api.yaml` spec. The output is a package you install, not code you commit.
+Genie (`geniespec` on PyPI) generates API code from an `api.yaml` spec. Install it like any other tool and run it from your build scripts; the generated code is gitignored, not committed.
 
 ```
-uvx geniespec build --spec api.yaml [--output .genie]
-uvx geniespec watch --spec api.yaml [--output .genie]
+geniespec build --spec api.yaml --target python-server [--output .]
+geniespec watch --spec api.yaml --target python-server [--output .] [-- <command>]
 ```
 
-- `build` writes `<output>/python`: a project with `pyproject.toml` and `src/<service>_api/v<major>/` (`api`, `endpoints`, `resources`, `internal`, `exceptions`). Only changed files are rewritten and files it no longer generates are removed.
-- `watch` rebuilds whenever the spec changes. If the spec is invalid it logs the error and keeps the previous output.
-- Consumers depend on the output as an editable path dependency, e.g. `my-service-api = { path = ".genie/python", editable = true }` in `[tool.uv.sources]`, and import it as `my_service_api.v1`.
-- Generated code needs `kiba-core` (`core.api`, `core.util.typing_util`), `pydantic` and `starlette` from the consumer.
+- `build` writes the target's package into the output directory, e.g. `./<service>_api/v<major>/` (`api`, `endpoints`, `resources`, `internal`, `exceptions`) for `python-server`. Only files in that package are touched: changed files are rewritten and files it no longer generates are removed.
+- `watch` builds, then rebuilds whenever the spec changes. If the spec is invalid it logs the error and keeps the previous output. Given a command after `--`, it runs it once the first build is done, keeps rebuilding while it runs, exits with its exit code and stops it when watch itself is stopped, e.g. `geniespec watch --spec api.yaml --target python-server -- uvicorn app:app --reload`.
+- Code run from the output directory imports the package directly, e.g. `from my_service_api.v1 import api`. Generated `python-server` code needs `kiba-core` (`core.api`, `core.util.typing_util`), `pydantic` and `starlette`.
+- The bundled templates are examples of a kibalabs-style target.
 
 # Development
 

geniespec-0.1.1.dev3/README.md

@@ -0,0 +1,63 @@
+# Genie
+
+Genie (`geniespec` on PyPI) generates API code from an `api.yaml` spec. Install it like any other tool and run it from your build scripts; the generated code is gitignored, not committed.
+
+```
+geniespec build --spec api.yaml --target python-server [--output .]
+geniespec watch --spec api.yaml --target python-server [--output .] [-- <command>]
+```
+
+- `build` writes the target's package into the output directory, e.g. `./<service>_api/v<major>/` (`api`, `endpoints`, `resources`, `internal`, `exceptions`) for `python-server`. Only files in that package are touched: changed files are rewritten and files it no longer generates are removed.
+- `watch` builds, then rebuilds whenever the spec changes. If the spec is invalid it logs the error and keeps the previous output. Given a command after `--`, it runs it once the first build is done, keeps rebuilding while it runs, exits with its exit code and stops it when watch itself is stopped, e.g. `geniespec watch --spec api.yaml --target python-server -- uvicorn app:app --reload`.
+- Code run from the output directory imports the package directly, e.g. `from my_service_api.v1 import api`. Generated `python-server` code needs `kiba-core` (`core.api`, `core.util.typing_util`), `pydantic` and `starlette`.
+- The bundled templates are examples of a kibalabs-style target.
+
+# Development
+
+```
+make install
+make lint-check type-check test
+```
+
+Merges to `main` publish a dev version to PyPI. To release, bump `version` in `pyproject.toml` in a PR, then run the Release workflow on `main` (Actions → Release → Run workflow). It tags `vX.Y.Z` and the Publish workflow publishes it. Only the release workflow can push version tags.
+
+# Things that need work
+
+## Typing of params and fields in general
+
+Enum and OneOf not supported yet
+
+I think we need to create an object for Type. what would it look like?
+
+
+```
+class BaseFieldType:
+    isNullable: bool
+
+
+class RawFieldType(BaseFieldType):
+    name: str
+
+
+class ClassFieldType(BaseFieldType):
+    fieldType: RawFieldType
+
+
+class ListFieldType:(BaseFieldType)
+    fieldType: RawFieldType
+    isNullable: bool
+
+
+class MappingFieldType(BaseFieldType):
+    keyFieldType: RawFieldType
+    valueFieldType: RawFieldType
+
+
+class OneOfFieldType(BaseFieldType):
+    fieldTypes: list[RawFieldType]
+
+
+class EnumFieldType(BaseFieldType):
+    values: list[str]
+
+```

{geniespec-0.1.1.dev2 → geniespec-0.1.1.dev3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "geniespec"
-version = "0.1.1.dev2"
+version = "0.1.1.dev3"
 description = "Generate API code from an api.yaml spec"
 readme = "README.md"
 license = "MIT"

{geniespec-0.1.1.dev2 → geniespec-0.1.1.dev3}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "geniespec"
-version = "0.1.1.dev2"
+version = "0.1.1.dev3"
 description = "Generate API code from an api.yaml spec"
 readme = "README.md"
 license = "MIT"

geniespec-0.1.1.dev3/src/geniespec/cli.py

@@ -0,0 +1,123 @@
+import argparse
+import pathlib
+import signal
+import subprocess
+import sys
+import tempfile
+import time
+import types
+
+import yaml  # type: ignore[import-untyped]
+from core import logging
+
+from geniespec.genie import TARGET_LANGUAGE_CODES
+from geniespec.genie import Renderer
+from geniespec.genie import SyntacticApiValidator
+from geniespec.types import KibaApi
+
+WATCH_INTERVAL_SECONDS = 0.5
+COMMAND_STOP_TIMEOUT_SECONDS = 10
+
+
+def _sync_directory(sourceDirectoryPath: pathlib.Path, targetDirectoryPath: pathlib.Path) -> list[pathlib.Path]:
+    changedPaths: list[pathlib.Path] = []
+    sourceRelativePaths = {path.relative_to(sourceDirectoryPath) for path in sourceDirectoryPath.rglob('*') if path.is_file()}
+    for relativePath in sorted(sourceRelativePaths):
+        content = (sourceDirectoryPath / relativePath).read_bytes()
+        targetPath = targetDirectoryPath / relativePath
+        if targetPath.is_file() and targetPath.read_bytes() == content:
+            continue
+        targetPath.parent.mkdir(parents=True, exist_ok=True)
+        temporaryPath = targetPath.with_name(f'.{targetPath.name}.tmp')
+        temporaryPath.write_bytes(content)
+        temporaryPath.replace(targetPath)
+        changedPaths.append(targetPath)
+    stalePaths = [path for path in targetDirectoryPath.rglob('*') if path.is_file() and '__pycache__' not in path.parts and path.relative_to(targetDirectoryPath) not in sourceRelativePaths]
+    for stalePath in stalePaths:
+        stalePath.unlink()
+    return changedPaths + stalePaths
+
+
+def build(specPath: pathlib.Path, target: str, outputDirectoryPath: pathlib.Path) -> list[pathlib.Path]:
+    with open(specPath) as specFile:
+        apiYaml = yaml.safe_load(specFile)
+    SyntacticApiValidator().validate(apiYaml)
+    api = KibaApi(**apiYaml)
+    with tempfile.TemporaryDirectory() as renderDirectory:
+        Renderer(target=target).render_directory(api=api, outputDirectoryPath=renderDirectory)
+        changedPaths: list[pathlib.Path] = []
+        # NOTE(krishan711): only sync the packages the target generates so other files in the output directory are never touched
+        for packagePath in sorted(pathlib.Path(renderDirectory).iterdir()):
+            changedPaths += _sync_directory(sourceDirectoryPath=packagePath, targetDirectoryPath=outputDirectoryPath / packagePath.name)
+        return changedPaths
+
+
+def _build_and_log(specPath: pathlib.Path, target: str, outputDirectoryPath: pathlib.Path) -> None:
+    changedPaths = build(specPath=specPath, target=target, outputDirectoryPath=outputDirectoryPath)
+    logging.info(f'geniespec: built {specPath} into {outputDirectoryPath} ({len(changedPaths)} files changed)')
+
+
+def _stop_process(process: subprocess.Popen[bytes]) -> None:
+    if process.poll() is not None:
+        return
+    process.terminate()
+    try:
+        process.wait(timeout=COMMAND_STOP_TIMEOUT_SECONDS)
+    except subprocess.TimeoutExpired:
+        process.kill()
+        process.wait()
+
+
+def watch(specPath: pathlib.Path, target: str, outputDirectoryPath: pathlib.Path, command: list[str]) -> int:
+    lastModifiedTime: int | None = None
+    process: subprocess.Popen[bytes] | None = None
+    try:
+        while True:
+            try:
+                modifiedTime: int | None = specPath.stat().st_mtime_ns
+            except FileNotFoundError:
+                modifiedTime = lastModifiedTime
+            if modifiedTime != lastModifiedTime:
+                lastModifiedTime = modifiedTime
+                try:
+                    _build_and_log(specPath=specPath, target=target, outputDirectoryPath=outputDirectoryPath)
+                except Exception as exception:  # noqa: BLE001
+                    logging.error(f'geniespec: failed to build {specPath}, keeping the previous output: {exception}')
+            if command and process is None:
+                process = subprocess.Popen(command)  # noqa: S603
+            if process is not None and process.poll() is not None:
+                return process.returncode
+            time.sleep(WATCH_INTERVAL_SECONDS)
+    finally:
+        if process is not None:
+            _stop_process(process=process)
+
+
+def _exit_on_terminate(signalNumber: int, frame: types.FrameType | None) -> None:  # noqa: ARG001
+    sys.exit(128 + signalNumber)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog='geniespec')
+    subparsers = parser.add_subparsers(dest='subcommand', required=True)
+    for subcommand in ('build', 'watch'):
+        subparser = subparsers.add_parser(subcommand)
+        subparser.add_argument('--spec', type=pathlib.Path, required=True)
+        subparser.add_argument('--target', choices=sorted(TARGET_LANGUAGE_CODES), required=True)
+        subparser.add_argument('--output', type=pathlib.Path, default=pathlib.Path())
+    subparsers.choices['watch'].add_argument('command', nargs=argparse.REMAINDER, help='command to run while watching, after --')
+    args = parser.parse_args()
+    logging.basicConfig(level=logging.INFO)
+    if args.subcommand == 'build':
+        _build_and_log(specPath=args.spec, target=args.target, outputDirectoryPath=args.output)
+        return
+    command = args.command[1:] if args.command[:1] == ['--'] else args.command
+    signal.signal(signal.SIGTERM, _exit_on_terminate)
+    try:
+        sys.exit(watch(specPath=args.spec, target=args.target, outputDirectoryPath=args.output, command=command))
+    except KeyboardInterrupt:
+        return
+
+
+if __name__ == '__main__':
+    main()

{geniespec-0.1.1.dev2 → geniespec-0.1.1.dev3}/src/geniespec/genie.py

@@ -46,6 +46,7 @@ from geniespec.types import ResponseTypes
 
 SCHEMA_FILE_PATH = pathlib.Path(__file__).parent / 'api_schema.yaml'
 TEMPLATES_DIRECTORY_PATH = pathlib.Path(__file__).parent / 'templates'
+TARGET_LANGUAGE_CODES = {'python-server': 'python'}
 
 
 class SyntacticValidationException(BadRequestException):
@@ -80,9 +81,9 @@ JINJA_FUNCTIONS: dict[str, typing.Callable[[str], BaseLanguageDefinition]] = {
 
 
 class Renderer:
-    def __init__(self) -> None:
-        self.templateDirectoryPath = str(TEMPLATES_DIRECTORY_PATH / 'python')
-        self.languageDefinition = get_language_definition(languageCode='python')
+    def __init__(self, target: str) -> None:
+        self.templateDirectoryPath = str(TEMPLATES_DIRECTORY_PATH / target)
+        self.languageDefinition = get_language_definition(languageCode=TARGET_LANGUAGE_CODES[target])
         self.jinjaEnvironment = jinja2.Environment(loader=jinja2.FileSystemLoader(self.templateDirectoryPath), autoescape=jinja2.select_autoescape(), keep_trailing_newline=True, trim_blocks=True)
         self.jinjaEnvironment.globals['autogenerated_notice'] = self.languageDefinition.AUTOGENERATED_NOTICE
 

{geniespec-0.1.1.dev2 → geniespec-0.1.1.dev3}/src/geniespec/languages.py

@@ -75,9 +75,6 @@ class BaseLanguageDefinition:
     def package_name(self, api: RenderableApi) -> str:
         raise NotImplementedError
 
-    def distribution_name(self, api: RenderableApi) -> str:
-        raise NotImplementedError
-
     def validation_errors(self, api: RenderableApi) -> list[str]:
         raise NotImplementedError
 
@@ -214,9 +211,6 @@ class PythonLanguageDefinition(BaseLanguageDefinition):
     def package_name(self, api: RenderableApi) -> str:
         return f'{self.snake_name(name=api.serviceName)}_api'
 
-    def distribution_name(self, api: RenderableApi) -> str:
-        return f'{self.kebab_name(name=api.serviceName)}-api'
-
     def internal_class_name(self, api: RenderableApi) -> str:
         return f'{self.pascal_name(name=api.serviceName)}ApiV{api.version.major}Internal'
 

geniespec-0.1.1.dev2/README.md

@@ -1,63 +0,0 @@
-# Genie
-
-Genie (`geniespec` on PyPI) generates API code from an `api.yaml` spec. The output is a package you install, not code you commit.
-
-```
-uvx geniespec build --spec api.yaml [--output .genie]
-uvx geniespec watch --spec api.yaml [--output .genie]
-```
-
-- `build` writes `<output>/python`: a project with `pyproject.toml` and `src/<service>_api/v<major>/` (`api`, `endpoints`, `resources`, `internal`, `exceptions`). Only changed files are rewritten and files it no longer generates are removed.
-- `watch` rebuilds whenever the spec changes. If the spec is invalid it logs the error and keeps the previous output.
-- Consumers depend on the output as an editable path dependency, e.g. `my-service-api = { path = ".genie/python", editable = true }` in `[tool.uv.sources]`, and import it as `my_service_api.v1`.
-- Generated code needs `kiba-core` (`core.api`, `core.util.typing_util`), `pydantic` and `starlette` from the consumer.
-
-# Development
-
-```
-make install
-make lint-check type-check test
-```
-
-Merges to `main` publish a dev version to PyPI. To release, bump `version` in `pyproject.toml` in a PR, then run the Release workflow on `main` (Actions → Release → Run workflow). It tags `vX.Y.Z` and the Publish workflow publishes it. Only the release workflow can push version tags.
-
-# Things that need work
-
-## Typing of params and fields in general
-
-Enum and OneOf not supported yet
-
-I think we need to create an object for Type. what would it look like?
-
-
-```
-class BaseFieldType:
-    isNullable: bool
-
-
-class RawFieldType(BaseFieldType):
-    name: str
-
-
-class ClassFieldType(BaseFieldType):
-    fieldType: RawFieldType
-
-
-class ListFieldType:(BaseFieldType)
-    fieldType: RawFieldType
-    isNullable: bool
-
-
-class MappingFieldType(BaseFieldType):
-    keyFieldType: RawFieldType
-    valueFieldType: RawFieldType
-
-
-class OneOfFieldType(BaseFieldType):
-    fieldTypes: list[RawFieldType]
-
-
-class EnumFieldType(BaseFieldType):
-    values: list[str]
-
-```

geniespec-0.1.1.dev2/src/geniespec/cli.py

@@ -1,85 +0,0 @@
-import argparse
-import pathlib
-import tempfile
-import time
-
-import yaml  # type: ignore[import-untyped]
-from core import logging
-
-from geniespec.genie import Renderer
-from geniespec.genie import SyntacticApiValidator
-from geniespec.types import KibaApi
-
-WATCH_INTERVAL_SECONDS = 0.5
-
-
-def _sync_directory(sourceDirectoryPath: pathlib.Path, targetDirectoryPath: pathlib.Path) -> list[pathlib.Path]:
-    changedPaths: list[pathlib.Path] = []
-    sourceRelativePaths = {path.relative_to(sourceDirectoryPath) for path in sourceDirectoryPath.rglob('*') if path.is_file()}
-    for relativePath in sorted(sourceRelativePaths):
-        content = (sourceDirectoryPath / relativePath).read_bytes()
-        targetPath = targetDirectoryPath / relativePath
-        if targetPath.is_file() and targetPath.read_bytes() == content:
-            continue
-        targetPath.parent.mkdir(parents=True, exist_ok=True)
-        temporaryPath = targetPath.with_name(f'.{targetPath.name}.tmp')
-        temporaryPath.write_bytes(content)
-        temporaryPath.replace(targetPath)
-        changedPaths.append(targetPath)
-    stalePaths = [path for path in targetDirectoryPath.rglob('*') if path.is_file() and '__pycache__' not in path.parts and path.relative_to(targetDirectoryPath) not in sourceRelativePaths]
-    for stalePath in stalePaths:
-        stalePath.unlink()
-    return changedPaths + stalePaths
-
-
-def build(specPath: pathlib.Path, outputDirectoryPath: pathlib.Path) -> list[pathlib.Path]:
-    with open(specPath) as specFile:
-        apiYaml = yaml.safe_load(specFile)
-    SyntacticApiValidator().validate(apiYaml)
-    api = KibaApi(**apiYaml)
-    with tempfile.TemporaryDirectory() as renderDirectory:
-        Renderer().render_directory(api=api, outputDirectoryPath=renderDirectory)
-        return _sync_directory(sourceDirectoryPath=pathlib.Path(renderDirectory), targetDirectoryPath=outputDirectoryPath / 'python')
-
-
-def _build_and_log(specPath: pathlib.Path, outputDirectoryPath: pathlib.Path) -> None:
-    changedPaths = build(specPath=specPath, outputDirectoryPath=outputDirectoryPath)
-    logging.info(f'geniespec: built {specPath} into {outputDirectoryPath} ({len(changedPaths)} files changed)')
-
-
-def watch(specPath: pathlib.Path, outputDirectoryPath: pathlib.Path) -> None:
-    lastModifiedTime: int | None = None
-    while True:
-        try:
-            modifiedTime: int | None = specPath.stat().st_mtime_ns
-        except FileNotFoundError:
-            modifiedTime = lastModifiedTime
-        if modifiedTime != lastModifiedTime:
-            lastModifiedTime = modifiedTime
-            try:
-                _build_and_log(specPath=specPath, outputDirectoryPath=outputDirectoryPath)
-            except Exception as exception:  # noqa: BLE001
-                logging.error(f'geniespec: failed to build {specPath}, keeping the previous output: {exception}')
-        time.sleep(WATCH_INTERVAL_SECONDS)
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(prog='geniespec')
-    subparsers = parser.add_subparsers(dest='command', required=True)
-    for command in ('build', 'watch'):
-        subparser = subparsers.add_parser(command)
-        subparser.add_argument('--spec', type=pathlib.Path, required=True)
-        subparser.add_argument('--output', type=pathlib.Path, default=pathlib.Path('.genie'))
-    args = parser.parse_args()
-    logging.basicConfig(level=logging.INFO)
-    if args.command == 'build':
-        _build_and_log(specPath=args.spec, outputDirectoryPath=args.output)
-        return
-    try:
-        watch(specPath=args.spec, outputDirectoryPath=args.output)
-    except KeyboardInterrupt:
-        return
-
-
-if __name__ == '__main__':
-    main()

geniespec-0.1.1.dev2/src/geniespec/templates/python/pyproject.toml.j2

@@ -1,8 +0,0 @@
-{{ autogenerated_notice }}
-[project]
-name = "{{ target.distribution_name(api=api) }}"
-version = "0.0.0"
-
-[build-system]
-requires = ["uv_build>=0.12,<0.13"]
-build-backend = "uv_build"