Allow concurrent query for async ws connections (#167)

Co-authored-by: Maxwell Flitton <[email protected]>

Author: Anton-2

src/surrealdb/connections/async_template.py

@@ -7,7 +7,7 @@
 
 class AsyncTemplate:
 
-    async def connect(self, url: str) -> Coroutine[Any, Any, None]:
+    async def connect(self, url: str) -> None:
         """Connects to a local or remote database endpoint.
 
         Args:
@@ -18,17 +18,17 @@ async def connect(self, url: str) -> Coroutine[Any, Any, None]:
             # Connect to a remote endpoint
             await db.connect('https://cloud.surrealdb.com/rpc');
         """
-        raise NotImplementedError(f"query not implemented for: {self}")
+        raise NotImplementedError(f"connect not implemented for: {self}")
 
-    async def close(self) -> Coroutine[Any, Any, None]:
+    async def close(self) -> None:
         """Closes the persistent connection to the database.
 
         Example:
             await db.close()
         """
-        raise NotImplementedError(f"query not implemented for: {self}")
+        raise NotImplementedError(f"close not implemented for: {self}")
 
-    async def use(self, namespace: str, database: str) -> Coroutine[Any, Any, None]:
+    async def use(self, namespace: str, database: str) -> None:
         """Switch to a specific namespace and database.
 
         Args:
@@ -38,9 +38,9 @@ async def use(self, namespace: str, database: str) -> Coroutine[Any, Any, None]:
         Example:
             await db.use('test', 'test')
         """
-        raise NotImplementedError(f"query not implemented for: {self}")
+        raise NotImplementedError(f"use not implemented for: {self}")
 
-    async def authenticate(self, token: str) -> Coroutine[Any, Any, None]:
+    async def authenticate(self, token: str) -> None:
         """Authenticate the current connection with a JWT token.
 
         Args:
@@ -51,15 +51,15 @@ async def authenticate(self, token: str) -> Coroutine[Any, Any, None]:
         """
         raise NotImplementedError(f"authenticate not implemented for: {self}")
 
-    async def invalidate(self) -> Coroutine[Any, Any, None]:
+    async def invalidate(self) -> None:
         """Invalidate the authentication for the current connection.
 
         Example:
             await db.invalidate()
         """
         raise NotImplementedError(f"invalidate not implemented for: {self}")
 
-    async def signup(self, vars: Dict) -> Coroutine[Any, Any, str]:
+    async def signup(self, vars: Dict) -> str:
         """Sign this connection up to a specific authentication scope.
         [See the docs](https://surrealdb.com/docs/sdk/python/methods/signup)
 
@@ -81,7 +81,7 @@ async def signup(self, vars: Dict) -> Coroutine[Any, Any, str]:
         """
         raise NotImplementedError(f"signup not implemented for: {self}")
 
-    async def signin(self, vars: Dict) -> Coroutine[Any, Any, str]:
+    async def signin(self, vars: Dict) -> str:
         """Sign this connection in to a specific authentication scope.
         [See the docs](https://surrealdb.com/docs/sdk/python/methods/signin)
 
@@ -94,9 +94,9 @@ async def signin(self, vars: Dict) -> Coroutine[Any, Any, str]:
                 password: 'surrealdb',
             })
         """
-        raise NotImplementedError(f"query not implemented for: {self}")
+        raise NotImplementedError(f"signin not implemented for: {self}")
 
-    async def let(self, key: str, value: Any) -> Coroutine[Any, Any, None]:
+    async def let(self, key: str, value: Any) -> None:
         """Assign a value as a variable for this connection.
 
         Args:
@@ -115,7 +115,7 @@ async def let(self, key: str, value: Any) -> Coroutine[Any, Any, None]:
         """
         raise NotImplementedError(f"let not implemented for: {self}")
 
-    async def unset(self, key: str) -> Coroutine[Any, Any, None]:
+    async def unset(self, key: str) -> None:
         """Removes a variable for this connection.
 
         Args:
@@ -124,11 +124,11 @@ async def unset(self, key: str) -> Coroutine[Any, Any, None]:
         Example:
             await db.unset('name')
         """
-        raise NotImplementedError(f"let not implemented for: {self}")
+        raise NotImplementedError(f"unset not implemented for: {self}")
 
     async def query(
         self, query: str, vars: Optional[Dict] = None
-    ) -> Coroutine[Any, Any, Union[List[dict], dict]]:
+    ) -> Union[List[dict], dict]:
         """Run a unset of SurrealQL statements against the database.
 
         Args:
@@ -145,7 +145,7 @@ async def query(
 
     async def select(
         self, thing: Union[str, RecordID, Table]
-    ) -> Coroutine[Any, Any, Union[List[dict], dict]]:
+    ) -> Union[List[dict], dict]:
         """Select all records in a table (or other entity),
         or a specific record, in the database.
 
