protoc-gen-sqlmodel 0.1.0__tar.gz

protoc_gen_sqlmodel-0.1.0/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.3
+Name: protoc-gen-sqlmodel
+Version: 0.1.0
+Summary: Add your description here
+Author: river-studio-main
+Author-email: river-studio-main <62842368+river-studio-main@users.noreply.github.com>
+Requires-Dist: logging>=0.4.9.6
+Requires-Dist: protobuf-py>=0.4.0
+Requires-Dist: protoc-gen-py>=0.4.0
+Requires-Dist: sqlmodel>=0.0.42
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# protoc-gen-sqlmodel
+A protoc plugin for producing sqlmodel classes
+Run with: 
+```shell
+uv run protoc input.proto --plugin=protoc-gen-custom-plugin=./plugin.py --custom-plugin_out=.
+```

protoc_gen_sqlmodel-0.1.0/README.md

@@ -0,0 +1,6 @@
+# protoc-gen-sqlmodel
+A protoc plugin for producing sqlmodel classes
+Run with: 
+```shell
+uv run protoc input.proto --plugin=protoc-gen-custom-plugin=./plugin.py --custom-plugin_out=.
+```

protoc_gen_sqlmodel-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "protoc-gen-sqlmodel"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "logging>=0.4.9.6",
+    "protobuf-py>=0.4.0",
+    "protoc-gen-py>=0.4.0",
+    "sqlmodel>=0.0.42",
+]
+
+[[project.authors]]
+name = "river-studio-main"
+email = "62842368+river-studio-main@users.noreply.github.com"
+
+[project.scripts]
+protoc-gen-sqlmodel = "protoc_gen_sqlmodel:main"
+
+[build-system]
+requires = ["uv_build>=0.12.7,<0.13.0"]
+build-backend = "uv_build"

protoc_gen_sqlmodel-0.1.0/pyproject.toml.orig

@@ -0,0 +1,22 @@
+[project]
+name = "protoc-gen-sqlmodel"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [
+    { name = "river-studio-main", email = "62842368+river-studio-main@users.noreply.github.com" },
+]
+requires-python = ">=3.14"
+dependencies = [
+    "logging>=0.4.9.6",
+    "protobuf-py>=0.4.0",
+    "protoc-gen-py>=0.4.0",
+    "sqlmodel>=0.0.42",
+]
+
+[project.scripts]
+protoc-gen-sqlmodel = "protoc_gen_sqlmodel:main"
+
+[build-system]
+requires = ["uv_build>=0.12.7,<0.13.0"]
+build-backend = "uv_build"

protoc_gen_sqlmodel-0.1.0/src/protoc_gen_sqlmodel/__init__.py

@@ -0,0 +1,7 @@
+from protobuf.plugin import run
+
+from .plugin import generate
+
+
+def main():
+    run("protoc-gen-sqlmodel", "0.1.0", generate)

protoc_gen_sqlmodel-0.1.0/src/protoc_gen_sqlmodel/plugin.py

