chatgraph 0.2.6__py3-none-any.whl → 0.3.0__py3-none-any.whl

chatgraph/__init__.py

@@ -1,21 +1,22 @@
 from .auth.credentials import Credential
 from .bot.chatbot_model import ChatbotApp
 from .bot.chatbot_router import ChatbotRouter
-from .messages.rabbitMQ_message_consumer import RabbitMessageConsumer
-from .types.message_types import Message, UserState
+from .messages.message_consumer import MessageConsumer
+from .types.message_types import UserCall, UserState, Element
 from .types.output_state import ChatbotResponse, RedirectResponse, EndChatResponse, TransferToHuman
 from .types.route import Route
 
 __all__ = [
     'ChatbotApp',
     'Credential',
-    'Message',
+    'UserCall',
     'ChatbotRouter',
     'ChatbotResponse',
     'RedirectResponse',
-    'RabbitMessageConsumer',
+    'MessageConsumer',
     'Route',
     'EndChatResponse',
     'TransferToHuman',
     'UserState',
+    'Element',
 ]

chatgraph/bot/chatbot_model.py

@@ -1,18 +1,18 @@
 import inspect
-from abc import ABC
 from functools import wraps
 from logging import debug
 import json
+from logging import error
 
 from ..error.chatbot_error import ChatbotError, ChatbotMessageError
-from ..messages.base_message_consumer import MessageConsumer
-from ..types.message_types import Message
+from ..messages.message_consumer import MessageConsumer
+from ..types.message_types import UserCall
 from ..types.output_state import ChatbotResponse, RedirectResponse, EndChatResponse, TransferToHuman
 from ..types.route import Route
 from .chatbot_router import ChatbotRouter
 
 
-class ChatbotApp(ABC):
+class ChatbotApp:
     """
     Classe principal para a aplicação do chatbot, gerencia as rotas e a lógica de processamento de mensagens.
     """
@@ -101,12 +101,12 @@ class ChatbotApp(ABC):
         self.__message_consumer.reprer()
         self.__message_consumer.start_consume(self.process_message)
     
-    def process_message(self, message: Message):
+    def process_message(self, userCall: UserCall):
         """
         Processa uma mensagem recebida, identificando a rota correspondente e executando a função associada.
 
         Args:
-            message (Message): A mensagem a ser processada.
+            userCall (Message): A mensagem a ser processada.
 
         Raises:
             ChatbotMessageError: Se nenhuma rota for encontrada para o menu atual do usuário.
@@ -115,60 +115,67 @@ class ChatbotApp(ABC):
         Returns:
             str: A resposta gerada pela função da rota, que pode ser uma mensagem ou o resultado de uma redireção.
         """
-        customer_id = message.user_state.customer_id
-        user_state = message.user_state
-        menu = message.user_state.menu
-        menu = menu.lower()
-        handler = self.__routes.get(menu, None)
+        customer_id = userCall.customer_id
+        route = userCall.route.lower()
+        menu = userCall.menu.lower()
+        obs = userCall.obs
+        handler = self.__routes.get(route, None)
 
         if not handler:
             raise ChatbotMessageError(
-                customer_id, f'Rota não encontrada para {menu}!'
+                customer_id, f'Rota não encontrada para {route}!'
             )
         func = handler['function']
-        message_name = handler['params'].get(Message, None)
+        userCall_name = handler['params'].get(UserCall, None)
         route_state_name = handler['params'].get(Route, None)
 
         kwargs = dict()
-        if message_name:
-            kwargs[message_name] = message
+        if userCall_name:
+            kwargs[userCall_name] = userCall
         if route_state_name:
-            kwargs[route_state_name] = Route(menu, list(self.__routes.keys()))
+            kwargs[route_state_name] = Route(route, list(self.__routes.keys()))
 
-        message_response = func(**kwargs)
+        userCall_response = func(**kwargs)
 
-        if type(message_response) in (str, float, int):
-            response = ChatbotResponse(message_response)
-            response = message_response.json()
+        if type(userCall_response) in (str, float, int):
+            response = ChatbotResponse(userCall_response)
+            response = response.json()
             response['user_state'] = {
                 'customer_id': customer_id,
+                'route': route,
                 'menu': menu,
-                'obs': user_state.obs,
+                'obs': obs,
             }
             return json.dumps(response)
