Implement command line interface

README.md

@@ -38,11 +38,12 @@ This project exists because I am unhappy with the state of the official Google p
   - Uses `SerializeToString()` rather than the built-in `__bytes__()`
   - Special wrapped types don't use Python's `None`
   - Timestamp/duration types don't use Python's built-in `datetime` module
+
 This project is a reimplementation from the ground up focused on idiomatic modern Python to help fix some of the above. While it may not be a 1:1 drop-in replacement due to changed method names and call patterns, the wire format is identical.
 
 ## Installation
 
-First, install the package. Note that the `[compiler]` feature flag tells it to install extra dependencies only needed by the `protoc` plugin:
+First, install the package. Note that the `[compiler]` feature flag tells it to install extra dependencies only needed by the code generator:
 
 ```sh
 # Install both the library and compiler
@@ -71,18 +72,10 @@ message Greeting {
 }
 ```
 
-You can run the following to invoke protoc directly:
+To compile the protobuf you would run the following:
 
 ```sh
-mkdir lib
-protoc -I . --python_betterproto_out=lib example.proto
-```
-
-or run the following to invoke protoc via grpcio-tools:
-
-```sh
-pip install grpcio-tools
-python -m grpc_tools.protoc -I . --python_betterproto_out=lib example.proto
+betterproto compile example.proto --output=lib
 ```
 
 This will generate `lib/hello/__init__.py` which looks like:
@@ -160,12 +153,6 @@ service Echo {
 }
 ```
 
-Generate echo proto file:
-
-```
-python -m grpc_tools.protoc -I . --python_betterproto_out=. echo.proto
-```
-
 A client can be implemented as follows:
 ```python
 import asyncio
@@ -175,16 +162,13 @@ from grpclib.client import Channel
 
 
 async def main():
-    channel = Channel(host="127.0.0.1", port=50051)
-    service = echo.EchoStub(channel)
-    response = await service.echo(echo.EchoRequest(value="hello", extra_times=1))
-    print(response)
-
-    async for response in service.echo_stream(echo.EchoRequest(value="hello", extra_times=1)):
-        print(response)
-
-    # don't forget to close the channel when done!
-    channel.close()
+    async with Channel(host="127.0.0.1", port=50051) as channel:
+      service = echo.EchoStub(channel)
+      response = await service.echo(echo.EchoRequest(value="hello", extra_times=1))
+      print(response)
+
+      async for response in service.echo_stream(echo.EchoRequest(value="hello", extra_times=1)):
+          print(response)
 
 
 if __name__ == "__main__":
@@ -278,23 +262,23 @@ You can use `betterproto.which_one_of(message, group_name)` to determine which o
 ```py
 >>> test = Test()
 >>> betterproto.which_one_of(test, "foo")
-["", None]
+("", None)
 
 >>> test.on = True
 >>> betterproto.which_one_of(test, "foo")
-["on", True]
+("on", True)
 
 # Setting one member of the group resets the others.
 >>> test.count = 57
 >>> betterproto.which_one_of(test, "foo")
-["count", 57]
+("count", 57)
 >>> test.on
 False
 
 # Default (zero) values also work.
 >>> test.name = ""
 >>> betterproto.which_one_of(test, "foo")
-["name", ""]
+("name", "")
 >>> test.count
 0
 >>> test.on
@@ -310,7 +294,7 @@ Again this is a little different than the official Google code generator:
 
 # New way (this project)
 >>> betterproto.which_one_of(message, "group")
-["foo", "foo's value"]
+("foo", "foo's value")
 ```
 
 ### Well-Known Google Types
@@ -445,7 +429,7 @@ poe full-test
 Betterproto includes compiled versions for Google's well-known types at [betterproto/lib/google](betterproto/lib/google).
 Be sure to regenerate these files when modifying the plugin output format, and validate by running the tests.
 
-Normally, the plugin does not compile any references to `google.protobuf`, since they are pre-compiled. To force compilation of `google.protobuf`, use the option `--custom_opt=INCLUDE_GOOGLE`. 
+Normally, the plugin does not compile any references to `google.protobuf`, since they are pre-compiled. To force compilation of `google.protobuf`, use the option `--custom_opt=INCLUDE_GOOGLE`.
 
 Assuming your `google.protobuf` source files (included with all releases of `protoc`) are located in `/usr/local/include`, you can regenerate them as follows:
 

docs/migrating.rst

