neobuilder6 6.1.0__py3-none-any.whl

neobuilder6/__init__.py

@@ -0,0 +1,5 @@
+__version__ = '6.1.0'
+
+__author__ = 'Thordur Matthiasson <doddi79@gmail.com>'
+__license__ = 'MIT License'
+__copyright__ = 'Copyright 2026 - Thordur Matthiasson, Copyright 2019-2024 - CCP Games ehf'

neobuilder6/cli/neobuilder.py

@@ -0,0 +1,48 @@
+import argparse
+
+from neobuilder6.neobuilder import NeoBuilder
+
+
+def main():
+    parser = argparse.ArgumentParser(prog='neobuild',
+                                     description='Builds neobuf packages with protoplasm6.',
+                                     epilog=(f'Neobuilder6 v{NeoBuilder.neobuilder_version()} - '
+                                             f'Protoplasm6 v{NeoBuilder.protoplasm_version()}'))
+    version_group = parser.add_mutually_exclusive_group()
+    version_group.add_argument('-m', '--major', action="store_true",
+                               help='Bump the major version number instead of the minor')
+    version_group.add_argument('-p', '--patch', action="store_true",
+                               help='Bump the patch version number instead of the minor')
+    parser.add_argument('package', help='Package name')
+    parser.add_argument('protopath', help='Path to the root of the protobuf files (default="./proto")',
+                        default='./proto', nargs='?')
+    parser.add_argument('-b', '--buildroot', help='Path to the root of the output build files (default="./build")',
+                        default='./build', nargs='?')
+    parser.add_argument('-v', '--verbose', action="store_true",
+                        help='Spits out DEBUG level logs')
+    parser.add_argument('-i', '--pyi', action=argparse.BooleanOptionalAction, default=True,
+                        help='Builds *.pyi type stubs for the pb2 files as well (default=True, use --no-pyi to skip)')
+    parser.add_argument('--alias-imports', action=argparse.BooleanOptionalAction, default=True,
+                        help='Alias imports everything in each proto package in the __init__.py of the '
+                             'corresponding Python package, e.g. so "from myshop.orders import *" works '
+                             '(default=True, use --no-alias-imports to skip)')
+    parser.add_argument('-I', '--include', action='append', help="Optional additional proto paths to include (can be used multiple times)", default=[])
+
+    args = parser.parse_args()
+
+    n = NeoBuilder(
+        package=args.package,
+        protopath=args.protopath,
+        build_root=args.buildroot,
+        major=args.major,
+        patch=args.patch,
+        verbose=args.verbose,
+        include_pyi=args.pyi,
+        extra_includes=args.include,
+        alias_imports=args.alias_imports,
+    )
+    n.build()
+
+
+if __name__ == '__main__':
+    main()

neobuilder6/data/templates/dataclass.jinja2

@@ -0,0 +1,12 @@
+{% from 'macros/indentclude.jinja2' import indentclude with context %}
+@dataclasses.dataclass
+class {{ class_name }}(bases.DataclassBase):
+    __proto_cls__ = pb2.{{ proto_cls_name }}
+
+    {{ indentclude('parts/_nested_messages.jinja2', 4) }}
+
+    {{ indentclude('parts/_enum_map.jinja2', 4) }}
+
+    {% for pf in field_map %}
+    {{ pf }}
+    {% endfor %}

neobuilder6/data/templates/dataclass_module.jinja2

@@ -0,0 +1,34 @@
+# Auto-Generated file - DO NOT EDIT!
+# Source module: {{ module_full_name }}
+# Generated at: {{ iso_timestamp }}
+from __future__ import annotations
+__all__ = [
+{% for a in all_list %}
+    '{{ a }}',
+{% endfor %}
+]
+import dataclasses
+import datetime
+import enum
+import typing
+from protoplasm6.casting import dictators
+from protoplasm6 import plasm
+{{ imports }}
+{{ proto_import }}
+
+import logging
+log = logging.getLogger(__name__)
+
+
+{% if enum_list %}
+{% for enum in enum_list %}
+{{ enum }}
+
+{% endfor %}
+{% endif %}
+{% if message_list %}
+{% for msg in message_list %}
+{{ msg }}
+
+{% endfor -%}
+{%- endif -%}

