Merge pull request #38 from NavAbility/33/async_calls

Async calls

Author: GearsAD

setup.py

@@ -36,5 +36,6 @@
         "black==21.9b0",
         "flake8==4.0.1",
         "pytest==6.2.5",
+        "pytest-asyncio==0.18.1",
     ],
 )

src/navability/entities/factor/__init__.py

@@ -30,24 +30,38 @@ def mutate(self, options: MutationOptions):
 class NavAbilityWebsocketClient(NavAbilityClient):
     def __init__(self, url: str = "wss://api.d1.navability.io/graphql") -> None:
         super().__init__()
-        transport = WebsocketsTransport(url=url)
-        self.client = GQLCLient(transport=transport, fetch_schema_from_transport=True)
+        self.transport = WebsocketsTransport(url=url)
 
-    def query(self, options: QueryOptions):
-        return self.client.execute(options.query, options.variables)
+    async def query(self, options: QueryOptions):
+        async with GQLCLient(
+            transport=self.transport, fetch_schema_from_transport=False
+        ) as client:
+            result = await client.execute(options.query, options.variables)
+            return result
 
-    def mutate(self, options: MutationOptions):
-        return self.client.execute(options.mutation, options.variables)
+    async def mutate(self, options: MutationOptions):
+        async with GQLCLient(
+            transport=self.transport, fetch_schema_from_transport=False
+        ) as client:
+            result = await client.execute(options.mutation, options.variables)
+            return result
 
 
 class NavAbilityHttpsClient(NavAbilityClient):
     def __init__(self, url: str = "https://api.d1.navability.io") -> None:
         super().__init__()
-        transport = AIOHTTPTransport(url=url)
-        self.client = GQLCLient(transport=transport, fetch_schema_from_transport=True)
-
-    def query(self, options: QueryOptions):
-        return self.client.execute(options.query, options.variables)
-
-    def mutate(self, options: MutationOptions):
-        return self.client.execute(options.mutation, options.variables)
+        self.transport = AIOHTTPTransport(url=url)
+
+    async def query(self, options: QueryOptions):
+        async with GQLCLient(
+            transport=self.transport, fetch_schema_from_transport=True
+        ) as client:
+            result = await client.execute(options.query, options.variables)
+            return result
+
+    async def mutate(self, options: MutationOptions):
+        async with GQLCLient(
+            transport=self.transport, fetch_schema_from_transport=True
+        ) as client:
+            result = await client.execute(options.mutation, options.variables)
+            return result

src/navability/entities/navabilityclient.py

@@ -34,40 +34,39 @@
 logger = logging.getLogger(__name__)
 
 