-        elif type(message_response) == ChatbotResponse:
-            route = self.__adjust_route(message_response.route, menu)
-            response = message_response.json()
+        elif type(userCall_response) == ChatbotResponse:
+            adjusted_route = self.__adjust_route(userCall_response.route, route)
+            response = userCall_response.json()
             response['user_state'] = {
                 'customer_id': customer_id,
-                'menu': route,
-                'obs': user_state.obs,
+                'route': adjusted_route,
+                'menu': menu,
+                'obs': obs,
             }
             return json.dumps(response)            
-        elif type(message_response) in (EndChatResponse, TransferToHuman):
-            response = message_response.json()
+        elif type(userCall_response) in (EndChatResponse, TransferToHuman):
+            response = userCall_response.json()
             response['user_state'] = {
                 'customer_id': customer_id,
                 'menu': None,
+                'route': None,
                 'obs': None,
             }
             return json.dumps(response)
-        elif type(message_response) == RedirectResponse:
-            route = self.__adjust_route(message_response.route, menu)
-            message.user_state.menu = route
-            return self.process_message(message)
+        
+        elif type(userCall_response) == RedirectResponse:
+            route = self.__adjust_route(userCall_response.route, route)
+            userCall.route = route
+            return self.process_message(userCall)
+        
         else:
-            raise ChatbotError('Tipo de retorno inválido!')
+            error('Tipo de retorno inválido!')
+            return None
+        
 
     def __adjust_route(self, route: str, absolute_route: str) -> str:
         """

chatgraph/gRPC/gRPCCall.py

@@ -0,0 +1,125 @@
+import os
+import grpc
+import chatgraph.pb.userstate_pb2 as userstate_pb2
+import chatgraph.pb.userstate_pb2_grpc as userstate_pb2_grpc
+
+import chatgraph.pb.voll_pb2 as whatsapp_pb2
+import chatgraph.pb.voll_pb2_grpc as whatsapp_pb2_grpc
+
+class WhatsappServiceClient:
+    def __init__(self, grpc_uri=None):
+        
+        self.grpc_uri = grpc_uri
+        
+        if not grpc_uri:
+            self.grpc_uri = os.getenv('GRPC_URI')
+        
+        if not self.grpc_uri:
+            raise ValueError("A variável de ambiente 'GRPC_URI' não está definida.")
+        
+        # Cria o canal gRPC
+        self.channel = grpc.insecure_channel(self.grpc_uri)
+        
+        # Cria o stub (client) para o serviço gRPC
+        self.stub = whatsapp_pb2_grpc.MessageServiceStub(self.channel)
+
+    def send_button(self, message_data):
+        # Cria o request para o método SendButton
+        request = whatsapp_pb2.MessageRequest(**message_data)
+
+        # Faz a chamada ao serviço gRPC
+        try:
+            response = self.stub.SendButton(request)
+            return response
+        except grpc.RpcError as e:
+            print(f"Erro ao fazer a requisição gRPC SendButton: {e}")
+            return None
+
+    def send_list(self, message_data):
+        # Cria o request para o método SendList
+        request = whatsapp_pb2.MessageRequest(**message_data)
+
+        # Faz a chamada ao serviço gRPC
+        try:
+            response = self.stub.SendList(request)
+            return response
+        except grpc.RpcError as e:
+            print(f"Erro ao fazer a requisição gRPC SendList: {e}")
+            return None
+
+    def send_text(self, message_data):
+        # Cria o request para o método SendText
+        request = whatsapp_pb2.MessageRequest(**message_data)
+
+        # Faz a chamada ao serviço gRPC
+        try:
+            response = self.stub.SendText(request)
+            return response
+        except grpc.RpcError as e:
+            print(f"Erro ao fazer a requisição gRPC SendText: {e}")
+            return None
+
+class UserStateServiceClient:
+    def __init__(self, grpc_uri=None):
+        
+        self.grpc_uri = grpc_uri
+        
+        if not grpc_uri:
+            self.grpc_uri = os.getenv('GRPC_URI')
+        
+        if not self.grpc_uri:
+            raise ValueError("A variável de ambiente 'GRPC_URI' não está definida.")
+        
+        # Cria o canal gRPC
+        self.channel = grpc.insecure_channel(self.grpc_uri)
+        
+        # Cria o stub (client) para o serviço gRPC
+        self.stub = userstate_pb2_grpc.UserStateServiceStub(self.channel)
+
+    def select_user_state(self, user_id):
+        # Cria o request para o método SelectUserState
+        request = userstate_pb2.UserStateId(user_id=user_id)
+
+        # Faz a chamada ao serviço gRPC
+        try:
+            response = self.stub.SelectUserState(request)
+            return response
+        except grpc.RpcError as e:
+            print(f"Erro ao fazer a requisição gRPC SelectUserState: {e}")
+            return None
+
+    def insert_user_state(self, user_state_data):
+        # Cria o request para o método InsertUserState
+        request = userstate_pb2.UserState(**user_state_data)
+
+        # Faz a chamada ao serviço gRPC
+        try:
+            response = self.stub.InsertUserState(request)
+            return response
+        except grpc.RpcError as e:
+            print(f"Erro ao fazer a requisição gRPC InsertUserState: {e}")
+            return None
+
+    def update_user_state(self, user_state_data):
+        # Cria o request para o método UpdateUserState
+        request = userstate_pb2.UserState(**user_state_data)
+
+        # Faz a chamada ao serviço gRPC
+        try:
+            response = self.stub.UpdateUserState(request)
+            return response
+        except grpc.RpcError as e:
+            print(f"Erro ao fazer a requisição gRPC UpdateUserState: {e}")
+            return None
+
+    def delete_user_state(self, user_id):
+        # Cria o request para o método DeleteUserState
+        request = userstate_pb2.UserStateId(user_id=user_id)
+
+        # Faz a chamada ao serviço gRPC
+        try:
+            response = self.stub.DeleteUserState(request)
+            return response
+        except grpc.RpcError as e:
+            print(f"Erro ao fazer a requisição gRPC DeleteUserState: {e}")
+            return None

chatgraph/messages/{rabbitMQ_message_consumer.py → message_consumer.py}

@@ -4,14 +4,13 @@ import os
 import pika
 from typing import Callable
 from ..auth.credentials import Credential
-from ..types.message_types import Message, UserState
-from .base_message_consumer import MessageConsumer
+from ..types.message_types import UserCall, UserState
 from rich.console import Console
 from rich.table import Table
 from rich.text import Text
 from rich.panel import Panel
 
-class RabbitMessageConsumer(MessageConsumer):
+class MessageConsumer:
     """
     Implementação de MessageConsumer para consumir mensagens de uma fila RabbitMQ.
 
