betterproto2-compiler 0.7.0__tar.gz → 0.7.1__tar.gz

{betterproto2_compiler-0.7.0 → betterproto2_compiler-0.7.1}/.gitignore

@@ -7,6 +7,7 @@
 .python-version
 build/
 */tests/output_*
+*/tests/outputs/*
 **/__pycache__
 dist
 **/*.egg-info
@@ -18,4 +19,4 @@ output
 .asv
 venv
 .devcontainer
-.ruff_cache
+.ruff_cache

{betterproto2_compiler-0.7.0 → betterproto2_compiler-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: betterproto2_compiler
-Version: 0.7.0
+Version: 0.7.1
 Summary: Compiler for betterproto2
 Project-URL: Documentation, https://betterproto.github.io/python-betterproto2/
 Project-URL: Repository, https://github.com/betterproto/python-betterproto2

{betterproto2_compiler-0.7.0 → betterproto2_compiler-0.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "betterproto2_compiler"
-version = "0.7.0"
+version = "0.7.1"
 description = "Compiler for betterproto2"
 authors = [
     { name = "Adrien Vannson", email = "adrien.vannson@protonmail.com" },
@@ -60,7 +60,7 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [tool.ruff]
-extend-exclude = ["tests/output_*", "src/betterproto2_compiler/lib"]
+extend-exclude = ["tests/outputs", "src/betterproto2_compiler/lib"]
 target-version = "py310"
 line-length = 120
 
@@ -88,7 +88,8 @@ cmd = "pytest"
 help = "Run tests"
 
 [tool.poe.tasks.generate]
-sequence = ["_generate_tests", "_generate_tests_lib"]
+# sequence = ["_generate_tests", "_generate_tests_lib"]
+sequence = ["_generate_tests"]
 help = "Generate test cases"
 
 [tool.poe.tasks._generate_tests]

{betterproto2_compiler-0.7.0 → betterproto2_compiler-0.7.1}/src/betterproto2_compiler/known_types/google_values.py

@@ -24,10 +24,10 @@ class BoolValue(VanillaBoolValue):
         return self.value
 
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, bool):
             return BoolValue(value=value)
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     def to_dict(
         self,
@@ -48,10 +48,10 @@ class Int32Value(VanillaInt32Value):
         return self.value
 
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, int):
             return Int32Value(value=value)
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     def to_dict(
         self,
@@ -72,10 +72,10 @@ class Int64Value(VanillaInt64Value):
         return self.value
 
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, int):
             return Int64Value(value=value)
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     def to_dict(
         self,
@@ -96,10 +96,10 @@ class UInt32Value(VanillaUInt32Value):
         return self.value
 
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, int):
             return UInt32Value(value=value)
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     def to_dict(
         self,
@@ -120,10 +120,10 @@ class UInt64Value(VanillaUInt64Value):
         return self.value
 
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, int):
             return UInt64Value(value=value)
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     def to_dict(
         self,
@@ -144,10 +144,10 @@ class FloatValue(VanillaFloatValue):
         return self.value
 
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, float):
             return FloatValue(value=value)
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     def to_dict(
         self,
@@ -168,10 +168,10 @@ class DoubleValue(VanillaDoubleValue):
         return self.value
 
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, float):
             return DoubleValue(value=value)
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     def to_dict(
         self,
@@ -192,10 +192,10 @@ class StringValue(VanillaStringValue):
         return self.value
 
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, str):
             return StringValue(value=value)
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     def to_dict(
         self,
@@ -216,10 +216,10 @@ class BytesValue(VanillaBytesValue):
         return self.value
 
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, bytes):
             return BytesValue(value=value)
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     def to_dict(
         self,

{betterproto2_compiler-0.7.0 → betterproto2_compiler-0.7.1}/src/betterproto2_compiler/plugin/models.py

@@ -34,10 +34,10 @@ from dataclasses import (
 
 from betterproto2 import unwrap
 
+from betterproto2_compiler import casing
 from betterproto2_compiler.compile.importing import get_type_reference, parse_source_type_name
 from betterproto2_compiler.compile.naming import (
     pythonize_class_name,
-    pythonize_enum_member_name,
     pythonize_field_name,
     pythonize_method_name,
 )
@@ -610,20 +610,47 @@ class EnumDefinitionCompiler(ProtoContentBase):
         """Representation of an Enum entry."""
 
         name: str
+        proto_name: str
         value: int
         comment: str
 
     def __post_init__(self) -> None:
-        # Get entries/allowed values for this Enum
         self.entries = [
             self.EnumEntry(
-                name=pythonize_enum_member_name(entry_proto_value.name, self.proto_obj.name),
+                name=entry_proto_value.name,
+                proto_name=entry_proto_value.name,
                 value=entry_proto_value.number,
                 comment=get_comment(proto_file=self.source_file, path=self.path + [2, entry_number]),
             )
             for entry_number, entry_proto_value in enumerate(self.proto_obj.value)
         ]
 
+        if not self.entries:
+            return
+
+        # Remove enum prefixes
+        enum_name: str = self.proto_obj.name
+
+        enum_name_reduced = enum_name.replace("_", "").lower()
+
+        first_entry = self.entries[0].name
+
+        # Find the potential common prefix
+        enum_prefix = ""
+        for i in range(len(first_entry)):
+            if first_entry[: i + 1].replace("_", "").lower() == enum_name_reduced:
+                enum_prefix = f"{first_entry[: i + 1]}_"
+                break
+
+        should_rename = enum_prefix and all(entry.name.startswith(enum_prefix) for entry in self.entries)
+
+        if should_rename:
+            for entry in self.entries:
+                entry.name = entry.name[len(enum_prefix) :]
+
+        for entry in self.entries:
+            entry.name = casing.sanitize_name(entry.name)
+
     @property
     def proto_name(self) -> str:
         return self.proto_obj.name
@@ -647,6 +674,10 @@ class EnumDefinitionCompiler(ProtoContentBase):
         """
         return self.output_file.get_descriptor_name(self.source_file)
 
+    @property
+    def has_renamed_entries(self) -> bool:
+        return any(entry.proto_name != entry.name for entry in self.entries)
+
 
 @dataclass(kw_only=True)
 class ServiceCompiler(ProtoContentBase):

{betterproto2_compiler-0.7.0 → betterproto2_compiler-0.7.1}/src/betterproto2_compiler/templates/service_stub_sync.py.j2

@@ -29,24 +29,22 @@
 {% block method_body %}
     {% if method.server_streaming %}
       {% if method.client_streaming %}
-        for response in self._channel.stream_stream(
+        yield from self._channel.stream_stream(
             "{{ method.route }}",
             {{ method.py_input_message_type }}.SerializeToString,
             {{ method.py_output_message_type }}.FromString,
-        )(iter(messages)):
-            yield response
+        )(iter(messages))
       {% else %}
         {% if method.is_input_msg_empty %}
         if message is None:
             message = {{ method.py_input_message_type }}()
 
         {% endif %}
-        for response in self._channel.unary_stream(
+        yield from self._channel.unary_stream(
             "{{ method.route }}",
             {{ method.py_input_message_type }}.SerializeToString,
             {{ method.py_output_message_type }}.FromString,
-        )(message):
-            yield response
+        )(message)
 
       {% endif %}
     {% else %}

{betterproto2_compiler-0.7.0 → betterproto2_compiler-0.7.1}/src/betterproto2_compiler/templates/template.py.j2

@@ -31,6 +31,16 @@ class {{ enum.py_name | add_to_all }}(betterproto2.Enum):
         return core_schema.int_schema(ge=0)
     {% endif %}
 
+    {% if enum.has_renamed_entries %}
+    betterproto_proto_names = {
+        {% for entry in enum.entries %}
+        {% if entry.proto_name != entry.name %}
+        {{ entry.value }}: "{{ entry.proto_name }}",
+        {% endif %}
+        {% endfor %}
+    }
+    {% endif %}
+
 {% endfor %}
 {% for _, message in output_file.messages|dictsort(by="key") %}
 {% if output_file.settings.pydantic_dataclasses %}

betterproto2_compiler-0.7.1/tests/generate.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python
+import asyncio
+import os
+import shutil
+
+from tests.util import protoc
+
+# Force pure-python implementation instead of C++, otherwise imports
+# break things because we can't properly reset the symbol database.
+os.environ["PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION"] = "python"
+
+
+async def generate_test(
+    name,
+    semaphore: asyncio.Semaphore,
+    *,
+    reference: bool = False,
+    pydantic: bool = False,
+    descriptors: bool = False,
+):
+    await semaphore.acquire()
+
+    dir_path = os.path.dirname(os.path.realpath(__file__))
+
+    options = []
+    if reference:
+        options.append("reference")
+    if pydantic:
+        options.append("pydantic")
+    if descriptors:
+        options.append("descriptors")
+
+    input_dir = dir_path + "/inputs/" + name
+    output_dir = dir_path + "/outputs/" + name + ("_" + "_".join(options) if options else "")
+
+    os.mkdir(output_dir)
+
+    stdout, stderr, returncode = await protoc(
+        input_dir,
+        output_dir,
+        reference=reference,
+        pydantic_dataclasses=pydantic,
+        google_protobuf_descriptors=descriptors,
+    )
+
+    if options:
+        options_str = ", ".join(options)
+        options_str = f" ({options_str})"
+    else:
+        options_str = ""
+
+    if returncode == 0:
+        print(f"\033[31;1;4mGenerated output for {name!r}{options_str}\033[0m")
+    else:
+        print(f"\033[31;1;4mFailed to generate reference output for {name!r}{options_str}\033[0m")
+        print(stderr.decode())
+
+    semaphore.release()
+
+
+async def main_async():
+    # Don't compile too many tests in parallel
+    semaphore = asyncio.Semaphore(os.cpu_count() or 1)
+
+    tasks = [
+        generate_test("any", semaphore),
+        generate_test("bool", semaphore, pydantic=True),
+        generate_test("bool", semaphore, reference=True),
+        generate_test("bool", semaphore),
+        generate_test("bytes", semaphore, reference=True),
+        generate_test("bytes", semaphore),
+        generate_test("casing_inner_class", semaphore),
+        generate_test("casing", semaphore, reference=True),
+        generate_test("casing", semaphore),
+        generate_test("deprecated", semaphore, reference=True),
+        generate_test("deprecated", semaphore),
+        generate_test("documentation", semaphore),
+        generate_test("double", semaphore, reference=True),
+        generate_test("double", semaphore),
+        generate_test("encoding_decoding", semaphore),
+        generate_test("enum", semaphore, reference=True),
+        generate_test("enum", semaphore),
+        generate_test("example_service", semaphore),
+        generate_test("features", semaphore),
+        generate_test("field_name_identical_to_type", semaphore, reference=True),
+        generate_test("field_name_identical_to_type", semaphore),
+        generate_test("fixed", semaphore, reference=True),
+        generate_test("fixed", semaphore),
+        generate_test("float", semaphore, reference=True),
+        generate_test("float", semaphore),
+        generate_test("google_impl_behavior_equivalence", semaphore, reference=True),
+        generate_test("google_impl_behavior_equivalence", semaphore),
+        generate_test("google", semaphore),
+        generate_test("googletypes_request", semaphore),
+        generate_test("googletypes_response_embedded", semaphore),
+        generate_test("googletypes_response", semaphore),
+        generate_test("googletypes_struct", semaphore, reference=True),
+        generate_test("googletypes_struct", semaphore),
+        generate_test("googletypes_value", semaphore, reference=True),
+        generate_test("googletypes_value", semaphore),
+        generate_test("googletypes", semaphore, reference=True),
+        generate_test("googletypes", semaphore),
+        generate_test("grpclib_reflection", semaphore, descriptors=True),
+        generate_test("grpclib_reflection", semaphore),
+        generate_test("import_cousin_package_same_name", semaphore, descriptors=True),
+        generate_test("import_cousin_package_same_name", semaphore),
+        generate_test("import_service_input_message", semaphore),
+        generate_test("int32", semaphore, reference=True),
+        generate_test("int32", semaphore),
+        generate_test("invalid_field", semaphore, pydantic=True),
+        generate_test("invalid_field", semaphore),
+        generate_test("manual_validation", semaphore, pydantic=True),
+        generate_test("manual_validation", semaphore),
+        generate_test("map", semaphore, reference=True),
+        generate_test("map", semaphore),
+        generate_test("mapmessage", semaphore, reference=True),
+        generate_test("mapmessage", semaphore),
+        generate_test("message_wrapping", semaphore),
+        generate_test("namespace_builtin_types", semaphore, reference=True),
+        generate_test("namespace_builtin_types", semaphore),
+        generate_test("namespace_keywords", semaphore, reference=True),
+        generate_test("namespace_keywords", semaphore),
+        generate_test("nested", semaphore, reference=True),
+        generate_test("nested", semaphore),
+        generate_test("nestedtwice", semaphore, reference=True),
+        generate_test("nestedtwice", semaphore),
+        generate_test("oneof_default_value_serialization", semaphore),
+        generate_test("oneof_empty", semaphore, reference=True),
+        generate_test("oneof_empty", semaphore),
+        generate_test("oneof_enum", semaphore, reference=True),
+        generate_test("oneof_enum", semaphore),
+        generate_test("oneof", semaphore, pydantic=True),
+        generate_test("oneof", semaphore, reference=True),
+        generate_test("oneof", semaphore),
+        generate_test("pickling", semaphore),
+        generate_test("proto3_field_presence_oneof", semaphore, reference=True),
+        generate_test("proto3_field_presence_oneof", semaphore),
+        generate_test("proto3_field_presence", semaphore, reference=True),
+        generate_test("proto3_field_presence", semaphore),
+        generate_test("recursivemessage", semaphore, reference=True),
+        generate_test("recursivemessage", semaphore),
+        generate_test("ref", semaphore, reference=True),
+        generate_test("ref", semaphore),
+        generate_test("regression_387", semaphore),
+        generate_test("regression_414", semaphore),
+        generate_test("repeated_duration_timestamp", semaphore, reference=True),
+        generate_test("repeated_duration_timestamp", semaphore),
+        generate_test("repeated", semaphore, reference=True),
+        generate_test("repeated", semaphore),
+        generate_test("repeatedmessage", semaphore, reference=True),
+        generate_test("repeatedmessage", semaphore),
+        generate_test("repeatedpacked", semaphore, reference=True),
+        generate_test("repeatedpacked", semaphore),
+        generate_test("rpc_empty_input_message", semaphore),
+        generate_test("service_uppercase", semaphore),
+        generate_test("service", semaphore),
+        generate_test("signed", semaphore, reference=True),
+        generate_test("signed", semaphore),
+        generate_test("simple_service", semaphore),
+        generate_test("stream_stream", semaphore),
+        generate_test("timestamp_dict_encode", semaphore, reference=True),
+        generate_test("timestamp_dict_encode", semaphore),
+        generate_test("unwrap", semaphore),
+        generate_test("validation", semaphore, pydantic=True),
+    ]
+    await asyncio.gather(*tasks)
+
+
+def main():
+    # Clean the output directory
+    dir_path = os.path.dirname(os.path.realpath(__file__))
+
+    shutil.rmtree(dir_path + "/outputs", ignore_errors=True)
+    os.mkdir(dir_path + "/outputs")
+
+    asyncio.run(main_async())
+
+
+if __name__ == "__main__":
+    main()

{betterproto2_compiler-0.7.0 → betterproto2_compiler-0.7.1}/tests/inputs/any/any.proto

@@ -1,5 +1,7 @@
 syntax = "proto3";
 
+import "google/protobuf/any.proto";
+
 package any;
 
 message Person {

betterproto2_compiler-0.7.1/tests/inputs/enum/enum.proto

@@ -0,0 +1,45 @@
+syntax = "proto3";
+
+package enum;
+
+// Tests that enums are correctly serialized and that it correctly handles skipped and out-of-order enum values
+message Test {
+    Choice choice = 1;
+    repeated Choice choices = 2;
+}
+
+enum Choice {
+    ZERO = 0;
+    ONE = 1;
+    // TWO = 2;
+    FOUR = 4;
+    THREE = 3;
+}
+
+// A "C" like enum with the enum name prefixed onto members, these should be stripped
+enum ArithmeticOperator {
+    ARITHMETIC_OPERATOR_NONE = 0;
+    ARITHMETIC_OPERATOR_PLUS = 1;
+    ARITHMETIC_OPERATOR_MINUS = 2;
+    ARITHMETIC_OPERATOR_0_PREFIXED = 3;
+}
+
+// If not all the fields are prefixed, the prefix should not be stripped at all
+enum NoStriping {
+    NO_STRIPING_NONE = 0;
+    NO_STRIPING_A = 1;
+    B = 2;
+}
+
+// Make sure that the prefix are removed even if it's difficult to infer the position
+// of underscores.
+enum HTTPCode {
+    HTTP_CODE_UNSPECIFIED = 0;
+    HTTP_CODE_OK = 200;
+    HTTP_CODE_NOT_FOUND = 404;
+}
+
+message EnumMessage {
+    ArithmeticOperator arithmetic_operator = 1;
+    NoStriping no_striping = 2;
+}

betterproto2_compiler-0.7.1/tests/inputs/google/google.proto

@@ -0,0 +1,12 @@
+syntax = "proto3";
+
+import "google/protobuf/any.proto";
+import "google/protobuf/api.proto";
+import "google/protobuf/duration.proto";
+import "google/protobuf/empty.proto";
+import "google/protobuf/field_mask.proto";
+import "google/protobuf/source_context.proto";
+import "google/protobuf/struct.proto";
+import "google/protobuf/timestamp.proto";
+import "google/protobuf/type.proto";
+import "google/protobuf/wrappers.proto";

betterproto2_compiler-0.7.1/tests/inputs/grpclib_reflection/example_service.proto

@@ -0,0 +1,24 @@
+syntax = "proto3";
+
+package example_service;
+
+import "google/protobuf/struct.proto";
+
+service Test {
+  rpc ExampleUnaryUnary(ExampleRequest) returns (ExampleResponse);
+  rpc ExampleUnaryStream(ExampleRequest) returns (stream ExampleResponse);
+  rpc ExampleStreamUnary(stream ExampleRequest) returns (ExampleResponse);
+  rpc ExampleStreamStream(stream ExampleRequest) returns (stream ExampleResponse);
+}
+
+message ExampleRequest {
+  string example_string = 1;
+  int64  example_integer = 2;
+  google.protobuf.Struct example_struct = 3;
+}
+
+message ExampleResponse {
+  string example_string = 1;
+  int64  example_integer = 2;
+  google.protobuf.Struct example_struct = 3;
+}