Metadata-Version: 2.1
Name: django-grpc-bus
Version: 1.0.2
Summary: Django rest gRPC framework
Home-page: https://github.com/rameezarshad/django-grpc-framework
Author: Rameez Arshad
Author-email: rameez.arshad@outlook.in
License: UNKNOWN
Download-URL: https://github.com/rameezarshad/django-grpc-framework/archive/main.zip
Description: Django gRPC Framework
        =====================
        
        Django gRPC framework is a advanced toolkit for building gRPC services.
        
        # Requirements
        
        * Python (3.6, 3.7, 3.8, 3.9)
        * Django (2.2, 3.0, 3.1)
        * Django Rest Framework (3.10, 3.11)
        * grpcio (1.34x)
        * grpcio-health (1.34x)
        * grpcio-reflection (1.34x)
        * grpcio-tools (1.34x)
        * isort
        
        
        Installation
        ------------
        
            $ pip install django-grpc-bus 
        
        
        Add ``django_grpc_bus`` to ``INSTALLED_APPS`` setting:
        
            INSTALLED_APPS = [
                ...
                'django_grpc_bus',
            ]
        
        Add ``MESSAGE_BUS`` to settings:
            
            MESSAGE_BUS = {
                'ROOT_HANDLERS_HOOK': 'path.to.handler',
                'SERVICE_META': os.path.join(BASE_DIR, 'service_meta.yaml'),
                'PRODUCER_ROOT': os.path.join(settings.BASE_DIR, 'generated_grpc'),
                'SERVICE_TEMPLATE': os.path.join(Path(__file__).resolve().parent, 'service_template'),
                'HANDLER_TEMPLATE': os.path.join(Path(__file__).resolve().parent, 'handler_template'),
                'SERVLETS': {
                    'service1': {
                        'host': localhost,
                        'port': 50051,
                    },
                    'service2': {
                        'host': localhost,
                        'port': 50052,
                    },
                    'service3': {
                        'host': localhost,
                        'port': 50053,
                    },
                }
            }
        
        # Example
        
        Let's take a look at a quick example of using gRPC framework to serve and consume gRPC services.
        
        Define ``service_meta.yml`` in the project root
        
        ```yaml
        apps:
          - name: app_1
            models:
              - name: model_1
                exclude:
                  - exclude_field_1
                  - exclude_field_2
          - name: app_2
            models:
              - name: model_2
                fields:
                  - field_1
                  - field_2
              - name: model_3
        ```
        By default all apps will be used as service, or to generate default service meta yaml for all apps using:
        
            ./manage.py generatemetayaml --file path.to.save.file
        
        Update the path of ``service_meta.yaml`` in MESSAGE_BUS settings.
        
        Generate default proto files (defined in ``service_meta.yaml``) to ``PRODUCER_ROOT`` path, using:
        
            ./manage.py generateproto
        
        Once the proto files are updated, generate the gRPC python out files to ``PRODUCER_ROOT`` path, using:
        
            ./manage.py generategrpc
        
        Define the components ``serializers.py``, ``services.py`` and ``handlers.py``
        
        * ``serializers.py`` are the similar to django rest serializers, example:
        
        ```python
        from django_grpc_bus import serializers as proto_serializers
        
        from path.to.generated_grpc.grpc import ModelName_pb2
        from app_name import models
        
        
        class ModelNameSerializer(proto_serializers.ModelProtoSerializer):
        
            class Meta:
                model = models.ModelName
                proto_class = ModelName_pb2.ModelNameData
        ```
        
        * ``services.py`` contains the gRPC producer services, inherited from class ModelService containing predefined mixins
         ``create``, ``retrieve``, ``update``, ``destroy`` and ``list``, example to define services.py:
        
        ```python
        from django_grpc_bus.generics import ModelService
        
        from app_name import models, serializers
        
        
        class ModelNameService(ModelService):
            queryset = models.ModelName.objects.all()
            serializer_class = serializers.ModelNameSerializer
        ```
        
        * ``handlers.py`` are the routers for services, that register the services, example:
        
        ```python
        from django_grpc_bus.handlers import BasicHandler
        
        
        handler = BasicHandler()
        
        handler.register('app_name.services.ModelNameService')
        
        ```
        
        To start with above components simply run the following command:
        
            ./manage.py generateservices -hd
        
        Predefined templates will be generated in the app directories and ``handlers.py`` will be get appended with service 
        registry.
        
        Start the server using:
        
            ./manage.py rungrpcserver --dev
        
        Server will get started at 50051 port.
        
        To consume the services, for now we are using gRPC reflection that lists all the registered services and its methods. 
        Use the client as:
        
        ```python
        from django_grpc_bus.client.registry import registry
        
        list_data = registry.servlet_name.service_name.list()  # Generator object will be returned as its stream response
        get_data = registry.servlet_name.service_name.retrieve({'id': 1})
        ```
        
        
Keywords: grpc framework django rest micro service message bus
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Requires-Python: >=3.6
Description-Content-Type: text/markdown