neobuilder6/data/templates/grpc_receiver.jinja2

@@ -0,0 +1,21 @@
+# Auto-Generated file - DO NOT EDIT!
+# Source module: {{ module_full_name }}
+# Generated at: {{ iso_timestamp }}
+__all__ = [
+{% for a in all_list %}
+    '{{ a }}',
+{% endfor %}
+]
+import datetime
+import typing
+from protoplasm6 import plasm
+{{ imports }}
+if typing.TYPE_CHECKING:
+    from grpc import ServicerContext
+    {{ api_import }}
+
+import logging
+log = logging.getLogger(__name__)
+
+
+{{ services }}

neobuilder6/data/templates/grpc_sender.jinja2

@@ -0,0 +1,21 @@
+# Auto-Generated file - DO NOT EDIT!
+# Source module: {{ module_full_name }}
+# Generated at: {{ iso_timestamp }}
+from __future__ import annotations
+__all__ = [
+{% for a in all_list %}
+    '{{ a }}',
+{% endfor %}
+]
+import datetime
+import typing
+from protoplasm6 import plasm
+{{ imports }}
+if typing.TYPE_CHECKING:
+    from grpc import ChannelCredentials
+
+import logging
+log = logging.getLogger(__name__)
+
+
+{{ services }}

neobuilder6/data/templates/interface.jinja2

@@ -0,0 +1,22 @@
+{% from 'macros/indentclude.jinja2' import indentclude with context %}
+# Auto-Generated file - DO NOT EDIT!
+# Source module: {{ module_full_name }}
+# Generated at: {{ iso_timestamp }}
+__all__ = [
+{% for a in all_clause %}
+    '{{ a }}',
+{% endfor %}
+]
+import datetime
+import typing
+from protoplasm6 import plasm
+
+{% for import_line in import_lines %}
+{{ import_line }}
+{% endfor %}
+
+import logging
+log = logging.getLogger(__name__)
+
+
+{{ services }}

neobuilder6/data/templates/macros/indentclude.jinja2

@@ -0,0 +1,2 @@
+{%- macro _inc(file_name, this) -%}{% include file_name with context %}{% endmacro %}
+{%- macro indentclude(file_name, spaces=4, this={}) -%}{{ _inc(file_name, this)|indent(spaces) }}{%- endmacro -%}

neobuilder6/data/templates/package_aliases.jinja2

@@ -0,0 +1,10 @@
+# Auto-Generated file - DO NOT EDIT!
+# Proto package alias imports, i.e. everything in the `{{ proto_package }}` proto package
+__all__ = [
+{% for name in names %}
+    '{{ name }}',
+{% endfor %}
+]
+{% for module in modules %}
+from {{ module }} import *
+{% endfor %}

neobuilder6/data/templates/parts/_enum_map.jinja2

@@ -0,0 +1 @@
+# ENUMS GO HERE...

neobuilder6/data/templates/parts/_interface_method.jinja2

@@ -0,0 +1,2 @@
+def {{ this.method_under_name }}(self{{ this.input_params }}) -> {{ this.return_type_hint }}:
+    raise plasm.Unimplemented()

neobuilder6/data/templates/parts/_interface_service.jinja2

@@ -0,0 +1,10 @@
+{% from 'macros/indentclude.jinja2' import indentclude with context %}
+class {{ service_name }}Interface:
+{% if is_grpc %}
+    __servicer_cls__ = {{ service_name }}GrpcServicer
+
+{% endif %}
+{% for method in method_list %}
+    {{ indentclude('parts/_interface_method.jinja2', (indent_spaces + 4), method) }}
+
+{% endfor %}

neobuilder6/data/templates/parts/_nested_messages.jinja2

@@ -0,0 +1 @@
+# NESTED MESSAGES GO HERE...

