betterproto2-compiler 0.0.1__tar.gz

betterproto2_compiler-0.0.1/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.0.1/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.1
+Name: betterproto2_compiler
+Version: 0.0.1
+Summary: Compiler for betterproto2
+Home-page: https://github.com/betterproto/python-betterproto2-compiler
+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: 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.0.1/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.0.1/pyproject.toml

@@ -0,0 +1,109 @@
+[tool.poetry]
+name = "betterproto2_compiler"
+version = "0.0.1"
+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"
+# betterproto = { git = "https://github.com/betterproto/python-betterproto2", rev = "881bd6e09a809dc61add4ae4ed6a3c70c1fca00a" }
+# 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]
+jinja2 = ">=3.0.3"
+mypy = "^1.11.2"
+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"]}
+
+[tool.poetry.group.test.dependencies]
+poethepoet = ">=0.9.0"
+pytest = "^6.2.5"
+protobuf = "^4"
+
+[tool.poetry.scripts]
+protoc-gen-python_betterproto = "betterproto2_compiler.plugin:main"
+
+[tool.ruff]
+extend-exclude = ["tests/output_*"]
+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
+
+    "I",
+]
+
+
+[tool.ruff.lint.isort]
+combine-as-imports = true
+
+# Dev workflow tasks
+
+[tool.poe.tasks.generate]
+script = "tests.generate:main"
+help = "Generate test cases"
+
+[tool.poe.tasks.types]
+cmd  = "mypy src --ignore-missing-imports"
+help = "Check types with mypy"
+
+[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-imports"]
+help = "Check that the source code is formatted and the imports sorted"
+
+[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-imports]
+cmd = "ruff check --select I src tests"
+help = "Check that the imports are sorted"
+
+[tool.poe.tasks.generate_lib]
+cmd = """
+protoc
+    --plugin=protoc-gen-custom=src/betterproto2_compiler/plugin/main.py
+    --custom_opt=INCLUDE_GOOGLE
+    --custom_out=src/betterproto/lib/std
+    -I /usr/local/include/
+    /usr/local/include/google/protobuf/**/*.proto
+"""
+help = "Regenerate the types in betterproto.lib.std.google"
+
+[build-system]
+requires = ["poetry-core>=1.0.0,<2"]
+build-backend = "poetry.core.masonry.api"

betterproto2_compiler-0.0.1/src/betterproto2_compiler/_types.py

@@ -0,0 +1,13 @@
+from typing import (
+    TYPE_CHECKING,
+    TypeVar,
+)
+
+if TYPE_CHECKING:
+    from grpclib._typing import IProtoMessage
+
+    from . import Message
+
+# Bound type variable to allow methods to return `self` of subclasses
+T = TypeVar("T", bound="Message")
+ST = TypeVar("ST", bound="IProtoMessage")

betterproto2_compiler-0.0.1/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.0.1/src/betterproto2_compiler/compile/importing.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+import os
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+    List,
+    Set,
+    Tuple,
+    Type,
+)
+
+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] = {
+    ".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,
+    typing_compiler: TypingCompiler,
+    request: "PluginRequestCompiler",
+    unwrap: bool = True,
+    pydantic: bool = False,
+) -> 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 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)
+
+    compiling_google_protobuf = current_package == ["google", "protobuf"]
+    importing_google_protobuf = py_package == ["google", "protobuf"]
+    if importing_google_protobuf and not compiling_google_protobuf:
+        py_package = ["betterproto", "lib"] + (["pydantic"] if pydantic else []) + py_package
+
+    if py_package[:1] == ["betterproto"]:
+        return reference_absolute(imports, py_package, py_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.0.1/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)