def preserve(
self, config: Callable[[PreservationReq],
None]) -> Observable[PreservationRes]:
mutation_req: Callable[[MutationReq],
None] = lambda x: x.preserve(config)
mutation_res: Callable[[MutationRes],
PreservationRes] = lambda x: x.preserve
observable = rx.of(
self.client.mutation(GaiaRequest.mutation(mutation_req)))
return mapM(observable, mutation_res)
def retrieve_codes(
self, config: Callable[[CodeReq], None]) -> Observable[CodeRes]:
code_req: Callable[[CodeReq], None] = lambda x: x.codes(config)
retrieval_req: Callable[[RetrievalReq],
None] = lambda x: x.knowledge(code_req)
query_req: Callable[[QueryReq],
None] = lambda x: x.retrieve(retrieval_req)
query_res: Callable[[QueryRes],
CodeRes] = lambda x: x.retrieve.knowledge.codes
observable = rx.of(self.client.query(GaiaRequest.query(query_req)))
return flat_mapQ(observable, query_res)
def retrieve_knowledge(
self, config: Callable[[KnowledgeReq],
None]) -> Observable[KnowledgeRes]:
retrieval_req: Callable[[RetrievalReq],
None] = lambda x: x.knowledge(config)
query_req: Callable[[QueryReq],
None] = lambda x: x.retrieve(retrieval_req)
query_res: Callable[[QueryRes],
KnowledgeRes] = lambda x: x.retrieve.knowledge
observable = rx.of(self.client.query(GaiaRequest.query(query_req)))
return mapQ(observable, query_res)
def retrieve_behaviour_execution(self, identity_id: Uuid, process_instance_id: Uuid,
config: Callable[[BehaviourExecutionDetailReq], None]) \
-> Observable[BehaviourExecutionDetailRes]:
behaviour_exec_query: Callable[[BehaviourExecutionDetailRes], None] = lambda x: x.behaviour_execution(
identity_id, process_instance_id, config)
retrieval_req: Callable[[RetrievalReq], None] = lambda x: x.experience(behaviour_exec_query)
query_req: Callable[[QueryReq], None] = lambda x: x.retrieve(retrieval_req)
query_res: Callable[[QueryRes], BehaviourExecutionDetailRes] = lambda \
x: x.retrieve.experience.behaviour_execution
observable = rx.from_callable(lambda: self.client.query(GaiaRequest.query(query_req)), self._scheduler)
return mapQ(observable, query_res)
def retrieve_experience(
self, config: Callable[[ExperienceReq],
None]) -> Observable[ExperienceRes]:
retrieval_req: Callable[[RetrievalReq],
None] = lambda x: x.experience(config)
query_req: Callable[[QueryReq],
None] = lambda x: x.retrieve(retrieval_req)
query_res: Callable[[QueryRes],
ExperienceRes] = lambda x: x.retrieve.experience
observable = rx.of(self.client.query(GaiaRequest.query(query_req)))
return mapQ(observable, query_res)
def introspect_skills(
self, config: Callable[[SkillIntrospectionReq], None]
) -> Observable[SkillIntrospectionRes]:
introspect_skills: Callable[[IntrospectionReq],
None] = lambda x: x.skills(config)
query_req: Callable[[QueryReq],
None] = lambda x: x.introspect(introspect_skills)
query_res: Callable[
[QueryRes], SkillIntrospectionRes] = lambda x: x.introspect.skills
observable = rx.of(self.client.query(GaiaRequest.query(query_req)))
return mapQ(observable, query_res)
def retrieve_behaviour_executions(self, identity_id: Uuid, config: Callable[[BehaviourExecutionReq], None],
limit: int = None, offset: int = None, startDate: str = None, endDate: str = None) \
-> Observable[BehaviourExecutionRes]:
executions_req: Callable[[BehaviourExecutionReq], None] = lambda x: x.behaviour_executions(identity_id, limit,
offset, startDate,
endDate, config)
retrieval_req: Callable[[RetrievalReq], None] = lambda x: x.experience(executions_req)
query_req: Callable[[QueryReq], None] = lambda x: x.retrieve(retrieval_req)
query_res: Callable[[QueryRes], BehaviourExecutionRes] = lambda x: x.retrieve.experience.behaviour_executions
observable = rx.from_callable(lambda: self.client.query(GaiaRequest.query(query_req)), self._scheduler)
return flat_mapQ(observable, query_res)
def retrieve_prompts(
self, config: Callable[[PromptReq],
None]) -> Observable[PromptRes]:
prompts_req: Callable[[PromptReq], None] = lambda x: x.prompts(config)
retrieval_req: Callable[[RetrievalReq],
None] = lambda x: x.knowledge(prompts_req)
query_req: Callable[[QueryReq],
None] = lambda x: x.retrieve(retrieval_req)
query_res: Callable[[QueryRes],
PromptRes] = lambda x: x.retrieve.knowledge.prompts
observable = rx.of(self.client.query(GaiaRequest.query(query_req)))
return flat_mapQ(observable, query_res)
def perceive_data(
self,
impulse: PerceiveDataImpulse) -> Observable[PerceivedImpulse]:
perceive_data_req: Callable[
[PerceptionReq],
None] = lambda x: x.perceive_data(impulse, lambda e: e.id())
mutation_req: Callable[[MutationReq],
None] = lambda x: x.perceive(perceive_data_req)
mutation_res: Callable[
[MutationRes],
PerceivedImpulse] = lambda x: x.perceive.perceive_data
observable = rx.of(
self.client.mutation(GaiaRequest.mutation(mutation_req)))
return mapM(observable, mutation_res)
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)
def retrieve_behaviour(
self, config: Callable[[BehaviourReq],
None]) -> Observable[BehaviourRes]:
behaviour_req: Callable[[BehaviourReq],
None] = lambda x: x.behaviours(config)
retrieval_req: Callable[[RetrievalReq],
None] = lambda x: x.knowledge(behaviour_req)
query_req: Callable[[QueryReq],
None] = lambda x: x.retrieve(retrieval_req)
query_res: Callable[
[QueryRes],
BehaviourRes] = lambda x: x.retrieve.knowledge.behaviours
observable = rx.of(self.client.query(GaiaRequest.query(query_req)))
return flat_mapQ(observable, query_res)
def retrieve_fulfilments(
self, config: Callable[[FulfilmentReq],
None]) -> Observable[FulfilmentRes]:
fulfilment_req: Callable[[FulfilmentReq],
None] = lambda x: x.fulfilments(config)
retrieval_req: Callable[[RetrievalReq],
None] = lambda x: x.knowledge(fulfilment_req)
query_req: Callable[[QueryReq],
None] = lambda x: x.retrieve(retrieval_req)
query_res: Callable[
[QueryRes],
FulfilmentRes] = lambda x: x.retrieve.knowledge.fulfilments
observable = rx.of(self.client.query(GaiaRequest.query(query_req)))
return flat_mapQ(observable, query_res)
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)
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)
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)
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)
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)
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)
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)
def practice(self, config: Callable[[PracticeReq], None]) -> Observable[PracticeRes]:
mutation_req:Callable[[MutationReq], None] = lambda x: x.practice(config)
mutation_res: Callable[[MutationRes], PracticeRes] = lambda x: x.practice
observable = rx.from_callable(lambda: self.client.query(GaiaRequest.mutation(mutation_req)), self._scheduler)
return mapM(observable, mutation_res)
def retrieve(self, config: Callable[[RetrievalReq], None]) -> Observable[RetrievalRes]:
query_req: Callable[[QueryReq], None] = lambda x: x.retrieve(config)
query_res: Callable[[QueryRes], RetrievalRes] = lambda x: x.retrieve
observable = rx.from_callable(lambda: self.client.query(GaiaRequest.query(query_req)), self._scheduler)
return mapQ(observable, query_res)
def introspect(self, config: Callable[[IntrospectionReq], None]) -> Observable[IntrospectionRes]:
query_req: Callable[[QueryReq], None] = lambda x: x.introspect(config)
query_res: Callable[[QueryRes], IntrospectionRes] = lambda x: x.introspect
observable = rx.from_callable(lambda: self.client.query(GaiaRequest.query(query_req)), self._scheduler)
return mapQ(observable, query_res)