neobuilder6/data/templates/root_init.jinja2

@@ -0,0 +1,12 @@
+__version__ = '{{ version }}'{% if version == '' %}  # NO VERSION NUMBERS FOUND?!? :({% endif +%}
+__protoplasm_version__ = '{{ protoplasm_version }}'
+__neobuilder_version__ = '{{ neobuilder_version }}'
+
+
+def load_symbols():
+    from {{ package_name }} import __everything__{% if alias_init %}
+
+
+
+{{ alias_init }}
+{%- endif %}

neobuilder6/descwrap/__init__.py

@@ -0,0 +1,2 @@
+from ._field import *
+from ._method import *

neobuilder6/descwrap/_field.py

@@ -0,0 +1,188 @@
+__all__ = [
+    'FieldKind',
+    'FieldDescriptorWrapper',
+]
+import dataclasses
+import enum
+from typing import *
+import keyword
+from google.protobuf.json_format import descriptor
+from google.protobuf import json_format
+from neobuilder6.structs.pytype import *
+
+
+class FieldKind(enum.IntFlag):
+    UNKNOWN             = 0x0000
+    DATA_SCALAR         = 0x0001
+    DATA_MESSAGE        = 0x0002
+    DATA_ENUM           = 0x0004
+
+    KIND_SINGLE         = 0x0010
+    KIND_LIST           = 0x0020
+    KIND_MAP            = 0x0040
+
+    SPECIAL_TIMESTAMP   = 0x00100
+    SPECIAL_BYTES       = 0x00200
+    SPECIAL_LONG        = 0x00400
+    SPECIAL_DURATION    = 0x00800
+    SPECIAL_ANY         = 0x01000
+    SPECIAL_EMPTY       = 0x02000
+    SPECIAL_STRUCT      = 0x04000
+    SPECIAL_VALUE       = 0x08000
+    SPECIAL_LIST_VALUE  = 0x10000
+    SPECIAL_NULL_VALUE  = 0x20000
+
+    SPECIAL_KEYWORD     = 0x10000000
+
+    # scalar
+    FIELD_SIMPLE = DATA_SCALAR | KIND_SINGLE
+    # Message
+    FIELD_MESSAGE = DATA_MESSAGE | KIND_SINGLE
+    # Enum
+    FIELD_ENUM = DATA_ENUM | KIND_SINGLE
+
+    # repeated scalar
+    FIELD_SIMPLE_LIST = DATA_SCALAR | KIND_LIST
+    # repeated Message
+    FIELD_MESSAGE_LIST = DATA_MESSAGE | KIND_LIST
+    # repeated Enum
+    FIELD_ENUM_LIST = DATA_ENUM | KIND_LIST
+
+    # map<scalar, scalar>
+    FIELD_SIMPLE_MAP = DATA_SCALAR | KIND_MAP
+    # map<scalar, Message>
+    FIELD_MESSAGE_MAP = DATA_MESSAGE | KIND_MAP
+    # map<scalar, Enum>
+    FIELD_ENUM_MAP = DATA_ENUM | KIND_MAP
+
+    FIELD_STRUCT_VALUES = SPECIAL_STRUCT | SPECIAL_VALUE | SPECIAL_LIST_VALUE | SPECIAL_NULL_VALUE
+
+    def __repr__(self) -> str:
+        return self.name or str(self.value)
+
+
+@dataclasses.dataclass
+class FieldDescriptorWrapper:
+    """This is a wrapper around Google's protobuf FieldDescriptor.
+
+    Its point is twofold.
+
+    1. To mask complex lookups and evaluations behind a simpler facade to use
+       in the rest of the code.
+    2. To abstract away the exact structure of Google's descriptor to guard
+       against future code changes, especially in internal parts that aren't
+       part of the official API.
+    """
+    real_descriptor: descriptor.FieldDescriptor = dataclasses.field(repr=False)
+
+    name: str = dataclasses.field(default='', init=False)
+
+    kind: FieldKind = dataclasses.field(default=FieldKind.UNKNOWN, init=False)
+
+    options: Optional[Any] = dataclasses.field(default=None, init=False, repr=False)
+
+    key_field: Optional[descriptor.FieldDescriptor] = dataclasses.field(default=None, init=False, repr=False)
+    value_field: Optional[descriptor.FieldDescriptor] = dataclasses.field(default=None, init=False, repr=False)
+    value_msg: Optional[descriptor.Descriptor] = dataclasses.field(default=None, init=False, repr=False)
+
+    py_type: PyType = dataclasses.field(default=PY_TYPE_MAP[ProtoType.UNKNOWN], init=False)
+    key_py_type: PyType = dataclasses.field(default=PY_TYPE_MAP[ProtoType.UNKNOWN], init=False)
+
+    is_proto_repeated: bool = dataclasses.field(default=False, init=False)
+
+    def __post_init__(self):
+        self.name = self.real_descriptor.name
+        self.is_proto_repeated = self.real_descriptor.is_repeated
+        self._check_field_kind()
+
+    def _load_options(self):
+        self.options = None
+        if self.real_descriptor.type == ProtoType.MESSAGE:
+            if self.real_descriptor.message_type.has_options:
+                self.options = self.real_descriptor.message_type.GetOptions()
+
+    def _check_field_kind(self):
+        self._load_options()
+
+        if self.options and self.options.map_entry:  # Message that is a map...
+            self.key_field = self.real_descriptor.message_type.fields_by_name['key']
+            self.key_py_type = PY_TYPE_MAP[self.key_field.type]
+            self.value_field = self.real_descriptor.message_type.fields_by_name['value']
+            self.kind |= FieldKind.KIND_MAP
+        else:
+            self.value_field = self.real_descriptor
+            if self.is_proto_repeated:
+                self.kind |= FieldKind.KIND_LIST
+            else:
+                self.kind |= FieldKind.KIND_SINGLE
+
+        if self.value_field.type == ProtoType.MESSAGE:  # Message
+            self.value_msg = self.value_field.message_type
+
+            if self.value_msg.full_name == 'google.protobuf.Timestamp':
+                self.kind |= FieldKind.DATA_SCALAR
+                self.kind |= FieldKind.SPECIAL_TIMESTAMP
+            elif self.value_msg.full_name == 'google.protobuf.Duration':
+                self.kind |= FieldKind.DATA_SCALAR
+                self.kind |= FieldKind.SPECIAL_DURATION
+            elif self.value_msg.full_name == 'google.protobuf.Any':
+                self.kind |= FieldKind.DATA_SCALAR
+                self.kind |= FieldKind.SPECIAL_ANY
+            elif self.value_msg.full_name == 'google.protobuf.Empty':
+                self.kind |= FieldKind.SPECIAL_EMPTY
+            elif self.value_msg.full_name == 'google.protobuf.Struct':
+                self.kind |= FieldKind.SPECIAL_STRUCT
+            elif self.value_msg.full_name == 'google.protobuf.Value':
+                self.kind |= FieldKind.SPECIAL_VALUE
+            elif self.value_msg.full_name == 'google.protobuf.ListValue':
+                self.kind |= FieldKind.SPECIAL_LIST_VALUE
+            elif self.value_msg.full_name == 'google.protobuf.NullValue':
+                self.kind |= FieldKind.SPECIAL_NULL_VALUE
+            else:
+                self.kind |= FieldKind.DATA_MESSAGE
+        elif self.value_field.type == ProtoType.ENUM:  # Enum
+            self.kind |= FieldKind.DATA_ENUM
+
+        else:  # Scalar
+            self.kind |= FieldKind.DATA_SCALAR
+
+            if self.value_field.type == ProtoType.BYTES:
+                self.kind |= FieldKind.SPECIAL_BYTES
+            else:
+                if self.value_field.cpp_type in json_format._INT64_TYPES:
+                    self.kind |= FieldKind.SPECIAL_LONG
+
+        self.py_type = PY_TYPE_MAP[self.value_field.type]
+
+        if keyword.iskeyword(self.name):
+            self.kind |= FieldKind.SPECIAL_KEYWORD
+
+    @property
+    def camelcase_name(self) -> str:
+        return self.real_descriptor.camelcase_name
+
+    @property
+    def json_name(self) -> str:
+        return self.real_descriptor.json_name
+
+    @property
+    def default_value(self) -> Any:
+        return self.real_descriptor.default_value
+
+    @property
+    def full_name(self) -> Any:
+        return self.real_descriptor.full_name
+
+
+# def main():
+#     fields = []
+#     from sandbox.test import RainbowMessage
+#     for f in RainbowMessage.DESCRIPTOR.fields:
+#         ff = FieldDescriptorWrapper(f)
+#         print(ff)
+#         fields.append(ff)
+#
+#     # print(fields)
+#
+# if __name__ == '__main__':
+#     main()

