betterproto2-compiler 0.2.0__py3-none-any.whl

betterproto2_compiler/lib/google/protobuf/compiler/__init__.py

@@ -0,0 +1,235 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# sources: google/protobuf/compiler/plugin.proto
+# plugin: python-betterproto2
+# This file has been @generated
+
+__all__ = (
+    "CodeGeneratorResponseFeature",
+    "CodeGeneratorRequest",
+    "CodeGeneratorResponse",
+    "CodeGeneratorResponseFile",
+    "Version",
+)
+
+
+from dataclasses import dataclass
+from typing import (
+    List,
+    Optional,
+)
+
+import betterproto2
+
+from ....message_pool import default_message_pool
+
+betterproto2.check_compiler_version("0.2.0")
+
+
+class CodeGeneratorResponseFeature(betterproto2.Enum):
+    """
+    Sync with code_generator.h.
+    """
+
+    FEATURE_NONE = 0
+
+    FEATURE_PROTO3_OPTIONAL = 1
+
+    FEATURE_SUPPORTS_EDITIONS = 2
+
+
+@dataclass(eq=False, repr=False)
+class CodeGeneratorRequest(betterproto2.Message):
+    """
+    An encoded CodeGeneratorRequest is written to the plugin's stdin.
+    """
+
+    file_to_generate: "List[str]" = betterproto2.field(1, betterproto2.TYPE_STRING, repeated=True)
+    """
+    The .proto files that were explicitly listed on the command-line.  The
+    code generator should generate code only for these files.  Each file's
+    descriptor will be included in proto_file, below.
+    """
+
+    parameter: "str" = betterproto2.field(2, betterproto2.TYPE_STRING)
+    """
+    The generator parameter passed on the command-line.
+    """
+
+    proto_file: "List[__protobuf__.FileDescriptorProto]" = betterproto2.field(
+        15, betterproto2.TYPE_MESSAGE, repeated=True
+    )
+    """
+    FileDescriptorProtos for all files in files_to_generate and everything
+    they import.  The files will appear in topological order, so each file
+    appears before any file that imports it.
+
+    Note: the files listed in files_to_generate will include runtime-retention
+    options only, but all other files will include source-retention options.
+    The source_file_descriptors field below is available in case you need
+    source-retention options for files_to_generate.
+
+    protoc guarantees that all proto_files will be written after
+    the fields above, even though this is not technically guaranteed by the
+    protobuf wire format.  This theoretically could allow a plugin to stream
+    in the FileDescriptorProtos and handle them one by one rather than read
+    the entire set into memory at once.  However, as of this writing, this
+    is not similarly optimized on protoc's end -- it will store all fields in
+    memory at once before sending them to the plugin.
+
+    Type names of fields and extensions in the FileDescriptorProto are always
+    fully qualified.
+    """
+
+    source_file_descriptors: "List[__protobuf__.FileDescriptorProto]" = betterproto2.field(
+        17, betterproto2.TYPE_MESSAGE, repeated=True
+    )
+    """
+    File descriptors with all options, including source-retention options.
+    These descriptors are only provided for the files listed in
+    files_to_generate.
+    """
+
+    compiler_version: "Optional[Version]" = betterproto2.field(3, betterproto2.TYPE_MESSAGE, optional=True)
+    """
+    The version number of protocol compiler.
+    """
+
+
+default_message_pool.register_message("google.protobuf.compiler", "CodeGeneratorRequest", CodeGeneratorRequest)
+
+
+@dataclass(eq=False, repr=False)
+class CodeGeneratorResponse(betterproto2.Message):
+    """
+    The plugin writes an encoded CodeGeneratorResponse to stdout.
+    """
+
+    error: "str" = betterproto2.field(1, betterproto2.TYPE_STRING)
+    """
+    Error message.  If non-empty, code generation failed.  The plugin process
+    should exit with status code zero even if it reports an error in this way.
+
+    This should be used to indicate errors in .proto files which prevent the
+    code generator from generating correct code.  Errors which indicate a
+    problem in protoc itself -- such as the input CodeGeneratorRequest being
+    unparseable -- should be reported by writing a message to stderr and
+    exiting with a non-zero status code.
+    """
+
+    supported_features: "int" = betterproto2.field(2, betterproto2.TYPE_UINT64)
+    """
+    A bitmask of supported features that the code generator supports.
+    This is a bitwise "or" of values from the Feature enum.
+    """
+
+    file: "List[CodeGeneratorResponseFile]" = betterproto2.field(15, betterproto2.TYPE_MESSAGE, repeated=True)
+
+
+default_message_pool.register_message("google.protobuf.compiler", "CodeGeneratorResponse", CodeGeneratorResponse)
+
+
+@dataclass(eq=False, repr=False)
+class CodeGeneratorResponseFile(betterproto2.Message):
+    """
+    Represents a single generated file.
+    """
+
+    name: "str" = betterproto2.field(1, betterproto2.TYPE_STRING)
+    """
+    The file name, relative to the output directory.  The name must not
+    contain "." or ".." components and must be relative, not be absolute (so,
+    the file cannot lie outside the output directory).  "/" must be used as
+    the path separator, not "\".
+
+    If the name is omitted, the content will be appended to the previous
+    file.  This allows the generator to break large files into small chunks,
+    and allows the generated text to be streamed back to protoc so that large
+    files need not reside completely in memory at one time.  Note that as of
+    this writing protoc does not optimize for this -- it will read the entire
+    CodeGeneratorResponse before writing files to disk.
+    """
+
+    insertion_point: "str" = betterproto2.field(2, betterproto2.TYPE_STRING)
+    """
+    If non-empty, indicates that the named file should already exist, and the
+    content here is to be inserted into that file at a defined insertion
+    point.  This feature allows a code generator to extend the output
+    produced by another code generator.  The original generator may provide
+    insertion points by placing special annotations in the file that look
+    like:
+      @@protoc_insertion_point(NAME)
+    The annotation can have arbitrary text before and after it on the line,
+    which allows it to be placed in a comment.  NAME should be replaced with
+    an identifier naming the point -- this is what other generators will use
+    as the insertion_point.  Code inserted at this point will be placed
+    immediately above the line containing the insertion point (thus multiple
+    insertions to the same point will come out in the order they were added).
+    The double-@ is intended to make it unlikely that the generated code
+    could contain things that look like insertion points by accident.
+
+    For example, the C++ code generator places the following line in the
+    .pb.h files that it generates:
+      // @@protoc_insertion_point(namespace_scope)
+    This line appears within the scope of the file's package namespace, but
+    outside of any particular class.  Another plugin can then specify the
+    insertion_point "namespace_scope" to generate additional classes or
+    other declarations that should be placed in this scope.
+
+    Note that if the line containing the insertion point begins with
+    whitespace, the same whitespace will be added to every line of the
+    inserted text.  This is useful for languages like Python, where
+    indentation matters.  In these languages, the insertion point comment
+    should be indented the same amount as any inserted code will need to be
+    in order to work correctly in that context.
+
+    The code generator that generates the initial file and the one which
+    inserts into it must both run as part of a single invocation of protoc.
+    Code generators are executed in the order in which they appear on the
+    command line.
+
+    If |insertion_point| is present, |name| must also be present.
+    """
+
+    content: "str" = betterproto2.field(15, betterproto2.TYPE_STRING)
+    """
+    The file contents.
+    """
+
+    generated_code_info: "Optional[__protobuf__.GeneratedCodeInfo]" = betterproto2.field(
+        16, betterproto2.TYPE_MESSAGE, optional=True
+    )
+    """
+    Information describing the file content being inserted. If an insertion
+    point is used, this information will be appropriately offset and inserted
+    into the code generation metadata for the generated files.
+    """
+
+
+default_message_pool.register_message(
+    "google.protobuf.compiler", "CodeGeneratorResponse.File", CodeGeneratorResponseFile
+)
+
+
+@dataclass(eq=False, repr=False)
+class Version(betterproto2.Message):
+    """
+    The version number of protocol compiler.
+    """
+
+    major: "int" = betterproto2.field(1, betterproto2.TYPE_INT32)
+
+    minor: "int" = betterproto2.field(2, betterproto2.TYPE_INT32)
+
+    patch: "int" = betterproto2.field(3, betterproto2.TYPE_INT32)
+
+    suffix: "str" = betterproto2.field(4, betterproto2.TYPE_STRING)
+    """
+    A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
+    be empty for mainline stable releases.
+    """
+
+
+default_message_pool.register_message("google.protobuf.compiler", "Version", Version)
+
+
+from ... import protobuf as __protobuf__