@@ -27,6 +26,7 @@ class RabbitMessageConsumer(MessageConsumer):
         self,
         credential: Credential,
         amqp_url: str,
+        grpc_uri: str,
         queue_consume: str,
         prefetch_count: int = 1,
         virtual_host: str = '/',
@@ -45,6 +45,7 @@ class RabbitMessageConsumer(MessageConsumer):
         self.__prefetch_count = prefetch_count
         self.__queue_consume = queue_consume
         self.__amqp_url = amqp_url
+        self.__grpc_uri = grpc_uri
         self.__credentials = pika.PlainCredentials(
             credential.username, credential.password
         )
@@ -58,7 +59,8 @@ class RabbitMessageConsumer(MessageConsumer):
         queue_env: str = 'RABBIT_QUEUE',
         prefetch_env: str = 'RABBIT_PREFETCH',
         vhost_env: str = 'RABBIT_VHOST',
-    ) -> 'RabbitMessageConsumer':
+        grpc_uri: str = 'GRPC_URI',
+    ) -> 'MessageConsumer':
         """
         Carrega as configurações do RabbitMQ a partir de variáveis de ambiente e retorna uma instância de RabbitMessageConsumer.
 
@@ -82,8 +84,9 @@ class RabbitMessageConsumer(MessageConsumer):
         queue = os.getenv(queue_env)
         prefetch = os.getenv(prefetch_env, 1)
         vhost = os.getenv(vhost_env, '/')
+        grpc = os.getenv(grpc_uri)
 
-        if not username or not password or not url or not queue:
+        if not username or not password or not url or not queue or not grpc:
             raise ValueError('Corrija as variáveis de ambiente!')
 
         return cls(
@@ -92,6 +95,7 @@ class RabbitMessageConsumer(MessageConsumer):
             queue_consume=queue,
             prefetch_count=int(prefetch),
             virtual_host=vhost,
+            grpc_uri=grpc,
         )
 
     def start_consume(self, process_message: Callable) -> None:
@@ -122,7 +126,7 @@ class RabbitMessageConsumer(MessageConsumer):
                 ),
             )
 
-            info('[x] Aguardando solicitações RPC')
+            info('[x] Server inicializado! Aguardando solicitações RPC')
             channel.start_consuming()
         except pika.exceptions.StreamLostError as e:
             debug(e)
@@ -154,7 +158,7 @@ class RabbitMessageConsumer(MessageConsumer):
         )
         ch.basic_ack(delivery_tag=method.delivery_tag)
 
-    def __transform_message(self, message: dict) -> Message:
+    def __transform_message(self, message: dict) -> UserCall:
         """
         Transforma o dicionário JSON recebido em uma instância de Message.
 