neobuilder6/descwrap/_method.py

@@ -0,0 +1,57 @@
+__all__ = [
+    'MethodDescriptorWrapper',
+]
+
+import dataclasses
+
+from neobuilder6.structs import *
+from google.protobuf.json_format import descriptor
+from protoplasm6.casting import castutils
+
+
+@dataclasses.dataclass
+class MethodDescriptorWrapper:
+    """This is a wrapper around Google's protobuf MethodDescriptor.
+
+    Its point is twofold.
+
+    1. To mask complex lookups and evaluations behind a simpler facade to use
+       in the rest of the code.
+    2. To abstract away the exact structure of Google's descriptor to guard
+       against future code changes, especially in internal parts that aren't
+       part of the official API.
+    """
+    real_descriptor: descriptor.MethodDescriptor = dataclasses.field(repr=False)
+
+    name: str = dataclasses.field(default='', init=False)
+    under_name: str = dataclasses.field(default='', init=False)
+
+    client_streaming: bool = False
+    server_streaming: bool = False
+
+    input_type: Optional[descriptor.Descriptor] = dataclasses.field(default=None, init=False, repr=False)
+    output_type: Optional[descriptor.Descriptor] = dataclasses.field(default=None, init=False, repr=False)
+
+    io_type: MethodIoType = dataclasses.field(default=MethodIoType._UNKNOWN, init=False)
+
+    service_descriptor: descriptor.ServiceDescriptor = dataclasses.field(default=None, init=False, repr=False)
+    file_descriptor: descriptor.FileDescriptor = dataclasses.field(default=None, init=False, repr=False)
+
+    def __post_init__(self):
+        self.name = self.real_descriptor.name
+        self.under_name = castutils.humps_to_under(self.name)
+        self.input_type = self.real_descriptor.input_type
+        self.output_type = self.real_descriptor.output_type
+        self.client_streaming = self.real_descriptor.client_streaming
+        self.server_streaming = self.real_descriptor.server_streaming
+        if self.client_streaming:
+            self.io_type |= MethodIoType._INPUT_STREAM
+        else:
+            self.io_type |= MethodIoType._INPUT_UNARY
+        if self.server_streaming:
+            self.io_type |= MethodIoType._OUTPUT_STREAM
+        else:
+            self.io_type |= MethodIoType._OUTPUT_UNARY
+
+        self.service_descriptor = self.real_descriptor.containing_service
+        self.file_descriptor = self.service_descriptor.file