@@ -4,7 +4,7 @@ Migrating Guide
 Google's protocolbuffers
 ------------------------
 
-betterproto has a mostly 1 to 1 drop in replacement for Google's protocolbuffers (after
+betterproto has a mostly 1 to 1 drop in replacement for Google's protocol buffers (after
 regenerating your protobufs of course) although there are some minor differences.
 
 .. note::

docs/quick-start.rst

@@ -40,22 +40,11 @@ Given you installed the compiler and have a proto file, e.g ``example.proto``:
       string message = 1;
     }
 
-To compile the proto you would run the following:
-
-You can run the following to invoke protoc directly:
+To compile the protobuf you would run the following:
 
 .. code-block:: sh
 
-    mkdir hello
-    protoc -I . --python_betterproto_out=lib example.proto
-
-or run the following to invoke protoc via grpcio-tools:
-
-.. code-block:: sh
-
-    pip install grpcio-tools
-    python -m grpc_tools.protoc -I . --python_betterproto_out=lib example.proto
-
+    betterproto compile example.proto --output=lib
 
 This will generate ``lib/__init__.py`` which looks like:
 
@@ -141,16 +130,13 @@ The generated client can be used like so:
 
 
     async def main():
-        channel = Channel(host="127.0.0.1", port=50051)
-        service = echo.EchoStub(channel)
-        response = await service.echo(value="hello", extra_times=1)
-        print(response)
-
-        async for response in service.echo_stream(value="hello", extra_times=1):
+        async with Channel(host="127.0.0.1", port=50051) as channel:
+            service = echo.EchoStub(channel)
+            response = await service.echo(value="hello", extra_times=1)
             print(response)
 
-        # don't forget to close the channel when you're done!
-        channel.close()
+            async for response in service.echo_stream(value="hello", extra_times=1):
+                print(response)
 
     asyncio.run(main())  # python 3.7 only
 

pyproject.toml

@@ -17,6 +17,8 @@ black = { version = ">=19.3b0", optional = true }
 dataclasses = { version = "^0.7", python = ">=3.6, <3.7" }
 grpclib = "^0.4.1"
 jinja2 = { version = ">=2.11.2", optional = true }
+typer = { version = "^0.3.2", optional = true }
+rich = { version = "^11.2.0", optional = true }
 python-dateutil = "^2.8"
 
 [tool.poetry.dev-dependencies]
@@ -36,13 +38,14 @@ sphinx = "3.1.2"
 sphinx-rtd-theme = "0.5.0"
 tomlkit = "^0.7.0"
 tox = "^3.15.1"
-
+# protobuf_parser = "1.0.0"
 
 [tool.poetry.scripts]
+betterproto = "betterproto:__main__.main"
 protoc-gen-python_betterproto = "betterproto.plugin:main"
 
 [tool.poetry.extras]
-compiler = ["black", "jinja2"]
+compiler = ["black", "jinja2", "typer", "rich", "protobuf_parser"]
 
 
 # Dev workflow tasks
@@ -81,12 +84,7 @@ help = "Clean out generated files from the workspace"
 
 [tool.poe.tasks.generate_lib]
 cmd = """
-protoc
-    --plugin=protoc-gen-custom=src/betterproto/plugin/main.py
-    --custom_opt=INCLUDE_GOOGLE
-    --custom_out=src/betterproto/lib
-    -I /usr/local/include/
-    /usr/local/include/google/protobuf/**/*.proto
+betterproto compile /usr/local/include/google/protobuf/**/*.proto
 """
 help = "Regenerate the types in betterproto.lib.google"
 

src/betterproto/__init__.py

@@ -9,7 +9,6 @@
 from abc import ABC
 from base64 import b64decode, b64encode
 from datetime import datetime, timedelta, timezone
-from dateutil.parser import isoparse
 from typing import (
     Any,
     Callable,
@@ -25,12 +24,13 @@
     get_type_hints,
 )
 
+from dateutil.parser import isoparse
+
 from ._types import T
 from ._version import __version__
 from .casing import camel_case, safe_snake_case, snake_case
 from .grpc.grpclib_client import ServiceStub
 
-
 # Proto 3 data types
 TYPE_ENUM = "enum"
 TYPE_BOOL = "bool"

src/betterproto/__main__.py

@@ -0,0 +1,7 @@
+from .plugin.exception_hook import install_exception_hook
+
+install_exception_hook()
+from .plugin.cli import app as main
+
+if __name__ == "__main__":
+    main()

src/betterproto/_types.py

