betterproto2-compiler 0.0.3__py3-none-any.whl → 0.1.1__py3-none-any.whl

betterproto2_compiler/compile/importing.py

@@ -3,22 +3,18 @@ from __future__ import annotations
 import os
 from typing import (
     TYPE_CHECKING,
-    Dict,
-    List,
-    Set,
-    Tuple,
-    Type,
 )
 
+from betterproto2.lib.google import protobuf as google_protobuf
+
 from ..casing import safe_snake_case
-from ..lib.google import protobuf as google_protobuf
 from .naming import pythonize_class_name
 
 if TYPE_CHECKING:
     from ..plugin.models import PluginRequestCompiler
     from ..plugin.typing_compiler import TypingCompiler
 
-WRAPPER_TYPES: Dict[str, Type] = {
+WRAPPER_TYPES: dict[str, type] = {
     ".google.protobuf.DoubleValue": google_protobuf.DoubleValue,
     ".google.protobuf.FloatValue": google_protobuf.FloatValue,
     ".google.protobuf.Int32Value": google_protobuf.Int32Value,
@@ -31,7 +27,7 @@ WRAPPER_TYPES: Dict[str, Type] = {
 }
 
 
-def parse_source_type_name(field_type_name: str, request: "PluginRequestCompiler") -> Tuple[str, str]:
+def parse_source_type_name(field_type_name: str, request: PluginRequestCompiler) -> tuple[str, str]:
     """
     Split full source type name into package and type name.
     E.g. 'root.package.Message' -> ('root.package', 'Message')
@@ -77,7 +73,7 @@ def get_type_reference(
     imports: set,
     source_type: str,
     typing_compiler: TypingCompiler,
-    request: "PluginRequestCompiler",
+    request: PluginRequestCompiler,
     unwrap: bool = True,
     pydantic: bool = False,
 ) -> str:
@@ -98,8 +94,8 @@ def get_type_reference(
 
     source_package, source_type = parse_source_type_name(source_type, request)
 
-    current_package: List[str] = package.split(".") if package else []
-    py_package: List[str] = source_package.split(".") if source_package else []
+    current_package: list[str] = package.split(".") if package else []
+    py_package: list[str] = source_package.split(".") if source_package else []
     py_type: str = pythonize_class_name(source_type)
 
     compiling_google_protobuf = current_package == ["google", "protobuf"]
@@ -122,7 +118,7 @@ def get_type_reference(
     return reference_cousin(current_package, imports, py_package, py_type)
 
 
-def reference_absolute(imports: Set[str], py_package: List[str], py_type: str) -> str:
+def reference_absolute(imports: set[str], py_package: list[str], py_type: str) -> str:
     """
     Returns a reference to a python type located in the root, i.e. sys.path.
     """
@@ -139,7 +135,7 @@ def reference_sibling(py_type: str) -> str:
     return f"{py_type}"
 
 
-def reference_descendent(current_package: List[str], imports: Set[str], py_package: List[str], py_type: str) -> str:
+def reference_descendent(current_package: list[str], imports: set[str], py_package: list[str], py_type: str) -> str:
     """
     Returns a reference to a python type in a package that is a descendent of the
     current package, and adds the required import that is aliased to avoid name
@@ -157,7 +153,7 @@ def reference_descendent(current_package: List[str], imports: Set[str], py_packa
         return f"{string_import}.{py_type}"
 
 
-def reference_ancestor(current_package: List[str], imports: Set[str], py_package: List[str], py_type: str) -> str:
+def reference_ancestor(current_package: list[str], imports: set[str], py_package: list[str], py_type: str) -> str:
     """
     Returns a reference to a python type in a package which is an ancestor to the
     current package, and adds the required import that is aliased (if possible) to avoid
@@ -178,7 +174,7 @@ def reference_ancestor(current_package: List[str], imports: Set[str], py_package
         return string_alias
 
 
-def reference_cousin(current_package: List[str], imports: Set[str], py_package: List[str], py_type: str) -> str:
+def reference_cousin(current_package: list[str], imports: set[str], py_package: list[str], py_type: str) -> str:
     """
     Returns a reference to a python type in a package that is not descendent, ancestor
     or sibling, and adds the required import that is aliased to avoid name conflicts.

betterproto2_compiler/lib/google/protobuf/__init__.py

@@ -1 +0,0 @@
-from betterproto2_compiler.lib.std.google.protobuf import *

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

@@ -1 +1,229 @@
-from betterproto2_compiler.lib.std.google.protobuf.compiler import *
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# sources: plugin.proto
+# plugin: python-betterproto2
+# This file has been @generated
+
+__all__ = (
+    "CodeGeneratorResponseFeature",
+    "CodeGeneratorRequest",
+    "CodeGeneratorResponse",
+    "CodeGeneratorResponseFile",
+    "Version",
+)
+
+
+from dataclasses import dataclass
+from typing import (
+    TYPE_CHECKING,
+    List,
+    Optional,
+)
+
+import betterproto2
+
+if TYPE_CHECKING:
+    pass
+
+betterproto2.check_compiler_version("0.1.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[betterproto2_lib_google_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[betterproto2_lib_google_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.
+    """
+
+
+@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.
+    """
+    minimum_edition: "int" = betterproto2.field(3, betterproto2.TYPE_INT32)
+    """
+    The minimum edition this plugin supports.  This will be treated as an
+    Edition enum, but we want to allow unknown values.  It should be specified
+    according the edition enum value, *not* the edition number.  Only takes
+    effect for plugins that have FEATURE_SUPPORTS_EDITIONS set.
+    """
+    maximum_edition: "int" = betterproto2.field(4, betterproto2.TYPE_INT32)
+    """
+    The maximum edition this plugin supports.  This will be treated as an
+    Edition enum, but we want to allow unknown values.  It should be specified
+    according the edition enum value, *not* the edition number.  Only takes
+    effect for plugins that have FEATURE_SUPPORTS_EDITIONS set.
+    """
+    file: "List[CodeGeneratorResponseFile]" = betterproto2.field(15, betterproto2.TYPE_MESSAGE, repeated=True)
+
+
+@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[betterproto2_lib_google_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.
+    """
+
+
+@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.
+    """
+
+
+import betterproto2.lib.google.protobuf as betterproto2_lib_google_protobuf

betterproto2_compiler/plugin/compiler.py

@@ -1,6 +1,7 @@
 import os.path
 import subprocess
 import sys
+from importlib import metadata
 
 from .module_validation import ModuleValidator
 
@@ -14,7 +15,7 @@ except ImportError as err:
         "Please ensure that you've installed betterproto as "
         '`pip install "betterproto[compiler]"` so that compiler dependencies '
         "are included."
-        "\033[0m"
+        "\033[0m",
     )
     raise SystemExit(1)
 
@@ -24,6 +25,8 @@ 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,
@@ -35,7 +38,7 @@ def outputfile_compiler(output_file: OutputTemplate) -> str:
     header_template = env.get_template("header.py.j2")
 
     code = body_template.render(output_file=output_file)
-    code = header_template.render(output_file=output_file) + "\n" + code
+    code = header_template.render(output_file=output_file, version=version) + "\n" + code
 
     # Sort imports, delete unused ones
     code = subprocess.check_output(