betterproto2-compiler 0.2.0__tar.gz

betterproto2_compiler-0.2.0/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2023 Daniel G. Taylor
+Copyright (c) 2024 The betterproto contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

betterproto2_compiler-0.2.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.3
+Name: betterproto2_compiler
+Version: 0.2.0
+Summary: Compiler for betterproto2
+License: MIT
+Keywords: protobuf,gRPC,compiler
+Author: Adrien Vannson
+Author-email: adrien.vannson@protonmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: betterproto2 (>=0.2.1,<0.3.0)
+Requires-Dist: grpclib (>=0.4.1,<0.5.0)
+Requires-Dist: jinja2 (>=3.0.3)
+Requires-Dist: ruff (>=0.7.4,<0.8.0)
+Requires-Dist: typing-extensions (>=4.7.1,<5.0.0)
+Project-URL: Repository, https://github.com/betterproto/python-betterproto2-compiler
+Description-Content-Type: text/markdown
+
+# Betterproto2 compiler
+
+![](https://github.com/betterproto/python-betterproto2-compiler/actions/workflows/ci.yml/badge.svg)
+
+
+
+## License
+
+Copyright © 2019 Daniel G. Taylor
+
+Copyright © 2024 The betterproto contributors
+

betterproto2_compiler-0.2.0/README.md

@@ -0,0 +1,11 @@
+# Betterproto2 compiler
+
+![](https://github.com/betterproto/python-betterproto2-compiler/actions/workflows/ci.yml/badge.svg)
+
+
+
+## License
+
+Copyright © 2019 Daniel G. Taylor
+
+Copyright © 2024 The betterproto contributors

betterproto2_compiler-0.2.0/pyproject.toml

@@ -0,0 +1,155 @@
+[tool.poetry]
+name = "betterproto2_compiler"
+version = "0.2.0"
+description = "Compiler for betterproto2"
+authors = ["Adrien Vannson <adrien.vannson@protonmail.com>", "Daniel G. Taylor <danielgtaylor@gmail.com>"]
+readme = "README.md"
+repository = "https://github.com/betterproto/python-betterproto2-compiler"
+keywords = ["protobuf", "gRPC", "compiler"]
+license = "MIT"
+packages = [
+    { include = "betterproto2_compiler", from = "src" }
+]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+betterproto2 = "^0.2.1"
+# The Ruff version is pinned. To update it, also update it in .pre-commit-config.yaml
+ruff = "~0.7.4"
+grpclib = "^0.4.1"
+jinja2 = ">=3.0.3"
+typing-extensions = "^4.7.1"
+
+[tool.poetry.group.dev.dependencies]
+pre-commit = "^2.17.0"
+grpcio-tools = "^1.54.2"
+mkdocs-material = {version = "^9.5.49", python = ">=3.10"}
+mkdocstrings = {version = "^0.27.0", python = ">=3.10", extras = ["python"]}
+poethepoet = ">=0.9.0"
+pyright = "^1.1.391"
+ipykernel = "^6.29.5"
+
+[tool.poetry.group.test.dependencies]
+pytest = "^6.2.5"
+protobuf = "^4"
+
+[tool.poetry.scripts]
+protoc-gen-python_betterproto2 = "betterproto2_compiler.plugin:main"
+
+[tool.ruff]
+extend-exclude = ["tests/output_*", "src/betterproto2_compiler/lib"]
+target-version = "py310"
+line-length = 120
+
+[tool.ruff.lint]
+select = [
+    "F401",  # Unused imports
+    "F841",  # Unused local variables
+    "F821",  # Undefined names
+    "E501",  # Line length violations
+
+    "SIM101", # Simplify unnecessary if-else blocks
+    "SIM102", # Simplify return or yield statements
+    "SIM103", # Simplify list/set/dict comprehensions
+
+    "UP",
+
+    "I",
+]
+
+
+[tool.ruff.lint.isort]
+combine-as-imports = true
+
+# Dev workflow tasks
+
+[tool.poe.tasks.test]
+cmd = "pytest"
+help = "Run tests"
+
+[tool.poe.tasks.generate]
+sequence = ["_generate_tests", "_generate_tests_lib"]
+help = "Generate test cases"
+
+[tool.poe.tasks._generate_tests]
+script = "tests.generate:main"
+
+[tool.poe.tasks._generate_tests_lib]
+shell = """
+python -m grpc.tools.protoc \
+    --python_betterproto2_out=tests/output_betterproto \
+    google/protobuf/any.proto \
+    google/protobuf/api.proto \
+    google/protobuf/duration.proto \
+    google/protobuf/empty.proto \
+    google/protobuf/field_mask.proto \
+    google/protobuf/source_context.proto \
+    google/protobuf/struct.proto \
+    google/protobuf/timestamp.proto \
+    google/protobuf/type.proto \
+    google/protobuf/wrappers.proto
+
+python -m grpc.tools.protoc \
+    --python_betterproto2_out=tests/output_betterproto_pydantic \
+    --python_betterproto2_opt=pydantic_dataclasses \
+    google/protobuf/any.proto \
+    google/protobuf/api.proto \
+    google/protobuf/duration.proto \
+    google/protobuf/empty.proto \
+    google/protobuf/field_mask.proto \
+    google/protobuf/source_context.proto \
+    google/protobuf/struct.proto \
+    google/protobuf/timestamp.proto \
+    google/protobuf/type.proto \
+    google/protobuf/wrappers.proto
+"""
+
+[tool.poe.tasks.typecheck]
+cmd  = "pyright src"
+help = "Typecheck the code with Pyright"
+
+[tool.poe.tasks.format]
+sequence = ["_format", "_sort-imports"]
+help = "Format the source code, and sort the imports"
+
+[tool.poe.tasks.check]
+sequence = ["_check-format", "_check-ruff-lint"]
+help = "Check that the source code is formatted and the code passes the linter"
+
+[tool.poe.tasks._format]
+cmd = "ruff format src tests"
+help = "Format the source code without sorting the imports"
+
+[tool.poe.tasks._sort-imports]
+cmd = "ruff check --select I --fix src tests"
+help = "Sort the imports"
+
+[tool.poe.tasks._check-format]
+cmd = "ruff format --diff src tests"
+help = "Check that the source code is formatted"
+
+[tool.poe.tasks._check-ruff-lint]
+cmd = "ruff check src tests"
+help = "Check the code with the Ruff linter"
+
+[tool.poe.tasks.serve-docs]
+cmd = "mkdocs serve"
+help = "Serve the documentation locally"
+
+[build-system]
+requires = ["poetry-core>=1.0.0,<2"]
+build-backend = "poetry.core.masonry.api"
+
+# python -m grpc.tools.protoc \
+#     --python_betterproto2_out=src/lib2 \
+#     google/protobuf/any.proto \
+#     google/protobuf/api.proto \
+#     google/protobuf/duration.proto \
+#     google/protobuf/empty.proto \
+#     google/protobuf/field_mask.proto \
+#     google/protobuf/source_context.proto \
+#     google/protobuf/struct.proto \
+#     google/protobuf/timestamp.proto \
+#     google/protobuf/type.proto \
+#     google/protobuf/wrappers.proto \
+#     google/protobuf/compiler/plugin.proto

betterproto2_compiler-0.2.0/src/betterproto2_compiler/casing.py

@@ -0,0 +1,140 @@
+import keyword
+import re
+
+# Word delimiters and symbols that will not be preserved when re-casing.
+# language=PythonRegExp
+SYMBOLS = "[^a-zA-Z0-9]*"
+
+# Optionally capitalized word.
+# language=PythonRegExp
+WORD = "[A-Z]*[a-z]*[0-9]*"
+
+# Uppercase word, not followed by lowercase letters.
+# language=PythonRegExp
+WORD_UPPER = "[A-Z]+(?![a-z])[0-9]*"
+
+
+def safe_snake_case(value: str) -> str:
+    """Snake case a value taking into account Python keywords."""
+    value = snake_case(value)
+    value = sanitize_name(value)
+    return value
+
+
+def snake_case(value: str, strict: bool = True) -> str:
+    """
+    Join words with an underscore into lowercase and remove symbols.
+
+    Parameters
+    -----------
+    value: :class:`str`
+        The value to convert.
+    strict: :class:`bool`
+        Whether or not to force single underscores.
+
+    Returns
+    --------
+    :class:`str`
+        The value in snake_case.
+    """
+
+    def substitute_word(symbols: str, word: str, is_start: bool) -> str:
+        if not word:
+            return ""
+        if strict:
+            delimiter_count = 0 if is_start else 1  # Single underscore if strict.
+        elif is_start:
+            delimiter_count = len(symbols)
+        elif word.isupper() or word.islower():
+            delimiter_count = max(1, len(symbols))  # Preserve all delimiters if not strict.
+        else:
+            delimiter_count = len(symbols) + 1  # Extra underscore for leading capital.
+
+        return ("_" * delimiter_count) + word.lower()
+
+    snake = re.sub(
+        f"(^)?({SYMBOLS})({WORD_UPPER}|{WORD})",
+        lambda groups: substitute_word(groups[2], groups[3], groups[1] is not None),
+        value,
+    )
+    return snake
+
+
+def pascal_case(value: str, strict: bool = True) -> str:
+    """
+    Capitalize each word and remove symbols.
+
+    Parameters
+    -----------
+    value: :class:`str`
+        The value to convert.
+    strict: :class:`bool`
+        Whether or not to output only alphanumeric characters.
+
+    Returns
+    --------
+    :class:`str`
+        The value in PascalCase.
+    """
+
+    def substitute_word(symbols, word):
+        if strict:
+            return word.capitalize()  # Remove all delimiters
+
+        if word.islower():
+            delimiter_length = len(symbols[:-1])  # Lose one delimiter
+        else:
+            delimiter_length = len(symbols)  # Preserve all delimiters
+
+        return ("_" * delimiter_length) + word.capitalize()
+
+    return re.sub(
+        f"({SYMBOLS})({WORD_UPPER}|{WORD})",
+        lambda groups: substitute_word(groups[1], groups[2]),
+        value,
+    )
+
+
+def camel_case(value: str, strict: bool = True) -> str:
+    """
+    Capitalize all words except first and remove symbols.
+
+    Parameters
+    -----------
+    value: :class:`str`
+        The value to convert.
+    strict: :class:`bool`
+        Whether or not to output only alphanumeric characters.
+
+    Returns
+    --------
+    :class:`str`
+        The value in camelCase.
+    """
+    return lowercase_first(pascal_case(value, strict=strict))
+
+
+def lowercase_first(value: str) -> str:
+    """
+    Lower cases the first character of the value.
+
+    Parameters
+    ----------
+    value: :class:`str`
+        The value to lower case.
+
+    Returns
+    -------
+    :class:`str`
+        The lower cased string.
+    """
+    return value[0:1].lower() + value[1:]
+
+
+def sanitize_name(value: str) -> str:
+    # https://www.python.org/dev/peps/pep-0008/#descriptive-naming-styles
+    if keyword.iskeyword(value):
+        return f"{value}_"
+    if not value.isidentifier():
+        return f"_{value}"
+    return value

betterproto2_compiler-0.2.0/src/betterproto2_compiler/compile/importing.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+import os
+from typing import (
+    TYPE_CHECKING,
+)
+
+from betterproto2_compiler.lib.google import protobuf as google_protobuf
+from betterproto2_compiler.settings import Settings
+
+from ..casing import safe_snake_case
+from .naming import pythonize_class_name
+
+if TYPE_CHECKING:
+    from ..plugin.models import PluginRequestCompiler
+
+WRAPPER_TYPES: dict[str, type] = {
+    ".google.protobuf.DoubleValue": google_protobuf.DoubleValue,
+    ".google.protobuf.FloatValue": google_protobuf.FloatValue,
+    ".google.protobuf.Int32Value": google_protobuf.Int32Value,
+    ".google.protobuf.Int64Value": google_protobuf.Int64Value,
+    ".google.protobuf.UInt32Value": google_protobuf.UInt32Value,
+    ".google.protobuf.UInt64Value": google_protobuf.UInt64Value,
+    ".google.protobuf.BoolValue": google_protobuf.BoolValue,
+    ".google.protobuf.StringValue": google_protobuf.StringValue,
+    ".google.protobuf.BytesValue": google_protobuf.BytesValue,
+}
+
+
+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')
+         'root.Message.SomeEnum' -> ('root', 'Message.SomeEnum')
+
+    The function goes through the symbols that have been defined (names, enums,
+    packages) to find the actual package and name of the object that is referenced.
+    """
+    if field_type_name[0] != ".":
+        raise RuntimeError("relative names are not supported")
+    field_type_name = field_type_name[1:]
+    parts = field_type_name.split(".")
+
+    answer = None
+
+    # a.b.c:
+    # i=0: "", "a.b.c"
+    # i=1: "a", "b.c"
+    # i=2: "a.b", "c"
+    for i in range(len(parts)):
+        package_name, object_name = ".".join(parts[:i]), ".".join(parts[i:])
+
+        package = request.output_packages.get(package_name)
+
+        if not package:
+            continue
+
+        if object_name in package.messages or object_name in package.enums:
+            if answer:
+                # This should have already been handeled by protoc
+                raise ValueError(f"ambiguous definition: {field_type_name}")
+            answer = package_name, object_name
+
+    if answer:
+        return answer
+
+    raise ValueError(f"can't find type name: {field_type_name}")
+
+
+def get_type_reference(
+    *,
+    package: str,
+    imports: set,
+    source_type: str,
+    request: PluginRequestCompiler,
+    unwrap: bool = True,
+    settings: Settings,
+) -> str:
+    """
+    Return a Python type name for a proto type reference. Adds the import if
+    necessary. Unwraps well known type if required.
+    """
+    if unwrap:
+        if source_type in WRAPPER_TYPES:
+            wrapped_type = type(WRAPPER_TYPES[source_type]().value)
+            return settings.typing_compiler.optional(wrapped_type.__name__)
+
+        if source_type == ".google.protobuf.Duration":
+            return "datetime.timedelta"
+
+        elif source_type == ".google.protobuf.Timestamp":
+            return "datetime.datetime"
+
+    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 []
+    py_type: str = pythonize_class_name(source_type)
+
+    if py_package == current_package:
+        return reference_sibling(py_type)
+
+    if py_package[: len(current_package)] == current_package:
+        return reference_descendent(current_package, imports, py_package, py_type)
+
+    if current_package[: len(py_package)] == py_package:
+        return reference_ancestor(current_package, imports, py_package, py_type)
+
+    return reference_cousin(current_package, imports, py_package, py_type)
+
+
+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.
+    """
+    string_import = ".".join(py_package)
+    string_alias = safe_snake_case(string_import)
+    imports.add(f"import {string_import} as {string_alias}")
+    return f"{string_alias}.{py_type}"
+
+
+def reference_sibling(py_type: str) -> str:
+    """
+    Returns a reference to a python type within the same package as the current package.
+    """
+    return f"{py_type}"
+
+
+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
+    conflicts.
+    """
+    importing_descendent = py_package[len(current_package) :]
+    string_from = ".".join(importing_descendent[:-1])
+    string_import = importing_descendent[-1]
+    if string_from:
+        string_alias = "_".join(importing_descendent)
+        imports.add(f"from .{string_from} import {string_import} as {string_alias}")
+        return f"{string_alias}.{py_type}"
+    else:
+        imports.add(f"from . import {string_import}")
+        return f"{string_import}.{py_type}"
+
+
+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
+    name conflicts.
+
+    Adds trailing __ to avoid name mangling (python.org/dev/peps/pep-0008/#id34).
+    """
+    distance_up = len(current_package) - len(py_package)
+    if py_package:
+        string_import = py_package[-1]
+        string_alias = f"_{'_' * distance_up}{string_import}__"
+        string_from = f"..{'.' * distance_up}"
+        imports.add(f"from {string_from} import {string_import} as {string_alias}")
+        return f"{string_alias}.{py_type}"
+    else:
+        string_alias = f"{'_' * distance_up}{py_type}__"
+        imports.add(f"from .{'.' * distance_up} import {py_type} as {string_alias}")
+        return string_alias
+
+
+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.
+    """
+    shared_ancestry = os.path.commonprefix([current_package, py_package])  # type: ignore
+    distance_up = len(current_package) - len(shared_ancestry)
+    string_from = f".{'.' * distance_up}" + ".".join(py_package[len(shared_ancestry) : -1])
+    string_import = py_package[-1]
+    # Add trailing __ to avoid name mangling (python.org/dev/peps/pep-0008/#id34)
+    string_alias = f"{'_' * distance_up}" + safe_snake_case(".".join(py_package[len(shared_ancestry) :])) + "__"
+    imports.add(f"from {string_from} import {string_import} as {string_alias}")
+    return f"{string_alias}.{py_type}"

betterproto2_compiler-0.2.0/src/betterproto2_compiler/compile/naming.py

@@ -0,0 +1,21 @@
+from betterproto2_compiler import casing
+
+
+def pythonize_class_name(name: str) -> str:
+    return casing.pascal_case(name)
+
+
+def pythonize_field_name(name: str) -> str:
+    return casing.safe_snake_case(name)
+
+
+def pythonize_method_name(name: str) -> str:
+    return casing.safe_snake_case(name)
+
+
+def pythonize_enum_member_name(name: str, enum_name: str) -> str:
+    enum_name = casing.snake_case(enum_name).upper()
+    find = name.find(enum_name)
+    if find != -1:
+        name = name[find + len(enum_name) :].strip("_")
+    return casing.sanitize_name(name)

betterproto2_compiler-0.2.0/src/betterproto2_compiler/known_types/__init__.py

@@ -0,0 +1,14 @@
+from collections.abc import Callable
+
+from .any import Any
+from .duration import Duration
+from .timestamp import Timestamp
+
+# For each (package, message name), lists the methods that should be added to the message definition.
+# The source code of the method is read from the `known_types` folder. If imports are needed, they can be directly added
+# to the template file: they will automatically be removed if not necessary.
+KNOWN_METHODS: dict[tuple[str, str], list[Callable]] = {
+    ("google.protobuf", "Any"): [Any.pack, Any.unpack, Any.to_dict],
+    ("google.protobuf", "Timestamp"): [Timestamp.from_datetime, Timestamp.to_datetime, Timestamp.timestamp_to_json],
+    ("google.protobuf", "Duration"): [Duration.from_timedelta, Duration.to_timedelta, Duration.delta_to_json],
+}

betterproto2_compiler-0.2.0/src/betterproto2_compiler/known_types/any.py

@@ -0,0 +1,36 @@
+import betterproto2
+
+from betterproto2_compiler.lib.google.protobuf import Any as VanillaAny
+
+default_message_pool = betterproto2.MessagePool()  # Only for typing purpose
+
+
+class Any(VanillaAny):
+    def pack(self, message: betterproto2.Message, message_pool: "betterproto2.MessagePool | None" = None) -> None:
+        """
+        Pack the given message in the `Any` object.
+
+        The message type must be registered in the message pool, which is done automatically when the module defining
+        the message type is imported.
+        """
+        message_pool = message_pool or default_message_pool
+
+        self.type_url = message_pool.type_to_url[type(message)]
+        self.value = bytes(message)
+
+    def unpack(self, message_pool: "betterproto2.MessagePool | None" = None) -> betterproto2.Message:
+        """
+        Return the message packed inside the `Any` object.
+
+        The target message type must be registered in the message pool, which is done automatically when the module
+        defining the message type is imported.
+        """
+        message_pool = message_pool or default_message_pool
+
+        message_type = message_pool.url_to_type[self.type_url]
+
+        return message_type().parse(self.value)
+
+    def to_dict(self) -> dict:  # pyright: ignore [reportIncompatibleMethodOverride]
+        # TOOO improve when dict is updated
+        return {"@type": self.type_url, "value": self.unpack().to_dict()}

betterproto2_compiler-0.2.0/src/betterproto2_compiler/known_types/duration.py

@@ -0,0 +1,25 @@
+import datetime
+
+from betterproto2_compiler.lib.google.protobuf import Duration as VanillaDuration
+
+
+class Duration(VanillaDuration):
+    @classmethod
+    def from_timedelta(
+        cls, delta: datetime.timedelta, *, _1_microsecond: datetime.timedelta = datetime.timedelta(microseconds=1)
+    ) -> "Duration":
+        total_ms = delta // _1_microsecond
+        seconds = int(total_ms / 1e6)
+        nanos = int((total_ms % 1e6) * 1e3)
+        return cls(seconds, nanos)
+
+    def to_timedelta(self) -> datetime.timedelta:
+        return datetime.timedelta(seconds=self.seconds, microseconds=self.nanos / 1e3)
+
+    @staticmethod
+    def delta_to_json(delta: datetime.timedelta) -> str:
+        parts = str(delta.total_seconds()).split(".")
+        if len(parts) > 1:
+            while len(parts[1]) not in (3, 6, 9):
+                parts[1] = f"{parts[1]}0"
+        return f"{'.'.join(parts)}s"