Update with master

Merge branch 'master' into michael-sayapin/master
Merge pull request #88 from boukeversteegh/fix/imports
2020-07-04 18:54:26 +02:00 · 2020-07-04 11:23:42 +02:00 · 2020-07-04 11:22:12 +02:00 · 2020-07-01 13:15:03 +02:00 · 2020-07-01 12:43:28 +02:00 · 2020-07-01 12:43:12 +02:00
147 changed files with 6492 additions and 1008 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -3,21 +3,72 @@ name: CI
 on: [push, pull_request]

 jobs:
-  build:

+  check-formatting:
    runs-on: ubuntu-latest
-    
+
+    name: Consult black on python formatting
+
    steps:
-    - uses: actions/checkout@v1
-    - uses: actions/setup-python@v1
-      with:
-        python-version: 3.7
-    - uses: dschep/install-pipenv-action@v1
-    - name: Install dependencies
-      run: |
-        sudo apt install protobuf-compiler
-        pipenv install --dev
-    - name: Run tests
-      run: |
-        pipenv run generate
-        pipenv run test
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2
+        with:
+          python-version: 3.7
+      - uses: Gr1N/setup-poetry@v2
+      - uses: actions/cache@v2
+        with:
+          path: ~/.cache/pypoetry/virtualenvs
+          key: ${{ runner.os }}-poetry-${{ hashFiles('poetry.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-poetry-
+      - name: Install dependencies
+        run: poetry install
+      - name: Run black
+        run: make check-style
+
+  run-tests:
+    runs-on: ubuntu-latest
+
+    name: Run tests with tox
+
+    strategy:
+      matrix:
+        python-version: [ '3.6', '3.7', '3.8']
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+      - uses: Gr1N/setup-poetry@v2
+      - uses: actions/cache@v2
+        with:
+          path: ~/.cache/pypoetry/virtualenvs
+          key: ${{ runner.os }}-poetry-${{ hashFiles('poetry.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-poetry-
+      - name: Install dependencies
+        run: |
+          sudo apt install protobuf-compiler libprotobuf-dev
+          poetry install
+      - name: Run tests
+        run: |
+          make generate
+          make test
+
+  build-release:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2
+        with:
+          python-version: 3.7
+      - uses: Gr1N/setup-poetry@v2
+      - name: Build package
+        run: poetry build
+      - name: Publish package to PyPI
+        if: github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags')
+        run: poetry publish -n
+        env:
+          POETRY_PYPI_TOKEN_PYPI: ${{ secrets.pypi }}
--- a/.gitignore
+++ b/.gitignore
@@ -1,13 +1,16 @@
+.coverage
+.DS_Store
 .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
+.python-version
+build/
+betterproto/tests/output_*
 **/__pycache__
 dist
 **/*.egg-info
 output
+.idea
+.DS_Store
+.tox
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -0,0 +1,69 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.2.5] - 2020-04-27
+
+- Add .j2 suffix to python template names to avoid confusing certain build tools [#72](https://github.com/danielgtaylor/python-betterproto/pull/72)
+
+## [1.2.4] - 2020-04-26
+
+- Enforce utf-8 for reading the readme in setup.py [#67](https://github.com/danielgtaylor/python-betterproto/pull/67)
+- Only import types from grpclib when type checking [#52](https://github.com/danielgtaylor/python-betterproto/pull/52)
+- Improve performance of serialize/deserialize by caching type information of fields in class [#46](https://github.com/danielgtaylor/python-betterproto/pull/46)
+- Support using Google's wrapper types as RPC output values [#40](https://github.com/danielgtaylor/python-betterproto/pull/40)
+- Fixes issue where protoc did not recognize plugin.py as win32 application [#38](https://github.com/danielgtaylor/python-betterproto/pull/38)
+- Fix services using non-pythonified field names [#34](https://github.com/danielgtaylor/python-betterproto/pull/34)
+- Add ability to provide metadata, timeout & deadline args to requests [#32](https://github.com/danielgtaylor/python-betterproto/pull/32)
+
+## [1.2.3] - 2020-04-15
+
+- Exclude empty lists from `to_dict` by default [#16](https://github.com/danielgtaylor/python-betterproto/pull/16)
+- Add `include_default_values` parameter for `to_dict` [#12](https://github.com/danielgtaylor/python-betterproto/pull/12)
+- Fix class names being prepended with duplicates when using protocol buffers that are nested more than once [#21](https://github.com/danielgtaylor/python-betterproto/pull/21)
+- Add support for python 3.6 [#30](https://github.com/danielgtaylor/python-betterproto/pull/30)
+
+## [1.2.2] - 2020-01-09
+
+- Mention lack of Proto 2 support in README.
+- Fix serialization of constructor parameters [#10](https://github.com/danielgtaylor/python-betterproto/pull/10)
+- Fix `casing` parameter propagation [#7](https://github.com/danielgtaylor/python-betterproto/pull/7)
+
+## [1.2.1] - 2019-10-29
+
+- Fix comment indentation bug in rendered gRPC methods.
+
+## [1.2.0] - 2019-10-28
+
+- Generated code output auto-formatting via [Black](https://github.com/psf/black)
+- Simplified gRPC helper functions
+
+## [1.1.0] - 2019-10-27
+
+- Better JSON casing support
+- Handle field names which clash with Python reserved words
+- Better handling of default values from type introspection
+- Support for Google Duration & Timestamp types
+- Support for Google wrapper types
+- Documentation updates
+
+## [1.0.1] - 2019-10-22
+
+- README to the PyPI details page
+
+## [1.0.0] - 2019-10-22
+
+- Initial release
+
+[1.2.5]: https://github.com/danielgtaylor/python-betterproto/compare/v1.2.4...v1.2.5
+[1.2.4]: https://github.com/danielgtaylor/python-betterproto/compare/v1.2.3...v1.2.4
+[1.2.3]: https://github.com/danielgtaylor/python-betterproto/compare/v1.2.2...v1.2.3
+[1.2.2]: https://github.com/danielgtaylor/python-betterproto/compare/v1.2.1...v1.2.2
+[1.2.1]: https://github.com/danielgtaylor/python-betterproto/compare/v1.2.0...v1.2.1
+[1.2.0]: https://github.com/danielgtaylor/python-betterproto/compare/v1.1.0...v1.2.0
+[1.1.0]: https://github.com/danielgtaylor/python-betterproto/compare/v1.0.1...v1.1.0
+[1.0.1]: https://github.com/danielgtaylor/python-betterproto/compare/v1.0.0...v1.0.1
+[1.0.0]: https://github.com/danielgtaylor/python-betterproto/releases/tag/v1.0.0
--- a/42
+++ b/42
@@ -0,0 +1,42 @@
+.PHONY: help setup generate test types format clean plugin full-test check-style
+
+help:               ## - Show this help.
+	@fgrep -h "##" $(MAKEFILE_LIST) | fgrep -v fgrep | sed -e 's/\\$$//' | sed -e 's/##//'
+
+# Dev workflow tasks
+
+generate:           ## - Generate test cases (do this once before running test)
+	poetry run ./betterproto/tests/generate.py
+
+test:               ## - Run tests
+	poetry run pytest --cov betterproto
+
+types:              ## - Check types with mypy
+	poetry run mypy betterproto --ignore-missing-imports
+
+format:             ## - Apply black formatting to source code
+	poetry run black . --exclude tests/output_
+
+clean:              ## - Clean out generated files from the workspace
+	rm -rf .coverage \
+	       .mypy_cache \
+	       .pytest_cache \
+	       dist \
+	       **/__pycache__ \
+	       betterproto/tests/output_*
+
+# Manual testing
+
+# By default write plugin output to a directory called output
+o=output
+plugin:             ## - Execute the protoc plugin, with output write to `output` or the value passed to `-o`
+	mkdir -p $(o)
+	protoc --plugin=protoc-gen-custom=betterproto/plugin.py $(i) --custom_out=$(o)
+
+# CI tasks
+
+full-test: generate ## - Run full testing sequence with multiple pythons
+	poetry run tox
+
+check-style:        ## - Check if code style is correct
+	poetry run black . --check --diff --exclude tests/output_
--- a/24
+++ b/24
@@ -1,24 +0,0 @@
-[[source]]
-name = "pypi"
-url = "https://pypi.org/simple"
-verify_ssl = true
-
-[dev-packages]
-flake8 = "*"
-mypy = "*"
-isort = "*"
-pytest = "*"
-rope = "*"
-
-[packages]
-protobuf = "*"
-jinja2 = "*"
-grpclib = "*"
-
-[requires]
-python_version = "3.7"
-
-[scripts]
-plugin = "protoc --plugin=protoc-gen-custom=betterproto/plugin.py --custom_out=output"
-generate = "python betterproto/tests/generate.py"
-test = "pytest ./betterproto/tests"
--- a/Pipfile.lock
+++ b/Pipfile.lock
@@ -1,344 +0,0 @@
-{
-    "_meta": {
-        "hash": {
-            "sha256": "f698150037f2a8ac554e4d37ecd4619ba35d1aa570f5b641d048ec9c6b23eb40"
-        },
-        "pipfile-spec": 6,
-        "requires": {
-            "python_version": "3.7"
-        },
-        "sources": [
-            {
-                "name": "pypi",
-                "url": "https://pypi.org/simple",
-                "verify_ssl": true
-            }
-        ]
-    },
-    "default": {
-        "grpclib": {
-            "hashes": [
-                "sha256:d19e2ea87cb073e5b0825dfee15336fd2b1c09278d271816e04c90faddc107ea"
-            ],
-            "index": "pypi",
-            "version": "==0.3.0"
-        },
-        "h2": {
-            "hashes": [
-                "sha256:ac377fcf586314ef3177bfd90c12c7826ab0840edeb03f0f24f511858326049e",
-                "sha256:b8a32bd282594424c0ac55845377eea13fa54fe4a8db012f3a198ed923dc3ab4"
-            ],
-            "version": "==3.1.1"
-        },
-        "hpack": {
-            "hashes": [
-                "sha256:0edd79eda27a53ba5be2dfabf3b15780928a0dff6eb0c60a3d6767720e970c89",
-                "sha256:8eec9c1f4bfae3408a3f30500261f7e6a65912dc138526ea054f9ad98892e9d2"
-            ],
-            "version": "==3.0.0"
-        },
-        "hyperframe": {
-            "hashes": [
-                "sha256:5187962cb16dcc078f23cb5a4b110098d546c3f41ff2d4038a9896893bbd0b40",
-                "sha256:a9f5c17f2cc3c719b917c4f33ed1c61bd1f8dfac4b1bd23b7c80b3400971b41f"
-            ],
-            "version": "==5.2.0"
-        },
-        "jinja2": {
-            "hashes": [
-                "sha256:74320bb91f31270f9551d46522e33af46a80c3d619f4a4bf42b3164d30b5911f",
-                "sha256:9fe95f19286cfefaa917656583d020be14e7859c6b0252588391e47db34527de"
-            ],
-            "index": "pypi",
-            "version": "==2.10.3"
-        },
-        "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"
-        },
-        "multidict": {
-            "hashes": [
-                "sha256:024b8129695a952ebd93373e45b5d341dbb87c17ce49637b34000093f243dd4f",
-                "sha256:041e9442b11409be5e4fc8b6a97e4bcead758ab1e11768d1e69160bdde18acc3",
-                "sha256:045b4dd0e5f6121e6f314d81759abd2c257db4634260abcfe0d3f7083c4908ef",
-                "sha256:047c0a04e382ef8bd74b0de01407e8d8632d7d1b4db6f2561106af812a68741b",
-                "sha256:068167c2d7bbeebd359665ac4fff756be5ffac9cda02375b5c5a7c4777038e73",
-                "sha256:148ff60e0fffa2f5fad2eb25aae7bef23d8f3b8bdaf947a65cdbe84a978092bc",
-                "sha256:1d1c77013a259971a72ddaa83b9f42c80a93ff12df6a4723be99d858fa30bee3",
-                "sha256:1d48bc124a6b7a55006d97917f695effa9725d05abe8ee78fd60d6588b8344cd",
-                "sha256:31dfa2fc323097f8ad7acd41aa38d7c614dd1960ac6681745b6da124093dc351",
-                "sha256:34f82db7f80c49f38b032c5abb605c458bac997a6c3142e0d6c130be6fb2b941",
-                "sha256:3d5dd8e5998fb4ace04789d1d008e2bb532de501218519d70bb672c4c5a2fc5d",
-                "sha256:4a6ae52bd3ee41ee0f3acf4c60ceb3f44e0e3bc52ab7da1c2b2aa6703363a3d1",
-                "sha256:4b02a3b2a2f01d0490dd39321c74273fed0568568ea0e7ea23e02bd1fb10a10b",
-                "sha256:4b843f8e1dd6a3195679d9838eb4670222e8b8d01bc36c9894d6c3538316fa0a",
-                "sha256:5de53a28f40ef3c4fd57aeab6b590c2c663de87a5af76136ced519923d3efbb3",
-                "sha256:61b2b33ede821b94fa99ce0b09c9ece049c7067a33b279f343adfe35108a4ea7",
-                "sha256:6a3a9b0f45fd75dc05d8e93dc21b18fc1670135ec9544d1ad4acbcf6b86781d0",
-                "sha256:76ad8e4c69dadbb31bad17c16baee61c0d1a4a73bed2590b741b2e1a46d3edd0",
-                "sha256:7ba19b777dc00194d1b473180d4ca89a054dd18de27d0ee2e42a103ec9b7d014",
-                "sha256:7c1b7eab7a49aa96f3db1f716f0113a8a2e93c7375dd3d5d21c4941f1405c9c5",
-                "sha256:7fc0eee3046041387cbace9314926aa48b681202f8897f8bff3809967a049036",
-                "sha256:8ccd1c5fff1aa1427100ce188557fc31f1e0a383ad8ec42c559aabd4ff08802d",
-                "sha256:8e08dd76de80539d613654915a2f5196dbccc67448df291e69a88712ea21e24a",
-                "sha256:c18498c50c59263841862ea0501da9f2b3659c00db54abfbf823a80787fde8ce",
-                "sha256:c49db89d602c24928e68c0d510f4fcf8989d77defd01c973d6cbe27e684833b1",
-                "sha256:ce20044d0317649ddbb4e54dab3c1bcc7483c78c27d3f58ab3d0c7e6bc60d26a",
-                "sha256:d1071414dd06ca2eafa90c85a079169bfeb0e5f57fd0b45d44c092546fcd6fd9",
-                "sha256:d3be11ac43ab1a3e979dac80843b42226d5d3cccd3986f2e03152720a4297cd7",
-                "sha256:db603a1c235d110c860d5f39988ebc8218ee028f07a7cbc056ba6424372ca31b"
-            ],
-            "version": "==4.5.2"
-        },
-        "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:7e4800063ccfc306a53c461442526c5571e1462f61583506ce97e4da6a1d88c8",
-                "sha256:ca563435f4941d0cb34767301c27bc65c510cb82e90b9ecf9cb52dc2c63caaa0"
-            ],
-            "index": "pypi",
-            "version": "==5.2.1"
-        },
-        "rope": {
-            "hashes": [
-                "sha256:6b728fdc3e98a83446c27a91fc5d56808a004f8beab7a31ab1d7224cecc7d969",
-                "sha256:c5c5a6a87f7b1a2095fb311135e2a3d1f194f5ecb96900fdd0a9100881f48aaf",
-                "sha256:f0dcf719b63200d492b85535ebe5ea9b29e0d0b8aebeb87fe03fc1a65924fdaf"
-            ],
-            "index": "pypi",
-            "version": "==0.14.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
@@ -2,14 +2,15 @@

 ![](https://github.com/danielgtaylor/python-betterproto/workflows/CI/badge.svg)

-This project aims to provide an improved experience when using Protobuf / gRPC in a modern Python environment by making use of modern language features and generating readable, understandable, idiomatic Python code. It will not support legacy features or environments. The following are supported:
+This project aims to provide an improved experience when using Protobuf / gRPC in a modern Python environment by making use of modern language features and generating readable, understandable, idiomatic Python code. It will not support legacy features or environments (e.g. Protobuf 2). The following are supported:

 - Protobuf 3 & gRPC code generation
  - Both binary & JSON serialization is built-in
- Python 3.7+ making use of:
+- Python 3.6+ making use of:
  - Enums
  - Dataclasses
  - `async`/`await`
+  - Timezone-aware `datetime` and `timedelta` objects
  - Relative imports
  - Mypy type checking

@@ -34,6 +35,8 @@ This project exists because I am unhappy with the state of the official Google p
  - Much code looks like C++ or Java ported 1:1 to Python
  - Capitalized function names like `HasField()` and `SerializeToString()`
  - 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.

@@ -43,10 +46,10 @@ First, install the package. Note that the `[compiler]` feature flag tells it to

 ```sh
 # Install both the library and compiler
-$ pip install betterproto[compiler]
+pip install "betterproto[compiler]"

 # Install just the library (to use the generated code output)
-$ pip install betterproto
+pip install betterproto
 ```

 Now, given you installed the compiler and have a proto file, e.g `example.proto`:
@@ -65,14 +68,15 @@ message Greeting {
 You can run the following:

 ```sh
-$ protoc -I . --python_betterproto_out=. example.proto
+mkdir lib
+protoc -I . --python_betterproto_out=lib example.proto
 ```

-This will generate `hello.py` which looks like:
+This will generate `lib/hello/__init__.py` which looks like:

-```py
+```python
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# sources: hello.proto
+# sources: example.proto
 # plugin: python-betterproto
 from dataclasses import dataclass

@@ -80,7 +84,7 @@ import betterproto


@dataclass
-class Hello(betterproto.Message):
+class Greeting(betterproto.Message):
    """Greeting represents a message you can tell a user."""

    message: str = betterproto.string_field(1)
@@ -88,23 +92,23 @@ class Hello(betterproto.Message):

 Now you can use it!

-```py
->>> from hello import Hello
->>> test = Hello()
+```python
+>>> from lib.hello import Greeting
+>>> test = Greeting()
 >>> test
-Hello(message='')
+Greeting(message='')

 >>> test.message = "Hey!"
 >>> test
-Hello(message="Hey!")
+Greeting(message="Hey!")

 >>> serialized = bytes(test)
 >>> serialized
 b'\n\x04Hey!'

->>> another = Hello().parse(serialized)
+>>> another = Greeting().parse(serialized)
 >>> another
-Hello(message="Hey!")
+Greeting(message="Hey!")

 >>> another.to_dict()
 {"message": "Hey!"}
@@ -155,7 +159,7 @@ You can use it like so (enable async in the interactive shell first):
 EchoResponse(values=["hello", "hello"])

 >>> async for response in service.echo_stream(value="hello", extra_times=1)
-    print(response)
+        print(response)

 EchoStreamResponse(value="hello")
 EchoStreamResponse(value="hello")
@@ -168,6 +172,12 @@ Both serializing and parsing are supported to/from JSON and Python dictionaries
 - Dicts: `Message().to_dict()`, `Message().from_dict(...)`
 - JSON: `Message().to_json()`, `Message().from_json(...)`

+For compatibility the default is to convert field names to `camelCase`. You can control this behavior by passing a casing value, e.g:
+
+```py
+>>> MyMessage().to_dict(casing=betterproto.Casing.SNAKE)
+```
+
 ### Determining if a message was sent

 Sometimes it is useful to be able to determine whether a message has been sent on the wire. This is how the Google wrapper types work to let you know whether a value is unset, set as the default (zero value), or set as something else, for example.
@@ -238,38 +248,141 @@ Again this is a little different than the official Google code generator:
 ["foo", "foo's value"]
 ```

+### Well-Known Google Types
+
+Google provides several well-known message types like a timestamp, duration, and several wrappers used to provide optional zero value support. Each of these has a special JSON representation and is handled a little differently from normal messages. The Python mapping for these is as follows:
+
+| Google Message              | Python Type                              | Default                |
+| --------------------------- | ---------------------------------------- | ---------------------- |
+| `google.protobuf.duration`  | [`datetime.timedelta`][td]               | `0`                    |
+| `google.protobuf.timestamp` | Timezone-aware [`datetime.datetime`][dt] | `1970-01-01T00:00:00Z` |
+| `google.protobuf.*Value`    | `Optional[...]`                          | `None`                 |
+| `google.protobuf.*`         | `betterproto.lib.google.protobuf.*`      | `None`                 |
+
+[td]: https://docs.python.org/3/library/datetime.html#timedelta-objects
+[dt]: https://docs.python.org/3/library/datetime.html#datetime.datetime
+
+For the wrapper types, the Python type corresponds to the wrapped type, e.g. `google.protobuf.BoolValue` becomes `Optional[bool]` while `google.protobuf.Int32Value` becomes `Optional[int]`. All of the optional values default to `None`, so don't forget to check for that possible state. Given:
+
+```protobuf
+syntax = "proto3";
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+import "google/protobuf/wrappers.proto";
+
+message Test {
+  google.protobuf.BoolValue maybe = 1;
+  google.protobuf.Timestamp ts = 2;
+  google.protobuf.Duration duration = 3;
+}
+```
+
+You can do stuff like:
+
+```py
+>>> t = Test().from_dict({"maybe": True, "ts": "2019-01-01T12:00:00Z", "duration": "1.200s"})
+>>> t
+Test(maybe=True, ts=datetime.datetime(2019, 1, 1, 12, 0, tzinfo=datetime.timezone.utc), duration=datetime.timedelta(seconds=1, microseconds=200000))
+
+>>> t.ts - t.duration
+datetime.datetime(2019, 1, 1, 11, 59, 58, 800000, tzinfo=datetime.timezone.utc)
+
+>>> t.ts.isoformat()
+'2019-01-01T12:00:00+00:00'
+
+>>> t.maybe = None
+>>> t.to_dict()
+{'ts': '2019-01-01T12:00:00Z', 'duration': '1.200s'}
+```
+
 ## Development

-First, make sure you have Python 3.7+ and `pipenv` installed, along with the official [Protobuf Compiler](https://github.com/protocolbuffers/protobuf/releases) for your platform. Then:
+Join us on [Slack](https://join.slack.com/t/betterproto/shared_invite/zt-f0n0uolx-iN8gBNrkPxtKHTLpG3o1OQ)!
+
+First, make sure you have Python 3.6+ and `poetry` installed, along with the official [Protobuf Compiler](https://github.com/protocolbuffers/protobuf/releases) for your platform. Then:

 ```sh
 # Get set up with the virtual env & dependencies
-$ pipenv install --dev
+poetry install

-# Link the local package
-$ pipenv shell
-$ pip install -e .
+# Activate the poetry environment
+poetry shell
 ```

+To benefit from the collection of standard development tasks ensure you have make installed and run `make help` to see available tasks.
+
+### Code style
+
+This project enforces [black](https://github.com/psf/black) python code formatting.
+
+Before committing changes run:
+
+```sh
+make format
+```
+
+To avoid merge conflicts later, non-black formatted python code will fail in CI.
+
 ### Tests

 There are two types of tests:

-1. Manually-written tests for some behavior of the library
-2. Proto files and JSON inputs for automated tests
+1. Standard tests
+2. Custom tests

-For #2, you can add a new `*.proto` file into the `betterproto/tests` directory along with a sample `*.json` input and it will get automatically picked up.
+#### Standard tests
+
+Adding a standard test case is easy.
+
+- Create a new directory `betterproto/tests/inputs/<name>`
+  - add `<name>.proto`  with a message called `Test`
+  - add `<name>.json` with some test data (optional)
+
+It will be picked up automatically when you run the tests.
+
+- See also: [Standard Tests Development Guide](betterproto/tests/README.md)
+
+#### Custom tests
+
+Custom tests are found in `tests/test_*.py` and are run with pytest.
+
+#### Running

 Here's how to run the tests.

 ```sh
-# Generate assets from sample .proto files
-$ pipenv run generate
-
+# Generate assets from sample .proto files required by the tests
+make generate
 # Run the tests
-$ pipenv run tests
+make test
 ```

+To run tests as they are run in CI (with tox) run:
+
+```sh
+make full-test
+```
+
+### (Re)compiling Google Well-known Types
+
+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`. 
+
+Assuming your `google.protobuf` source files (included with all releases of `protoc`) are located in `/usr/local/include`, you can regenerate them as follows:
+
+```sh
+protoc \
+    --plugin=protoc-gen-custom=betterproto/plugin.py \
+    --custom_opt=INCLUDE_GOOGLE \
+    --custom_out=betterproto/lib \
+    -I /usr/local/include/ \
+    /usr/local/include/google/protobuf/*.proto
+```
+
+
 ### TODO

 - [x] Fixed length fields
@@ -284,6 +397,9 @@ $ pipenv run tests
 - [x] Refs to nested types
 - [x] Imports in proto files
 - [x] Well-known Google types
+  - [ ] Support as request input
+  - [ ] Support as response output
+    - [ ] Automatically wrap/unwrap responses
 - [x] OneOf support
  - [x] Basic support on the wire
  - [x] Check which was set from the group
@@ -295,18 +411,22 @@ $ pipenv run tests
  - [x] Bytes as base64
  - [ ] Any support
  - [x] Enum strings
-  - [ ] Well known types support (timestamp, duration, wrappers)
-  - [ ] Support different casing (orig vs. camel vs. others?)
+  - [x] Well known types support (timestamp, duration, wrappers)
+  - [x] Support different casing (orig vs. camel vs. others?)
 - [ ] Async service stubs
  - [x] Unary-unary
  - [x] Server streaming response
  - [ ] Client streaming request
- [ ] Renaming messages and fields to conform to Python name standards
- [ ] Renaming clashes with language keywords and standard library top-level packages
+- [x] Renaming messages and fields to conform to Python name standards
+- [x] Renaming clashes with language keywords
 - [x] Python package
 - [x] Automate running tests
 - [ ] Cleanup!

+## Community
+
+Join us on [Slack](https://join.slack.com/t/betterproto/shared_invite/zt-f0n0uolx-iN8gBNrkPxtKHTLpG3o1OQ)!
+
 ## License

 Copyright © 2019 Daniel G. Taylor
--- a/betterproto/init.py
+++ b/betterproto/init.py
@@ -3,27 +3,34 @@ import enum
 import inspect
 import json
 import struct
+import sys
 from abc import ABC
-from base64 import b64encode, b64decode
+from base64 import b64decode, b64encode
+from datetime import datetime, timedelta, timezone
 from typing import (
    Any,
-    AsyncGenerator,
    Callable,
    Dict,
    Generator,
-    Iterable,
    List,
    Optional,
-    SupportsBytes,
+    Set,
    Tuple,
    Type,
-    TypeVar,
    Union,
    get_type_hints,
 )

-import grpclib.client
-import grpclib.const
+from ._types import T
+from .casing import camel_case, safe_snake_case, safe_snake_case, snake_case
+from .grpc.grpclib_client import ServiceStub
+
+if not (sys.version_info.major == 3 and sys.version_info.minor >= 7):
+    # Apply backport of datetime.fromisoformat from 3.7
+    from backports.datetime_fromisoformat import MonkeyPatch
+
+    MonkeyPatch.patch_fromisoformat()
+

 # Proto 3 data types
 TYPE_ENUM = "enum"
@@ -101,6 +108,21 @@ WIRE_FIXED_64_TYPES = [TYPE_DOUBLE, TYPE_FIXED64, TYPE_SFIXED64]
 WIRE_LEN_DELIM_TYPES = [TYPE_STRING, TYPE_BYTES, TYPE_MESSAGE, TYPE_MAP]


+# Protobuf datetimes start at the Unix Epoch in 1970 in UTC.
+def datetime_default_gen():
+    return datetime(1970, 1, 1, tzinfo=timezone.utc)
+
+
+DATETIME_ZERO = datetime_default_gen()
+
+
+class Casing(enum.Enum):
+    """Casing constants for serialization."""
+
+    CAMEL = camel_case
+    SNAKE = snake_case
+
+
 class _PLACEHOLDER:
    pass

@@ -108,18 +130,6 @@ class _PLACEHOLDER:
 PLACEHOLDER: Any = _PLACEHOLDER()


-def get_default(proto_type: str) -> Any:
-    """Get the default (zero value) for a given type."""
-    return {
-        TYPE_BOOL: False,
-        TYPE_FLOAT: 0.0,
-        TYPE_DOUBLE: 0.0,
-        TYPE_STRING: "",
-        TYPE_BYTES: b"",
-        TYPE_MAP: {},
-    }.get(proto_type, 0)
-
-
@dataclasses.dataclass(frozen=True)
 class FieldMetadata:
    """Stores internal metadata used for parsing & serialization."""
@@ -129,9 +139,11 @@ class FieldMetadata:
    # Protobuf type name
    proto_type: str
    # Map information if the proto_type is a map
-    map_types: Optional[Tuple[str, str]]
+    map_types: Optional[Tuple[str, str]] = None
    # Groups several "one-of" fields together
-    group: Optional[str]
+    group: Optional[str] = None
+    # Describes the wrapped type (e.g. when using google.protobuf.BoolValue)
+    wraps: Optional[str] = None

    @staticmethod
    def get(field: dataclasses.Field) -> "FieldMetadata":
@@ -145,11 +157,14 @@ def dataclass_field(
    *,
    map_types: Optional[Tuple[str, str]] = None,
    group: Optional[str] = None,
+    wraps: Optional[str] = None,
 ) -> dataclasses.Field:
    """Creates a dataclass field with attached protobuf metadata."""
    return dataclasses.field(
        default=PLACEHOLDER,
-        metadata={"betterproto": FieldMetadata(number, proto_type, map_types, group)},
+        metadata={
+            "betterproto": FieldMetadata(number, proto_type, map_types, group, wraps)
+        },
    )


@@ -222,8 +237,10 @@ def bytes_field(number: int, group: Optional[str] = None) -> Any:
    return dataclass_field(number, TYPE_BYTES, group=group)


-def message_field(number: int, group: Optional[str] = None) -> Any:
-    return dataclass_field(number, TYPE_MESSAGE, group=group)
+def message_field(
+    number: int, group: Optional[str] = None, wraps: Optional[str] = None
+) -> Any:
+    return dataclass_field(number, TYPE_MESSAGE, group=group, wraps=wraps)


 def map_field(
@@ -274,7 +291,7 @@ def encode_varint(value: int) -> bytes:
    return bytes(b + [bits])


-def _preprocess_single(proto_type: str, value: Any) -> bytes:
+def _preprocess_single(proto_type: str, wraps: str, value: Any) -> bytes:
    """Adjusts values before serialization."""
    if proto_type in [
        TYPE_ENUM,
@@ -297,16 +314,37 @@ def _preprocess_single(proto_type: str, value: Any) -> bytes:
    elif proto_type == TYPE_STRING:
        return value.encode("utf-8")
    elif proto_type == TYPE_MESSAGE:
+        if isinstance(value, datetime):
+            # Convert the `datetime` to a timestamp message.
+            seconds = int(value.timestamp())
+            nanos = int(value.microsecond * 1e3)
+            value = _Timestamp(seconds=seconds, nanos=nanos)
+        elif isinstance(value, timedelta):
+            # Convert the `timedelta` to a duration message.
+            total_ms = value // timedelta(microseconds=1)
+            seconds = int(total_ms / 1e6)
+            nanos = int((total_ms % 1e6) * 1e3)
+            value = _Duration(seconds=seconds, nanos=nanos)
+        elif wraps:
+            if value is None:
+                return b""
+            value = _get_wrapper(wraps)(value=value)
+
        return bytes(value)

    return value


 def _serialize_single(
-    field_number: int, proto_type: str, value: Any, *, serialize_empty: bool = False
+    field_number: int,
+    proto_type: str,
+    value: Any,
+    *,
+    serialize_empty: bool = False,
+    wraps: str = "",
 ) -> bytes:
    """Serializes a single field and value."""
-    value = _preprocess_single(proto_type, value)
+    value = _preprocess_single(proto_type, wraps, value)

    output = b""
    if proto_type in WIRE_VARINT_TYPES:
@@ -319,7 +357,7 @@ def _serialize_single(
        key = encode_varint((field_number << 3) | 1)
        output += key + value
    elif proto_type in WIRE_LEN_DELIM_TYPES:
-        if len(value) or serialize_empty:
+        if len(value) or serialize_empty or wraps:
            key = encode_varint((field_number << 3) | 2)
            output += key + encode_varint(len(value)) + value
    else:
@@ -359,7 +397,6 @@ def parse_fields(value: bytes) -> Generator[ParsedField, None, None]:
    while i < len(value):
        start = i
        num_wire, i = decode_varint(value, i)
-        # print(num_wire, i)
        number = num_wire >> 3
        wire_type = num_wire & 0x7

@@ -375,15 +412,87 @@ def parse_fields(value: bytes) -> Generator[ParsedField, None, None]:
        elif wire_type == 5:
            decoded, i = value[i : i + 4], i + 4

-        # print(ParsedField(number=number, wire_type=wire_type, value=decoded))
-
        yield ParsedField(
            number=number, wire_type=wire_type, value=decoded, raw=value[start:i]
        )


-# Bound type variable to allow methods to return `self` of subclasses
-T = TypeVar("T", bound="Message")
+class ProtoClassMetadata:
+    oneof_group_by_field: Dict[str, str]
+    oneof_field_by_group: Dict[str, Set[dataclasses.Field]]
+    default_gen: Dict[str, Callable]
+    cls_by_field: Dict[str, Type]
+    field_name_by_number: Dict[int, str]
+    meta_by_field_name: Dict[str, FieldMetadata]
+    __slots__ = (
+        "oneof_group_by_field",
+        "oneof_field_by_group",
+        "default_gen",
+        "cls_by_field",
+        "field_name_by_number",
+        "meta_by_field_name",
+    )
+
+    def __init__(self, cls: Type["Message"]):
+        by_field = {}
+        by_group: Dict[str, Set] = {}
+        by_field_name = {}
+        by_field_number = {}
+
+        fields = dataclasses.fields(cls)
+        for field in fields:
+            meta = FieldMetadata.get(field)
+
+            if meta.group:
+                # This is part of a one-of group.
+                by_field[field.name] = meta.group
+
+                by_group.setdefault(meta.group, set()).add(field)
+
+            by_field_name[field.name] = meta
+            by_field_number[meta.number] = field.name
+
+        self.oneof_group_by_field = by_field
+        self.oneof_field_by_group = by_group
+        self.field_name_by_number = by_field_number
+        self.meta_by_field_name = by_field_name
+
+        self.default_gen = self._get_default_gen(cls, fields)
+        self.cls_by_field = self._get_cls_by_field(cls, fields)
+
+    @staticmethod
+    def _get_default_gen(cls, fields):
+        default_gen = {}
+
+        for field in fields:
+            default_gen[field.name] = cls._get_field_default_gen(field)
+
+        return default_gen
+
+    @staticmethod
+    def _get_cls_by_field(cls, fields):
+        field_cls = {}
+
+        for field in fields:
+            meta = FieldMetadata.get(field)
+            if meta.proto_type == TYPE_MAP:
+                assert meta.map_types
+                kt = cls._cls_for(field, index=0)
+                vt = cls._cls_for(field, index=1)
+                Entry = dataclasses.make_dataclass(
+                    "Entry",
+                    [
+                        ("key", kt, dataclass_field(1, meta.map_types[0])),
+                        ("value", vt, dataclass_field(2, meta.map_types[1])),
+                    ],
+                    bases=(Message,),
+                )
+                field_cls[field.name] = Entry
+                field_cls[field.name + ".value"] = vt
+            else:
+                field_cls[field.name] = cls._cls_for(field)
+
+        return field_cls


 class Message(ABC):
@@ -393,106 +502,131 @@ class Message(ABC):
    to go between Python, binary and JSON protobuf message representations.
    """

+    _serialized_on_wire: bool
+    _unknown_fields: bytes
+    _group_current: Dict[str, str]
+
    def __post_init__(self) -> None:
-        # Set a default value for each field in the class after `__init__` has
-        # already been run.
-        group_map = {"fields": {}, "groups": {}}
-        for field in dataclasses.fields(self):
-            meta = FieldMetadata.get(field)
+        # Keep track of whether every field was default
+        all_sentinel = True
+
+        # Set current field of each group after `__init__` has already been run.
+        group_current: Dict[str, str] = {}
+        for field_name, meta in self._betterproto.meta_by_field_name.items():

            if meta.group:
-                group_map["fields"][field.name] = meta.group
+                group_current.setdefault(meta.group)

-                if meta.group not in group_map["groups"]:
-                    group_map["groups"][meta.group] = {"current": None, "fields": set()}
-                group_map["groups"][meta.group]["fields"].add(field)
-
-            if getattr(self, field.name) != PLACEHOLDER:
+            if getattr(self, field_name) != PLACEHOLDER:
                # Skip anything not set to the sentinel value
+                all_sentinel = False

                if meta.group:
                    # This was set, so make it the selected value of the one-of.
-                    group_map["groups"][meta.group]["current"] = field
+                    group_current[meta.group] = field_name

                continue

-            setattr(self, field.name, self._get_field_default(field, meta))
+            setattr(self, field_name, self._get_field_default(field_name))

        # Now that all the defaults are set, reset it!
-        self.__dict__["_serialized_on_wire"] = False
+        self.__dict__["_serialized_on_wire"] = not all_sentinel
        self.__dict__["_unknown_fields"] = b""
-        self.__dict__["_group_map"] = group_map
+        self.__dict__["_group_current"] = group_current

    def __setattr__(self, attr: str, value: Any) -> None:
        if attr != "_serialized_on_wire":
            # Track when a field has been set.
            self.__dict__["_serialized_on_wire"] = True

-        if attr in getattr(self, "_group_map", {}).get("fields", {}):
-            group = self._group_map["fields"][attr]
-            for field in self._group_map["groups"][group]["fields"]:
-                if field.name == attr:
-                    self._group_map["groups"][group]["current"] = field
-                else:
-                    super().__setattr__(
-                        field.name,
-                        self._get_field_default(field, FieldMetadata.get(field)),
-                    )
+        if hasattr(self, "_group_current"):  # __post_init__ had already run
+            if attr in self._betterproto.oneof_group_by_field:
+                group = self._betterproto.oneof_group_by_field[attr]
+                for field in self._betterproto.oneof_field_by_group[group]:
+                    if field.name == attr:
+                        self._group_current[group] = field.name
+                    else:
+                        super().__setattr__(
+                            field.name, self._get_field_default(field.name),
+                        )

        super().__setattr__(attr, value)

+    @property
+    def _betterproto(self):
+        """
+        Lazy initialize metadata for each protobuf class.
+        It may be initialized multiple times in a multi-threaded environment,
+        but that won't affect the correctness.
+        """
+        meta = getattr(self.__class__, "_betterproto_meta", None)
+        if not meta:
+            meta = ProtoClassMetadata(self.__class__)
+            self.__class__._betterproto_meta = meta
+        return meta
+
    def __bytes__(self) -> bytes:
        """
        Get the binary encoded Protobuf representation of this instance.
        """
        output = b""
-        for field in dataclasses.fields(self):
-            meta = FieldMetadata.get(field)
-            value = getattr(self, field.name)
+        for field_name, meta in self._betterproto.meta_by_field_name.items():
+            value = getattr(self, field_name)
+
+            if value is None:
+                # Optional items should be skipped. This is used for the Google
+                # wrapper types.
+                continue

            # Being selected in a a group means this field is the one that is
            # currently set in a `oneof` group, so it must be serialized even
            # if the value is the default zero value.
            selected_in_group = False
-            if meta.group and self._group_map["groups"][meta.group]["current"] == field:
+            if meta.group and self._group_current[meta.group] == field_name:
                selected_in_group = True

-            if isinstance(value, list):
-                if not len(value) and not selected_in_group:
-                    # Empty values are not serialized
-                    continue
+            serialize_empty = False
+            if isinstance(value, Message) and value._serialized_on_wire:
+                # Empty messages can still be sent on the wire if they were
+                # set (or recieved empty).
+                serialize_empty = True

+            if value == self._get_field_default(field_name) and not (
+                selected_in_group or serialize_empty
+            ):
+                # Default (zero) values are not serialized. Two exceptions are
+                # if this is the selected oneof item or if we know we have to
+                # serialize an empty message (i.e. zero value was explicitly
+                # set by the user).
+                continue
+
+            if isinstance(value, list):
                if meta.proto_type in PACKED_TYPES:
                    # Packed lists look like a length-delimited field. First,
                    # preprocess/encode each value into a buffer and then
                    # treat it like a field of raw bytes.
                    buf = b""
                    for item in value:
-                        buf += _preprocess_single(meta.proto_type, item)
+                        buf += _preprocess_single(meta.proto_type, "", item)
                    output += _serialize_single(meta.number, TYPE_BYTES, buf)
                else:
                    for item in value:
-                        output += _serialize_single(meta.number, meta.proto_type, item)
+                        output += _serialize_single(
+                            meta.number, meta.proto_type, item, wraps=meta.wraps or ""
+                        )
            elif isinstance(value, dict):
-                if not len(value) and not selected_in_group:
-                    # Empty values are not serialized
-                    continue
-
                for k, v in value.items():
                    assert meta.map_types
                    sk = _serialize_single(1, meta.map_types[0], k)
                    sv = _serialize_single(2, meta.map_types[1], v)
                    output += _serialize_single(meta.number, meta.proto_type, sk + sv)
            else:
-                if value == get_default(meta.proto_type) and not selected_in_group:
-                    # Default (zero) values are not serialized
-                    continue
-
-                serialize_empty = False
-                if isinstance(value, Message) and value._serialized_on_wire:
-                    serialize_empty = True
                output += _serialize_single(
-                    meta.number, meta.proto_type, value, serialize_empty=serialize_empty
+                    meta.number,
+                    meta.proto_type,
+                    value,
+                    serialize_empty=serialize_empty,
+                    wraps=meta.wraps or "",
                )

        return output + self._unknown_fields
@@ -500,35 +634,53 @@ class Message(ABC):
    # For compatibility with other libraries
    SerializeToString = __bytes__

-    def _cls_for(self, field: dataclasses.Field, index: int = 0) -> Type:
+    @classmethod
+    def _type_hint(cls, field_name: str) -> Type:
+        module = inspect.getmodule(cls)
+        type_hints = get_type_hints(cls, vars(module))
+        return type_hints[field_name]
+
+    @classmethod
+    def _cls_for(cls, field: dataclasses.Field, index: int = 0) -> Type:
        """Get the message class for a field from the type hints."""
-        module = inspect.getmodule(self.__class__)
-        type_hints = get_type_hints(self.__class__, vars(module))
-        cls = type_hints[field.name]
-        if hasattr(cls, "__args__") and index >= 0:
-            cls = type_hints[field.name].__args__[index]
-        return cls
+        field_cls = cls._type_hint(field.name)
+        if hasattr(field_cls, "__args__") and index >= 0:
+            field_cls = field_cls.__args__[index]
+        return field_cls

-    def _get_field_default(self, field: dataclasses.Field, meta: FieldMetadata) -> Any:
-        t = self._cls_for(field, index=-1)
+    def _get_field_default(self, field_name):
+        return self._betterproto.default_gen[field_name]()

-        value: Any = 0
-        if meta.proto_type == TYPE_MAP:
-            # Maps cannot be repeated, so we check these first.
-            value = {}
-        elif hasattr(t, "__args__") and len(t.__args__) == 1:
-            # Anything else with type args is a list.
-            value = []
-        elif meta.proto_type == TYPE_MESSAGE:
-            # Message means creating an instance of the right type.
-            value = t()
+    @classmethod
+    def _get_field_default_gen(cls, field: dataclasses.Field) -> Any:
+        t = cls._type_hint(field.name)
+
+        if hasattr(t, "__origin__"):
+            if t.__origin__ in (dict, Dict):
+                # This is some kind of map (dict in Python).
+                return dict
+            elif t.__origin__ in (list, List):
+                # This is some kind of list (repeated) field.
+                return list
+            elif t.__origin__ == Union and t.__args__[1] == type(None):
+                # This is an optional (wrapped) field. For setting the default we
+                # really don't care what kind of field it is.
+                return type(None)
+            else:
+                return t
+        elif issubclass(t, Enum):
+            # Enums always default to zero.
+            return int
+        elif t == datetime:
+            # Offsets are relative to 1970-01-01T00:00:00Z
+            return datetime_default_gen
        else:
-            value = get_default(meta.proto_type)
-
-        return value
+            # This is either a primitive scalar or another message type. Calling
+            # it should result in its zero value.
+            return t

    def _postprocess_single(
-        self, wire_type: int, meta: FieldMetadata, field: dataclasses.Field, value: Any
+        self, wire_type: int, meta: FieldMetadata, field_name: str, value: Any
    ) -> Any:
        """Adjusts values after parsing."""
        if wire_type == WIRE_VARINT:
@@ -540,6 +692,9 @@ class Message(ABC):
            elif meta.proto_type in [TYPE_SINT32, TYPE_SINT64]:
                # Undo zig-zag encoding
                value = (value >> 1) ^ (-(value & 1))
+            elif meta.proto_type == TYPE_BOOL:
+                # Booleans use a varint encoding, so convert it to true/false.
+                value = value > 0
        elif wire_type in [WIRE_FIXED_32, WIRE_FIXED_64]:
            fmt = _pack_fmt(meta.proto_type)
            value = struct.unpack(fmt, value)[0]
@@ -547,24 +702,21 @@ class Message(ABC):
            if meta.proto_type == TYPE_STRING:
                value = value.decode("utf-8")
            elif meta.proto_type == TYPE_MESSAGE:
-                cls = self._cls_for(field)
-                value = cls().parse(value)
-                value._serialized_on_wire = True
+                cls = self._betterproto.cls_by_field[field_name]
+
+                if cls == datetime:
+                    value = _Timestamp().parse(value).to_datetime()
+                elif cls == timedelta:
+                    value = _Duration().parse(value).to_timedelta()
+                elif meta.wraps:
+                    # This is a Google wrapper value message around a single
+                    # scalar type.
+                    value = _get_wrapper(meta.wraps)().parse(value).value
+                else:
+                    value = cls().parse(value)
+                    value._serialized_on_wire = True
            elif meta.proto_type == TYPE_MAP:
-                # TODO: This is slow, use a cache to make it faster since each
-                #       key/value pair will recreate the class.
-                assert meta.map_types
-                kt = self._cls_for(field, index=0)
-                vt = self._cls_for(field, index=1)
-                Entry = dataclasses.make_dataclass(
-                    "Entry",
-                    [
-                        ("key", kt, dataclass_field(1, meta.map_types[0])),
-                        ("value", vt, dataclass_field(2, meta.map_types[1])),
-                    ],
-                    bases=(Message,),
-                )
-                value = Entry().parse(value)
+                value = self._betterproto.cls_by_field[field_name]().parse(value)

        return value

@@ -573,49 +725,46 @@ class Message(ABC):
        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 = FieldMetadata.get(field)
-
-                value: Any
-                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):
-                        if meta.proto_type in ["float", "fixed32", "sfixed32"]:
-                            decoded, pos = parsed.value[pos : pos + 4], pos + 4
-                            wire_type = WIRE_FIXED_32
-                        elif meta.proto_type in ["double", "fixed64", "sfixed64"]:
-                            decoded, pos = parsed.value[pos : pos + 8], pos + 8
-                            wire_type = WIRE_FIXED_64
-                        else:
-                            decoded, pos = decode_varint(parsed.value, pos)
-                            wire_type = WIRE_VARINT
-                        decoded = self._postprocess_single(
-                            wire_type, meta, field, decoded
-                        )
-                        value.append(decoded)
-                else:
-                    value = self._postprocess_single(
-                        parsed.wire_type, meta, field, parsed.value
-                    )
-
-                current = getattr(self, field.name)
-                if meta.proto_type == TYPE_MAP:
-                    # Value represents a single key/value pair entry in the map.
-                    current[value.key] = value.value
-                elif isinstance(current, list) and not isinstance(value, list):
-                    current.append(value)
-                else:
-                    setattr(self, field.name, value)
-            else:
+            field_name = self._betterproto.field_name_by_number.get(parsed.number)
+            if not field_name:
                self._unknown_fields += parsed.raw
+                continue
+
+            meta = self._betterproto.meta_by_field_name[field_name]
+
+            value: Any
+            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):
+                    if meta.proto_type in ["float", "fixed32", "sfixed32"]:
+                        decoded, pos = parsed.value[pos : pos + 4], pos + 4
+                        wire_type = WIRE_FIXED_32
+                    elif meta.proto_type in ["double", "fixed64", "sfixed64"]:
+                        decoded, pos = parsed.value[pos : pos + 8], pos + 8
+                        wire_type = WIRE_FIXED_64
+                    else:
+                        decoded, pos = decode_varint(parsed.value, pos)
+                        wire_type = WIRE_VARINT
+                    decoded = self._postprocess_single(
+                        wire_type, meta, field_name, decoded
+                    )
+                    value.append(decoded)
+            else:
+                value = self._postprocess_single(
+                    parsed.wire_type, meta, field_name, parsed.value
+                )
+
+            current = getattr(self, field_name)
+            if meta.proto_type == TYPE_MAP:
+                # Value represents a single key/value pair entry in the map.
+                current[value.key] = value.value
+            elif isinstance(current, list) and not isinstance(value, list):
+                current.append(value)
+            else:
+                setattr(self, field_name, value)

        return self

@@ -624,48 +773,69 @@ class Message(ABC):
    def FromString(cls: Type[T], data: bytes) -> T:
        return cls().parse(data)

-    def to_dict(self) -> dict:
+    def to_dict(
+        self, casing: Casing = Casing.CAMEL, include_default_values: bool = False
+    ) -> Dict[str, Any]:
        """
        Returns a dict representation of this message instance which can be
-        used to serialize to e.g. JSON.
+        used to serialize to e.g. JSON. Defaults to camel casing for
+        compatibility but can be set to other modes.
+
+        `include_default_values` can be set to `True` to include default
+        values of fields. E.g. an `int32` type field with `0` value will
+        not be in returned dict if `include_default_values` is set to
+        `False`.
        """
        output: Dict[str, Any] = {}
-        for field in dataclasses.fields(self):
-            meta = FieldMetadata.get(field)
-            v = getattr(self, field.name)
+        for field_name, meta in self._betterproto.meta_by_field_name.items():
+            v = getattr(self, field_name)
+            cased_name = casing(field_name).rstrip("_")  # type: ignore
            if meta.proto_type == "message":
-                if isinstance(v, list):
+                if isinstance(v, datetime):
+                    if v != DATETIME_ZERO or include_default_values:
+                        output[cased_name] = _Timestamp.timestamp_to_json(v)
+                elif isinstance(v, timedelta):
+                    if v != timedelta(0) or include_default_values:
+                        output[cased_name] = _Duration.delta_to_json(v)
+                elif meta.wraps:
+                    if v is not None or include_default_values:
+                        output[cased_name] = v
+                elif isinstance(v, list):
                    # Convert each item.
-                    v = [i.to_dict() for i in v]
-                    output[field.name] = v
-                elif v._serialized_on_wire:
-                    output[field.name] = v.to_dict()
+                    v = [i.to_dict(casing, include_default_values) for i in v]
+                    if v or include_default_values:
+                        output[cased_name] = v
+                else:
+                    if v._serialized_on_wire or include_default_values:
+                        output[cased_name] = v.to_dict(casing, include_default_values)
            elif meta.proto_type == "map":
                for k in v:
                    if hasattr(v[k], "to_dict"):
-                        v[k] = v[k].to_dict()
+                        v[k] = v[k].to_dict(casing, include_default_values)

-                if v:
-                    output[field.name] = v
-            elif v != get_default(meta.proto_type):
+                if v or include_default_values:
+                    output[cased_name] = v
+            elif v != self._get_field_default(field_name) or include_default_values:
                if meta.proto_type in INT_64_TYPES:
                    if isinstance(v, list):
-                        output[field.name] = [str(n) for n in v]
+                        output[cased_name] = [str(n) for n in v]
                    else:
-                        output[field.name] = str(v)
+                        output[cased_name] = str(v)
                elif meta.proto_type == TYPE_BYTES:
                    if isinstance(v, list):
-                        output[field.name] = [b64encode(b).decode("utf8") for b in v]
+                        output[cased_name] = [b64encode(b).decode("utf8") for b in v]
                    else:
-                        output[field.name] = b64encode(v).decode("utf8")
+                        output[cased_name] = b64encode(v).decode("utf8")
                elif meta.proto_type == TYPE_ENUM:
-                    enum_values = list(self._cls_for(field))
+                    enum_values = list(
+                        self._betterproto.cls_by_field[field_name]
+                    )  # type: ignore
                    if isinstance(v, list):
-                        output[field.name] = [enum_values[e].name for e in v]
+                        output[cased_name] = [enum_values[e].name for e in v]
                    else:
-                        output[field.name] = enum_values[v].name
+                        output[cased_name] = enum_values[v].name
                else:
-                    output[field.name] = v
+                    output[cased_name] = v
        return output

    def from_dict(self: T, value: dict) -> T:
@@ -674,44 +844,56 @@ class Message(ABC):
        returns the instance itself and is therefore assignable and chainable.
        """
        self._serialized_on_wire = True
-        for field in dataclasses.fields(self):
-            meta = FieldMetadata.get(field)
-            if field.name in value and value[field.name] is not None:
+        fields_by_name = {f.name: f for f in dataclasses.fields(self)}
+        for key in value:
+            field_name = safe_snake_case(key)
+            meta = self._betterproto.meta_by_field_name.get(field_name)
+            if not meta:
+                continue
+
+            if value[key] is not None:
                if meta.proto_type == "message":
-                    v = getattr(self, field.name)
-                    # print(v, value[field.name])
+                    v = getattr(self, field_name)
                    if isinstance(v, list):
-                        cls = self._cls_for(field)
-                        for i in range(len(value[field.name])):
-                            v.append(cls().from_dict(value[field.name][i]))
+                        cls = self._betterproto.cls_by_field[field_name]
+                        for i in range(len(value[key])):
+                            v.append(cls().from_dict(value[key][i]))
+                    elif isinstance(v, datetime):
+                        v = datetime.fromisoformat(value[key].replace("Z", "+00:00"))
+                        setattr(self, field_name, v)
+                    elif isinstance(v, timedelta):
+                        v = timedelta(seconds=float(value[key][:-1]))
+                        setattr(self, field_name, v)
+                    elif meta.wraps:
+                        setattr(self, field_name, value[key])
                    else:
-                        v.from_dict(value[field.name])
+                        v.from_dict(value[key])
                elif meta.map_types and meta.map_types[1] == TYPE_MESSAGE:
-                    v = getattr(self, field.name)
-                    cls = self._cls_for(field, index=1)
-                    for k in value[field.name]:
-                        v[k] = cls().from_dict(value[field.name][k])
+                    v = getattr(self, field_name)
+                    cls = self._betterproto.cls_by_field[field_name + ".value"]
+                    for k in value[key]:
+                        v[k] = cls().from_dict(value[key][k])
                else:
-                    v = value[field.name]
+                    v = value[key]
                    if meta.proto_type in INT_64_TYPES:
-                        if isinstance(value[field.name], list):
-                            v = [int(n) for n in value[field.name]]
+                        if isinstance(value[key], list):
+                            v = [int(n) for n in value[key]]
                        else:
-                            v = int(value[field.name])
+                            v = int(value[key])
                    elif meta.proto_type == TYPE_BYTES:
-                        if isinstance(value[field.name], list):
-                            v = [b64decode(n) for n in value[field.name]]
+                        if isinstance(value[key], list):
+                            v = [b64decode(n) for n in value[key]]
                        else:
-                            v = b64decode(value[field.name])
+                            v = b64decode(value[key])
                    elif meta.proto_type == TYPE_ENUM:
-                        enum_cls = self._cls_for(field)
+                        enum_cls = self._betterproto.cls_by_field[field_name]
                        if isinstance(v, list):
                            v = [enum_cls.from_string(e) for e in v]
                        elif isinstance(v, str):
                            v = enum_cls.from_string(v)

                    if v is not None:
-                        setattr(self, field.name, v)
+                        setattr(self, field_name, v)
        return self

    def to_json(self, indent: Union[None, int, str] = None) -> str:
@@ -737,39 +919,92 @@ def serialized_on_wire(message: Message) -> bool:

 def which_one_of(message: Message, group_name: str) -> Tuple[str, Any]:
    """Return the name and value of a message's one-of field group."""
-    field = message._group_map["groups"].get(group_name, {}).get("current")
-    if not field:
+    field_name = message._group_current.get(group_name)
+    if not field_name:
        return ("", None)
-    return (field.name, getattr(message, field.name))
+    return (field_name, getattr(message, field_name))


-class ServiceStub(ABC):
+# Circular import workaround: google.protobuf depends on base classes defined above.
+from .lib.google.protobuf import (
+    Duration,
+    Timestamp,
+    BoolValue,
+    BytesValue,
+    DoubleValue,
+    FloatValue,
+    Int32Value,
+    Int64Value,
+    StringValue,
+    UInt32Value,
+    UInt64Value,
+)
+
+
+class _Duration(Duration):
+    def to_timedelta(self) -> timedelta:
+        return timedelta(seconds=self.seconds, microseconds=self.nanos / 1e3)
+
+    @staticmethod
+    def delta_to_json(delta: timedelta) -> str:
+        parts = str(delta.total_seconds()).split(".")
+        if len(parts) > 1:
+            while len(parts[1]) not in [3, 6, 9]:
+                parts[1] = parts[1] + "0"
+        return ".".join(parts) + "s"
+
+
+class _Timestamp(Timestamp):
+    def to_datetime(self) -> datetime:
+        ts = self.seconds + (self.nanos / 1e9)
+        return datetime.fromtimestamp(ts, tz=timezone.utc)
+
+    @staticmethod
+    def timestamp_to_json(dt: datetime) -> str:
+        nanos = dt.microsecond * 1e3
+        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 result + "Z"
+        if (nanos % 1e6) == 0:
+            # Serialize 3 fractional digits.
+            return result + ".%03dZ" % (nanos / 1e6)
+        if (nanos % 1e3) == 0:
+            # Serialize 6 fractional digits.
+            return result + ".%06dZ" % (nanos / 1e3)
+        # Serialize 9 fractional digits.
+        return result + ".%09dZ" % nanos
+
+
+class _WrappedMessage(Message):
    """
-    Base class for async gRPC service stubs.
+    Google protobuf wrapper types base class. JSON representation is just the
+    value itself.
    """

-    def __init__(self, channel: grpclib.client.Channel) -> None:
-        self.channel = channel
+    value: Any

-    async def _unary_unary(
-        self, route: str, request_type: Type, response_type: Type[T], request: Any
-    ) -> T:
-        """Make a unary request and return the response."""
-        async with self.channel.request(
-            route, grpclib.const.Cardinality.UNARY_UNARY, request_type, response_type
-        ) as stream:
-            await stream.send_message(request, end=True)
-            response = await stream.recv_message()
-            assert response is not None
-            return response
+    def to_dict(self, casing: Casing = Casing.CAMEL) -> Any:
+        return self.value

-    async def _unary_stream(
-        self, route: str, request_type: Type, response_type: Type[T], request: Any
-    ) -> AsyncGenerator[T, None]:
-        """Make a unary request and return the stream response iterator."""
-        async with self.channel.request(
-            route, grpclib.const.Cardinality.UNARY_STREAM, request_type, response_type
-        ) as stream:
-            await stream.send_message(request, end=True)
-            async for message in stream:
-                yield message
+    def from_dict(self: T, value: Any) -> T:
+        if value is not None:
+            self.value = value
+        return self
+
+
+def _get_wrapper(proto_type: str) -> Type:
+    """Get the wrapper message class for a wrapped type."""
+    return {
+        TYPE_BOOL: BoolValue,
+        TYPE_INT32: Int32Value,
+        TYPE_UINT32: UInt32Value,
+        TYPE_INT64: Int64Value,
+        TYPE_UINT64: UInt64Value,
+        TYPE_FLOAT: FloatValue,
+        TYPE_DOUBLE: DoubleValue,
+        TYPE_STRING: StringValue,
+        TYPE_BYTES: BytesValue,
+    }[proto_type]
--- a/betterproto/pycache/init.cpython-37.pyc
+++ b/betterproto/pycache/init.cpython-37.pyc
--- a/betterproto/_types.py
+++ b/betterproto/_types.py
@@ -0,0 +1,9 @@
+from typing import TYPE_CHECKING, TypeVar
+
+if TYPE_CHECKING:
+    from . import Message
+    from grpclib._protocols import IProtoMessage
+
+# Bound type variable to allow methods to return `self` of subclasses
+T = TypeVar("T", bound="Message")
+ST = TypeVar("ST", bound="IProtoMessage")
--- a/betterproto/casing.py
+++ b/betterproto/casing.py
@@ -0,0 +1,120 @@
+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)
+    if value in [
+        "and",
+        "as",
+        "assert",
+        "break",
+        "class",
+        "continue",
+        "def",
+        "del",
+        "elif",
+        "else",
+        "except",
+        "finally",
+        "for",
+        "from",
+        "global",
+        "if",
+        "import",
+        "in",
+        "is",
+        "lambda",
+        "nonlocal",
+        "not",
+        "or",
+        "pass",
+        "raise",
+        "return",
+        "try",
+        "while",
+        "with",
+        "yield",
+    ]:
+        # https://www.python.org/dev/peps/pep-0008/#descriptive-naming-styles
+        value += "_"
+    return value
+
+
+def snake_case(value: str, strict: bool = True):
+    """
+    Join words with an underscore into lowercase and remove symbols.
+    @param value: value to convert
+    @param strict: force single underscores
+    """
+
+    def substitute_word(symbols, word, is_start):
+        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):
+    """
+    Capitalize each word and remove symbols.
+    @param value: value to convert
+    @param strict: output only alphanumeric characters
+    """
+
+    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):
+    """
+    Capitalize all words except first and remove symbols.
+    """
+    return lowercase_first(pascal_case(value, strict=strict))
+
+
+def lowercase_first(value: str):
+    return value[0:1].lower() + value[1:]
--- a/betterproto/compile/init.py
+++ b/betterproto/compile/init.py
--- a/betterproto/compile/importing.py
+++ b/betterproto/compile/importing.py
@@ -0,0 +1,160 @@
+import os
+import re
+from typing import Dict, List, Set, Type
+
+from betterproto import safe_snake_case
+from betterproto.compile.naming import pythonize_class_name
+from betterproto.lib.google import protobuf as google_protobuf
+
+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):
+    """
+    Split full source type name into package and type name.
+    E.g. 'root.package.Message' -> ('root.package', 'Message')
+         'root.Message.SomeEnum' -> ('root', 'Message.SomeEnum')
+    """
+    package_match = re.match(r"^\.?([^A-Z]+)\.(.+)", field_type_name)
+    if package_match:
+        package = package_match.group(1)
+        name = package_match.group(2)
+    else:
+        package = ""
+        name = field_type_name.lstrip(".")
+    return package, name
+
+
+def get_type_reference(
+    package: str, imports: set, source_type: str, unwrap: bool = True,
+) -> 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 f"Optional[{wrapped_type.__name__}]"
+
+        if source_type == ".google.protobuf.Duration":
+            return "timedelta"
+
+        if source_type == ".google.protobuf.Timestamp":
+            return "datetime"
+
+    source_package, source_type = parse_source_type_name(source_type)
+
+    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"] + 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, py_package, py_type):
+    """
+    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])
+    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}"
--- a/betterproto/compile/naming.py
+++ b/betterproto/compile/naming.py
@@ -0,0 +1,13 @@
+from betterproto import casing
+
+
+def pythonize_class_name(name):
+    return casing.pascal_case(name)
+
+
+def pythonize_field_name(name: str):
+    return casing.safe_snake_case(name)
+
+
+def pythonize_method_name(name: str):
+    return casing.safe_snake_case(name)
--- a/betterproto/grpc/init.py
+++ b/betterproto/grpc/init.py
--- a/betterproto/grpc/grpclib_client.py
+++ b/betterproto/grpc/grpclib_client.py
@@ -0,0 +1,170 @@
+from abc import ABC
+import asyncio
+import grpclib.const
+from typing import (
+    Any,
+    AsyncIterable,
+    AsyncIterator,
+    Collection,
+    Iterable,
+    Mapping,
+    Optional,
+    Tuple,
+    TYPE_CHECKING,
+    Type,
+    Union,
+)
+from .._types import ST, T
+
+if TYPE_CHECKING:
+    from grpclib._protocols import IProtoMessage
+    from grpclib.client import Channel, Stream
+    from grpclib.metadata import Deadline
+
+
+_Value = Union[str, bytes]
+_MetadataLike = Union[Mapping[str, _Value], Collection[Tuple[str, _Value]]]
+_MessageSource = Union[Iterable["IProtoMessage"], AsyncIterable["IProtoMessage"]]
+
+
+class ServiceStub(ABC):
+    """
+    Base class for async gRPC clients.
+    """
+
+    def __init__(
+        self,
+        channel: "Channel",
+        *,
+        timeout: Optional[float] = None,
+        deadline: Optional["Deadline"] = None,
+        metadata: Optional[_MetadataLike] = None,
+    ) -> None:
+        self.channel = channel
+        self.timeout = timeout
+        self.deadline = deadline
+        self.metadata = metadata
+
+    def __resolve_request_kwargs(
+        self,
+        timeout: Optional[float],
+        deadline: Optional["Deadline"],
+        metadata: Optional[_MetadataLike],
+    ):
+        return {
+            "timeout": self.timeout if timeout is None else timeout,
+            "deadline": self.deadline if deadline is None else deadline,
+            "metadata": self.metadata if metadata is None else metadata,
+        }
+
+    async def _unary_unary(
+        self,
+        route: str,
+        request: "IProtoMessage",
+        response_type: Type[T],
+        *,
+        timeout: Optional[float] = None,
+        deadline: Optional["Deadline"] = None,
+        metadata: Optional[_MetadataLike] = None,
+    ) -> T:
+        """Make a unary request and return the response."""
+        async with self.channel.request(
+            route,
+            grpclib.const.Cardinality.UNARY_UNARY,
+            type(request),
+            response_type,
+            **self.__resolve_request_kwargs(timeout, deadline, metadata),
+        ) as stream:
+            await stream.send_message(request, end=True)
+            response = await stream.recv_message()
+            assert response is not None
+            return response
+
+    async def _unary_stream(
+        self,
+        route: str,
+        request: "IProtoMessage",
+        response_type: Type[T],
+        *,
+        timeout: Optional[float] = None,
+        deadline: Optional["Deadline"] = None,
+        metadata: Optional[_MetadataLike] = None,
+    ) -> AsyncIterator[T]:
+        """Make a unary request and return the stream response iterator."""
+        async with self.channel.request(
+            route,
+            grpclib.const.Cardinality.UNARY_STREAM,
+            type(request),
+            response_type,
+            **self.__resolve_request_kwargs(timeout, deadline, metadata),
+        ) as stream:
+            await stream.send_message(request, end=True)
+            async for message in stream:
+                yield message
+
+    async def _stream_unary(
+        self,
+        route: str,
+        request_iterator: _MessageSource,
+        request_type: Type[ST],
+        response_type: Type[T],
+        *,
+        timeout: Optional[float] = None,
+        deadline: Optional["Deadline"] = None,
+        metadata: Optional[_MetadataLike] = None,
+    ) -> T:
+        """Make a stream request and return the response."""
+        async with self.channel.request(
+            route,
+            grpclib.const.Cardinality.STREAM_UNARY,
+            request_type,
+            response_type,
+            **self.__resolve_request_kwargs(timeout, deadline, metadata),
+        ) as stream:
+            await self._send_messages(stream, request_iterator)
+            response = await stream.recv_message()
+            assert response is not None
+            return response
+
+    async def _stream_stream(
+        self,
+        route: str,
+        request_iterator: _MessageSource,
+        request_type: Type[ST],
+        response_type: Type[T],
+        *,
+        timeout: Optional[float] = None,
+        deadline: Optional["Deadline"] = None,
+        metadata: Optional[_MetadataLike] = None,
+    ) -> AsyncIterator[T]:
+        """
+        Make a stream request and return an AsyncIterator to iterate over response
+        messages.
+        """
+        async with self.channel.request(
+            route,
+            grpclib.const.Cardinality.STREAM_STREAM,
+            request_type,
+            response_type,
+            **self.__resolve_request_kwargs(timeout, deadline, metadata),
+        ) as stream:
+            await stream.send_request()
+            sending_task = asyncio.ensure_future(
+                self._send_messages(stream, request_iterator)
+            )
+            try:
+                async for response in stream:
+                    yield response
+            except:
+                sending_task.cancel()
+                raise
+
+    @staticmethod
+    async def _send_messages(stream, messages: _MessageSource):
+        if isinstance(messages, AsyncIterable):
+            async for message in messages:
+                await stream.send_message(message)
+        else:
+            for message in messages:
+                await stream.send_message(message)
+        await stream.end()
--- a/betterproto/grpc/util/init.py
+++ b/betterproto/grpc/util/init.py
--- a/betterproto/grpc/util/async_channel.py
+++ b/betterproto/grpc/util/async_channel.py
@@ -0,0 +1,198 @@
+import asyncio
+from typing import (
+    AsyncIterable,
+    AsyncIterator,
+    Iterable,
+    Optional,
+    TypeVar,
+    Union,
+)
+
+T = TypeVar("T")
+
+
+class ChannelClosed(Exception):
+    """
+    An exception raised on an attempt to send through a closed channel
+    """
+
+    pass
+
+
+class ChannelDone(Exception):
+    """
+    An exception raised on an attempt to send recieve from a channel that is both closed
+    and empty.
+    """
+
+    pass
+
+
+class AsyncChannel(AsyncIterable[T]):
+    """
+    A buffered async channel for sending items between coroutines with FIFO ordering.
+
+    This makes decoupled bidirection steaming gRPC requests easy if used like:
+
+    .. code-block:: python
+        client = GeneratedStub(grpclib_chan)
+        request_chan = await AsyncChannel()
+        # We can start be sending all the requests we already have
+        await request_chan.send_from([ReqestObject(...), ReqestObject(...)])
+        async for response in client.rpc_call(request_chan):
+            # The response iterator will remain active until the connection is closed
+            ...
+            # More items can be sent at any time
+            await request_chan.send(ReqestObject(...))
+            ...
+            # The channel must be closed to complete the gRPC connection
+            request_chan.close()
+
+    Items can be sent through the channel by either:
+    - providing an iterable to the send_from method
+    - passing them to the send method one at a time
+
+    Items can be recieved from the channel by either:
+    - iterating over the channel with a for loop to get all items
+    - calling the recieve method to get one item at a time
+
+    If the channel is empty then recievers will wait until either an item appears or the
+    channel is closed.
+
+    Once the channel is closed then subsequent attempt to send through the channel will
+    fail with a ChannelClosed exception.
+
+    When th channel is closed and empty then it is done, and further attempts to recieve
+    from it will fail with a ChannelDone exception
+
+    If multiple coroutines recieve from the channel concurrently, each item sent will be
+    recieved by only one of the recievers.
+
+    :param source:
+        An optional iterable will items that should be sent through the channel
+        immediately.
+    :param buffer_limit:
+        Limit the number of items that can be buffered in the channel, A value less than
+        1 implies no limit. If the channel is full then attempts to send more items will
+        result in the sender waiting until an item is recieved from the channel.
+    :param close:
+        If set to True then the channel will automatically close after exhausting source
+        or immediately if no source is provided.
+    """
+
+    def __init__(
+        self, *, buffer_limit: int = 0, close: bool = False,
+    ):
+        self._queue: asyncio.Queue[Union[T, object]] = asyncio.Queue(buffer_limit)
+        self._closed = False
+        self._waiting_recievers: int = 0
+        # Track whether flush has been invoked so it can only happen once
+        self._flushed = False
+
+    def __aiter__(self) -> AsyncIterator[T]:
+        return self
+
+    async def __anext__(self) -> T:
+        if self.done():
+            raise StopAsyncIteration
+        self._waiting_recievers += 1
+        try:
+            result = await self._queue.get()
+            if result is self.__flush:
+                raise StopAsyncIteration
+            return result
+        finally:
+            self._waiting_recievers -= 1
+            self._queue.task_done()
+
+    def closed(self) -> bool:
+        """
+        Returns True if this channel is closed and no-longer accepting new items
+        """
+        return self._closed
+
+    def done(self) -> bool:
+        """
+        Check if this channel is done.
+
+        :return: True if this channel is closed and and has been drained of items in
+        which case any further attempts to recieve an item from this channel will raise
+        a ChannelDone exception.
+        """
+        # After close the channel is not yet done until there is at least one waiting
+        # reciever per enqueued item.
+        return self._closed and self._queue.qsize() <= self._waiting_recievers
+
+    async def send_from(
+        self, source: Union[Iterable[T], AsyncIterable[T]], close: bool = False
+    ) -> "AsyncChannel[T]":
+        """
+        Iterates the given [Async]Iterable and sends all the resulting items.
+        If close is set to True then subsequent send calls will be rejected with a
+        ChannelClosed exception.
+        :param source: an iterable of items to send
+        :param close:
+            if True then the channel will be closed after the source has been exhausted
+
+        """
+        if self._closed:
+            raise ChannelClosed("Cannot send through a closed channel")
+        if isinstance(source, AsyncIterable):
+            async for item in source:
+                await self._queue.put(item)
+        else:
+            for item in source:
+                await self._queue.put(item)
+        if close:
+            # Complete the closing process
+            self.close()
+        return self
+
+    async def send(self, item: T) -> "AsyncChannel[T]":
+        """
+        Send a single item over this channel.
+        :param item: The item to send
+        """
+        if self._closed:
+            raise ChannelClosed("Cannot send through a closed channel")
+        await self._queue.put(item)
+        return self
+
+    async def recieve(self) -> Optional[T]:
+        """
+        Returns the next item from this channel when it becomes available,
+        or None if the channel is closed before another item is sent.
+        :return: An item from the channel
+        """
+        if self.done():
+            raise ChannelDone("Cannot recieve from a closed channel")
+        self._waiting_recievers += 1
+        try:
+            result = await self._queue.get()
+            if result is self.__flush:
+                return None
+            return result
+        finally:
+            self._waiting_recievers -= 1
+            self._queue.task_done()
+
+    def close(self):
+        """
+        Close this channel to new items
+        """
+        self._closed = True
+        asyncio.ensure_future(self._flush_queue())
+
+    async def _flush_queue(self):
+        """
+        To be called after the channel is closed. Pushes a number of self.__flush
+        objects to the queue to ensure no waiting consumers get deadlocked.
+        """
+        if not self._flushed:
+            self._flushed = True
+            deadlocked_recievers = max(0, self._waiting_recievers - self._queue.qsize())
+            for _ in range(deadlocked_recievers):
+                await self._queue.put(self.__flush)
+
+    # A special signal object for flushing the queue when the channel is closed
+    __flush = object()
--- a/betterproto/lib/init.py
+++ b/betterproto/lib/init.py
--- a/betterproto/lib/google/init.py
+++ b/betterproto/lib/google/init.py
--- a/betterproto/lib/google/protobuf/init.py
+++ b/betterproto/lib/google/protobuf/init.py
--- a/betterproto/plugin.bat
+++ b/betterproto/plugin.bat
@@ -0,0 +1,2 @@
+@SET plugin_dir=%~dp0
+@python %plugin_dir%/plugin.py %*
--- a/betterproto/plugin.py
+++ b/betterproto/plugin.py
@@ -1,82 +1,65 @@
 #!/usr/bin/env python

 import itertools
-import json
 import os.path
+import pathlib
 import re
 import sys
 import textwrap
-from typing import Any, List, Tuple
+from typing import List, Union
+
+import betterproto
+from betterproto.compile.importing import get_type_reference
+from betterproto.compile.naming import (
+    pythonize_class_name,
+    pythonize_field_name,
+    pythonize_method_name,
+)

 try:
+    # betterproto[compiler] specific dependencies
+    import black
+    from google.protobuf.compiler import plugin_pb2 as plugin
+    from google.protobuf.descriptor_pb2 import (
+        DescriptorProto,
+        EnumDescriptorProto,
+        FieldDescriptorProto,
+    )
+    import google.protobuf.wrappers_pb2 as google_wrappers
    import jinja2
-except ImportError:
+except ImportError as err:
+    missing_import = err.args[0][17:-1]
    print(
-        "Unable to import `jinja2`. Did you install the compiler feature with `pip install betterproto[compiler]`?"
+        "\033[31m"
+        f"Unable to import `{missing_import}` from betterproto plugin! "
+        "Please ensure that you've installed betterproto as "
+        '`pip install "betterproto[compiler]"` so that compiler dependencies '
+        "are included."
+        "\033[0m"
    )
    raise SystemExit(1)

-from google.protobuf.compiler import plugin_pb2 as plugin
-from google.protobuf.descriptor_pb2 import (
-    DescriptorProto,
-    EnumDescriptorProto,
-    FieldDescriptorProto,
-    FileDescriptorProto,
-    ServiceDescriptorProto,
-)

-
-def snake_case(value: str) -> str:
-    return (
-        re.sub(r"(?<=[a-z])[A-Z]|[A-Z](?=[^A-Z])", r"_\g<0>", value).lower().strip("_")
-    )
-
-
-def get_ref_type(package: str, imports: set, type_name: str) -> str:
-    """
-    Return a Python type name for a proto type reference. Adds the import if
-    necessary.
-    """
-    type_name = type_name.lstrip(".")
-    if type_name.startswith(package):
-        # This is the current package, which has nested types flattened.
-        type_name = f'"{type_name.lstrip(package).lstrip(".").replace(".", "")}"'
-
-    if "." in type_name:
-        # This is imported from another package. No need
-        # to use a forward ref and we need to add the import.
-        parts = type_name.split(".")
-        imports.add(f"from .{'.'.join(parts[:-2])} import {parts[-2]}")
-        type_name = f"{parts[-2]}.{parts[-1]}"
-
-    return type_name
-
-
-def py_type(
-    package: str,
-    imports: set,
-    message: DescriptorProto,
-    descriptor: FieldDescriptorProto,
-) -> str:
-    if descriptor.type in [1, 2, 6, 7, 15, 16]:
+def py_type(package: str, imports: set, field: FieldDescriptorProto) -> str:
+    if field.type in [1, 2]:
        return "float"
-    elif descriptor.type in [3, 4, 5, 13, 17, 18]:
+    elif field.type in [3, 4, 5, 6, 7, 13, 15, 16, 17, 18]:
        return "int"
-    elif descriptor.type == 8:
+    elif field.type == 8:
        return "bool"
-    elif descriptor.type == 9:
+    elif field.type == 9:
        return "str"
-    elif descriptor.type in [11, 14]:
+    elif field.type in [11, 14]:
        # Type referencing another defined Message or a named enum
-        return get_ref_type(package, imports, descriptor.type_name)
-    elif descriptor.type == 12:
+        return get_type_reference(package, imports, field.type_name)
+    elif field.type == 12:
        return "bytes"
    else:
-        raise NotImplementedError(f"Unknown type {descriptor.type}")
+        raise NotImplementedError(f"Unknown type {field.type}")


-def get_py_zero(type_num: int) -> str:
-    zero = 0
+def get_py_zero(type_num: int) -> Union[str, float]:
+    zero: Union[str, float] = 0
    if type_num in []:
        zero = 0.0
    elif type_num == 8:
@@ -92,19 +75,19 @@ def get_py_zero(type_num: int) -> str:


 def traverse(proto_file):
-    def _traverse(path, items):
+    def _traverse(path, items, prefix=""):
        for i, item in enumerate(items):
+            # Adjust the name since we flatten the heirarchy.
+            item.name = next_prefix = prefix + item.name
            yield item, path + [i]

            if isinstance(item, DescriptorProto):
                for enum in item.enum_type:
-                    enum.name = item.name + enum.name
+                    enum.name = next_prefix + enum.name
                    yield enum, path + [i, 4]

                if item.nested_type:
-                    for n, p in _traverse(path + [i, 3], item.nested_type):
-                        # Adjust the name since we flatten the heirarchy.
-                        n.name = item.name + n.name
+                    for n, p in _traverse(path + [i, 3], item.nested_type, next_prefix):
                        yield n, p

    return itertools.chain(
@@ -112,46 +95,53 @@ def traverse(proto_file):
    )


-def get_comment(proto_file, path: List[int]) -> str:
+def get_comment(proto_file, path: List[int], indent: int = 4) -> str:
+    pad = " " * indent
    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
+                sci.leading_comments.strip().replace("\n", ""), width=79 - indent
            )

            if path[-2] == 2 and path[-4] != 6:
                # This is a field
-                return "    # " + "    # ".join(lines)
+                return f"{pad}# " + f"\n{pad}# ".join(lines)
            else:
                # This is a message, enum, service, or method
-                if len(lines) == 1 and len(lines[0]) < 70:
+                if len(lines) == 1 and len(lines[0]) < 79 - indent - 6:
                    lines[0] = lines[0].strip('"')
-                    return f'    """{lines[0]}"""'
+                    return f'{pad}"""{lines[0]}"""'
                else:
-                    joined = "\n    ".join(lines)
-                    return f'    """\n    {joined}\n    """'
+                    joined = f"\n{pad}".join(lines)
+                    return f'{pad}"""\n{pad}{joined}\n{pad}"""'

    return ""


 def generate_code(request, response):
+    plugin_options = request.parameter.split(",") if request.parameter else []
+
    env = jinja2.Environment(
        trim_blocks=True,
        lstrip_blocks=True,
        loader=jinja2.FileSystemLoader("%s/templates/" % os.path.dirname(__file__)),
    )
-    template = env.get_template("template.py")
+    template = env.get_template("template.py.j2")

    output_map = {}
    for proto_file in request.proto_file:
-        out = proto_file.package
-        if not out:
-            out = os.path.splitext(proto_file.name)[0].replace(os.path.sep, ".")
+        if (
+            proto_file.package == "google.protobuf"
+            and "INCLUDE_GOOGLE" not in plugin_options
+        ):
+            continue

-        if out not in output_map:
-            output_map[out] = {"package": proto_file.package, "files": []}
-        output_map[out]["files"].append(proto_file)
+        output_file = str(pathlib.Path(*proto_file.package.split("."), "__init__.py"))
+
+        if output_file not in output_map:
+            output_map[output_file] = {"package": proto_file.package, "files": []}
+        output_map[output_file]["files"].append(proto_file)

    # TODO: Figure out how to handle gRPC request/response messages and add
    # processing below for Service.
@@ -163,23 +153,17 @@ def generate_code(request, response):
            "package": package,
            "files": [f.name for f in options["files"]],
            "imports": set(),
+            "datetime_imports": set(),
            "typing_imports": set(),
            "messages": [],
            "enums": [],
            "services": [],
        }

-        type_mapping = {}
-
        for proto_file in options["files"]:
-            # print(proto_file.message_type, file=sys.stderr)
-            # print(proto_file.service, file=sys.stderr)
-            # print(proto_file.source_code_info, file=sys.stderr)
-
+            item: DescriptorProto
            for item, path in traverse(proto_file):
-                # print(item, file=sys.stderr)
-                # print(path, file=sys.stderr)
-                data = {"name": item.name}
+                data = {"name": item.name, "py_name": pythonize_class_name(item.name)}

                if isinstance(item, DescriptorProto):
                    # print(item, file=sys.stderr)
@@ -196,13 +180,23 @@ def generate_code(request, response):
                    )

                    for i, f in enumerate(item.field):
-                        t = py_type(package, output["imports"], item, f)
+                        t = py_type(package, output["imports"], f)
                        zero = get_py_zero(f.type)

                        repeated = False
                        packed = False

                        field_type = f.Type.Name(f.type).lower()[5:]
+
+                        field_wraps = ""
+                        match_wrapper = re.match(
+                            r"\.google\.protobuf\.(.+)Value", f.type_name
+                        )
+                        if match_wrapper:
+                            wrapped_type = "TYPE_" + match_wrapper.group(1).upper()
+                            if hasattr(betterproto, wrapped_type):
+                                field_wraps = f"betterproto.{wrapped_type}"
+
                        map_types = None
                        if f.type == 11:
                            # This might be a map...
@@ -221,13 +215,11 @@ def generate_code(request, response):
                                            k = py_type(
                                                package,
                                                output["imports"],
-                                                item,
                                                nested.field[0],
                                            )
                                            v = py_type(
                                                package,
                                                output["imports"],
-                                                item,
                                                nested.field[1],
                                            )
                                            t = f"Dict[{k}, {v}]"
@@ -252,13 +244,23 @@ def generate_code(request, response):
                        if f.HasField("oneof_index"):
                            one_of = item.oneof_decl[f.oneof_index].name

+                        if "Optional[" in t:
+                            output["typing_imports"].add("Optional")
+
+                        if "timedelta" in t:
+                            output["datetime_imports"].add("timedelta")
+                        elif "datetime" in t:
+                            output["datetime_imports"].add("datetime")
+
                        data["properties"].append(
                            {
                                "name": f.name,
+                                "py_name": pythonize_field_name(f.name),
                                "number": f.number,
                                "comment": get_comment(proto_file, path + [2, i]),
                                "proto_type": int(f.type),
                                "field_type": field_type,
+                                "field_wraps": field_wraps,
                                "map_types": map_types,
                                "type": t,
                                "zero": zero,
@@ -294,16 +296,14 @@ def generate_code(request, response):

                data = {
                    "name": service.name,
+                    "py_name": pythonize_class_name(service.name),
                    "comment": get_comment(proto_file, [6, i]),
                    "methods": [],
                }

                for j, method in enumerate(service.method):
-                    if method.client_streaming:
-                        raise NotImplementedError("Client streaming not yet supported")
-
                    input_message = None
-                    input_type = get_ref_type(
+                    input_type = get_type_reference(
                        package, output["imports"], method.input_type
                    ).strip('"')
                    for msg in output["messages"]:
@@ -317,53 +317,64 @@ def generate_code(request, response):
                    data["methods"].append(
                        {
                            "name": method.name,
-                            "py_name": snake_case(method.name),
-                            "comment": get_comment(proto_file, [6, i, 2, j]),
+                            "py_name": pythonize_method_name(method.name),
+                            "comment": get_comment(proto_file, [6, i, 2, j], indent=8),
                            "route": f"/{package}.{service.name}/{method.name}",
-                            "input": get_ref_type(
+                            "input": get_type_reference(
                                package, output["imports"], method.input_type
                            ).strip('"'),
                            "input_message": input_message,
-                            "output": get_ref_type(
-                                package, output["imports"], method.output_type
+                            "output": get_type_reference(
+                                package,
+                                output["imports"],
+                                method.output_type,
+                                unwrap=False,
                            ).strip('"'),
                            "client_streaming": method.client_streaming,
                            "server_streaming": method.server_streaming,
                        }
                    )

+                    if method.client_streaming:
+                        output["typing_imports"].add("AsyncIterable")
+                        output["typing_imports"].add("Iterable")
+                        output["typing_imports"].add("Union")
                    if method.server_streaming:
-                        output["typing_imports"].add("AsyncGenerator")
+                        output["typing_imports"].add("AsyncIterator")

                output["services"].append(data)

        output["imports"] = sorted(output["imports"])
+        output["datetime_imports"] = sorted(output["datetime_imports"])
        output["typing_imports"] = sorted(output["typing_imports"])

        # Fill response
        f = response.file.add()
-        # print(filename, file=sys.stderr)
-        f.name = filename.replace(".", os.path.sep) + ".py"
+        f.name = filename

-        # f.content = json.dumps(output, indent=2)
-        f.content = template.render(description=output).rstrip("\n") + "\n"
+        # Render and then format the output file.
+        f.content = black.format_str(
+            template.render(description=output),
+            mode=black.FileMode(target_versions=set([black.TargetVersion.PY37])),
+        )

-    inits = set([""])
-    for f in response.file:
-        # Ensure output paths exist
-        # print(f.name, file=sys.stderr)
-        dirnames = os.path.dirname(f.name)
-        if dirnames:
-            os.makedirs(dirnames, exist_ok=True)
-            base = ""
-            for part in dirnames.split(os.path.sep):
-                base = os.path.join(base, part)
-                inits.add(base)
+    # Make each output directory a package with __init__ file
+    output_paths = set(pathlib.Path(path) for path in output_map.keys())
+    init_files = (
+        set(
+            directory.joinpath("__init__.py")
+            for path in output_paths
+            for directory in path.parents
+        )
+        - output_paths
+    )

-    for base in inits:
+    for init_file in init_files:
        init = response.file.add()
-        init.name = os.path.join(base, "__init__.py")
-        init.content = b""
+        init.name = str(init_file)
+
+    for filename in sorted(output_paths.union(init_files)):
+        print(f"Writing {filename}", file=sys.stderr)


 def main():
--- a/betterproto/templates/template.py
+++ b/betterproto/templates/template.py
@@ -1,95 +0,0 @@
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# sources: {{ ', '.join(description.files) }}
-# plugin: python-betterproto
-from dataclasses import dataclass
-{% if description.typing_imports %}
-from typing import {% for i in description.typing_imports %}{{ i }}{% if not loop.last %}, {% endif %}{% endfor %}
-
-{% endif %}
-
-import betterproto
-{% if description.services %}
-import grpclib
-{% endif %}
-{% for i in description.imports %}
-
-{{ i }}
-{% endfor %}
-
-
-{% if description.enums %}{% for enum in description.enums %}
-class {{ enum.name }}(betterproto.Enum):
-    {% if enum.comment %}
-{{ enum.comment }}
-
-    {% endif %}
-    {% for entry in enum.entries %}
-        {% if entry.comment %}
-{{ entry.comment }}
-        {% endif %}
-    {{ entry.name }} = {{ entry.value }}
-    {% endfor %}
-
-
-{% endfor %}
-{% endif %}
-{% 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.field_type == 'map'%}, betterproto.{{ field.map_types[0] }}, betterproto.{{ field.map_types[1] }}{% endif %}{% if field.one_of %}, group="{{ field.one_of }}"{% endif %})
-    {% endfor %}
-    {% if not message.properties %}
-    pass
-    {% endif %}
-
-
-{% endfor %}
-{% for service in description.services %}
-class {{ service.name }}Stub(betterproto.ServiceStub):
-    {% if service.comment %}
-{{ service.comment }}
-
-    {% endif %}
-    {% for method in service.methods %}
-    async def {{ method.py_name }}(self{% if method.input_message and method.input_message.properties %}, *, {% for field in method.input_message.properties %}{{ field.name }}: {% if field.zero == "None" %}Optional[{{ field.type }}]{% else %}{{ field.type }}{% endif %} = {{ field.zero }}{% if not loop.last %}, {% endif %}{% endfor %}{% endif %}) -> {% if method.server_streaming %}AsyncGenerator[{{ method.output }}, None]{% else %}{{ method.output }}{% endif %}:
-        {% if method.comment %}
-{{ method.comment }}
-
-        {% endif %}
-        request = {{ method.input }}()
-        {% for field in method.input_message.properties %}
-            {% if field.field_type == 'message' %}
-        if {{ field.name }} is not None:
-            request.{{ field.name }} = {{ field.name }}
-            {% else %}
-        request.{{ field.name }} = {{ field.name }}
-            {% endif %}
-        {% endfor %}
-
-        {% if method.server_streaming %}
-        async for response in self._unary_stream(
-            "{{ method.route }}",
-            {{ method.input }},
-            {{ method.output }},
-            request,
-        ):
-            yield response
-        {% else %}
-        return await self._unary_unary(
-            "{{ method.route }}",
-            {{ method.input }},
-            {{ method.output }},
-            request,
-        )
-        {% endif %}
-
-    {% endfor %}
-{% endfor %}
--- a/betterproto/templates/template.py.j2
+++ b/betterproto/templates/template.py.j2
@@ -0,0 +1,135 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# sources: {{ ', '.join(description.files) }}
+# plugin: python-betterproto
+from dataclasses import dataclass
+{% if description.datetime_imports %}
+from datetime import {% for i in description.datetime_imports %}{{ i }}{% if not loop.last %}, {% endif %}{% endfor %}
+
+{% endif%}
+{% if description.typing_imports %}
+from typing import {% for i in description.typing_imports %}{{ i }}{% if not loop.last %}, {% endif %}{% endfor %}
+
+{% endif %}
+
+import betterproto
+{% if description.services %}
+import grpclib
+{% endif %}
+
+{% for i in description.imports %}
+{{ i }}
+{% endfor %}
+
+
+{% if description.enums %}{% for enum in description.enums %}
+class {{ enum.py_name }}(betterproto.Enum):
+    {% if enum.comment %}
+{{ enum.comment }}
+
+    {% endif %}
+    {% for entry in enum.entries %}
+        {% if entry.comment %}
+{{ entry.comment }}
+        {% endif %}
+    {{ entry.name }} = {{ entry.value }}
+    {% endfor %}
+
+
+{% endfor %}
+{% endif %}
+{% for message in description.messages %}
+@dataclass
+class {{ message.py_name }}(betterproto.Message):
+    {% if message.comment %}
+{{ message.comment }}
+
+    {% endif %}
+    {% for field in message.properties %}
+        {% if field.comment %}
+{{ field.comment }}
+        {% endif %}
+    {{ field.py_name }}: {{ field.type }} = betterproto.{{ field.field_type }}_field({{ field.number }}{% if field.field_type == 'map'%}, betterproto.{{ field.map_types[0] }}, betterproto.{{ field.map_types[1] }}{% endif %}{% if field.one_of %}, group="{{ field.one_of }}"{% endif %}{% if field.field_wraps %}, wraps={{ field.field_wraps }}{% endif %})
+    {% endfor %}
+    {% if not message.properties %}
+    pass
+    {% endif %}
+
+
+{% endfor %}
+{% for service in description.services %}
+class {{ service.py_name }}Stub(betterproto.ServiceStub):
+    {% if service.comment %}
+{{ service.comment }}
+
+    {% endif %}
+    {% for method in service.methods %}
+    async def {{ method.py_name }}(self
+        {%- if not method.client_streaming -%}
+            {%- if method.input_message and method.input_message.properties -%}, *,
+                {%- for field in method.input_message.properties -%}
+                    {{ field.py_name }}: {% if field.zero == "None" and not field.type.startswith("Optional[") -%}
+                                            Optional[{{ field.type }}]
+                                         {%- else -%}
+                                            {{ field.type }}
+                                         {%- endif -%} = {{ field.zero }}
+                    {%- if not loop.last %}, {% endif -%}
+                {%- endfor -%}
+            {%- endif -%}
+        {%- else -%}
+            {# Client streaming: need a request iterator instead #}
+            , request_iterator: Union[AsyncIterable["{{ method.input }}"], Iterable["{{ method.input }}"]]
+        {%- endif -%}
+            ) -> {% if method.server_streaming %}AsyncIterator[{{ method.output }}]{% else %}{{ method.output }}{% endif %}:
+        {% if method.comment %}
+{{ method.comment }}
+
+        {% endif %}
+        {% if not method.client_streaming %}
+        request = {{ method.input }}()
+        {% for field in method.input_message.properties %}
+            {% if field.field_type == 'message' %}
+        if {{ field.py_name }} is not None:
+            request.{{ field.py_name }} = {{ field.py_name }}
+            {% else %}
+        request.{{ field.py_name }} = {{ field.py_name }}
+            {% endif %}
+        {% endfor %}
+        {% endif %}
+
+        {% if method.server_streaming %}
+            {% if method.client_streaming %}
+        async for response in self._stream_stream(
+            "{{ method.route }}",
+            request_iterator,
+            {{ method.input }},
+            {{ method.output }},
+        ):
+            yield response
+            {% else %}{# i.e. not client streaming #}
+        async for response in self._unary_stream(
+            "{{ method.route }}",
+            request,
+            {{ method.output }},
+        ):
+            yield response
+
+            {% endif %}{# if client streaming #}
+        {% else %}{# i.e. not server streaming #}
+            {% if method.client_streaming %}
+        return await self._stream_unary(
+            "{{ method.route }}",
+            request_iterator,
+            {{ method.input }},
+            {{ method.output }}
+        )
+            {% else %}{# i.e. not client streaming #}
+        return await self._unary_unary(
+            "{{ method.route }}",
+            request,
+            {{ method.output }}
+        )
+            {% endif %}{# client streaming #}
+        {% endif %}
+
+    {% endfor %}
+{% endfor %}
--- a/betterproto/tests/README.md
+++ b/betterproto/tests/README.md
@@ -0,0 +1,91 @@
+# Standard Tests Development Guide
+
+Standard test cases are found in [betterproto/tests/inputs](inputs), where each subdirectory represents a testcase, that is verified in isolation.
+
+```
+inputs/
+   bool/
+   double/
+   int32/
+   ...
+```
+
+## Test case directory structure
+
+Each testcase has a `<name>.proto` file with a message called `Test`, and optionally a matching `.json` file and a custom test called `test_*.py`.
+
+```bash
+bool/
+  bool.proto
+  bool.json     # optional
+  test_bool.py  # optional
+```
+
+### proto
+
+`<name>.proto` &mdash; *The protobuf message to test*
+
+```protobuf
+syntax = "proto3";
+
+message Test {
+    bool value = 1;
+}
+```
+
+You can add multiple `.proto` files to the test case, as long as one file matches the directory name. 
+
+### json
+
+`<name>.json` &mdash; *Test-data to validate the message with*
+
+```json
+{
+  "value": true
+}
+```
+
+### pytest
+
+`test_<name>.py` &mdash; *Custom test to validate specific aspects of the generated class*
+
+```python
+from betterproto.tests.output_betterproto.bool.bool import Test
+
+def test_value():
+    message = Test()
+    assert not message.value, "Boolean is False by default"
+```
+
+## Standard tests
+
+The following tests are automatically executed for all cases:
+
+- [x] Can the generated python code be imported?
+- [x] Can the generated message class be instantiated?
+- [x] Is the generated code compatible with the Google's `grpc_tools.protoc` implementation?
+  - _when `.json` is present_ 
+
+## Running the tests
+
+- `pipenv run generate`  
+  This generates:
+  - `betterproto/tests/output_betterproto` &mdash; *the plugin generated python classes*
+  - `betterproto/tests/output_reference` &mdash; *reference implementation classes*
+- `pipenv run test`
+
+## Intentionally Failing tests
+
+The standard test suite includes tests that fail by intention. These tests document known bugs and missing features that are intended to be corrected in the future.
+
+When running `pytest`, they show up as `x` or  `X` in the test results.
+
+```
+betterproto/tests/test_inputs.py ..x...x..x...x.X........xx........x.....x.......x.xx....x...................... [ 84%]
+```
+
+- `.` &mdash; PASSED
+- `x` &mdash; XFAIL: expected failure
+- `X` &mdash; XPASS: expected failure, but still passed
+
+Test cases marked for expected failure are declared in [inputs/config.py](inputs/config.py)
--- a/betterproto/tests/init.py
+++ b/betterproto/tests/init.py
--- a/betterproto/tests/generate.py
+++ b/betterproto/tests/generate.py
@@ -1,83 +1,143 @@
 #!/usr/bin/env python
+import asyncio
 import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+from typing import Set
+
+from betterproto.tests.util import (
+    get_directories,
+    inputs_path,
+    output_path_betterproto,
+    output_path_reference,
+    protoc_plugin,
+    protoc_reference,
+)

 # Force pure-python implementation instead of C++, otherwise imports
 # break things because we can't properly reset the symbol database.
 os.environ["PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION"] = "python"

-import importlib
-import json
-import subprocess
-import sys
-from typing import Generator, Tuple

-from google.protobuf import symbol_database
-from google.protobuf.descriptor_pool import DescriptorPool
-from google.protobuf.json_format import MessageToJson, Parse
+def clear_directory(dir_path: Path):
+    for file_or_directory in dir_path.glob("*"):
+        if file_or_directory.is_dir():
+            shutil.rmtree(file_or_directory)
+        else:
+            file_or_directory.unlink()


-root = os.path.dirname(os.path.realpath(__file__))
+async def generate(whitelist: Set[str], verbose: bool):
+    test_case_names = set(get_directories(inputs_path)) - {"__pycache__"}
+
+    path_whitelist = set()
+    name_whitelist = set()
+    for item in whitelist:
+        if item in test_case_names:
+            name_whitelist.add(item)
+            continue
+        path_whitelist.add(item)
+
+    generation_tasks = []
+    for test_case_name in sorted(test_case_names):
+        test_case_input_path = inputs_path.joinpath(test_case_name).resolve()
+        if (
+            whitelist
+            and str(test_case_input_path) not in path_whitelist
+            and test_case_name not in name_whitelist
+        ):
+            continue
+        generation_tasks.append(
+            generate_test_case_output(test_case_input_path, test_case_name, verbose)
+        )
+
+    failed_test_cases = []
+    # Wait for all subprocs and match any failures to names to report
+    for test_case_name, result in zip(
+        sorted(test_case_names), await asyncio.gather(*generation_tasks)
+    ):
+        if result != 0:
+            failed_test_cases.append(test_case_name)
+
+    if failed_test_cases:
+        sys.stderr.write(
+            "\n\033[31;1;4mFailed to generate the following test cases:\033[0m\n"
+        )
+        for failed_test_case in failed_test_cases:
+            sys.stderr.write(f"- {failed_test_case}\n")


-def get_files(end: str) -> Generator[str, None, None]:
-    for r, dirs, files in os.walk(root):
-        for filename in [f for f in files if f.endswith(end)]:
-            yield os.path.join(r, filename)
+async def generate_test_case_output(
+    test_case_input_path: Path, test_case_name: str, verbose: bool
+) -> int:
+    """
+    Returns the max of the subprocess return values
+    """
+
+    test_case_output_path_reference = output_path_reference.joinpath(test_case_name)
+    test_case_output_path_betterproto = output_path_betterproto.joinpath(test_case_name)
+
+    os.makedirs(test_case_output_path_reference, exist_ok=True)
+    os.makedirs(test_case_output_path_betterproto, exist_ok=True)
+
+    clear_directory(test_case_output_path_reference)
+    clear_directory(test_case_output_path_betterproto)
+
+    (
+        (ref_out, ref_err, ref_code),
+        (plg_out, plg_err, plg_code),
+    ) = await asyncio.gather(
+        protoc_reference(test_case_input_path, test_case_output_path_reference),
+        protoc_plugin(test_case_input_path, test_case_output_path_betterproto),
+    )
+
+    message = f"Generated output for {test_case_name!r}"
+    if verbose:
+        print(f"\033[31;1;4m{message}\033[0m")
+        if ref_out:
+            sys.stdout.buffer.write(ref_out)
+        if ref_err:
+            sys.stderr.buffer.write(ref_err)
+        if plg_out:
+            sys.stdout.buffer.write(plg_out)
+        if plg_err:
+            sys.stderr.buffer.write(plg_err)
+        sys.stdout.buffer.flush()
+        sys.stderr.buffer.flush()
+    else:
+        print(message)
+
+    return max(ref_code, plg_code)


-def get_base(filename: str) -> str:
-    return os.path.splitext(os.path.basename(filename))[0]
+HELP = "\n".join(
+    (
+        "Usage: python generate.py [-h] [-v] [DIRECTORIES or NAMES]",
+        "Generate python classes for standard tests.",
+        "",
+        "DIRECTORIES    One or more relative or absolute directories of test-cases to generate classes for.",
+        "               python generate.py inputs/bool inputs/double inputs/enum",
+        "",
+        "NAMES          One or more test-case names to generate classes for.",
+        "               python generate.py bool double enums",
+    )
+)


-def ensure_ext(filename: str, ext: str) -> str:
-    if not filename.endswith(ext):
-        return filename + ext
-    return filename
+def main():
+    if set(sys.argv).intersection({"-h", "--help"}):
+        print(HELP)
+        return
+    if sys.argv[1:2] == ["-v"]:
+        verbose = True
+        whitelist = set(sys.argv[2:])
+    else:
+        verbose = False
+        whitelist = set(sys.argv[1:])
+    asyncio.get_event_loop().run_until_complete(generate(whitelist, verbose))


 if __name__ == "__main__":
-    os.chdir(root)
-
-    if len(sys.argv) > 1:
-        proto_files = [ensure_ext(f, ".proto") for f in sys.argv[1:]]
-        bases = {get_base(f) for f in proto_files}
-        json_files = [
-            f for f in get_files(".json") if get_base(f).split("-")[0] in bases
-        ]
-    else:
-        proto_files = get_files(".proto")
-        json_files = get_files(".json")
-
-    for filename in proto_files:
-        print(f"Generating code for {os.path.basename(filename)}")
-        subprocess.run(
-            f"protoc --python_out=. {os.path.basename(filename)}", shell=True
-        )
-        subprocess.run(
-            f"protoc --plugin=protoc-gen-custom=../plugin.py --custom_out=. {os.path.basename(filename)}",
-            shell=True,
-        )
-
-    for filename in json_files:
-        # Reset the internal symbol database so we can import the `Test` message
-        # multiple times. Ugh.
-        sym = symbol_database.Default()
-        sym.pool = DescriptorPool()
-
-        parts = get_base(filename).split("-")
-        out = filename.replace(".json", ".bin")
-        print(f"Using {parts[0]}_pb2 to generate {os.path.basename(out)}")
-
-        imported = importlib.import_module(f"{parts[0]}_pb2")
-        input_json = open(filename).read()
-        parsed = Parse(input_json, imported.Test())
-        serialized = parsed.SerializeToString()
-        serialized_json = MessageToJson(parsed, preserving_proto_field_name=True)
-
-        s_loaded = json.loads(serialized_json)
-        in_loaded = json.loads(input_json)
-
-        if s_loaded != in_loaded:
-            raise AssertionError("Expected JSON to be equal:", s_loaded, in_loaded)
-
-        open(out, "wb").write(serialized)
+    main()
--- a/betterproto/tests/grpc/init.py
+++ b/betterproto/tests/grpc/init.py
--- a/betterproto/tests/grpc/test_grpclib_client.py
+++ b/betterproto/tests/grpc/test_grpclib_client.py
@@ -0,0 +1,154 @@
+import asyncio
+from betterproto.tests.output_betterproto.service.service import (
+    DoThingResponse,
+    DoThingRequest,
+    GetThingRequest,
+    GetThingResponse,
+    TestStub as ThingServiceClient,
+)
+import grpclib
+from grpclib.testing import ChannelFor
+import pytest
+from betterproto.grpc.util.async_channel import AsyncChannel
+from .thing_service import ThingService
+
+
+async def _test_client(client, name="clean room", **kwargs):
+    response = await client.do_thing(name=name)
+    assert response.names == [name]
+
+
+def _assert_request_meta_recieved(deadline, metadata):
+    def server_side_test(stream):
+        assert stream.deadline._timestamp == pytest.approx(
+            deadline._timestamp, 1
+        ), "The provided deadline should be recieved serverside"
+        assert (
+            stream.metadata["authorization"] == metadata["authorization"]
+        ), "The provided authorization metadata should be recieved serverside"
+
+    return server_side_test
+
+
+@pytest.mark.asyncio
+async def test_simple_service_call():
+    async with ChannelFor([ThingService()]) as channel:
+        await _test_client(ThingServiceClient(channel))
+
+
+@pytest.mark.asyncio
+async def test_service_call_with_upfront_request_params():
+    # Setting deadline
+    deadline = grpclib.metadata.Deadline.from_timeout(22)
+    metadata = {"authorization": "12345"}
+    async with ChannelFor(
+        [ThingService(test_hook=_assert_request_meta_recieved(deadline, metadata),)]
+    ) as channel:
+        await _test_client(
+            ThingServiceClient(channel, deadline=deadline, metadata=metadata)
+        )
+
+    # Setting timeout
+    timeout = 99
+    deadline = grpclib.metadata.Deadline.from_timeout(timeout)
+    metadata = {"authorization": "12345"}
+    async with ChannelFor(
+        [ThingService(test_hook=_assert_request_meta_recieved(deadline, metadata),)]
+    ) as channel:
+        await _test_client(
+            ThingServiceClient(channel, timeout=timeout, metadata=metadata)
+        )
+
+
+@pytest.mark.asyncio
+async def test_service_call_lower_level_with_overrides():
+    THING_TO_DO = "get milk"
+
+    # Setting deadline
+    deadline = grpclib.metadata.Deadline.from_timeout(22)
+    metadata = {"authorization": "12345"}
+    kwarg_deadline = grpclib.metadata.Deadline.from_timeout(28)
+    kwarg_metadata = {"authorization": "12345"}
+    async with ChannelFor(
+        [ThingService(test_hook=_assert_request_meta_recieved(deadline, metadata),)]
+    ) as channel:
+        client = ThingServiceClient(channel, deadline=deadline, metadata=metadata)
+        response = await client._unary_unary(
+            "/service.Test/DoThing",
+            DoThingRequest(THING_TO_DO),
+            DoThingResponse,
+            deadline=kwarg_deadline,
+            metadata=kwarg_metadata,
+        )
+        assert response.names == [THING_TO_DO]
+
+    # Setting timeout
+    timeout = 99
+    deadline = grpclib.metadata.Deadline.from_timeout(timeout)
+    metadata = {"authorization": "12345"}
+    kwarg_timeout = 9000
+    kwarg_deadline = grpclib.metadata.Deadline.from_timeout(kwarg_timeout)
+    kwarg_metadata = {"authorization": "09876"}
+    async with ChannelFor(
+        [
+            ThingService(
+                test_hook=_assert_request_meta_recieved(kwarg_deadline, kwarg_metadata),
+            )
+        ]
+    ) as channel:
+        client = ThingServiceClient(channel, deadline=deadline, metadata=metadata)
+        response = await client._unary_unary(
+            "/service.Test/DoThing",
+            DoThingRequest(THING_TO_DO),
+            DoThingResponse,
+            timeout=kwarg_timeout,
+            metadata=kwarg_metadata,
+        )
+        assert response.names == [THING_TO_DO]
+
+
+@pytest.mark.asyncio
+async def test_async_gen_for_unary_stream_request():
+    thing_name = "my milkshakes"
+
+    async with ChannelFor([ThingService()]) as channel:
+        client = ThingServiceClient(channel)
+        expected_versions = [5, 4, 3, 2, 1]
+        async for response in client.get_thing_versions(name=thing_name):
+            assert response.name == thing_name
+            assert response.version == expected_versions.pop()
+
+
+@pytest.mark.asyncio
+async def test_async_gen_for_stream_stream_request():
+    some_things = ["cake", "cricket", "coral reef"]
+    more_things = ["ball", "that", "56kmodem", "liberal humanism", "cheesesticks"]
+    expected_things = (*some_things, *more_things)
+
+    async with ChannelFor([ThingService()]) as channel:
+        client = ThingServiceClient(channel)
+        # Use an AsyncChannel to decouple sending and recieving, it'll send some_things
+        # immediately and we'll use it to send more_things later, after recieving some
+        # results
+        request_chan = AsyncChannel()
+        send_initial_requests = asyncio.ensure_future(
+            request_chan.send_from(GetThingRequest(name) for name in some_things)
+        )
+        response_index = 0
+        async for response in client.get_different_things(request_chan):
+            assert response.name == expected_things[response_index]
+            assert response.version == response_index + 1
+            response_index += 1
+            if more_things:
+                # Send some more requests as we recieve reponses to be sure coordination of
+                # send/recieve events doesn't matter
+                await request_chan.send(GetThingRequest(more_things.pop(0)))
+            elif not send_initial_requests.done():
+                # Make sure the sending task it completed
+                await send_initial_requests
+            else:
+                # No more things to send make sure channel is closed
+                request_chan.close()
+        assert response_index == len(
+            expected_things
+        ), "Didn't recieve all exptected responses"
--- a/betterproto/tests/grpc/test_stream_stream.py
+++ b/betterproto/tests/grpc/test_stream_stream.py
@@ -0,0 +1,100 @@
+import asyncio
+import betterproto
+from betterproto.grpc.util.async_channel import AsyncChannel
+from dataclasses import dataclass
+import pytest
+from typing import AsyncIterator
+
+
+@dataclass
+class Message(betterproto.Message):
+    body: str = betterproto.string_field(1)
+
+
+@pytest.fixture
+def expected_responses():
+    return [Message("Hello world 1"), Message("Hello world 2"), Message("Done")]
+
+
+class ClientStub:
+    async def connect(self, requests: AsyncIterator):
+        await asyncio.sleep(0.1)
+        async for request in requests:
+            await asyncio.sleep(0.1)
+            yield request
+        await asyncio.sleep(0.1)
+        yield Message("Done")
+
+
+async def to_list(generator: AsyncIterator):
+    result = []
+    async for value in generator:
+        result.append(value)
+    return result
+
+
+@pytest.fixture
+def client():
+    # channel = Channel(host='127.0.0.1', port=50051)
+    # return ClientStub(channel)
+    return ClientStub()
+
+
+@pytest.mark.asyncio
+async def test_send_from_before_connect_and_close_automatically(
+    client, expected_responses
+):
+    requests = AsyncChannel()
+    await requests.send_from(
+        [Message(body="Hello world 1"), Message(body="Hello world 2")], close=True
+    )
+    responses = client.connect(requests)
+
+    assert await to_list(responses) == expected_responses
+
+
+@pytest.mark.asyncio
+async def test_send_from_after_connect_and_close_automatically(
+    client, expected_responses
+):
+    requests = AsyncChannel()
+    responses = client.connect(requests)
+    await requests.send_from(
+        [Message(body="Hello world 1"), Message(body="Hello world 2")], close=True
+    )
+
+    assert await to_list(responses) == expected_responses
+
+
+@pytest.mark.asyncio
+async def test_send_from_close_manually_immediately(client, expected_responses):
+    requests = AsyncChannel()
+    responses = client.connect(requests)
+    await requests.send_from(
+        [Message(body="Hello world 1"), Message(body="Hello world 2")], close=False
+    )
+    requests.close()
+
+    assert await to_list(responses) == expected_responses
+
+
+@pytest.mark.asyncio
+async def test_send_individually_and_close_before_connect(client, expected_responses):
+    requests = AsyncChannel()
+    await requests.send(Message(body="Hello world 1"))
+    await requests.send(Message(body="Hello world 2"))
+    requests.close()
+    responses = client.connect(requests)
+
+    assert await to_list(responses) == expected_responses
+
+
+@pytest.mark.asyncio
+async def test_send_individually_and_close_after_connect(client, expected_responses):
+    requests = AsyncChannel()
+    await requests.send(Message(body="Hello world 1"))
+    await requests.send(Message(body="Hello world 2"))
+    responses = client.connect(requests)
+    requests.close()
+
+    assert await to_list(responses) == expected_responses
--- a/betterproto/tests/grpc/thing_service.py
+++ b/betterproto/tests/grpc/thing_service.py
@@ -0,0 +1,83 @@
+from betterproto.tests.output_betterproto.service.service import (
+    DoThingResponse,
+    DoThingRequest,
+    GetThingRequest,
+    GetThingResponse,
+    TestStub as ThingServiceClient,
+)
+import grpclib
+from typing import Any, Dict
+
+
+class ThingService:
+    def __init__(self, test_hook=None):
+        # This lets us pass assertions to the servicer ;)
+        self.test_hook = test_hook
+
+    async def do_thing(
+        self, stream: "grpclib.server.Stream[DoThingRequest, DoThingResponse]"
+    ):
+        request = await stream.recv_message()
+        if self.test_hook is not None:
+            self.test_hook(stream)
+        await stream.send_message(DoThingResponse([request.name]))
+
+    async def do_many_things(
+        self, stream: "grpclib.server.Stream[DoThingRequest, DoThingResponse]"
+    ):
+        thing_names = [request.name for request in stream]
+        if self.test_hook is not None:
+            self.test_hook(stream)
+        await stream.send_message(DoThingResponse(thing_names))
+
+    async def get_thing_versions(
+        self, stream: "grpclib.server.Stream[GetThingRequest, GetThingResponse]"
+    ):
+        request = await stream.recv_message()
+        if self.test_hook is not None:
+            self.test_hook(stream)
+        for version_num in range(1, 6):
+            await stream.send_message(
+                GetThingResponse(name=request.name, version=version_num)
+            )
+
+    async def get_different_things(
+        self, stream: "grpclib.server.Stream[GetThingRequest, GetThingResponse]"
+    ):
+        if self.test_hook is not None:
+            self.test_hook(stream)
+        #  Respond to each input item immediately
+        response_num = 0
+        async for request in stream:
+            response_num += 1
+            await stream.send_message(
+                GetThingResponse(name=request.name, version=response_num)
+            )
+
+    def __mapping__(self) -> Dict[str, "grpclib.const.Handler"]:
+        return {
+            "/service.Test/DoThing": grpclib.const.Handler(
+                self.do_thing,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                DoThingRequest,
+                DoThingResponse,
+            ),
+            "/service.Test/DoManyThings": grpclib.const.Handler(
+                self.do_many_things,
+                grpclib.const.Cardinality.STREAM_UNARY,
+                DoThingRequest,
+                DoThingResponse,
+            ),
+            "/service.Test/GetThingVersions": grpclib.const.Handler(
+                self.get_thing_versions,
+                grpclib.const.Cardinality.UNARY_STREAM,
+                GetThingRequest,
+                GetThingResponse,
+            ),
+            "/service.Test/GetDifferentThings": grpclib.const.Handler(
+                self.get_different_things,
+                grpclib.const.Cardinality.STREAM_STREAM,
+                GetThingRequest,
+                GetThingResponse,
+            ),
+        }
--- a/betterproto/tests/inputs/bool/bool.json
+++ b/betterproto/tests/inputs/bool/bool.json
@@ -0,0 +1,3 @@
+{
+  "value": true
+}
--- a/betterproto/tests/inputs/bool/bool.proto
+++ b/betterproto/tests/inputs/bool/bool.proto
@@ -0,0 +1,5 @@
+syntax = "proto3";
+
+message Test {
+    bool value = 1;
+}
--- a/betterproto/tests/inputs/bool/test_bool.py
+++ b/betterproto/tests/inputs/bool/test_bool.py
@@ -0,0 +1,6 @@
+from betterproto.tests.output_betterproto.bool import Test
+
+
+def test_value():
+    message = Test()
+    assert not message.value, "Boolean is False by default"
--- a/betterproto/tests/inputs/bytes/bytes.json
+++ b/betterproto/tests/inputs/bytes/bytes.json
--- a/betterproto/tests/inputs/bytes/bytes.proto
+++ b/betterproto/tests/inputs/bytes/bytes.proto
--- a/betterproto/tests/inputs/casing/casing.json
+++ b/betterproto/tests/inputs/casing/casing.json
@@ -0,0 +1,4 @@
+{
+  "camelCase": 1,
+  "snakeCase": "ONE"
+}
--- a/betterproto/tests/inputs/casing/casing.proto
+++ b/betterproto/tests/inputs/casing/casing.proto
@@ -0,0 +1,18 @@
+syntax = "proto3";
+
+enum my_enum {
+  ZERO = 0;
+  ONE = 1;
+  TWO = 2;
+}
+
+message Test {
+  int32 camelCase = 1;
+  my_enum snake_case = 2;
+  snake_case_message snake_case_message = 3;
+  int32 UPPERCASE = 4;
+}
+
+message snake_case_message {
+
+}
--- a/betterproto/tests/inputs/casing/test_casing.py
+++ b/betterproto/tests/inputs/casing/test_casing.py
@@ -0,0 +1,23 @@
+import betterproto.tests.output_betterproto.casing as casing
+from betterproto.tests.output_betterproto.casing import Test
+
+
+def test_message_attributes():
+    message = Test()
+    assert hasattr(
+        message, "snake_case_message"
+    ), "snake_case field name is same in python"
+    assert hasattr(message, "camel_case"), "CamelCase field is snake_case in python"
+    assert hasattr(message, "uppercase"), "UPPERCASE field is lowercase in python"
+
+
+def test_message_casing():
+    assert hasattr(
+        casing, "SnakeCaseMessage"
+    ), "snake_case Message name is converted to CamelCase in python"
+
+
+def test_enum_casing():
+    assert hasattr(
+        casing, "MyEnum"
+    ), "snake_case Enum name is converted to CamelCase in python"
--- a/betterproto/tests/inputs/casing_message_field_uppercase/casing_message_field_uppercase.proto
+++ b/betterproto/tests/inputs/casing_message_field_uppercase/casing_message_field_uppercase.proto
@@ -0,0 +1,7 @@
+syntax = "proto3";
+
+message Test {
+  int32 UPPERCASE = 1;
+  int32 UPPERCASE_V2 = 2;
+  int32 UPPER_CAMEL_CASE = 3;
+}
--- a/betterproto/tests/inputs/casing_message_field_uppercase/casing_message_field_uppercase.py
+++ b/betterproto/tests/inputs/casing_message_field_uppercase/casing_message_field_uppercase.py
@@ -0,0 +1,14 @@
+from betterproto.tests.output_betterproto.casing_message_field_uppercase import Test
+
+
+def test_message_casing():
+    message = Test()
+    assert hasattr(
+        message, "uppercase"
+    ), "UPPERCASE attribute is converted to 'uppercase' in python"
+    assert hasattr(
+        message, "uppercase_v2"
+    ), "UPPERCASE_V2 attribute is converted to 'uppercase_v2' in python"
+    assert hasattr(
+        message, "upper_camel_case"
+    ), "UPPER_CAMEL_CASE attribute is converted to upper_camel_case in python"
--- a/betterproto/tests/inputs/config.py
+++ b/betterproto/tests/inputs/config.py
@@ -0,0 +1,22 @@
+# Test cases that are expected to fail, e.g. unimplemented features or bug-fixes.
+# Remove from list when fixed.
+xfail = {
+    "import_circular_dependency",
+    "oneof_enum",  # 63
+    "namespace_keywords",  # 70
+    "namespace_builtin_types",  # 53
+    "googletypes_struct",  # 9
+    "googletypes_value",  # 9
+    "enum_skipped_value",  # 93
+    "import_capitalized_package",
+    "example",  # This is the example in the readme. Not a test.
+}
+
+services = {
+    "googletypes_response",
+    "googletypes_response_embedded",
+    "service",
+    "import_service_input_message",
+    "googletypes_service_returns_empty",
+    "googletypes_service_returns_googletype",
+}
--- a/betterproto/tests/inputs/double/double-negative.json
+++ b/betterproto/tests/inputs/double/double-negative.json
--- a/betterproto/tests/inputs/double/double.json
+++ b/betterproto/tests/inputs/double/double.json
--- a/betterproto/tests/inputs/double/double.proto
+++ b/betterproto/tests/inputs/double/double.proto
--- a/betterproto/tests/inputs/enum_skipped_value/enum_skipped_value.proto
+++ b/betterproto/tests/inputs/enum_skipped_value/enum_skipped_value.proto
@@ -0,0 +1,12 @@
+syntax = "proto3";
+
+message Test {
+  enum MyEnum {
+    ZERO = 0;
+    ONE = 1;
+    // TWO = 2;
+    THREE = 3;
+    FOUR = 4;
+  }
+  MyEnum x = 1;
+}
--- a/betterproto/tests/inputs/enum_skipped_value/test_enum_skipped_value.py
+++ b/betterproto/tests/inputs/enum_skipped_value/test_enum_skipped_value.py
@@ -0,0 +1,18 @@
+from betterproto.tests.output_betterproto.enum_skipped_value import (
+    Test,
+    TestMyEnum,
+)
+import pytest
+
+
+@pytest.mark.xfail(reason="#93")
+def test_message_attributes():
+    assert (
+        Test(x=TestMyEnum.ONE).to_dict()["x"] == "ONE"
+    ), "MyEnum.ONE is not serialized to 'ONE'"
+    assert (
+        Test(x=TestMyEnum.THREE).to_dict()["x"] == "THREE"
+    ), "MyEnum.THREE is not serialized to 'THREE'"
+    assert (
+        Test(x=TestMyEnum.FOUR).to_dict()["x"] == "FOUR"
+    ), "MyEnum.FOUR is not serialized to 'FOUR'"
--- a/betterproto/tests/inputs/enums/enums.json
+++ b/betterproto/tests/inputs/enums/enums.json
--- a/betterproto/tests/inputs/enums/enums.proto
+++ b/betterproto/tests/inputs/enums/enums.proto
--- a/betterproto/tests/inputs/example/example.proto
+++ b/betterproto/tests/inputs/example/example.proto
@@ -0,0 +1,8 @@
+syntax = "proto3";
+
+package hello;
+
+// Greeting represents a message you can tell a user.
+message Greeting {
+  string message = 1;
+}
--- a/betterproto/tests/inputs/fixed/fixed.json
+++ b/betterproto/tests/inputs/fixed/fixed.json
@@ -0,0 +1,6 @@
+{
+  "foo": 4294967295,
+  "bar": -2147483648,
+  "baz": "18446744073709551615",
+  "qux": "-9223372036854775808"
+}
--- a/betterproto/tests/inputs/fixed/fixed.proto
+++ b/betterproto/tests/inputs/fixed/fixed.proto
@@ -0,0 +1,8 @@
+syntax = "proto3";
+
+message Test {
+  fixed32 foo = 1;
+  sfixed32 bar = 2;
+  fixed64 baz = 3;
+  sfixed64 qux = 4;
+}
--- a/betterproto/tests/inputs/googletypes/googletypes-missing.json
+++ b/betterproto/tests/inputs/googletypes/googletypes-missing.json
@@ -0,0 +1 @@
+{}
--- a/betterproto/tests/inputs/googletypes/googletypes.json
+++ b/betterproto/tests/inputs/googletypes/googletypes.json
@@ -0,0 +1,7 @@
+{
+  "maybe": false,
+  "ts": "1972-01-01T10:00:20.021Z",
+  "duration": "1.200s",
+  "important": 10,
+  "empty": {}
+}
--- a/betterproto/tests/inputs/googletypes/googletypes.proto
+++ b/betterproto/tests/inputs/googletypes/googletypes.proto
@@ -0,0 +1,14 @@
+syntax = "proto3";
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+import "google/protobuf/wrappers.proto";
+import "google/protobuf/empty.proto";
+
+message Test {
+  google.protobuf.BoolValue maybe = 1;
+  google.protobuf.Timestamp ts = 2;
+  google.protobuf.Duration duration = 3;
+  google.protobuf.Int32Value important = 4;
+  google.protobuf.Empty empty = 5;
+}
--- a/betterproto/tests/inputs/googletypes_response/googletypes_response.proto
+++ b/betterproto/tests/inputs/googletypes_response/googletypes_response.proto
@@ -0,0 +1,21 @@
+syntax = "proto3";
+
+import "google/protobuf/wrappers.proto";
+
+// Tests that wrapped values can be used directly as return values
+
+service Test {
+    rpc GetDouble (Input) returns (google.protobuf.DoubleValue);
+    rpc GetFloat (Input) returns (google.protobuf.FloatValue);
+    rpc GetInt64 (Input) returns (google.protobuf.Int64Value);
+    rpc GetUInt64 (Input) returns (google.protobuf.UInt64Value);
+    rpc GetInt32 (Input) returns (google.protobuf.Int32Value);
+    rpc GetUInt32 (Input) returns (google.protobuf.UInt32Value);
+    rpc GetBool (Input) returns (google.protobuf.BoolValue);
+    rpc GetString (Input) returns (google.protobuf.StringValue);
+    rpc GetBytes (Input) returns (google.protobuf.BytesValue);
+}
+
+message Input {
+
+}
--- a/betterproto/tests/inputs/googletypes_response/test_googletypes_response.py
+++ b/betterproto/tests/inputs/googletypes_response/test_googletypes_response.py
@@ -0,0 +1,54 @@
+from typing import Any, Callable, Optional
+
+import betterproto.lib.google.protobuf as protobuf
+import pytest
+
+from betterproto.tests.mocks import MockChannel
+from betterproto.tests.output_betterproto.googletypes_response import TestStub
+
+test_cases = [
+    (TestStub.get_double, protobuf.DoubleValue, 2.5),
+    (TestStub.get_float, protobuf.FloatValue, 2.5),
+    (TestStub.get_int64, protobuf.Int64Value, -64),
+    (TestStub.get_u_int64, protobuf.UInt64Value, 64),
+    (TestStub.get_int32, protobuf.Int32Value, -32),
+    (TestStub.get_u_int32, protobuf.UInt32Value, 32),
+    (TestStub.get_bool, protobuf.BoolValue, True),
+    (TestStub.get_string, protobuf.StringValue, "string"),
+    (TestStub.get_bytes, protobuf.BytesValue, bytes(0xFF)[0:4]),
+]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(["service_method", "wrapper_class", "value"], test_cases)
+async def test_channel_recieves_wrapped_type(
+    service_method: Callable[[TestStub], Any], wrapper_class: Callable, value
+):
+    wrapped_value = wrapper_class()
+    wrapped_value.value = value
+    channel = MockChannel(responses=[wrapped_value])
+    service = TestStub(channel)
+
+    await service_method(service)
+
+    assert channel.requests[0]["response_type"] != Optional[type(value)]
+    assert channel.requests[0]["response_type"] == type(wrapped_value)
+
+
+@pytest.mark.asyncio
+@pytest.mark.xfail
+@pytest.mark.parametrize(["service_method", "wrapper_class", "value"], test_cases)
+async def test_service_unwraps_response(
+    service_method: Callable[[TestStub], Any], wrapper_class: Callable, value
+):
+    """
+    grpclib does not unwrap wrapper values returned by services
+    """
+    wrapped_value = wrapper_class()
+    wrapped_value.value = value
+    service = TestStub(MockChannel(responses=[wrapped_value]))
+
+    response_value = await service_method(service)
+
+    assert response_value == value
+    assert type(response_value) == type(value)
--- a/betterproto/tests/inputs/googletypes_response_embedded/googletypes_response_embedded.proto
+++ b/betterproto/tests/inputs/googletypes_response_embedded/googletypes_response_embedded.proto
@@ -0,0 +1,24 @@
+syntax = "proto3";
+
+import "google/protobuf/wrappers.proto";
+
+// Tests that wrapped values are supported as part of output message
+service Test {
+    rpc getOutput (Input) returns (Output);
+}
+
+message Input {
+
+}
+
+message Output {
+    google.protobuf.DoubleValue double_value = 1;
+    google.protobuf.FloatValue float_value = 2;
+    google.protobuf.Int64Value int64_value = 3;
+    google.protobuf.UInt64Value uint64_value = 4;
+    google.protobuf.Int32Value int32_value = 5;
+    google.protobuf.UInt32Value uint32_value = 6;
+    google.protobuf.BoolValue bool_value = 7;
+    google.protobuf.StringValue string_value = 8;
+    google.protobuf.BytesValue bytes_value = 9;
+}
--- a/betterproto/tests/inputs/googletypes_response_embedded/test_googletypes_response_embedded.py
+++ b/betterproto/tests/inputs/googletypes_response_embedded/test_googletypes_response_embedded.py
@@ -0,0 +1,39 @@
+import pytest
+
+from betterproto.tests.mocks import MockChannel
+from betterproto.tests.output_betterproto.googletypes_response_embedded import (
+    Output,
+    TestStub,
+)
+
+
+@pytest.mark.asyncio
+async def test_service_passes_through_unwrapped_values_embedded_in_response():
+    """
+    We do not not need to implement value unwrapping for embedded well-known types,
+    as this is already handled by grpclib. This test merely shows that this is the case.
+    """
+    output = Output(
+        double_value=10.0,
+        float_value=12.0,
+        int64_value=-13,
+        uint64_value=14,
+        int32_value=-15,
+        uint32_value=16,
+        bool_value=True,
+        string_value="string",
+        bytes_value=bytes(0xFF)[0:4],
+    )
+
+    service = TestStub(MockChannel(responses=[output]))
+    response = await service.get_output()
+
+    assert response.double_value == 10.0
+    assert response.float_value == 12.0
+    assert response.int64_value == -13
+    assert response.uint64_value == 14
+    assert response.int32_value == -15
+    assert response.uint32_value == 16
+    assert response.bool_value
+    assert response.string_value == "string"
+    assert response.bytes_value == bytes(0xFF)[0:4]
--- a/betterproto/tests/inputs/googletypes_service_returns_empty/googletypes_service_returns_empty.proto
+++ b/betterproto/tests/inputs/googletypes_service_returns_empty/googletypes_service_returns_empty.proto
@@ -0,0 +1,11 @@
+syntax = "proto3";
+
+import "google/protobuf/empty.proto";
+
+service Test {
+    rpc Send (RequestMessage) returns (google.protobuf.Empty) {
+    }
+}
+
+message RequestMessage {
+}
--- a/betterproto/tests/inputs/googletypes_service_returns_googletype/googletypes_service_returns_googletype.proto
+++ b/betterproto/tests/inputs/googletypes_service_returns_googletype/googletypes_service_returns_googletype.proto
@@ -0,0 +1,16 @@
+syntax = "proto3";
+
+import "google/protobuf/empty.proto";
+import "google/protobuf/struct.proto";
+
+// Tests that imports are generated correctly when returning Google well-known types
+
+service Test {
+    rpc GetEmpty (RequestMessage) returns (google.protobuf.Empty);
+    rpc GetStruct (RequestMessage) returns (google.protobuf.Struct);
+    rpc GetListValue (RequestMessage) returns (google.protobuf.ListValue);
+    rpc GetValue (RequestMessage) returns (google.protobuf.Value);
+}
+
+message RequestMessage {
+}
--- a/betterproto/tests/inputs/googletypes_struct/googletypes_struct.json
+++ b/betterproto/tests/inputs/googletypes_struct/googletypes_struct.json
@@ -0,0 +1,5 @@
+{
+  "struct": {
+    "key": true
+  }
+}
--- a/betterproto/tests/inputs/googletypes_struct/googletypes_struct.proto
+++ b/betterproto/tests/inputs/googletypes_struct/googletypes_struct.proto
@@ -0,0 +1,7 @@
+syntax = "proto3";
+
+import "google/protobuf/struct.proto";
+
+message Test {
+  google.protobuf.Struct struct = 1;
+}
--- a/betterproto/tests/inputs/googletypes_value/googletypes_value.json
+++ b/betterproto/tests/inputs/googletypes_value/googletypes_value.json
@@ -0,0 +1,11 @@
+{
+  "value1": "hello world",
+  "value2": true,
+  "value3": 1,
+  "value4": null,
+  "value5": [
+    1,
+    2,
+    3
+  ]
+}
--- a/betterproto/tests/inputs/googletypes_value/googletypes_value.proto
+++ b/betterproto/tests/inputs/googletypes_value/googletypes_value.proto
@@ -0,0 +1,13 @@
+syntax = "proto3";
+
+import "google/protobuf/struct.proto";
+
+// Tests that fields of type google.protobuf.Value can contain arbitrary JSON-values.
+
+message Test {
+  google.protobuf.Value value1 = 1;
+  google.protobuf.Value value2 = 2;
+  google.protobuf.Value value3 = 3;
+  google.protobuf.Value value4 = 4;
+  google.protobuf.Value value5 = 5;
+}
--- a/betterproto/tests/inputs/import_capitalized_package/capitalized.proto
+++ b/betterproto/tests/inputs/import_capitalized_package/capitalized.proto
@@ -0,0 +1,8 @@
+syntax = "proto3";
+
+
+package Capitalized;
+
+message Message {
+
+}
--- a/betterproto/tests/inputs/import_capitalized_package/test.proto
+++ b/betterproto/tests/inputs/import_capitalized_package/test.proto
@@ -0,0 +1,9 @@
+syntax = "proto3";
+
+import "capitalized.proto";
+
+// Tests that we can import from a package with a capital name, that looks like a nested type, but isn't.
+
+message Test {
+  Capitalized.Message message = 1;
+}
--- a/betterproto/tests/inputs/import_child_package_from_package/child.proto
+++ b/betterproto/tests/inputs/import_child_package_from_package/child.proto
@@ -0,0 +1,7 @@
+syntax = "proto3";
+
+package package.childpackage;
+
+message ChildMessage {
+
+}
--- a/betterproto/tests/inputs/import_child_package_from_package/import_child_package_from_package.proto
+++ b/betterproto/tests/inputs/import_child_package_from_package/import_child_package_from_package.proto
@@ -0,0 +1,9 @@
+syntax = "proto3";
+
+import "package_message.proto";
+
+// Tests generated imports when a message in a package refers to a message in a nested child package.
+
+message Test {
+  package.PackageMessage message = 1;
+}
--- a/betterproto/tests/inputs/import_child_package_from_package/package_message.proto
+++ b/betterproto/tests/inputs/import_child_package_from_package/package_message.proto
@@ -0,0 +1,9 @@
+syntax = "proto3";
+
+import "child.proto";
+
+package package;
+
+message PackageMessage {
+    package.childpackage.ChildMessage c = 1;
+}
--- a/betterproto/tests/inputs/import_child_package_from_root/child.proto
+++ b/betterproto/tests/inputs/import_child_package_from_root/child.proto
@@ -0,0 +1,7 @@
+syntax = "proto3";
+
+package childpackage;
+
+message Message {
+
+}
--- a/betterproto/tests/inputs/import_child_package_from_root/import_child_package_from_root.proto
+++ b/betterproto/tests/inputs/import_child_package_from_root/import_child_package_from_root.proto
@@ -0,0 +1,9 @@
+syntax = "proto3";
+
+import "child.proto";
+
+// Tests generated imports when a message in root refers to a message in a child package.
+
+message Test {
+  childpackage.Message child = 1;
+}
--- a/betterproto/tests/inputs/import_circular_dependency/import_circular_dependency.proto
+++ b/betterproto/tests/inputs/import_circular_dependency/import_circular_dependency.proto
@@ -0,0 +1,28 @@
+syntax = "proto3";
+
+import "root.proto";
+import "other.proto";
+
+// This test-case verifies support for circular dependencies in the generated python files.
+//
+// This is important because we generate 1 python file/module per package, rather than 1 file per proto file.
+//
+// Scenario:
+//
+//     The proto messages depend on each other in a non-circular way:
+//
+//           Test -------> RootPackageMessage <--------------.
+//             `------------------------------------> OtherPackageMessage
+//
+//     Test and RootPackageMessage are in different files, but belong to the same package (root):
+//
+//           (Test -------> RootPackageMessage) <------------.
+//             `------------------------------------> OtherPackageMessage
+//
+//     After grouping the packages into single files or modules, a circular dependency is created:
+//
+//           (root: Test & RootPackageMessage) <-------> (other: OtherPackageMessage)
+message Test {
+  RootPackageMessage message = 1;
+  other.OtherPackageMessage other = 2;
+}
--- a/betterproto/tests/inputs/import_circular_dependency/other.proto
+++ b/betterproto/tests/inputs/import_circular_dependency/other.proto
@@ -0,0 +1,8 @@
+syntax = "proto3";
+
+import "root.proto";
+package other;
+
+message OtherPackageMessage {
+    RootPackageMessage rootPackageMessage = 1;
+}
--- a/betterproto/tests/inputs/import_circular_dependency/root.proto
+++ b/betterproto/tests/inputs/import_circular_dependency/root.proto
@@ -0,0 +1,5 @@
+syntax = "proto3";
+
+message RootPackageMessage {
+
+}
--- a/betterproto/tests/inputs/import_cousin_package/cousin.proto
+++ b/betterproto/tests/inputs/import_cousin_package/cousin.proto
@@ -0,0 +1,6 @@
+syntax = "proto3";
+
+package cousin.cousin_subpackage;
+
+message CousinMessage {
+}
--- a/betterproto/tests/inputs/import_cousin_package/test.proto
+++ b/betterproto/tests/inputs/import_cousin_package/test.proto
@@ -0,0 +1,11 @@
+syntax = "proto3";
+
+package test.subpackage;
+
+import "cousin.proto";
+
+// Verify that we can import message unrelated to us
+
+message Test {
+    cousin.cousin_subpackage.CousinMessage message = 1;
+}
--- a/betterproto/tests/inputs/import_cousin_package_same_name/cousin.proto
+++ b/betterproto/tests/inputs/import_cousin_package_same_name/cousin.proto
@@ -0,0 +1,6 @@
+syntax = "proto3";
+
+package cousin.subpackage;
+
+message CousinMessage {
+}
--- a/betterproto/tests/inputs/import_cousin_package_same_name/test.proto
+++ b/betterproto/tests/inputs/import_cousin_package_same_name/test.proto
@@ -0,0 +1,11 @@
+syntax = "proto3";
+
+package test.subpackage;
+
+import "cousin.proto";
+
+// Verify that we can import a message unrelated to us, in a subpackage with the same name as us.
+
+message Test {
+    cousin.subpackage.CousinMessage message = 1;
+}
--- a/betterproto/tests/inputs/import_packages_same_name/import_packages_same_name.proto
+++ b/betterproto/tests/inputs/import_packages_same_name/import_packages_same_name.proto
@@ -0,0 +1,11 @@
+syntax = "proto3";
+
+import "users_v1.proto";
+import "posts_v1.proto";
+
+// Tests generated message can correctly reference two packages with the same leaf-name
+
+message Test {
+  users.v1.User user = 1;
+  posts.v1.Post post = 2;
+}
--- a/betterproto/tests/inputs/import_packages_same_name/posts_v1.proto
+++ b/betterproto/tests/inputs/import_packages_same_name/posts_v1.proto
@@ -0,0 +1,7 @@
+syntax = "proto3";
+
+package posts.v1;
+
+message Post {
+
+}
--- a/betterproto/tests/inputs/import_packages_same_name/users_v1.proto
+++ b/betterproto/tests/inputs/import_packages_same_name/users_v1.proto
@@ -0,0 +1,7 @@
+syntax = "proto3";
+
+package users.v1;
+
+message User {
+
+}
--- a/betterproto/tests/inputs/import_parent_package_from_child/import_parent_package_from_child.proto
+++ b/betterproto/tests/inputs/import_parent_package_from_child/import_parent_package_from_child.proto
@@ -0,0 +1,12 @@
+syntax = "proto3";
+
+import "parent_package_message.proto";
+
+package parent.child;
+
+// Tests generated imports when a message refers to a message defined in its parent package
+
+message Test {
+  ParentPackageMessage message_implicit = 1;
+  parent.ParentPackageMessage message_explicit = 2;
+}
--- a/betterproto/tests/inputs/import_parent_package_from_child/parent_package_message.proto
+++ b/betterproto/tests/inputs/import_parent_package_from_child/parent_package_message.proto
@@ -0,0 +1,6 @@
+syntax = "proto3";
+
+package parent;
+
+message ParentPackageMessage {
+}
--- a/betterproto/tests/inputs/import_root_package_from_child/child.proto
+++ b/betterproto/tests/inputs/import_root_package_from_child/child.proto
@@ -0,0 +1,11 @@
+syntax = "proto3";
+
+package child;
+
+import "root.proto";
+
+// Verify that we can import root message from child package
+
+message Test {
+    RootMessage message = 1;
+}
--- a/betterproto/tests/inputs/import_root_package_from_child/root.proto
+++ b/betterproto/tests/inputs/import_root_package_from_child/root.proto
@@ -0,0 +1,5 @@
+syntax = "proto3";
+
+
+message RootMessage {
+}
--- a/betterproto/tests/inputs/import_root_sibling/import_root_sibling.proto
+++ b/betterproto/tests/inputs/import_root_sibling/import_root_sibling.proto
@@ -0,0 +1,9 @@
+syntax = "proto3";
+
+import "sibling.proto";
+
+// Tests generated imports when a message in the root package refers to another message in the root package
+
+message Test {
+  SiblingMessage sibling = 1;
+}
--- a/betterproto/tests/inputs/import_root_sibling/sibling.proto
+++ b/betterproto/tests/inputs/import_root_sibling/sibling.proto
@@ -0,0 +1,5 @@
+syntax = "proto3";
+
+message SiblingMessage {
+
+}
--- a/betterproto/tests/inputs/import_service_input_message/import_service_input_message.proto
+++ b/betterproto/tests/inputs/import_service_input_message/import_service_input_message.proto
@@ -0,0 +1,15 @@
+syntax = "proto3";
+
+import "request_message.proto";
+
+// Tests generated service correctly imports the RequestMessage
+
+service Test {
+    rpc DoThing (RequestMessage) returns (RequestResponse);
+}
+
+
+message RequestResponse {
+    int32 value = 1;
+}
+
--- a/betterproto/tests/inputs/import_service_input_message/request_message.proto
+++ b/betterproto/tests/inputs/import_service_input_message/request_message.proto
@@ -0,0 +1,5 @@
+syntax = "proto3";
+
+message RequestMessage {
+    int32 argument = 1;
+}
--- a/betterproto/tests/inputs/import_service_input_message/test_import_service.py
+++ b/betterproto/tests/inputs/import_service_input_message/test_import_service.py
@@ -0,0 +1,16 @@
+import pytest
+
+from betterproto.tests.mocks import MockChannel
+from betterproto.tests.output_betterproto.import_service_input_message import (
+    RequestResponse,
+    TestStub,
+)
+
+
+@pytest.mark.xfail(reason="#68 Request Input Messages are not imported for service")
+@pytest.mark.asyncio
+async def test_service_correctly_imports_reference_message():
+    mock_response = RequestResponse(value=10)
+    service = TestStub(MockChannel([mock_response]))
+    response = await service.do_thing()
+    assert mock_response == response
--- a/betterproto/tests/inputs/int32/int32.json
+++ b/betterproto/tests/inputs/int32/int32.json
@@ -0,0 +1,4 @@
+{
+  "positive": 150,
+  "negative": -150
+}
--- a/betterproto/tests/inputs/int32/int32.proto
+++ b/betterproto/tests/inputs/int32/int32.proto
@@ -3,5 +3,6 @@ syntax = "proto3";
 // Some documentation about the Test message.
 message Test {
    // Some documentation about the count.
-    int32 count = 1;
+    int32 positive = 1;
+    int32 negative = 2;
 }
--- a/betterproto/tests/inputs/map/map.json
+++ b/betterproto/tests/inputs/map/map.json
--- a/betterproto/tests/inputs/map/map.proto
+++ b/betterproto/tests/inputs/map/map.proto
--- a/betterproto/tests/inputs/mapmessage/mapmessage.json
+++ b/betterproto/tests/inputs/mapmessage/mapmessage.json
--- a/betterproto/tests/inputs/mapmessage/mapmessage.proto
+++ b/betterproto/tests/inputs/mapmessage/mapmessage.proto
--- a/betterproto/tests/inputs/namespace_builtin_types/namespace_builtin_types.json
+++ b/betterproto/tests/inputs/namespace_builtin_types/namespace_builtin_types.json
@@ -0,0 +1,16 @@
+{
+  "int": "value-for-int",
+  "float": "value-for-float",
+  "complex": "value-for-complex",
+  "list": "value-for-list",
+  "tuple": "value-for-tuple",
+  "range": "value-for-range",
+  "str": "value-for-str",
+  "bytearray": "value-for-bytearray",
+  "bytes": "value-for-bytes",
+  "memoryview": "value-for-memoryview",
+  "set": "value-for-set",
+  "frozenset": "value-for-frozenset",
+  "map": "value-for-map",
+  "bool": "value-for-bool"
+}
--- a/betterproto/tests/inputs/namespace_builtin_types/namespace_builtin_types.proto
+++ b/betterproto/tests/inputs/namespace_builtin_types/namespace_builtin_types.proto
@@ -0,0 +1,38 @@
+syntax = "proto3";
+
+// Tests that messages may contain fields with names that are python types
+
+message Test {
+    // https://docs.python.org/2/library/stdtypes.html#numeric-types-int-float-long-complex
+    string int = 1;
+    string float = 2;
+    string complex = 3;
+
+    // https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range
+    string list = 4;
+    string tuple = 5;
+    string range = 6;
+
+    // https://docs.python.org/3/library/stdtypes.html#str
+    string str = 7;
+
+    // https://docs.python.org/3/library/stdtypes.html#bytearray-objects
+    string bytearray = 8;
+
+    // https://docs.python.org/3/library/stdtypes.html#bytes-and-bytearray-operations
+    string bytes = 9;
+
+    // https://docs.python.org/3/library/stdtypes.html#memory-views
+    string memoryview = 10;
+
+    // https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset
+    string set = 11;
+    string frozenset = 12;
+
+    // https://docs.python.org/3/library/stdtypes.html#dict
+    string map = 13;
+    string dict = 14;
+
+    // https://docs.python.org/3/library/stdtypes.html#boolean-values
+    string bool = 15;
+}
--- a/Show More
+++ b/Show More