@@ -158,13 +158,13 @@ async def select(
         Example:
             db.select('person')
         """
-        raise NotImplementedError(f"query not implemented for: {self}")
+        raise NotImplementedError(f"select not implemented for: {self}")
 
     async def create(
         self,
         thing: Union[str, RecordID, Table],
         data: Optional[Union[List[dict], dict]] = None,
-    ) -> Coroutine[Any, Any, Union[List[dict], dict]]:
+    ) -> Union[List[dict], dict]:
         """Create a record in the database.
 
         This function will run the following query in the database:
@@ -181,7 +181,7 @@ async def create(
 
     async def update(
         self, thing: Union[str, RecordID, Table], data: Optional[Dict] = None
-    ) -> Coroutine[Any, Any, Union[List[dict], dict]]:
+    ) -> Union[List[dict], dict]:
         """Update all records in a table, or a specific record, in the database.
 
         This function replaces the current document / record data with the
@@ -207,11 +207,11 @@ async def update(
                         },
                 })
         """
-        raise NotImplementedError(f"query not implemented for: {self}")
+        raise NotImplementedError(f"update not implemented for: {self}")
 
     async def upsert(
         self, thing: Union[str, RecordID, Table], data: Optional[Dict] = None
-    ) -> Coroutine[Any, Any, Union[List[dict], dict]]:
+    ) -> Union[List[dict], dict]:
         """Insert records into the database, or to update them if they exist.
 
 
@@ -239,7 +239,7 @@ async def upsert(
 
     async def merge(
         self, thing: Union[str, RecordID, Table], data: Optional[Dict] = None
-    ) -> Coroutine[Any, Any, Union[List[dict], dict]]:
+    ) -> Union[List[dict], dict]:
         """Modify by deep merging all records in a table, or a specific record, in the database.
 
         This function merges the current document / record data with the
@@ -267,11 +267,11 @@ async def merge(
                     })
 
         """
-        raise NotImplementedError(f"query not implemented for: {self}")
+        raise NotImplementedError(f"merge not implemented for: {self}")
 
     async def patch(
         self, thing: Union[str, RecordID, Table], data: Optional[Dict] = None
-    ) -> Coroutine[Any, Any, Union[List[dict], dict]]:
+    ) -> Union[List[dict], dict]:
         """Apply JSON Patch changes to all records, or a specific record, in the database.
 
         This function patches the current document / record data with
@@ -296,11 +296,11 @@ async def patch(
                 { 'op': "remove", "path": "/temp" },
             ])
         """
-        raise NotImplementedError(f"query not implemented for: {self}")
+        raise NotImplementedError(f"patch not implemented for: {self}")
 
     async def delete(
         self, thing: Union[str, RecordID, Table]
-    ) -> Coroutine[Any, Any, Union[List[dict], dict]]:
+    ) -> Union[List[dict], dict]:
         """Delete all records in a table, or a specific record, from the database.
 
         This function will run the following query in the database:
@@ -324,11 +324,11 @@ async def info(self) -> Coroutine[Any, Any, dict]:
         Example:
             await db.info()
         """
-        raise NotImplementedError(f"query not implemented for: {self}")
+        raise NotImplementedError(f"info not implemented for: {self}")
 
     async def insert(
         self, table: Union[str, Table], data: Union[List[dict], dict]
-    ) -> Coroutine[Any, Any, Union[List[dict], dict]]:
+    ) -> Union[List[dict], dict]:
         """
         Inserts one or multiple records in the database.
 
@@ -343,11 +343,11 @@ async def insert(
             await db.insert('person', [{ name: 'Tobie'}, { name: 'Jaime'}])
 
         """
-        raise NotImplementedError(f"query not implemented for: {self}")
+        raise NotImplementedError(f"insert not implemented for: {self}")
 
     async def insert_relation(
         self, table: Union[str, Table], data: Union[List[dict], dict]
-    ) -> Coroutine[Any, Any, Union[List[dict], dict]]:
+    ) -> Union[List[dict], dict]:
         """
         Inserts one or multiple relations in the database.
 
@@ -362,11 +362,11 @@ async def insert_relation(
             await db.insert_relation('likes', { in: person:1, id: 'object', out: person:2})
 
         """
-        raise NotImplementedError(f"query not implemented for: {self}")
+        raise NotImplementedError(f"insert_relation not implemented for: {self}")
 
     async def live(
         self, table: Union[str, Table], diff: bool = False
-    ) -> Coroutine[Any, Any, UUID]:
+    ) -> UUID:
         """Initiates a live query for a specified table name.
 
         Args:
@@ -381,11 +381,11 @@ async def live(
         Example:
             await db.live('person')
         """
-        raise NotImplementedError(f"query not implemented for: {self}")
+        raise NotImplementedError(f"live not implemented for: {self}")
 
     async def subscribe_live(
         self, query_uuid: Union[str, UUID]
-    ) -> Coroutine[Any, Any, Queue]:
+    ) -> Queue:
         """Returns a queue that receives notification messages from a running live query.
 
         Args:
@@ -397,9 +397,9 @@ async def subscribe_live(
         Example:
             await db.subscribe_live(UUID)
         """
-        raise NotImplementedError(f"query not implemented for: {self}")
+        raise NotImplementedError(f"subscribe_live not implemented for: {self}")
 
-    async def kill(self, query_uuid: Union[str, UUID]) -> Coroutine[Any, Any, None]:
+    async def kill(self, query_uuid: Union[str, UUID]) -> None:
         """Kills a running live query by it's UUID.
 
         Args:
@@ -409,4 +409,4 @@ async def kill(self, query_uuid: Union[str, UUID]) -> Coroutine[Any, Any, None]:
             await db.kill(UUID)
 
         """
-        raise NotImplementedError(f"query not implemented for: {self}")
+        raise NotImplementedError(f"kill not implemented for: {self}")