@@ -166,12 +170,13 @@ class RabbitMessageConsumer(MessageConsumer):
         """
         
         user_state = message.get('user_state', {})
-        return Message(
+        return UserCall(
             type=message.get('type', ''),
             text=message.get('text', ''),
             user_state=UserState(
                 customer_id=user_state.get('customer_id', ''),
                 menu=user_state.get('menu', ''),
+                route=user_state.get('route', ''),
                 lst_update=user_state.get('lst_update', ''),
                 obs=user_state.get('obs', {}),
             ),
@@ -179,6 +184,7 @@ class RabbitMessageConsumer(MessageConsumer):
             customer_phone=message.get('customer_phone', ''),
             company_phone=message.get('company_phone', ''),
             status=message.get('status'),
+            grpc_uri=self.__grpc_uri,
         )
 
     def reprer(self):

chatgraph/pb/userstate.proto

@@ -0,0 +1,29 @@
+syntax = "proto3";
+
+package userstate;
+
+option go_package = "./pb/userstate";
+
+service UserStateService {
+    rpc SelectUserState(UserStateId) returns (UserState);
+    rpc InsertUserState(UserState) returns (RequestStatus);
+    rpc UpdateUserState(UserState) returns (RequestStatus);
+    rpc DeleteUserState(UserStateId) returns (RequestStatus);
+}
+
+message UserState {
+    string user_id = 1;
+    string menu_id = 2;
+    string route = 3;
+    string obs = 4;
+    string date = 5;
+}
+
+message UserStateId {
+    string user_id = 1;
+}
+
+message RequestStatus {
+    bool status = 1;
+    string message = 2;
+}

chatgraph/pb/userstate_pb2.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: userstate.proto
+# Protobuf Python Version: 5.27.2
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    27,
+    2,
+    '',
+    'userstate.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0fuserstate.proto\x12\tuserstate\"W\n\tUserState\x12\x0f\n\x07user_id\x18\x01 \x01(\t\x12\x0f\n\x07menu_id\x18\x02 \x01(\t\x12\r\n\x05route\x18\x03 \x01(\t\x12\x0b\n\x03obs\x18\x04 \x01(\t\x12\x0c\n\x04\x64\x61te\x18\x05 \x01(\t\"\x1e\n\x0bUserStateId\x12\x0f\n\x07user_id\x18\x01 \x01(\t\"0\n\rRequestStatus\x12\x0e\n\x06status\x18\x01 \x01(\x08\x12\x0f\n\x07message\x18\x02 \x01(\t2\x9e\x02\n\x10UserStateService\x12?\n\x0fSelectUserState\x12\x16.userstate.UserStateId\x1a\x14.userstate.UserState\x12\x41\n\x0fInsertUserState\x12\x14.userstate.UserState\x1a\x18.userstate.RequestStatus\x12\x41\n\x0fUpdateUserState\x12\x14.userstate.UserState\x1a\x18.userstate.RequestStatus\x12\x43\n\x0f\x44\x65leteUserState\x12\x16.userstate.UserStateId\x1a\x18.userstate.RequestStatusB\x10Z\x0e./pb/userstateb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'userstate_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'Z\016./pb/userstate'
+  _globals['_USERSTATE']._serialized_start=30
+  _globals['_USERSTATE']._serialized_end=117
+  _globals['_USERSTATEID']._serialized_start=119
+  _globals['_USERSTATEID']._serialized_end=149
+  _globals['_REQUESTSTATUS']._serialized_start=151
+  _globals['_REQUESTSTATUS']._serialized_end=199
+  _globals['_USERSTATESERVICE']._serialized_start=202
+  _globals['_USERSTATESERVICE']._serialized_end=488
+# @@protoc_insertion_point(module_scope)

chatgraph/pb/userstate_pb2_grpc.py

@@ -0,0 +1,226 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+import chatgraph.pb.userstate_pb2 as userstate__pb2
+
+GRPC_GENERATED_VERSION = '1.66.2'
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + f' but the generated code in userstate_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+    )
+
+
+class UserStateServiceStub(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.SelectUserState = channel.unary_unary(
+                '/userstate.UserStateService/SelectUserState',
+                request_serializer=userstate__pb2.UserStateId.SerializeToString,
+                response_deserializer=userstate__pb2.UserState.FromString,
+                _registered_method=True)
+        self.InsertUserState = channel.unary_unary(
+                '/userstate.UserStateService/InsertUserState',
+                request_serializer=userstate__pb2.UserState.SerializeToString,
+                response_deserializer=userstate__pb2.RequestStatus.FromString,
+                _registered_method=True)
+        self.UpdateUserState = channel.unary_unary(
+                '/userstate.UserStateService/UpdateUserState',
+                request_serializer=userstate__pb2.UserState.SerializeToString,
+                response_deserializer=userstate__pb2.RequestStatus.FromString,
+                _registered_method=True)
+        self.DeleteUserState = channel.unary_unary(
+                '/userstate.UserStateService/DeleteUserState',
+                request_serializer=userstate__pb2.UserStateId.SerializeToString,
+                response_deserializer=userstate__pb2.RequestStatus.FromString,
+                _registered_method=True)
+
+
+class UserStateServiceServicer(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def SelectUserState(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def InsertUserState(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def UpdateUserState(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def DeleteUserState(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_UserStateServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'SelectUserState': grpc.unary_unary_rpc_method_handler(
+                    servicer.SelectUserState,
+                    request_deserializer=userstate__pb2.UserStateId.FromString,
+                    response_serializer=userstate__pb2.UserState.SerializeToString,
+            ),
+            'InsertUserState': grpc.unary_unary_rpc_method_handler(
+                    servicer.InsertUserState,
+                    request_deserializer=userstate__pb2.UserState.FromString,
+                    response_serializer=userstate__pb2.RequestStatus.SerializeToString,
+            ),
+            'UpdateUserState': grpc.unary_unary_rpc_method_handler(
+                    servicer.UpdateUserState,
+                    request_deserializer=userstate__pb2.UserState.FromString,
+                    response_serializer=userstate__pb2.RequestStatus.SerializeToString,
+            ),
+            'DeleteUserState': grpc.unary_unary_rpc_method_handler(
+                    servicer.DeleteUserState,
+                    request_deserializer=userstate__pb2.UserStateId.FromString,
+                    response_serializer=userstate__pb2.RequestStatus.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'userstate.UserStateService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('userstate.UserStateService', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class UserStateService(object):
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def SelectUserState(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/userstate.UserStateService/SelectUserState',
+            userstate__pb2.UserStateId.SerializeToString,
+            userstate__pb2.UserState.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def InsertUserState(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/userstate.UserStateService/InsertUserState',
+            userstate__pb2.UserState.SerializeToString,
+            userstate__pb2.RequestStatus.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def UpdateUserState(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/userstate.UserStateService/UpdateUserState',
+            userstate__pb2.UserState.SerializeToString,
+            userstate__pb2.RequestStatus.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def DeleteUserState(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/userstate.UserStateService/DeleteUserState',
+            userstate__pb2.UserStateId.SerializeToString,
+            userstate__pb2.RequestStatus.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)