def preserve_create_fulfilments(
        self, impulses: List[CreateFulfilmentImpulse]
    ) -> Observable[CreatedFulfilmentImpulse]:
        fulfilment_req = lambda x: x.id()
        create_req: Callable[[PreservationReq], None] = lambda x: x.create(
            lambda e: e.fulfilments(impulses, fulfilment_req))
        mutation_req: Callable[[MutationReq],
                               None] = lambda x: x.preserve(create_req)
        mutation_res: Callable[
            [MutationRes],
            CreatedFulfilmentImpulse] = lambda x: x.preserve.create.fulfilments

        observable = rx.of(
            self.client.mutation(GaiaRequest.mutation(mutation_req)))
        return flat_mapM(observable, mutation_res)
    def preserve_delete_prompts(
        self, impulses: List[DeletePromptImpulse]
    ) -> Observable[DeletedPromptImpulse]:
        prompt_req = lambda x: x.id()
        delete_prompts: Callable[[PreservationReq], None] = lambda x: x.delete(
            lambda e: e.prompts(impulses, prompt_req))
        mutation_req: Callable[[MutationReq],
                               None] = lambda x: x.preserve(delete_prompts)
        mutation_res: Callable[
            [MutationRes],
            DeletedPromptImpulse] = lambda x: x.preserve.delete.prompts

        observable = rx.of(
            self.client.mutation(GaiaRequest.mutation(mutation_req)))
        return flat_mapM(observable, mutation_res)
    def preserve_update_intents(
        self, impulses: List[UpdateIntentImpulse]
    ) -> Observable[UpdatedIntentImpulse]:
        intent_req = lambda x: x.id()
        update_intents: Callable[[PreservationReq], None] = lambda x: x.update(
            lambda e: e.intents(impulses, intent_req))
        mutation_req: Callable[[MutationReq],
                               None] = lambda x: x.preserve(update_intents)
        mutation_res: Callable[
            [MutationRes],
            UpdatedIntentImpulse] = lambda x: x.preserve.update.intents

        observable = rx.of(
            self.client.mutation(GaiaRequest.mutation(mutation_req)))
        return flat_mapM(observable, mutation_res)
Пример #4
0
    def preserve_delete_edges(self, impulses: List[DeleteEdgeImpulse]) -> Observable[DeletedEdgeImpulse]:
        def data_req(x):
            x.source()
            x.edge_id()

        def edge_req(x):
            x.id()
            x.data(data_req)

        delete_edges: Callable[[PreservationReq], None] = lambda x: x.delete(lambda e: e.edges(impulses, edge_req))
        mutation_req: Callable[[MutationReq], None] = lambda x: x.preserve(delete_edges)
        mutation_res: Callable[[MutationRes], DeletedEdgeImpulse] = lambda x: x.preserve.delete.edges

        observable = rx.from_callable(lambda: self.client.mutation(GaiaRequest.mutation(mutation_req)),
                                      self._scheduler)
        return flat_mapM(observable, mutation_res)
    def preserve_delete_behaviours(
        self, impulses: List[DeleteBehaviourImpulse]
    ) -> Observable[DeletedBehaviourImpulse]:
        behaviour_req = lambda x: x.id()
        delete_behaviours: Callable[
            [PreservationReq], None] = lambda x: x.delete(
                lambda e: e.behaviours(impulses, behaviour_req))
        mutation_req: Callable[[MutationReq],
                               None] = lambda x: x.preserve(delete_behaviours)
        mutation_res: Callable[
            [MutationRes],
            DeletedBehaviourImpulse] = lambda x: x.preserve.delete.behaviours

        observable = rx.of(
            self.client.mutation(GaiaRequest.mutation(mutation_req)))
        return flat_mapM(observable, mutation_res)
Пример #6
0
    def preserve_delete_behaviours(self, impulses: List[DeleteBehaviourImpulse]) -> Observable[DeletedBehaviourImpulse]:
        def data_req(x):
            x.identity_id()
            x.reference()

        def behaviour_req(x):
            x.id()
            x.data(data_req)

        delete_behaviours: Callable[[PreservationReq], None] = lambda x: x.delete(
            lambda e: e.behaviours(impulses, behaviour_req))
        mutation_req: Callable[[MutationReq], None] = lambda x: x.preserve(delete_behaviours)
        mutation_res: Callable[[MutationRes], DeletedBehaviourImpulse] = lambda x: x.preserve.delete.behaviours

        observable = rx.from_callable(lambda: self.client.mutation(GaiaRequest.mutation(mutation_req)),
                                      self._scheduler)
        return flat_mapM(observable, mutation_res)
