betterproto2-compiler 0.2.0__py3-none-any.whl

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/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/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/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/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/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"

betterproto2_compiler/known_types/timestamp.py

@@ -0,0 +1,45 @@
+import datetime
+
+from betterproto2_compiler.lib.google.protobuf import Timestamp as VanillaTimestamp
+
+
+class Timestamp(VanillaTimestamp):
+    @classmethod
+    def from_datetime(cls, dt: datetime.datetime) -> "Timestamp":
+        # manual epoch offset calulation to avoid rounding errors,
+        # to support negative timestamps (before 1970) and skirt
+        # around datetime bugs (apparently 0 isn't a year in [0, 9999]??)
+        offset = dt - datetime.datetime(1970, 1, 1, tzinfo=datetime.timezone.utc)
+        # below is the same as timedelta.total_seconds() but without dividing by 1e6
+        # so we end up with microseconds as integers instead of seconds as float
+        offset_us = (offset.days * 24 * 60 * 60 + offset.seconds) * 10**6 + offset.microseconds
+        seconds, us = divmod(offset_us, 10**6)
+        return cls(seconds, us * 1000)
+
+    def to_datetime(self) -> datetime.datetime:
+        # datetime.fromtimestamp() expects a timestamp in seconds, not microseconds
+        # if we pass it as a floating point number, we will run into rounding errors
+        # see also #407
+        offset = datetime.timedelta(seconds=self.seconds, microseconds=self.nanos // 1000)
+        return datetime.datetime(1970, 1, 1, tzinfo=datetime.timezone.utc) + offset
+
+    @staticmethod
+    def timestamp_to_json(dt: datetime.datetime) -> str:
+        nanos = dt.microsecond * 1e3
+        if dt.tzinfo is not None:
+            # change timezone aware datetime objects to utc
+            dt = dt.astimezone(datetime.timezone.utc)
+        copy = dt.replace(microsecond=0, tzinfo=None)
+        result = copy.isoformat()
+        if (nanos % 1e9) == 0:
+            # If there are 0 fractional digits, the fractional
+            # point '.' should be omitted when serializing.
+            return f"{result}Z"
+        if (nanos % 1e6) == 0:
+            # Serialize 3 fractional digits.
+            return f"{result}.{int(nanos // 1e6) :03d}Z"
+        if (nanos % 1e3) == 0:
+            # Serialize 6 fractional digits.
+            return f"{result}.{int(nanos // 1e3) :06d}Z"
+        # Serialize 9 fractional digits.
+        return f"{result}.{nanos:09d}"