@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+"""
+This plugin parses protobuf files into SQLModel classes.
+The plugin system exposes the following structure, used as a base for functional parsing:
+
+Schema
+└── DescFile
+    ├── extensions 	Sequence[DescExtension]
+    ├── dependencies 	Sequence[DescFile]
+    ├── enums 	Sequence[DescEnum]
+    │   └── values 	Sequence[DescEnumValue]
+    ├── messages 	Sequence[DescMessage]
+    │   ├── fields 	Sequence[DescField]
+    │   ├── nested_enums 	Sequence[DescEnum]
+    │   ├── nested_messages 	Sequence[DescMessage]
+    │   └── oneofs 	Sequence[DescOneof]
+    └── Sequence[DescService]
+        └── ...
+
+Services are skipped at the moment.
+"""
+
+from logging import getLogger
+
+from protobuf import (
+    DescEnum,
+    DescExtension,
+    DescField,
+    DescFieldValueEnum,
+    DescFieldValueList,
+    DescFieldValueMap,
+    DescFieldValueMessage,
+    DescFieldValueScalar,
+    DescMessage,
+    DescOneof,
+    ScalarType,
+)
+from protobuf._descriptors import SupportedFieldPresence
+from protobuf.plugin import File, Module, Schema
+
+ENUM = Module("enum").ident("Enum")
+FIELD = Module("sqlmodel").ident("Field")
+SQLMODEL = Module("sqlmodel").ident("SQLModel")
+ANY = Module("typing").ident("Any")
+FINAL = Module("typing").ident("Final")
+EXTENSION = Module("protobuf").ident("Extension")
+FIELD_OPT = Module("protobuf.wkt").ident("FieldOptions")
+MESSAGE_OPT = Module("protobuf.wkt").ident("MessageOptions")
+
+
+logger = getLogger()
+
+
+def get_presence(presence: SupportedFieldPresence) -> str:
+    match presence:
+        case SupportedFieldPresence.EXPLICIT:
+            return " | None "
+        case SupportedFieldPresence.IMPLICIT:
+            return ""
+        case _:
+            return ""
+
+
+def get_python_scalar_type(scalar: ScalarType):
+    match scalar:
+        case ScalarType.BOOL:
+            return "bool"
+        case ScalarType.BYTES:
+            return "bytes"
+        case (
+            ScalarType.DOUBLE
+            | ScalarType.FIXED32
+            | ScalarType.FIXED64
+            | ScalarType.FLOAT
+            | ScalarType.SFIXED32
+            | ScalarType.SFIXED64
+        ):
+            return "float"
+        case (
+            ScalarType.INT32
+            | ScalarType.INT64
+            | ScalarType.UINT32
+            | ScalarType.UINT64
+            | ScalarType.SINT32
+            | ScalarType.SINT64
+        ):
+            return "int"
+        case ScalarType.STRING:
+            return "str"
+
+
+def handle_leaf_enum(desc: DescEnum, f: File):
+    with f.scope(f"class {desc.name}(", ENUM, ", int):"):
+        for v in desc.values:
+            f.print(f"{v.local_name} = {v.number}")
+    f.print()
+
+
+def handle_leaf_oneof(desc: DescOneof, f: File):
+    f.print(f"# oneof {desc.local_name}")
+    distinguisher = f"which_{desc.local_name}: "
+    f.print(
+        distinguisher,
+        Module("typing").ident("Literal"),
+        "['",
+        "', '".join([field.local_name for field in desc.fields]),
+        "']",
+    )
+    for field in desc.fields:
+        handle_leaf_field(field, f)
+    f.print()
+
+
+def handle_import(element: DescEnum | DescMessage):
+    if element.file.proto.package == "google.protobuf":  # well known types
+        match element.name:
+            case "Timestamp":
+                return Module("datetime").ident("datetime")
+            case "Any":
+                return Module("typing").ident("Any")
+    return Module.for_desc(element.file, "_sqlmodel").ident(element.name)
+
+
+def handle_leaf_field(desc: DescField, f: File):
+    field_name, field_presence = desc.name, get_presence(desc.presence)
+    field_preamble, field_presence_preamble = f"{field_name}: ", f"{field_presence}= "
+    print_components = [field_preamble]
+
+    match desc.value:
+        case DescFieldValueScalar(scalar, default_value, _):
+            print_components.append(get_python_scalar_type(scalar))
+            if default_value:
+                print_components.extend(
+                    [field_presence_preamble, FIELD, f"(default={default_value})"]
+                )
+            else:
+                print_components.append(field_presence)
+        case DescFieldValueMessage(message, _, _):
+            print_components.extend([handle_import(message), field_presence])
+        case DescFieldValueEnum(enum, default_value, _):
+            print_components.append(handle_import(enum))
+            if default_value is not None:  # can be 0
+                print_components.extend(
+                    [field_presence_preamble, FIELD, f"(default={default_value})"]
+                )
+            else:
+                print_components.append(field_presence)
+        case DescFieldValueMap(key, value):
+            print_components.append(f"dict[{get_python_scalar_type(key)}, ")
+            match value:
+                case ScalarType():
+                    print_components.append(f"{get_python_scalar_type(value)}]")
+                case DescMessage() | DescEnum():
+                    print_components.extend([handle_import(value), "]"])
+            print_components.append(field_presence)
+        case DescFieldValueList(element, _, _):
+            print_components.append("list[")
+            match element:
+                case ScalarType():
+                    print_components.append(f"{get_python_scalar_type(element)}]")
+                case DescEnum() | DescMessage():
+                    print_components.extend(
+                        [
+                            handle_import(element),
+                            "]",
+                            field_presence,
+                        ]  # is this a bug? shouldn't field_presence be added to the scalar case too?
+                    )
+    # if opts := desc.proto.options:
+    #     from .sqlmodel_extensions_pb import ext_sqlmodel_type
+
+    # if ext_sqlmodel_type in opts:
+    #     print_components.extend(
+    #         [
+    #             field_presence_preamble,
+    #             FIELD,
+    #             f"(sa_column={handle_import(opts[ext_sqlmodel_type])})",
+    #         ]
+    #     )
+    f.print(*print_components)
+
+
+def handle_message(desc: DescMessage, f: File, root: bool = True):
+    class_suffix = "):"
+    if opts := desc.proto.options:
+        from .proto.sqlmodel_extensions_pb import ext_table
+
+        class_suffix = ", table=True):" if ext_table in opts else "):"
+    with f.scope(f"class {desc.name}(", SQLMODEL, class_suffix):
+        for nm in desc.nested_enums:
+            handle_leaf_enum(nm, f)
+        for nm in desc.nested_messages:
+            handle_message(nm, f, False)
+        for field in desc.fields:
+            handle_leaf_field(field, f)
+        for oneof in desc.oneofs:
+            handle_leaf_oneof(oneof, f)
+    f.print()
+    if root:
+        f.print()
+
+
+def handle_extension(desc: DescExtension, f: File):
+    match desc.extendee.type_name:
+        case "google.protobuf.MessageOptions":
+            ext = MESSAGE_OPT
+        case "google.protobuf.FieldOptions":
+            ext = FIELD_OPT
+    match desc.value:
+        case DescFieldValueScalar(scalar, _, _):
+            ext_type = get_python_scalar_type(scalar)
+
+    f.print(
+        f"ext_{desc.name}: ",
+        FINAL,
+        "[",
+        EXTENSION,
+        "[",
+        ext,
+        ", ",
+        ext_type,
+        "]] = ",
+        EXTENSION,
+        "()",
+    )
+
+
+def generate(schema: Schema) -> None:
+    for desc in schema.files_to_generate:
+        f = schema.generate_file(desc, "_sqlmodel.py")
+        f.preamble(desc)
+        for ext in desc.extensions:
+            handle_extension(ext, f)
+        for e in desc.enums:
+            handle_leaf_enum(e, f)
+        for m in desc.messages:
+            handle_message(m, f)