betterproto2_compiler/lib/message_pool.py

@@ -0,0 +1,3 @@
+import betterproto2
+
+default_message_pool = betterproto2.MessagePool()

betterproto2_compiler/plugin/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["main"]
+
+from .main import main

betterproto2_compiler/plugin/__main__.py

@@ -0,0 +1,3 @@
+from .main import main
+
+main()

betterproto2_compiler/plugin/compiler.py

@@ -0,0 +1,70 @@
+import os.path
+import subprocess
+import sys
+from importlib import metadata
+
+from .module_validation import ModuleValidator
+
+try:
+    # betterproto[compiler] specific dependencies
+    import jinja2
+except ImportError as err:
+    print(
+        "\033[31m"
+        f"Unable to import `{err.name}` from betterproto plugin! "
+        "Please ensure that you've installed betterproto as "
+        '`pip install "betterproto[compiler]"` so that compiler dependencies '
+        "are included."
+        "\033[0m",
+    )
+    raise SystemExit(1)
+
+from .models import OutputTemplate
+
+
+def outputfile_compiler(output_file: OutputTemplate) -> str:
+    templates_folder = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "templates"))
+
+    version = metadata.version("betterproto2_compiler")
+
+    env = jinja2.Environment(
+        trim_blocks=True,
+        lstrip_blocks=True,
+        loader=jinja2.FileSystemLoader(templates_folder),
+        undefined=jinja2.StrictUndefined,
+    )
+    # Load the body first so we have a compleate list of imports needed.
+    body_template = env.get_template("template.py.j2")
+    header_template = env.get_template("header.py.j2")
+
+    code = body_template.render(output_file=output_file)
+    code = header_template.render(output_file=output_file, version=version) + "\n" + code
+
+    try:
+        # Sort imports, delete unused ones
+        code = subprocess.check_output(
+            ["ruff", "check", "--select", "I,F401,TCH005", "--fix", "--silent", "-"],
+            input=code,
+            encoding="utf-8",
+        )
+
+        # Format the code
+        code = subprocess.check_output(["ruff", "format", "-"], input=code, encoding="utf-8")
+    except subprocess.CalledProcessError:
+        with open("invalid-generated-code.py", "w") as f:
+            f.write(code)
+
+        raise SyntaxError(
+            f"Can't format the source code:\nThe invalid generated code has been written in `invalid-generated-code.py`"
+        )
+
+    # Validate the generated code.
+    validator = ModuleValidator(iter(code.splitlines()))
+    if not validator.validate():
+        message_builder = ["[WARNING]: Generated code has collisions in the module:"]
+        for collision, lines in validator.collisions.items():
+            message_builder.append(f'  "{collision}" on lines:')
+            for num, line in lines:
+                message_builder.append(f"    {num}:{line}")
+        print("\n".join(message_builder), file=sys.stderr)
+    return code