@@ -2,6 +2,7 @@
 
 if TYPE_CHECKING:
     from grpclib._typing import IProtoMessage
+
     from . import Message
 
 # Bound type variable to allow methods to return `self` of subclasses

src/betterproto/plugin/__init__.py

@@ -1 +0,0 @@
-from .main import main

src/betterproto/plugin/__main__.py

@@ -1,4 +1,4 @@
 from .main import main
 
-
-main()
+if __name__ == "__main__":
+    main()

src/betterproto/plugin/cli/__init__.py

@@ -0,0 +1,6 @@
+VERBOSE = False
+
+from black.const import DEFAULT_LINE_LENGTH as DEFAULT_LINE_LENGTH
+
+from .commands import app as app
+from .runner import compile_protobufs as compile_protobufs

src/betterproto/plugin/cli/commands.py

@@ -0,0 +1,115 @@
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+import protobuf_parser
+import rich
+import typer
+from rich.syntax import Syntax
+
+from ... import __version__
+from ..models import monkey_patch_oneof_index
+from . import DEFAULT_LINE_LENGTH, VERBOSE, utils
+from .runner import compile_protobufs
+
+monkey_patch_oneof_index()
+app = typer.Typer()
+
+
+@app.callback(context_settings={"help_option_names": ["-h", "--help"]})
+def callback(ctx: typer.Context) -> None:
+    """The callback for all things betterproto"""
+    if ctx.invoked_subcommand is None:
+        rich.print(ctx.get_help())
+
+
+@app.command()
+def version(ctx: typer.Context) -> None:
+    rich.print("betterproto version:", __version__)
+
+
+@app.command(context_settings={"help_option_names": ["-h", "--help"]})
+@utils.run_sync
+async def compile(
+    verbose: bool = typer.Option(
+        VERBOSE, "-v", "--verbose", help="Whether or not to be verbose"
+    ),
+    line_length: int = typer.Option(
+        DEFAULT_LINE_LENGTH,
+        "-l",
+        "--line-length",
+        help="The line length to format with",
+    ),
+    generate_services: bool = typer.Option(
+        True, help="Whether or not to generate servicer stubs"
+    ),
+    output: Optional[Path] = typer.Option(
+        None,
+        help="The name of the output directory",
+        file_okay=False,
+        allow_dash=True,
+    ),
+    paths: List[Path] = typer.Argument(
+        ...,
+        help="The protobuf files to compile",
+        exists=True,
+        allow_dash=True,
+        readable=False,
+    ),
+) -> None:
+    """The recommended way to compile your protobuf files."""
+    files = utils.get_files(paths)
+
+    if not files:
+        return rich.print("[bold]No files found to compile")
+
+    for output_path, protos in files.items():
+        output = output or (Path(output_path.parent.name) / output_path.name).resolve()
+        output.mkdir(exist_ok=True, parents=True)
+
+        results = await compile_protobufs(
+            *protos,
+            output=output,
+            verbose=verbose,
+            generate_services=generate_services,
+            line_length=line_length,
+            from_cli=True,
+        )
+
+        for result in results:
+            for error in result.errors:
+                if error.message.startswith("Syntax error"):
+                    rich.print(
+                        f"[red]File {str(result.file)}:\n",
+                        Syntax.from_path(
+                            str(result.file),
+                            line_numbers=True,
+                            line_range=(max(error.line - 5, 0), error.line),
+                        ),
+                        f"{' ' * (error.column + 3)}^\nSyntaxError: {error.message}[red]",
+                        file=sys.stderr,
+                    )
+                elif isinstance(error, protobuf_parser.Warning):
+                    rich.print(f"Warning: {error}", file=sys.stderr)
+                else:
+                    failed_files = "\n".join(f" - {file}" for file in protos)
+                    rich.print(
+                        f"[red]Protoc failed to generate outputs for:\n\n"
+                        f"{failed_files}\n\nSee the output for the issue:\n{error}[red]",
+                        file=sys.stderr,
+                    )
+
+        # has_warnings = all(isinstance(e, Warning) for e in errors)
+        # if not errors or has_warnings:
+        if True:
+            rich.print(
+                f"[bold green]Finished generating output for "
+                f"{len(protos)} file{'s' if len(protos) != 1 else ''}, "
+                f"output is in {output.as_posix()}"
+            )
+
+        # if errors:
+        #     if not has_warnings:
+        #         exit(2)
+        #     exit(1)
+        exit(0)