protoc_gen_sqlmodel-0.1.0/src/protoc_gen_sqlmodel/proto/__init__.py

@@ -0,0 +1 @@
+

protoc_gen_sqlmodel-0.1.0/src/protoc_gen_sqlmodel/proto/sqlmodel_extensions.proto

@@ -0,0 +1,15 @@
+syntax = "proto3";
+
+package example.sqlmodel;
+
+import "google/protobuf/descriptor.proto";
+
+// Marks a protobuf message as a SQLModel table.
+extend google.protobuf.MessageOptions {
+  bool table = 50001;
+}
+
+// Overrides the default protobuf-to-SQLModel field conversion.
+extend google.protobuf.FieldOptions {
+  string sqlmodel_type = 50002;
+}

protoc_gen_sqlmodel-0.1.0/src/protoc_gen_sqlmodel/proto/sqlmodel_extensions_pb.py

@@ -0,0 +1,48 @@
+# Generated from sqlmodel_extensions.proto. DO NOT EDIT.
+# Generated by protoc-gen-py v0.4.0 with parameter "".
+# ruff: noqa: PGH004
+# ruff: noqa
+# fmt: off
+
+from __future__ import annotations
+
+from typing import Final, TYPE_CHECKING
+
+from protobuf import Extension
+from protobuf._codegen import file_desc
+from protobuf.wkt import FieldOptions, MessageOptions, descriptor_pb
+
+if TYPE_CHECKING:
+    from protobuf import DescFile
+
+
+ext_table: Final[Extension[MessageOptions, bool]] = Extension()
+"""
+```proto
+extend google.protobuf.MessageOptions { optional bool table = 50001 [json_name = "[example.sqlmodel.table]"] }
+```
+"""
+
+ext_sqlmodel_type: Final[Extension[FieldOptions, str]] = Extension()
+"""
+```proto
+extend google.protobuf.FieldOptions { optional string sqlmodel_type = 50002 [json_name = "[example.sqlmodel.sqlmodel_type]"] }
+```
+"""
+
+
+_DESC = file_desc(
+    b'\n\x19sqlmodel_extensions.proto\x12\x10example.sqlmodel\x1a google/protobuf/descriptor.proto:7\n\x05table\x18\xd1\x86\x03 \x01(\x08\x12\x1f.google.protobuf.MessageOptionsR\x05table:D\n\rsqlmodel_type\x18\xd2\x86\x03 \x01(\t\x12\x1d.google.protobuf.FieldOptionsR\x0csqlmodelTypeb\x06proto3',
+    [
+        descriptor_pb.desc(),
+    ],
+    {
+        "table": ext_table,
+        "sqlmodel_type": ext_sqlmodel_type,
+    },
+)
+
+
+def desc() -> DescFile:
+    """Returns the descriptor for the file `sqlmodel_extensions.proto`."""
+    return _DESC