Initial commit

2019-10-05 08:36:23 -07:00 · 2019-10-05 08:36:23 -07:00 · 6ed3b09f44
commit 6ed3b09f44
26 changed files with 1026 additions and 0 deletions
--- a/.env.default
+++ b/.env.default
@ -0,0 +1 @@
 PYTHONPATH=.
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,9 @@
 .env
 .vscode/settings.json
 .mypy_cache
 .pytest_cache
 betterproto/tests/*.bin
 betterproto/tests/*_pb2.py
 betterproto/tests/*.py
 !betterproto/tests/generate.py
 !betterproto/tests/test_*.py
--- a/21
+++ b/21
@ -0,0 +1,21 @@
 [[source]]
 name = "pypi"
 url = "https://pypi.org/simple"
 verify_ssl = true
 [dev-packages]
 flake8 = "*"
 mypy = "*"
 isort = "*"
 pytest = "*"
 [packages]
 protobuf = "*"
 jinja2 = "*"
 [requires]
 python_version = "3.7"
 [scripts]
 generate = "python betterproto/tests/generate.py"
 test = "pytest ./betterproto/tests"
--- a/Pipfile.lock
+++ b/Pipfile.lock
@ -0,0 +1,273 @@
 {
    "_meta": {
        "hash": {
            "sha256": "817b0f61c21a4841d0cfcc977becb16b4d55090f3d78c1ebcd6974c298a06348"
        },
        "pipfile-spec": 6,
        "requires": {
            "python_version": "3.7"
        },
        "sources": [
            {
                "name": "pypi",
                "url": "https://pypi.org/simple",
                "verify_ssl": true
            }
        ]
    },
    "default": {
        "jinja2": {
            "hashes": [
                "sha256:065c4f02ebe7f7cf559e49ee5a95fb800a9e4528727aec6f24402a5374c65013",
                "sha256:14dd6caf1527abb21f08f86c784eac40853ba93edb79552aa1e4b8aef1b61c7b"
            ],
            "index": "pypi",
            "version": "==2.10.1"
        },
        "markupsafe": {
            "hashes": [
                "sha256:00bc623926325b26bb9605ae9eae8a215691f33cae5df11ca5424f06f2d1f473",
                "sha256:09027a7803a62ca78792ad89403b1b7a73a01c8cb65909cd876f7fcebd79b161",
                "sha256:09c4b7f37d6c648cb13f9230d847adf22f8171b1ccc4d5682398e77f40309235",
                "sha256:1027c282dad077d0bae18be6794e6b6b8c91d58ed8a8d89a89d59693b9131db5",
                "sha256:24982cc2533820871eba85ba648cd53d8623687ff11cbb805be4ff7b4c971aff",
                "sha256:29872e92839765e546828bb7754a68c418d927cd064fd4708fab9fe9c8bb116b",
                "sha256:43a55c2930bbc139570ac2452adf3d70cdbb3cfe5912c71cdce1c2c6bbd9c5d1",
                "sha256:46c99d2de99945ec5cb54f23c8cd5689f6d7177305ebff350a58ce5f8de1669e",
                "sha256:500d4957e52ddc3351cabf489e79c91c17f6e0899158447047588650b5e69183",
                "sha256:535f6fc4d397c1563d08b88e485c3496cf5784e927af890fb3c3aac7f933ec66",
                "sha256:62fe6c95e3ec8a7fad637b7f3d372c15ec1caa01ab47926cfdf7a75b40e0eac1",
                "sha256:6dd73240d2af64df90aa7c4e7481e23825ea70af4b4922f8ede5b9e35f78a3b1",
                "sha256:717ba8fe3ae9cc0006d7c451f0bb265ee07739daf76355d06366154ee68d221e",
                "sha256:79855e1c5b8da654cf486b830bd42c06e8780cea587384cf6545b7d9ac013a0b",
                "sha256:7c1699dfe0cf8ff607dbdcc1e9b9af1755371f92a68f706051cc8c37d447c905",
                "sha256:88e5fcfb52ee7b911e8bb6d6aa2fd21fbecc674eadd44118a9cc3863f938e735",
                "sha256:8defac2f2ccd6805ebf65f5eeb132adcf2ab57aa11fdf4c0dd5169a004710e7d",
                "sha256:98c7086708b163d425c67c7a91bad6e466bb99d797aa64f965e9d25c12111a5e",
                "sha256:9add70b36c5666a2ed02b43b335fe19002ee5235efd4b8a89bfcf9005bebac0d",
                "sha256:9bf40443012702a1d2070043cb6291650a0841ece432556f784f004937f0f32c",
                "sha256:ade5e387d2ad0d7ebf59146cc00c8044acbd863725f887353a10df825fc8ae21",
                "sha256:b00c1de48212e4cc9603895652c5c410df699856a2853135b3967591e4beebc2",
                "sha256:b1282f8c00509d99fef04d8ba936b156d419be841854fe901d8ae224c59f0be5",
                "sha256:b2051432115498d3562c084a49bba65d97cf251f5a331c64a12ee7e04dacc51b",
                "sha256:ba59edeaa2fc6114428f1637ffff42da1e311e29382d81b339c1817d37ec93c6",
                "sha256:c8716a48d94b06bb3b2524c2b77e055fb313aeb4ea620c8dd03a105574ba704f",
                "sha256:cd5df75523866410809ca100dc9681e301e3c27567cf498077e8551b6d20e42f",
                "sha256:e249096428b3ae81b08327a63a485ad0878de3fb939049038579ac0ef61e17e7"
            ],
            "version": "==1.1.1"
        },
        "protobuf": {
            "hashes": [
                "sha256:125713564d8cfed7610e52444c9769b8dcb0b55e25cc7841f2290ee7bc86636f",
                "sha256:1accdb7a47e51503be64d9a57543964ba674edac103215576399d2d0e34eac77",
                "sha256:27003d12d4f68e3cbea9eb67427cab3bfddd47ff90670cb367fcd7a3a89b9657",
                "sha256:3264f3c431a631b0b31e9db2ae8c927b79fc1a7b1b06b31e8e5bcf2af91fe896",
                "sha256:3c5ab0f5c71ca5af27143e60613729e3488bb45f6d3f143dc918a20af8bab0bf",
                "sha256:45dcf8758873e3f69feab075e5f3177270739f146255225474ee0b90429adef6",
                "sha256:56a77d61a91186cc5676d8e11b36a5feb513873e4ae88d2ee5cf530d52bbcd3b",
                "sha256:5984e4947bbcef5bd849d6244aec507d31786f2dd3344139adc1489fb403b300",
                "sha256:6b0441da73796dd00821763bb4119674eaf252776beb50ae3883bed179a60b2a",
                "sha256:6f6677c5ade94d4fe75a912926d6796d5c71a2a90c2aeefe0d6f211d75c74789",
                "sha256:84a825a9418d7196e2acc48f8746cf1ee75877ed2f30433ab92a133f3eaf8fbe",
                "sha256:b842c34fe043ccf78b4a6cf1019d7b80113707d68c88842d061fa2b8fb6ddedc",
                "sha256:ca33d2f09dae149a1dcf942d2d825ebb06343b77b437198c9e2ef115cf5d5bc1",
                "sha256:db83b5c12c0cd30150bb568e6feb2435c49ce4e68fe2d7b903113f0e221e58fe",
                "sha256:f50f3b1c5c1c1334ca7ce9cad5992f098f460ffd6388a3cabad10b66c2006b09",
                "sha256:f99f127909731cafb841c52f9216e447d3e4afb99b17bebfad327a75aee206de"
            ],
            "index": "pypi",
            "version": "==3.10.0"
        },
        "six": {
            "hashes": [
                "sha256:3350809f0555b11f552448330d0b52d5f24c91a322ea4a15ef22629740f3761c",
                "sha256:d16a0141ec1a18405cd4ce8b4613101da75da0e9a7aec5bdd4fa804d0e0eba73"
            ],
            "version": "==1.12.0"
        }
    },
    "develop": {
        "atomicwrites": {
            "hashes": [
                "sha256:03472c30eb2c5d1ba9227e4c2ca66ab8287fbfbbda3888aa93dc2e28fc6811b4",
                "sha256:75a9445bac02d8d058d5e1fe689654ba5a6556a1dfd8ce6ec55a0ed79866cfa6"
            ],
            "version": "==1.3.0"
        },
        "attrs": {
            "hashes": [
                "sha256:ec20e7a4825331c1b5ebf261d111e16fa9612c1f7a5e1f884f12bd53a664dfd2",
                "sha256:f913492e1663d3c36f502e5e9ba6cd13cf19d7fab50aa13239e420fef95e1396"
            ],
            "version": "==19.2.0"
        },
        "entrypoints": {
            "hashes": [
                "sha256:589f874b313739ad35be6e0cd7efde2a4e9b6fea91edcc34e58ecbb8dbe56d19",
                "sha256:c70dd71abe5a8c85e55e12c19bd91ccfeec11a6e99044204511f9ed547d48451"
            ],
            "version": "==0.3"
        },
        "flake8": {
            "hashes": [
                "sha256:19241c1cbc971b9962473e4438a2ca19749a7dd002dd1a946eaba171b4114548",
                "sha256:8e9dfa3cecb2400b3738a42c54c3043e821682b9c840b0448c0503f781130696"
            ],
            "index": "pypi",
            "version": "==3.7.8"
        },
        "importlib-metadata": {
            "hashes": [
                "sha256:aa18d7378b00b40847790e7c27e11673d7fed219354109d0e7b9e5b25dc3ad26",
                "sha256:d5f18a79777f3aa179c145737780282e27b508fc8fd688cb17c7a813e8bd39af"
            ],
            "markers": "python_version < '3.8'",
            "version": "==0.23"
        },
        "isort": {
            "hashes": [
                "sha256:54da7e92468955c4fceacd0c86bd0ec997b0e1ee80d97f67c35a78b719dccab1",
                "sha256:6e811fcb295968434526407adb8796944f1988c5b65e8139058f2014cbe100fd"
            ],
            "index": "pypi",
            "version": "==4.3.21"
        },
        "mccabe": {
            "hashes": [
                "sha256:ab8a6258860da4b6677da4bd2fe5dc2c659cff31b3ee4f7f5d64e79735b80d42",
                "sha256:dd8d182285a0fe56bace7f45b5e7d1a6ebcbf524e8f3bd87eb0f125271b8831f"
            ],
            "version": "==0.6.1"
        },
        "more-itertools": {
            "hashes": [
                "sha256:409cd48d4db7052af495b09dec721011634af3753ae1ef92d2b32f73a745f832",
                "sha256:92b8c4b06dac4f0611c0729b2f2ede52b2e1bac1ab48f089c7ddc12e26bb60c4"
            ],
            "version": "==7.2.0"
        },
        "mypy": {
            "hashes": [
                "sha256:1d98fd818ad3128a5408148c9e4a5edce6ed6b58cc314283e631dd5d9216527b",
                "sha256:22ee018e8fc212fe601aba65d3699689dd29a26410ef0d2cc1943de7bec7e3ac",
                "sha256:3a24f80776edc706ec8d05329e854d5b9e464cd332e25cde10c8da2da0a0db6c",
                "sha256:42a78944e80770f21609f504ca6c8173f7768043205b5ac51c9144e057dcf879",
                "sha256:4b2b20106973548975f0c0b1112eceb4d77ed0cafe0a231a1318f3b3a22fc795",
                "sha256:591a9625b4d285f3ba69f541c84c0ad9e7bffa7794da3fa0585ef13cf95cb021",
                "sha256:5b4b70da3d8bae73b908a90bb2c387b977e59d484d22c604a2131f6f4397c1a3",
                "sha256:84edda1ffeda0941b2ab38ecf49302326df79947fa33d98cdcfbf8ca9cf0bb23",
                "sha256:b2b83d29babd61b876ae375786960a5374bba0e4aba3c293328ca6ca5dc448dd",
                "sha256:cc4502f84c37223a1a5ab700649b5ab1b5e4d2bf2d426907161f20672a21930b",
                "sha256:e29e24dd6e7f39f200a5bb55dcaa645d38a397dd5a6674f6042ef02df5795046"
            ],
            "index": "pypi",
            "version": "==0.730"
        },
        "mypy-extensions": {
            "hashes": [
                "sha256:a161e3b917053de87dbe469987e173e49fb454eca10ef28b48b384538cc11458"
            ],
            "version": "==0.4.2"
        },
        "packaging": {
            "hashes": [
                "sha256:28b924174df7a2fa32c1953825ff29c61e2f5e082343165438812f00d3a7fc47",
                "sha256:d9551545c6d761f3def1677baf08ab2a3ca17c56879e70fecba2fc4dde4ed108"
            ],
            "version": "==19.2"
        },
        "pluggy": {
            "hashes": [
                "sha256:0db4b7601aae1d35b4a033282da476845aa19185c1e6964b25cf324b5e4ec3e6",
                "sha256:fa5fa1622fa6dd5c030e9cad086fa19ef6a0cf6d7a2d12318e10cb49d6d68f34"
            ],
            "version": "==0.13.0"
        },
        "py": {
            "hashes": [
                "sha256:64f65755aee5b381cea27766a3a147c3f15b9b6b9ac88676de66ba2ae36793fa",
                "sha256:dc639b046a6e2cff5bbe40194ad65936d6ba360b52b3c3fe1d08a82dd50b5e53"
            ],
            "version": "==1.8.0"
        },
        "pycodestyle": {
            "hashes": [
                "sha256:95a2219d12372f05704562a14ec30bc76b05a5b297b21a5dfe3f6fac3491ae56",
                "sha256:e40a936c9a450ad81df37f549d676d127b1b66000a6c500caa2b085bc0ca976c"
            ],
            "version": "==2.5.0"
        },
        "pyflakes": {
            "hashes": [
                "sha256:17dbeb2e3f4d772725c777fabc446d5634d1038f234e77343108ce445ea69ce0",
                "sha256:d976835886f8c5b31d47970ed689944a0262b5f3afa00a5a7b4dc81e5449f8a2"
            ],
            "version": "==2.1.1"
        },
        "pyparsing": {
            "hashes": [
                "sha256:6f98a7b9397e206d78cc01df10131398f1c8b8510a2f4d97d9abd82e1aacdd80",
                "sha256:d9338df12903bbf5d65a0e4e87c2161968b10d2e489652bb47001d82a9b028b4"
            ],
            "version": "==2.4.2"
        },
        "pytest": {
            "hashes": [
                "sha256:13c1c9b22127a77fc684eee24791efafcef343335d855e3573791c68588fe1a5",
                "sha256:d8ba7be9466f55ef96ba203fc0f90d0cf212f2f927e69186e1353e30bc7f62e5"
            ],
            "index": "pypi",
            "version": "==5.2.0"
        },
        "six": {
            "hashes": [
                "sha256:3350809f0555b11f552448330d0b52d5f24c91a322ea4a15ef22629740f3761c",
                "sha256:d16a0141ec1a18405cd4ce8b4613101da75da0e9a7aec5bdd4fa804d0e0eba73"
            ],
            "version": "==1.12.0"
        },
        "typed-ast": {
            "hashes": [
                "sha256:18511a0b3e7922276346bcb47e2ef9f38fb90fd31cb9223eed42c85d1312344e",
                "sha256:262c247a82d005e43b5b7f69aff746370538e176131c32dda9cb0f324d27141e",
                "sha256:2b907eb046d049bcd9892e3076c7a6456c93a25bebfe554e931620c90e6a25b0",
                "sha256:354c16e5babd09f5cb0ee000d54cfa38401d8b8891eefa878ac772f827181a3c",
                "sha256:4e0b70c6fc4d010f8107726af5fd37921b666f5b31d9331f0bd24ad9a088e631",
                "sha256:630968c5cdee51a11c05a30453f8cd65e0cc1d2ad0d9192819df9978984529f4",
                "sha256:66480f95b8167c9c5c5c87f32cf437d585937970f3fc24386f313a4c97b44e34",
                "sha256:71211d26ffd12d63a83e079ff258ac9d56a1376a25bc80b1cdcdf601b855b90b",
                "sha256:95bd11af7eafc16e829af2d3df510cecfd4387f6453355188342c3e79a2ec87a",
                "sha256:bc6c7d3fa1325a0c6613512a093bc2a2a15aeec350451cbdf9e1d4bffe3e3233",
                "sha256:cc34a6f5b426748a507dd5d1de4c1978f2eb5626d51326e43280941206c209e1",
                "sha256:d755f03c1e4a51e9b24d899561fec4ccaf51f210d52abdf8c07ee2849b212a36",
                "sha256:d7c45933b1bdfaf9f36c579671fec15d25b06c8398f113dab64c18ed1adda01d",
                "sha256:d896919306dd0aa22d0132f62a1b78d11aaf4c9fc5b3410d3c666b818191630a",
                "sha256:ffde2fbfad571af120fcbfbbc61c72469e72f550d676c3342492a9dfdefb8f12"
            ],
            "version": "==1.4.0"
        },
        "typing-extensions": {
            "hashes": [
                "sha256:2ed632b30bb54fc3941c382decfd0ee4148f5c591651c9272473fea2c6397d95",
                "sha256:b1edbbf0652660e32ae780ac9433f4231e7339c7f9a8057d0f042fcbcea49b87",
                "sha256:d8179012ec2c620d3791ca6fe2bf7979d979acdbef1fca0bc56b37411db682ed"
            ],
            "version": "==3.7.4"
        },
        "wcwidth": {
            "hashes": [
                "sha256:3df37372226d6e63e1b1e1eda15c594bca98a22d33a23832a90998faa96bc65e",
                "sha256:f4ebe71925af7b40a864553f761ed559b43544f8f71746c2d756c7fe788ade7c"
            ],
            "version": "==0.1.7"
        },
        "zipp": {
            "hashes": [
                "sha256:3718b1cbcd963c7d4c5511a8240812904164b7f381b647143a89d3b98f9bcd8e",
                "sha256:f06903e9f1f43b12d371004b4ac7b06ab39a44adc747266928ae6debfa7b3335"
            ],
            "version": "==0.6.0"
        }
    }
 }
--- a/README.md
+++ b/README.md
@ -0,0 +1,10 @@
 # TODO
 - [ ] Fixed length fields
 - [x] Zig-zag signed fields (sint32, sint64)
 - [x] Don't encode zero values for nested types~
 - [ ] Enums
 - [ ] Maps
 - [ ] Support passthrough of unknown fields
 - [ ] JSON that isn't naive.
 - [ ] Cleanup!
--- a/betterproto/init.py
+++ b/betterproto/init.py
@ -0,0 +1,262 @@
 from abc import ABC
 import json
 import struct
 from typing import (
    Union,
    Generator,
    Any,
    SupportsBytes,
    List,
    Tuple,
    Callable,
    Type,
    Iterable,
    TypeVar,
 )
 import dataclasses
 from . import parse, serialize
 PACKED_TYPES = [
    "bool",
    "int32",
    "int64",
    "uint32",
    "uint64",
    "sint32",
    "sint64",
    "float",
    "double",
 ]
 # Wire types
 # https://developers.google.com/protocol-buffers/docs/encoding#structure
 WIRE_VARINT = 0
 WIRE_FIXED_64 = 1
 WIRE_LEN_DELIM = 2
 WIRE_FIXED_32 = 5
@dataclasses.dataclass(frozen=True)
 class _Meta:
    number: int
    proto_type: str
    default: Any
 def field(number: int, proto_type: str, default: Any) -> dataclasses.Field:
    kwargs = {}
    if callable(default):
        kwargs["default_factory"] = default
    elif isinstance(default, dict) or isinstance(default, list):
        kwargs["default_factory"] = lambda: default
    else:
        kwargs["default"] = default
    return dataclasses.field(
        **kwargs, metadata={"betterproto": _Meta(number, proto_type, default)}
    )
 def int32_field(
    number: int, default: Union[int, Type[Iterable]] = 0
 ) -> dataclasses.Field:
    return field(number, "int32", default=default)
 def int64_field(number: int, default: int = 0) -> dataclasses.Field:
    return field(number, "int64", default=default)
 def uint32_field(number: int, default: int = 0) -> dataclasses.Field:
    return field(number, "uint32", default=default)
 def uint64_field(number: int, default: int = 0) -> dataclasses.Field:
    return field(number, "uint64", default=default)
 def sint32_field(number: int, default: int = 0) -> dataclasses.Field:
    return field(number, "sint32", default=default)
 def sint64_field(number: int, default: int = 0) -> dataclasses.Field:
    return field(number, "sint64", default=default)
 def float_field(number: int, default: float = 0.0) -> dataclasses.Field:
    return field(number, "float", default=default)
 def double_field(number: int, default: float = 0.0) -> dataclasses.Field:
    return field(number, "double", default=default)
 def string_field(number: int, default: str = "") -> dataclasses.Field:
    return field(number, "string", default=default)
 def message_field(number: int, default: Type["ProtoMessage"]) -> dataclasses.Field:
    return field(number, "message", default=default)
 def _serialize_single(meta: _Meta, value: Any) -> bytes:
    output = b""
    if meta.proto_type in ["int32", "int64", "uint32", "uint64"]:
        if value < 0:
            # Handle negative numbers.
            value += 1 << 64
        output = serialize.varint(meta.number, value)
    elif meta.proto_type in ["sint32", "sint64"]:
        if value >= 0:
            value = value << 1
        else:
            value = (value << 1) ^ (~0)
        output = serialize.varint(meta.number, value)
    elif meta.proto_type == "string":
        output = serialize.len_delim(meta.number, value.encode("utf-8"))
    elif meta.proto_type == "message":
        b = bytes(value)
        if len(b):
            output = serialize.len_delim(meta.number, b)
    else:
        raise NotImplementedError()
    return output
 def _parse_single(wire_type: int, meta: _Meta, field: Any, value: Any) -> Any:
    if wire_type == WIRE_VARINT:
        if meta.proto_type in ["int32", "int64"]:
            bits = int(meta.proto_type[3:])
            value = value & ((1 << bits) - 1)
            signbit = 1 << (bits - 1)
            value = int((value ^ signbit) - signbit)
        elif meta.proto_type in ["sint32", "sint64"]:
            # Undo zig-zag encoding
            value = (value >> 1) ^ (-(value & 1))
    elif wire_type == WIRE_LEN_DELIM:
        if meta.proto_type in ["string"]:
            value = value.decode("utf-8")
        elif meta.proto_type in ["message"]:
            value = field.default_factory().parse(value)
    return value
 # Bound type variable to allow methods to return `self` of subclasses
 T = TypeVar("T", bound="Message")
 class Message(ABC):
    """
    A protobuf message base class. Generated code will inherit from this and
    register the message fields which get used by the serializers and parsers
    to go between Python, binary and JSON protobuf message representations.
    """
    def __bytes__(self) -> bytes:
        """
        Get the binary encoded Protobuf representation of this instance.
        """
        output = b""
        for field in dataclasses.fields(self):
            meta: _Meta = field.metadata.get("betterproto")
            value = getattr(self, field.name)
            if isinstance(value, list):
                if not len(value):
                    continue
                if meta.proto_type in PACKED_TYPES:
                    output += serialize.packed(meta.number, value)
                else:
                    for item in value:
                        output += _serialize_single(meta, item)
            else:
                if value == field.default:
                    continue
                output += _serialize_single(meta, value)
        return output
    def parse(self, data: bytes) -> T:
        """
        Parse the binary encoded Protobuf into this message instance. This
        returns the instance itself and is therefore assignable and chainable.
        """
        fields = {f.metadata["betterproto"].number: f for f in dataclasses.fields(self)}
        for parsed in parse.fields(data):
            if parsed.number in fields:
                field = fields[parsed.number]
                meta: _Meta = field.metadata.get("betterproto")
                if (
                    parsed.wire_type == WIRE_LEN_DELIM
                    and meta.proto_type in PACKED_TYPES
                ):
                    # This is a packed repeated field.
                    pos = 0
                    value = []
                    while pos < len(parsed.value):
                        decoded, pos = parse._decode_varint(parsed.value, pos)
                        decoded = _parse_single(WIRE_VARINT, meta, field, decoded)
                        value.append(decoded)
                else:
                    value = _parse_single(parsed.wire_type, meta, field, parsed.value)
                if isinstance(getattr(self, field.name), list) and not isinstance(
                    value, list
                ):
                    getattr(self, field.name).append(value)
                else:
                    setattr(self, field.name, value)
            else:
                # TODO: handle unknown fields
                pass
        return self
    def to_dict(self) -> dict:
        """
        Returns a dict representation of this message instance which can be
        used to serialize to e.g. JSON.
        """
        output = {}
        for field in dataclasses.fields(self):
            meta: Meta_ = field.metadata.get("betterproto")
            v = getattr(self, field.name)
            if meta.proto_type == "message":
                v = v.to_dict()
                if v:
                    output[field.name] = v
            elif v != field.default:
                output[field.name] = getattr(self, field.name)
        return output
    def from_dict(self, value: dict) -> T:
        """
        Parse the key/value pairs in `value` into this message instance. This
        returns the instance itself and is therefore assignable and chainable.
        """
        for field in dataclasses.fields(self):
            meta: Meta_ = field.metadata.get("betterproto")
            if field.name in value:
                if meta.proto_type == "message":
                    getattr(self, field.name).from_dict(value[field.name])
                else:
                    setattr(self, field.name, value[field.name])
        return self
    def to_json(self) -> bytes:
        """Returns the encoded JSON representation of this message instance."""
        return json.dumps(self.to_dict())
    def from_json(self, value: bytes) -> T:
        """
        Parse the key/value pairs in `value` into this message instance. This
        returns the instance itself and is therefore assignable and chainable.
        """
        return self.from_dict(json.loads(value))
--- a/betterproto/pycache/init.cpython-37.pyc
+++ b/betterproto/pycache/init.cpython-37.pyc
--- a/betterproto/parse.py
+++ b/betterproto/parse.py
@ -0,0 +1,64 @@
 import struct
 from typing import Union, Generator, Any, SupportsBytes, List, Tuple
 from dataclasses import dataclass
 def _decode_varint(
    buffer: bytes, pos: int, signed: bool = False, result_type: type = int
 ) -> Tuple[int, int]:
    result = 0
    shift = 0
    while 1:
        b = buffer[pos]
        result |= (b & 0x7F) << shift
        pos += 1
        if not (b & 0x80):
            result = result_type(result)
            return (result, pos)
        shift += 7
        if shift >= 64:
            raise ValueError("Too many bytes when decoding varint.")
 def packed(value: bytes, signed: bool = False, result_type: type = int) -> list:
    parsed = []
    pos = 0
    while pos < len(value):
        decoded, pos = _decode_varint(
            value, pos, signed=signed, result_type=result_type
        )
        parsed.append(decoded)
    return parsed
@dataclass(frozen=True)
 class Field:
    number: int
    wire_type: int
    value: Any
 def fields(value: bytes) -> Generator[Field, None, None]:
    i = 0
    while i < len(value):
        num_wire, i = _decode_varint(value, i)
        print(num_wire, i)
        number = num_wire >> 3
        wire_type = num_wire & 0x7
        if wire_type == 0:
            decoded, i = _decode_varint(value, i)
        elif wire_type == 1:
            decoded, i = None, i + 4
        elif wire_type == 2:
            length, i = _decode_varint(value, i)
            decoded = value[i : i + length]
            i += length
        elif wire_type == 5:
            decoded, i = None, i + 2
        else:
            raise NotImplementedError(f"Wire type {wire_type}")
        # print(Field(number=number, wire_type=wire_type, value=decoded))
        yield Field(number=number, wire_type=wire_type, value=decoded)
--- a/betterproto/py.typed
+++ b/betterproto/py.typed
--- a/betterproto/serialize.py
+++ b/betterproto/serialize.py
@ -0,0 +1,44 @@
 import struct
 from typing import Union, Generator, Any, SupportsBytes, List, Tuple
 from dataclasses import dataclass
 def _varint(value: int) -> bytes:
    # From https://github.com/protocolbuffers/protobuf/blob/master/python/google/protobuf/internal/encoder.py#L372
    b: List[int] = []
    bits = value & 0x7F
    value >>= 7
    while value:
        b.append(0x80 | bits)
        bits = value & 0x7F
        value >>= 7
        print(value)
    return bytes(b + [bits])
 def varint(field_number: int, value: Union[int, float]) -> bytes:
    key = _varint(field_number << 3)
    return key + _varint(value)
 def len_delim(field_number: int, value: Union[str, bytes]) -> bytes:
    key = _varint((field_number << 3) | 2)
    if isinstance(value, str):
        value = value.encode("utf-8")
    return key + _varint(len(value)) + value
 def packed(field_number: int, value: list) -> bytes:
    key = _varint((field_number << 3) | 2)
    packed = b""
    for item in value:
        if item < 0:
            # Handle negative numbers.
            item += 1 << 64
        packed += _varint(item)
    return key + _varint(len(packed)) + packed
--- a/betterproto/templates/main.py
+++ b/betterproto/templates/main.py
@ -0,0 +1,24 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # source: {{ description.filename }}
 from dataclasses import dataclass
 from typing import List
 import betterproto
 {% for message in description.messages %}
@dataclass
 class {{ message.name }}(betterproto.Message):
    {% if message.comment %}
 {{ message.comment }}
    {% endif %}
    {% for field in message.properties %}
        {% if field.comment %}
 {{ field.comment }}
        {% endif %}
    {{ field.name }}: {{ field.type }} = betterproto.{{ field.field_type }}_field({{ field.number }}{% if field.zero %}, default={{ field.zero }}{% endif %})
    {% endfor %}
 {% endfor %}
--- a/betterproto/tests/generate.py
+++ b/betterproto/tests/generate.py
@ -0,0 +1,45 @@
 #!/usr/bin/env python
 import os  # isort: skip
 os.environ["PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION"] = "python"
 import subprocess
 import importlib
 from typing import Generator, Tuple
 from google.protobuf.json_format import Parse
 from google.protobuf import symbol_database
 from google.protobuf.descriptor_pool import DescriptorPool
 root = os.path.dirname(os.path.realpath(__file__))
 def get_files(end: str) -> Generator[Tuple[str, str], None, None]:
    for r, dirs, files in os.walk(root):
        for filename in [f for f in files if f.endswith(end)]:
            parts = os.path.splitext(filename)[0].split("-")
            yield [parts[0], os.path.join(r, filename)]
 if __name__ == "__main__":
    os.chdir(root)
    for base, filename in get_files(".proto"):
        subprocess.run(
            f"protoc --python_out=. {os.path.basename(filename)}", shell=True
        )
        subprocess.run(
            f"protoc --plugin=protoc-gen-custom=../../protoc-gen-betterpy.py --custom_out=. {os.path.basename(filename)}",
            shell=True,
        )
    for base, filename in get_files(".json"):
        # Reset the internal symbol database so we can import the `Test` message
        # multiple times. Ugh.
        sym = symbol_database.Default()
        sym.pool = DescriptorPool()
        imported = importlib.import_module(f"{base}_pb2")
        out = filename.replace(".json", ".bin")
        serialized = Parse(open(filename).read(), imported.Test()).SerializeToString()
        open(out, "wb").write(serialized)
--- a/betterproto/tests/int32-negative.json
+++ b/betterproto/tests/int32-negative.json
@ -0,0 +1,3 @@
 {
  "count": -150
 }
--- a/betterproto/tests/int32.json
+++ b/betterproto/tests/int32.json
@ -0,0 +1,3 @@
 {
  "count": 150
 }
--- a/betterproto/tests/int32.proto
+++ b/betterproto/tests/int32.proto
@ -0,0 +1,7 @@
 syntax = "proto3";
 // Some documentation about the Test message.
 message Test {
    // Some documentation about the count.
    int32 count = 1;
 }
--- a/betterproto/tests/nested.json
+++ b/betterproto/tests/nested.json
@ -0,0 +1,5 @@
 {
  "nested": {
    "count": 150
  }
 }
--- a/betterproto/tests/nested.proto
+++ b/betterproto/tests/nested.proto
@ -0,0 +1,17 @@
 syntax = "proto3";
 // A test message with a nested message inside of it.
 message Test {
    // This is the nested type.
    message Nested {
      // Stores a simple counter.
      int32 count = 1;
    }
    Nested nested = 1;
    Sibling sibling = 2;
 }
 message Sibling {
  int32 foo = 1;
 }
--- a/betterproto/tests/repeated.json
+++ b/betterproto/tests/repeated.json
@ -0,0 +1,3 @@
 {
  "names": ["one", "two", "three"]
 }
--- a/betterproto/tests/repeated.proto
+++ b/betterproto/tests/repeated.proto
@ -0,0 +1,5 @@
 syntax = "proto3";
 message Test {
    repeated string names = 1;
 }
--- a/betterproto/tests/repeatedpacked.json
+++ b/betterproto/tests/repeatedpacked.json
@ -0,0 +1,3 @@
 {
  "counts": [1, 2, -1, -2]
 }
--- a/betterproto/tests/repeatedpacked.proto
+++ b/betterproto/tests/repeatedpacked.proto
@ -0,0 +1,5 @@
 syntax = "proto3";
 message Test {
    repeated int32 counts = 1;
 }
--- a/betterproto/tests/signed-negative.json
+++ b/betterproto/tests/signed-negative.json
@ -0,0 +1,4 @@
 {
  "signed_32": -150,
  "signed_64": -150
 }
--- a/betterproto/tests/signed.json
+++ b/betterproto/tests/signed.json
@ -0,0 +1,4 @@
 {
  "signed_32": 150,
  "signed_64": 150
 }
--- a/betterproto/tests/signed.proto
+++ b/betterproto/tests/signed.proto
@ -0,0 +1,6 @@
 syntax = "proto3";
 message Test {
    sint32 signed_32 = 1;
    sint64 signed_64 = 2;
 }
--- a/betterproto/tests/test_inputs.py
+++ b/betterproto/tests/test_inputs.py
@ -0,0 +1,23 @@
 import importlib
 import pytest
 import json
 from generate import get_files
 inputs = get_files(".bin")
@pytest.mark.parametrize("name,filename", inputs)
 def test_sample(name: str, filename: str) -> None:
    imported = importlib.import_module(name)
    data_binary = open(filename, "rb").read()
    data_dict = json.loads(open(filename.replace(".bin", ".json")).read())
    t1 = imported.Test().parse(data_binary)
    t2 = imported.Test().from_dict(data_dict)
    print(t1)
    print(t2)
    assert t1 == t2
    assert bytes(t1) == data_binary
    assert bytes(t2) == data_binary
    assert t1.to_dict() == data_dict
    assert t2.to_dict() == data_dict
--- a/protoc-gen-betterpy.py
+++ b/protoc-gen-betterpy.py
@ -0,0 +1,185 @@
 #!/usr/bin/env python
 import sys
 import itertools
 import json
 import os.path
 from typing import Tuple, Any, List
 import textwrap
 from google.protobuf.descriptor_pb2 import (
    DescriptorProto,
    EnumDescriptorProto,
    FileDescriptorProto,
 )
 from google.protobuf.compiler import plugin_pb2 as plugin
 from jinja2 import Environment, PackageLoader
 def py_type(descriptor: DescriptorProto) -> Tuple[str, str]:
    if descriptor.type in [1, 2, 6, 7, 15, 16]:
        return "float", descriptor.default_value
    elif descriptor.type in [3, 4, 5, 13, 17, 18]:
        return "int", descriptor.default_value
    elif descriptor.type == 8:
        return "bool", descriptor.default_value.capitalize()
    elif descriptor.type == 9:
        default = ""
        if descriptor.default_value:
            default = f'"{descriptor.default_value}"'
        return "str", default
    elif descriptor.type == 11:
        # Type referencing another defined Message
        # print(descriptor.type_name, file=sys.stderr)
        # message_type = descriptor.type_name.replace(".", "")
        message_type = descriptor.type_name.split(".").pop()
        return f'"{message_type}"', f"lambda: {message_type}()"
    elif descriptor.type == 12:
        default = ""
        if descriptor.default_value:
            default = f'b"{descriptor.default_value}"'
        return "bytes", default
    else:
        raise NotImplementedError()
 def traverse(proto_file):
    def _traverse(path, items):
        for i, item in enumerate(items):
            yield item, path + [i]
            if isinstance(item, DescriptorProto):
                for enum in item.enum_type:
                    yield enum, path + [i, 4]
                if item.nested_type:
                    for n, p in _traverse(path + [i, 3], item.nested_type):
                        yield n, p
    return itertools.chain(
        _traverse([5], proto_file.enum_type), _traverse([4], proto_file.message_type)
    )
 def get_comment(proto_file, path: List[int]) -> str:
    for sci in proto_file.source_code_info.location:
        # print(list(sci.path), path, file=sys.stderr)
        if list(sci.path) == path and sci.leading_comments:
            lines = textwrap.wrap(
                sci.leading_comments.strip().replace("\n", ""), width=75
            )
            if path[-2] == 2:
                # This is a field
                return "    # " + "    # ".join(lines)
            else:
                # This is a class
                if len(lines) == 1 and len(lines[0]) < 70:
                    return f'    """{lines[0]}"""'
                else:
                    return f'    """\n{"    ".join(lines)}\n    """'
    return ""
 def generate_code(request, response):
    env = Environment(
        trim_blocks=True,
        lstrip_blocks=True,
        loader=PackageLoader("betterproto", "templates"),
    )
    template = env.get_template("main.py")
    for proto_file in request.proto_file:
        # print(proto_file.message_type, file=sys.stderr)
        # print(proto_file.source_code_info, file=sys.stderr)
        output = {
            "package": proto_file.package,
            "filename": proto_file.name,
            "messages": [],
        }
        # Parse request
        for item, path in traverse(proto_file):
            # print(item, file=sys.stderr)
            # print(path, file=sys.stderr)
            data = {"name": item.name}
            if isinstance(item, DescriptorProto):
                # print(item, file=sys.stderr)
                data.update(
                    {
                        "type": "Message",
                        "comment": get_comment(proto_file, path),
                        "properties": [],
                    }
                )
                for i, f in enumerate(item.field):
                    t, zero = py_type(f)
                    repeated = False
                    packed = False
                    if f.label == 3:
                        # Repeated field
                        repeated = True
                        t = f"List[{t}]"
                        zero = "list"
                        if f.type in [1, 2, 3, 4, 5, 6, 7, 8, 13, 15, 16, 17, 18]:
                            packed = True
                    data["properties"].append(
                        {
                            "name": f.name,
                            "number": f.number,
                            "comment": get_comment(proto_file, path + [2, i]),
                            "proto_type": int(f.type),
                            "field_type": f.Type.Name(f.type).lower()[5:],
                            "type": t,
                            "zero": zero,
                            "repeated": repeated,
                            "packed": packed,
                        }
                    )
                    # print(f, file=sys.stderr)
            # elif isinstance(item, EnumDescriptorProto):
            #     data.update({
            #         'type': 'Enum',
            #         'values': [{'name': v.name, 'value': v.number}
            #                    for v in item.value]
            #     })
            output["messages"].append(data)
        # Fill response
        f = response.file.add()
        f.name = os.path.splitext(proto_file.name)[0] + ".py"
        # f.content = json.dumps(output, indent=2)
        f.content = template.render(description=output).rstrip("\n") + "\n"
 if __name__ == "__main__":
    # Read request message from stdin
    data = sys.stdin.buffer.read()
    # Parse request
    request = plugin.CodeGeneratorRequest()
    request.ParseFromString(data)
    # Create response
    response = plugin.CodeGeneratorResponse()
    # Generate code
    generate_code(request, response)
    # Serialise response message
    output = response.SerializeToString()
    # Write to stdout
    sys.stdout.buffer.write(output)