feat/added_new_async_driver

- Added the Async SQLite driver
- Added the Async Postgres driver
- Added the Async UnqLite driver

Author: JCGCosta

.gitignore

@@ -2,4 +2,5 @@
 /.idea
 /tmp
 /samples
-test.py
+test.py
+energy_members.unqlite

CHANGELOG.txt

@@ -1,7 +1,10 @@
 Change Log
 ===============
-VERSION="0.0.15"
-LAST_UPDATE="11/11/2025"
+VERSION="0.0.16"
+LAST_UPDATE="12/11/2025"
 ------------------
-- Added the Async SQLite driver requirement
+- Readme updates
+- Added the Async SQLite driver
+- Added the Async Postgres driver
+- Added the Async UnqLite driver
 ------------------

OntologicalFramework/OntologyToAPI-BusinessModel.ttl

@@ -65,7 +65,7 @@ xsd:duration rdf:type rdfs:Datatype .
                            owl:InverseFunctionalProperty ;
                   rdfs:domain :BusinessModel ;
                   rdfs:range <http://www.cedri.com/SmartLEM-Metadata#Metadata> ;
-                  rdfs:comment "The metadata required to acheive some goal of a business model" .
+                  rdfs:comment "The metadata required to achieve some goal of a business model" .
 
 
 #################################################################

OntologyToAPI/core/Connectors/IndentifyConnector.py

@@ -2,12 +2,22 @@
 from OntologyToAPI.core.Connectors.Stateless.APIConnection import APIConnection
 from OntologyToAPI.core.Connectors.Stateless.MYSQLConnection import MySQLConnection
 from OntologyToAPI.core.Connectors.Stateless.MongoDBConnection import MongoDBConnection
+from OntologyToAPI.core.Connectors.Stateless.SQLITEConnection import SQLiteConnection
+from OntologyToAPI.core.Connectors.Stateless.POSTGRESQLConnection import PostgreSQLConnection
+from OntologyToAPI.core.Connectors.Stateless.UNQLITEConnection import UnQLiteConnection
 
 SUPPORTED_CONNECTIONS = {
     "API": APIConnection,
+    "SOCKET": SocketConnection,
+
+    # SQL Databases
     "MYSQL": MySQLConnection,
+    "SQLITE": SQLiteConnection,
+    "POSTGRESQL": PostgreSQLConnection,
+
+    # NoSQL Databases
     "MONGODB": MongoDBConnection,
-    "Socket": SocketConnection
+    "UNQLITE": UnQLiteConnection
 }
 
 def identifyConnector(CommunicationTechnology, args):

OntologyToAPI/core/Connectors/Stateless/POSTGRESQLConnection.py

@@ -0,0 +1,27 @@
+from sqlalchemy import text, create_engine
+from sqlalchemy.ext.asyncio import create_async_engine
+from datetime import datetime
+
+async def datetime_handler(row, keys):
+    return {
+        key: (val.isoformat() if isinstance(val, datetime) else val)
+        for key, val in zip(keys, row)
+    }
+
+class PostgreSQLConnection:
+    def __init__(self, args):
+        self.engine = create_async_engine(args["hasConnectionString"])
+
+    async def exec_query(self, query: str):
+        async with self.engine.connect() as connection:
+            result = await connection.execute(text(query))
+            rows = result.fetchall()
+            keys = result.keys()
+        return [await datetime_handler(row, keys) for row in rows]
+
+    async def exec_insert(self, query: str):
+        async with self.engine.begin() as connection:
+            await connection.execute(text(query))
+            result = await connection.execute(text("SELECT LAST_INSERT_ID() AS id"))
+            row = result.fetchone()
+            return row.id

OntologyToAPI/core/Connectors/Stateless/SQLITEConnection.py

@@ -0,0 +1,27 @@
+from sqlalchemy import text, create_engine
+from sqlalchemy.ext.asyncio import create_async_engine
+from datetime import datetime
+
+async def datetime_handler(row, keys):
+    return {
+        key: (val.isoformat() if isinstance(val, datetime) else val)
+        for key, val in zip(keys, row)
+    }
+
+class SQLiteConnection:
+    def __init__(self, args):
+        self.engine = create_async_engine(args["hasConnectionString"])
+
+    async def exec_query(self, query: str):
+        async with self.engine.connect() as connection:
+            result = await connection.execute(text(query))
+            rows = result.fetchall()
+            keys = result.keys()
+        return [await datetime_handler(row, keys) for row in rows]
+
+    async def exec_insert(self, query: str):
+        async with self.engine.begin() as connection:
+            await connection.execute(text(query))
+            result = await connection.execute(text("SELECT LAST_INSERT_ID() AS id"))
+            row = result.fetchone()
+            return row.id

OntologyToAPI/core/Connectors/Stateless/UNQLITEConnection.py