betterproto2_compiler/plugin/main.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+
+import os
+import sys
+
+from betterproto2_compiler.lib.google.protobuf.compiler import (
+    CodeGeneratorRequest,
+)
+from betterproto2_compiler.plugin.parser import generate_code
+
+
+def main() -> None:
+    """The plugin's main entry point."""
+    # Read request message from stdin
+    data = sys.stdin.buffer.read()
+
+    # Parse request
+    request = CodeGeneratorRequest()
+    request.parse(data)
+
+    dump_file = os.getenv("BETTERPROTO_DUMP")
+    if dump_file:
+        dump_request(dump_file, request)
+
+    # Generate code
+    response = generate_code(request)
+
+    # Serialise response message
+    output = response.SerializeToString()
+
+    # Write to stdout
+    sys.stdout.buffer.write(output)
+
+
+def dump_request(dump_file: str, request: CodeGeneratorRequest) -> None:
+    """
+    For developers: Supports running plugin.py standalone so its possible to debug it.
+    Run protoc (or generate.py) with BETTERPROTO_DUMP="yourfile.bin" to write the request to a file.
+    Then run plugin.py from your IDE in debugging mode, and redirect stdin to the file.
+    """
+    with open(str(dump_file), "wb") as fh:
+        sys.stderr.write(f"\033[31mWriting input from protoc to: {dump_file}\033[0m\n")
+        fh.write(request.SerializeToString())
+
+
+if __name__ == "__main__":
+    main()