neobuilder6/generators/servicebuilders/__init__.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+from . import base
+from batutils.tpu import strimp
+import typing
+
+import logging
+log = logging.getLogger(__name__)
+
+_CACHE = {}
+
+
+def get_builder_module(implementation_name: str):
+    if implementation_name not in _CACHE:
+        _CACHE[implementation_name] = strimp.get_module(f'{__package__}.{implementation_name}', logger=log, reraise=True)
+    return _CACHE[implementation_name]
+
+
+def get_module_builder(implementation_name: str) -> typing.Type[base.AbstractModuleBuilder]:
+    return getattr(get_builder_module(implementation_name), 'ModuleBuilder')
+
+
+def get_service_builder(implementation_name: str) -> typing.Type[base.AbstractServiceBuilder]:
+    return getattr(get_builder_module(implementation_name), 'ServiceBuilder')
+
+
+def get_method_builder(implementation_name: str) -> typing.Type[base.AbstractMethodBuilder]:
+    return getattr(get_builder_module(implementation_name), 'MethodBuilder')

neobuilder6/generators/servicebuilders/base.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+from neobuilder6.generators.symbols import service as symbols_service
+from neobuilder6.generators.symbols import modules
+import datetime
+from typing import *
+
+
+class AbstractModuleBuilder(object):
+    builder_name = ''
+
+    def __init__(self, module: modules.ProtoModule):
+        self.module = module
+        self.indent_str = self.module.indent
+        self.service_joiner = '\n\n'
+
+    def get_template_context(self) -> Dict:
+        return {
+            'module_full_name': self.module.get_module_full_name(),
+            'iso_timestamp': datetime.datetime.now().isoformat(),
+        }
+
+    def render_top(self) -> str:
+        # TODO(thordurm@ccpgames.com) 2022-06-24: Remove... why?
+        return ('# Auto-Generated file - DO NOT EDIT!\n'
+                f'# Source module: {self.module.get_module_full_name()}\n'
+                f'# Generated at: {datetime.datetime.now().isoformat()}\n')
+
+    def render_service_list(self) -> List[str]:
+        return [svc.render(self.builder_name) for svc in self.module.service_map.values()]
+
+    def render_services(self) -> str:
+        return '\n'.join(self.render_service_list())
+
+    def get_render_filename(self) -> str:
+        raise NotImplementedError('AbstractModuleBuilder not implemented')
+
+    def render(self) -> str:
+        raise NotImplementedError('AbstractModuleBuilder not implemented')
+
+
+class AbstractServiceBuilder(object):
+    builder_name = ''
+
+    def __init__(self, service: symbols_service.ProtoService, indent_level: int = 0):
+        self.service = service
+        self.indent_level = indent_level
+        self.indent_str = self.service.indent
+        self.base_indent = self.indent_str * indent_level
+
+    def get_template_context(self) -> Dict:
+        return {
+            'is_grpc': self.service.module.is_grpc_file(),
+            'service': self.service,
+            'service_name': self.service.service_descriptor.name,
+            '_indent_level': self.indent_level,
+            '_indent_str': self.indent_str,
+            '_base_indent': self.base_indent,
+            'method_list': [self.get_method_context(m) for m in self.service.method_map.values()],
+            'indent_spaces': self.indent_level * 4,
+        }
+
+    def get_method_context(self, method: symbols_service.ProtoMethod) -> Dict[str, Any]:
+        return {
+            'method': method,
+        }
+
+    def render_methods(self) -> str:
+        ____ = self.indent_str
+        i = self.base_indent
+        buf = []
+        if self.service.method_map:
+            buf.append(
+                '\n'.join([m.render(self.builder_name, self.indent_level + 1) for m in self.service.method_map.values()]))
+        else:
+            buf.append(f'{i}pass\n')
+        return ''.join(buf)
+
+    def render(self) -> str:
+        raise NotImplementedError('AbstractServiceBuilder not implemented')
+
+
+class AbstractMethodBuilder(object):
+    def __init__(self, method: symbols_service.ProtoMethod, indent_level: int = 0):
+        self.method = method
+        self.indent_level = indent_level
+        self.indent_str = self.method.indent
+        self.base_indent = self.indent_str * indent_level
+
+    def get_template_context(self) -> Dict:
+        return {
+            'method': self.method,
+            '_indent_level': self.indent_level,
+            '_indent_str': self.indent_str,
+            '_base_indent': self.base_indent,
+            'indent_spaces': self.indent_level * 4,
+        }
+
+    def render(self) -> str:
+        raise NotImplementedError('AbstractServiceMethod not implemented')