@@ -0,0 +1,87 @@
+import asyncio
+import json
+import logging
+from urllib.parse import urlparse, unquote
+from typing import Any, Dict, List
+from unqlite import UnQLite
+
+class UnQLiteConnection:
+    def __init__(self, args: Dict[str, str]):
+        raw = args.get("hasConnectionString")
+        if not raw:
+            raise ValueError("Missing 'hasConnectionString' in args.")
+        parsed = urlparse(raw)
+
+        if parsed.scheme not in ("unqlite+asyncio",):
+            raise ValueError(f"Unsupported scheme: {parsed.scheme}. Use 'unqlite+asyncio'.")
+
+        path = unquote(parsed.netloc or "")
+        if not path:
+            raise ValueError(f"Empty database path in connection string.")
+        if path == "/:memory:":
+            db_path = ":memory:"
+        else:
+            db_path = path
+
+        try:
+            self._db = UnQLite(db_path)
+        except Exception as e:
+            raise Exception(f"Could not open UnQLite database at '{db_path}': {e}")
+
+    # ---------- public API ----------
+
+    async def exec_query(self, collection_query: str) -> List[Dict[str, Any]]:
+        collection, filt = self._parse_collection_query(collection_query)
+        docs = await asyncio.to_thread(self._get_collection_docs, collection)
+        return self._filter_docs(docs, filt)
+
+    # ---------- internals (sync) ----------
+
+    def _parse_collection_query(self, collection_query: str):
+        try:
+            collection, json_str = collection_query.split(".", 1)
+            filt = json.loads(json_str)
+            if not isinstance(filt, dict):
+                raise ValueError("Filter JSON must be an object.")
+            return collection, filt
+        except Exception as e:
+            raise ValueError(f"Invalid collection_query format; expected 'collection.{{...}}'. Error: {e}")
+
+    def _get_collection_docs(self, collection: str) -> List[Dict[str, Any]]:
+        try:
+            if collection not in self._db:
+                return []
+            data = self._db[collection]
+            if isinstance(data, (bytes, str)):
+                data = json.loads(data)
+            if isinstance(data, list):
+                return [d for d in data if isinstance(d, dict)]
+            if isinstance(data, dict):
+                return [data]
+            return []
+        except Exception as e:
+            logging.error(f"Error reading collection '{collection}': {e}")
+            return []
+
+    def _persist_collection(self, collection: str, docs: List[Dict[str, Any]]) -> None:
+        try:
+            self._db[collection] = json.dumps(docs, separators=(",", ":"))
+        except Exception as e:
+            logging.error(f"Error writing collection '{collection}': {e}")
+            raise
+
+    def _filter_docs(self, docs: List[Dict[str, Any]], filt: Dict[str, Any]) -> List[Dict[str, Any]]:
+        def match(doc: Dict[str, Any]) -> bool:
+            for key, cond in filt.items():
+                val = doc.get(key, None)
+                if isinstance(cond, dict):
+                    for op, rhs in cond.items():
+                        if op == "$gt" and not (val is not None and val > rhs): return False
+                        if op == "$lt" and not (val is not None and val < rhs): return False
+                        if op == "$eq" and not (val == rhs): return False
+                        # extend here with $gte, $lte, $ne, $in, etc.
+                else:
+                    if val != cond:
+                        return False
+            return True
+        return [d for d in docs if match(d)]

README.md

@@ -21,6 +21,9 @@ The ontological framework is composed of four main modules:
   - **ExternalCode Ontology Module:** This module has all the technical details to connect to an external code, it also adds the possibility to dynamically require python packages.
   - **Communications Ontology Module:** This module describes the communication technologies that can be used to fetch the data of some metadata in multiple forms (e. g).
 
+> A full manual on how to extend your own ontologies using the OntologyToAPI framework is still in development, but you can check the examples provided at the samples repository to get started at https://github.com/JCGCosta/OntologyToAPISamples
+
+
 > From now on you must be ready to go and create your own ontological specification importing the [Ontology Modules](https://github.com/JCGCosta/OntologyToAPI/tree/master/OntologicalFramework) and extending it. You can do this by using the Protégé ontology editor (https://protege.stanford.edu/). Or if you prefer you can use any text editor to create your ontology files in the supported formats (.ttl, .rdf, .owl).
 
 ### Step 1: Installing the Package
@@ -31,7 +34,6 @@ pip install -U ontologytoapi
 
 ### Step 2: Running
 
-- If you want to do a quick test we provided some .ttl samples at the following repository: https://github.com/JCGCosta/OntologyToAPISamples
 - With your metadata and business models ontologies implemented you can generate your API by having the following python file as an entry point:
 
 ```python
@@ -50,3 +52,25 @@ if __name__ == "__main__":
     api_app = APIGen.generate_api_routes()
     uvicorn.run(api_app, host="127.0.0.1", port=5000)
 ```
+
+## Supported communication technologies are (Currently):
+
+#### Stateful Connections
+- "SOCKET" - For Socket connections using asyncio streams
+
+#### Stateless Connections
+- "API" - For REST APIs using requests driver
+- "MYSQL" - For MySQL Databases using aiomysql driver
+- "SQLITE" - For SQLite Databases using aiosqlite driver
+- "POSTGRESQL" - For PostgreSQL Databases using asyncpg driver
+- "MONGODB" - For MongoDB Databases using motor driver
+- "UNQLITE" - For UnQLite Databases using unqlite+asyncio driver
+
+## Next Steps: 
+
+Next steps involve extending the support for new communication technologies.
+- "FILE" - For File operations using aiofiles driver
+- "WEBSOCKET" - For WebSocket connections using websockets driver
+- "MQTT" - For MQTT connections using asyncio-mqtt driver
+- "REDIS" - For Redis Databases using aioredis driver
+- "CASSANDRA" - For Cassandra Databases using cassandra-driver with asyncio support

requirements.txt

@@ -10,6 +10,8 @@ python-multipart~=0.0.20
 
 # Dependencies for async operations in specific databases
 
+asyncio~=4.0.0 # Core async library
+asyncpg~=0.27.0 # Async PostgreSQL driver
 aiomysql~=0.2.0 # Async MySQL driver
 aiosqlite~=0.21.0 # Async SQLite driver
 motor~=3.7.1 # Async MongoDB driver