Пример #7
0
    def preserve_update_identities(self, impulses: List[UpdateIdentityImpulse]) -> Observable[UpdatedIdentityImpulse]:
        def data_req(x):
            x.identity_id()
            x.tenant_id()
            x.qualifier()
            x.available_languages()

        def identities_req(x):
            x.id()
            x.data(data_req)

        update_identities: Callable[[PreservationReq], None] = lambda x: x.update(
            lambda e: e.identities(impulses, identities_req))
        mutation_req: Callable[[MutationReq], None] = lambda x: x.preserve(update_identities)
        mutation_res: Callable[[MutationRes], UpdatedIdentityImpulse] = lambda x: x.preserve.update.identities

        observable = rx.from_callable(lambda: self.client.mutation(GaiaRequest.mutation(mutation_req)),
                                      self._scheduler)
        return flat_mapM(observable, mutation_res)
Пример #8
0
    def preserve_create_edges(self, impulses: List[CreateEdgeImpulse]) -> Observable[CreatedEdgeImpulse]:
        def data_req(x):
            x.source()
            x.target()
            x.type()
            x.weight()
            x.edge_id()
            x.properties()

        def edge_req(x):
            x.id()
            x.data(data_req)

        create_req: Callable[[PreservationReq], None] = lambda x: x.create(lambda e: e.edges(impulses, edge_req))
        mutation_req: Callable[[MutationReq], None] = lambda x: x.preserve(create_req)
        mutation_res: Callable[[MutationRes], CreatedEdgeImpulse] = lambda x: x.preserve.create.edges

        observable = rx.from_callable(lambda: self.client.mutation(GaiaRequest.mutation(mutation_req)),
                                      self._scheduler)
        return flat_mapM(observable, mutation_res)
Пример #9
0
    def preserve_create_behaviours(self, impulses: List[CreateBehaviourImpulse]) -> Observable[CreatedBehaviourImpulse]:
        def data_req(x):
            x.identity_id()
            x.reference()
            x.qualifier()
            x.appendent()
            x.label_list()

        def behaviour_req(x):
            x.id()
            x.data(data_req)

        create_req: Callable[[PreservationReq], None] = lambda x: x.create(
            lambda e: e.behaviours(impulses, behaviour_req))
        mutation_req: Callable[[MutationReq], None] = lambda x: x.preserve(create_req)
        mutation_res: Callable[[MutationRes], CreatedBehaviourImpulse] = lambda x: x.preserve.create.behaviours

        observable = rx.from_callable(lambda: self.client.mutation(GaiaRequest.mutation(mutation_req)),
                                      self._scheduler)
        return flat_mapM(observable, mutation_res)
Пример #10
0
    def preserve_update_codes(self, impulses: List[UpdateCodeImpulse]) -> Observable[UpdatedCodeImpulse]:
        def data_req(x):
            x.identity_id()
            x.reference()
            x.qualifier()
            x.appendent()
            x.code()
            x.type()
            x.label_list()

        def code_req(x):
            x.id()
            x.data(data_req)

        update_codes: Callable[[PreservationReq], None] = lambda x: x.update(lambda e: e.codes(impulses, code_req))
        mutation_req: Callable[[MutationReq], None] = lambda x: x.preserve(update_codes)
        mutation_res: Callable[[MutationRes], UpdatedCodeImpulse] = lambda x: x.preserve.update.codes

        observable = rx.from_callable(lambda: self.client.mutation(GaiaRequest.mutation(mutation_req)),
                                      self._scheduler)
        return flat_mapM(observable, mutation_res)
Пример #11
0
    def preserve_update_fulfilments(self, impulses: List[UpdateFulfilmentImpulse]) -> Observable[
        UpdatedFulfilmentImpulse]:
        def data_req(x):
            x.identity_id()
            x.reference()
            x.qualifier()
            x.appendent()
            x.utterance()
            x.label_list()
            x.version()

        def fulfilment_req(x):
            x.id()
            x.data(data_req)

        update_fulfilments: Callable[[PreservationReq], None] = lambda x: x.update(
            lambda e: e.fulfilments(impulses, fulfilment_req))
        mutation_req: Callable[[MutationReq], None] = lambda x: x.preserve(update_fulfilments)
        mutation_res: Callable[[MutationRes], UpdatedFulfilmentImpulse] = lambda x: x.preserve.update.fulfilments

        observable = rx.from_callable(lambda: self.client.mutation(GaiaRequest.mutation(mutation_req)),
                                      self._scheduler)
        return flat_mapM(observable, mutation_res)