-def addFactor(navAbilityClient: NavAbilityClient, client: Client, f: Factor):
-    return navAbilityClient.mutate(
+async def addFactor(navAbilityClient: NavAbilityClient, client: Client, f: Factor):
+    result = await navAbilityClient.mutate(
         MutationOptions(
             gql(GQL_ADDFACTOR),
             {"factor": {"client": client.dump(), "packedData": f.dumps()}},
         )
-    )["addFactor"]
+    )
+    return result["addFactor"]
 
 
-def listFactors(
+async def listFactors(
     navAbilityClient: NavAbilityClient,
     client: Client,
     regexFilter: str = ".*",
     tags: List[str] = None,
     solvable: int = 0,
 ) -> List[str]:
-    return [
-        v.label
-        for v in getFactors(
-            navAbilityClient,
-            client,
-            detail=QueryDetail.SKELETON,
-            regexFilter=regexFilter,
-            tags=tags,
-            solvable=solvable,
-        )
-    ]
+    factors = await getFactors(
+        navAbilityClient,
+        client,
+        detail=QueryDetail.SKELETON,
+        regexFilter=regexFilter,
+        tags=tags,
+        solvable=solvable,
+    )
+    return [f.label for f in factors]
 
 
 # Alias
 lsf = listFactors
 
 
-def getFactors(
+async def getFactors(
     navAbilityClient: NavAbilityClient,
     client: Client,
     detail: QueryDetail = QueryDetail.SKELETON,
@@ -86,7 +85,7 @@ def getFactors(
         "fields_full": detail == QueryDetail.FULL,
     }
     logger.debug(f"Query params: {params}")
-    res = navAbilityClient.query(
+    res = await navAbilityClient.query(
         QueryOptions(gql(GQL_FRAGMENT_FACTORS + GQL_GETFACTORS), params)
     )
     logger.debug(f"Query result: {res}")
@@ -116,11 +115,11 @@ def getFactors(
     ]
 
 
-def getFactor(navAbilityClient: NavAbilityClient, client: Client, label: str):
+async def getFactor(navAbilityClient: NavAbilityClient, client: Client, label: str):
     params = client.dump()
     params["label"] = label
     logger.debug(f"Query params: {params}")
-    res = navAbilityClient.query(
+    res = await navAbilityClient.query(
         QueryOptions(gql(GQL_FRAGMENT_FACTORS + GQL_GETFACTOR), params)
     )
     logger.debug(f"Query result: {res}")

src/navability/services/factor.py

@@ -5,7 +5,8 @@
 from navability.entities.navabilityclient import MutationOptions, NavAbilityClient
 
 
-def solveSession(navAbilityClient: NavAbilityClient, client: Client):
-    return navAbilityClient.mutate(
+async def solveSession(navAbilityClient: NavAbilityClient, client: Client):
+    result = await navAbilityClient.mutate(
         MutationOptions(gql(GQL_SOLVESESSION), {"client": client.dump()})
-    )["solveSession"]
+    )
+    return result["solveSession"]

src/navability/services/solve.py

@@ -5,16 +5,16 @@
 from navability.entities.statusmessage import StatusMessageSchema
 
 
-def getStatusMessages(navAbilityClient: NavAbilityClient, id: str):
-    statusMessages = navAbilityClient.query(
+async def getStatusMessages(navAbilityClient: NavAbilityClient, id: str):
+    statusMessages = await navAbilityClient.query(
         QueryOptions(gql(GQL_GETSTATUSMESSAGES), {"id": id})
     )
     schema = StatusMessageSchema(many=True)
     return schema.load(statusMessages["statusMessages"])
 
 
-def getStatusLatest(navAbilityClient: NavAbilityClient, id: str):
-    statusMessages = navAbilityClient.query(
+async def getStatusLatest(navAbilityClient: NavAbilityClient, id: str):
+    statusMessages = await navAbilityClient.query(
         QueryOptions(gql(GQL_GETSTATUSLATEST), {"id": id})
     )
     schema = StatusMessageSchema()

src/navability/services/status.py

@@ -5,7 +5,7 @@
 from navability.services import getStatusLatest
 
 
-def waitForCompletion(
+async def waitForCompletion(
     navAbilityClient: NavAbilityClient,
     requestIds: List[str],
     maxSeconds: int = 60,
@@ -21,13 +21,13 @@ def waitForCompletion(
             Defaults to "Complete".
     """
     wait_time = maxSeconds
-    while any(
-        [
-            getStatusLatest(navAbilityClient, res).state != expectedStatus
-            for res in requestIds
-        ]
-    ):
+    tasksInProgress = True
+    while tasksInProgress:
         time.sleep(2)
         wait_time -= 2
         if wait_time <= 0:
             raise Exception(exceptionMessage)
+        tasksInProgress = False
+        for requestId in requestIds:
+            result = await getStatusLatest(navAbilityClient, requestId)
+            tasksInProgress |= result.state != expectedStatus

src/navability/services/utils.py

@@ -34,40 +34,40 @@
 logger = logging.getLogger(__name__)
 
 
-def addVariable(navAbilityClient: NavAbilityClient, client: Client, v: Variable):
-    return navAbilityClient.mutate(
+async def addVariable(navAbilityClient: NavAbilityClient, client: Client, v: Variable):
+    result = await navAbilityClient.mutate(
         MutationOptions(
             gql(GQL_ADDVARIABLE),
             {"variable": {"client": client.dump(), "packedData": v.dumpsPacked()}},
         )
-    )["addVariable"]
+    )
+    return result["addVariable"]
 
 
-def listVariables(
+async def listVariables(
     navAbilityClient: NavAbilityClient,
     client: Client,
     regexFilter: str = ".*",
     tags: List[str] = None,
     solvable: int = 0,
 ) -> List[str]:
-    return [
-        v.label
-        for v in getVariables(
-            navAbilityClient,
-            client,
-            detail=QueryDetail.SKELETON,
-            regexFilter=regexFilter,
-            tags=tags,
-            solvable=solvable,
-        )
-    ]
+    variables = await getVariables(
+        navAbilityClient,
+        client,
+        detail=QueryDetail.SKELETON,
+        regexFilter=regexFilter,
+        tags=tags,
+        solvable=solvable,
+    )
+    result = [v.label for v in variables]
+    return result
 
 
 # Alias
 ls = listVariables
 
 
-def getVariables(
+async def getVariables(
     navAbilityClient: NavAbilityClient,
     client: Client,
     detail: QueryDetail = QueryDetail.SKELETON,
@@ -86,7 +86,7 @@ def getVariables(
         "fields_full": detail == QueryDetail.FULL,
     }
     logger.debug(f"Query params: {params}")
-    res = navAbilityClient.query(
+    res = await navAbilityClient.query(
         QueryOptions(gql(GQL_FRAGMENT_VARIABLES + GQL_GETVARIABLES), params)
     )
     logger.debug(f"Query result: {res}")
@@ -116,11 +116,11 @@ def getVariables(
     ]
 
 
-def getVariable(navAbilityClient: NavAbilityClient, client: Client, label: str):
+async def getVariable(navAbilityClient: NavAbilityClient, client: Client, label: str):
     params = client.dump()
     params["label"] = label
     logger.debug(f"Query params: {params}")
-    res = navAbilityClient.query(
+    res = await navAbilityClient.query(
         QueryOptions(gql(GQL_FRAGMENT_VARIABLES + GQL_GETVARIABLE), params)
     )
     logger.debug(f"Query result: {res}")

src/navability/services/variable.py

@@ -65,7 +65,7 @@ def client(env_config) -> Client:
 
 
 @pytest.fixture(scope="module")
-def example_graph(navability_https_client: NavAbilityClient, client: Client):
+async def example_graph(navability_https_client: NavAbilityClient, client: Client):
     variables = [
         Variable("x0", VariableType.Pose2.value),
         Variable("x1", VariableType.Pose2.value),
@@ -105,23 +105,23 @@ def example_graph(navability_https_client: NavAbilityClient, client: Client):
     ]
     # Variables
     result_ids = [
-        addVariable(navability_https_client, client, v) for v in variables
-    ] + [addFactor(navability_https_client, client, f) for f in factors]
+        await addVariable(navability_https_client, client, v) for v in variables
+    ] + [await addFactor(navability_https_client, client, f) for f in factors]
 
     logging.info(f"[Fixture] Adding variables and factors, waiting for completion")
 
-    waitForCompletion(navability_https_client, result_ids, maxSeconds=120)
+    await waitForCompletion(navability_https_client, result_ids, maxSeconds=120)
 
     return (navability_https_client, client, variables, factors)
 
 
 @pytest.fixture(scope="module")
-def example_graph_solved(example_graph):
+async def example_graph_solved(example_graph):
     """Get the graph after it has been solved.
     NOTE this changes the graph, so tests need to be defensive.
     """
     navability_https_client, client, variables, factors = example_graph
     logging.info(f"[Fixture] Solving graph, client = {client.dumps()}")
-    requestId = solveSession(navability_https_client, client)
-    waitForCompletion(navability_https_client, [requestId], maxSeconds=180)
+    requestId = await solveSession(navability_https_client, client)
+    await waitForCompletion(navability_https_client, [requestId], maxSeconds=180)
     return (navability_https_client, client, variables, factors)

tests/conftest.py

@@ -1,16 +1,22 @@
+import asyncio
+
+import pytest
+
 from navability.entities import Client
 from navability.services import lsf  # getFactor
 
 
-def test_lsf(example_graph):
+@pytest.mark.asyncio
+async def test_lsf(example_graph):
     navability_client, client, variables, factors = example_graph
-    assert set(lsf(navability_client, client)) == set([f.label for f in factors])
+    assert set(await lsf(navability_client, client)) == set([f.label for f in factors])
 
 
-def test_lsf_no_session(example_graph):
+@pytest.mark.asyncio
+async def test_lsf_no_session(example_graph):
     navability_client, client, variables, factors = example_graph
     noSessionClient = Client(client.userId, client.robotId, "DoesntExist")
-    assert lsf(navability_client, noSessionClient) == []
+    assert await lsf(navability_client, noSessionClient) == []
 
 
 # def test_getFactor(example_graph):
@@ -19,3 +25,10 @@ def test_lsf_no_session(example_graph):
 #         getFactor(navability_client, client, factors[0].label).label
 #         == variables[0].label
 #     )
+
+# Redefining the event loop so we can we can use module-level fixtures.
+@pytest.fixture(scope="module")
+def event_loop():
+    loop = asyncio.get_event_loop()
+    yield loop
+    loop.close()