ontologytoapi 0.0.5__tar.gz

ontologytoapi-0.0.5/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Julio César G. Costa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ontologytoapi-0.0.5/MANIFEST.in

@@ -0,0 +1,6 @@
+include README.md
+include LICENSE
+include requirements.txt
+include CHANGELOG.md
+
+global-include *.py

ontologytoapi-0.0.5/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: ontologytoapi
+Version: 0.0.5
+Summary: Multi purpose API Generator based on an Ontology Framework.
+Home-page: https://github.com/JCGCosta/OntologyToAPI
+Author: Júlio César Guimarães Costa
+Author-email: juliocesargcosta123@gmail.com
+License: MIT License
+Keywords: Ontology,API
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Microsoft :: Windows :: Windows 11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: SQLAlchemy
+Requires-Dist: pydantic
+Requires-Dist: requests
+Requires-Dist: pymongo
+Requires-Dist: rdflib
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: aiomysql
+Requires-Dist: motor
+Requires-Dist: aiofiles
+Requires-Dist: python-multipart
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+# OntologyToAPI
+> This project is an ontology-driven API generator designed for 
+> backend development by transforming structured domain 
+> knowledge into fully functional APIs. The tool accepts ontologies 
+> specified in Turtle (.ttl), Resource Description Framework (.rdf)
+> and Web Ontology Language (.owl).
+
+> [![Publish to PyPI and TestPyPI](https://github.com/JCGCosta/OntologyToAPI/actions/workflows/python-publish.yml/badge.svg)](https://github.com/JCGCosta/OntologyToAPI/actions/workflows/python-publish.yml)
+
+
+## Ontological Framework:
+
+- The following classes, relationships and data properties serve as a semantic blueprint for both metadata and business models.
+
+<img src="https://github.com/JCGCosta/OntologyToAPI/blob/master/OntologicalFramework.jpg?raw=true" alt="AbstractOntologyClasses" title="Abstract Ontology Classes.">
+
+The ontological framework is composed of two main modules:
+
+  - **Metadata Ontology Module:** This module defines the essential classes and properties required to describe the metadata and its sources (e.g. Query to be executed on the CommunicationTechnology).
+  - **BusinessModel Ontology Module:** This module captures the specific business logic and rules governing some operation, it requires an ExternalCode concretization, and it can require any metadata or parameter (To be sent in the API request).
+  - **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).
+
+> From now on you must be ready to go and create your own ontological specification importing the Ontology Modules 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
+
+```bash
+# Now inside the environment install the python package
+pip install ontologytoapi
+```
+
+
+### Step 2: Running
+
+- If you want to see a quick ontology sample in .ttl please access the following link: https://github.com/JCGCosta/OntologyToAPI/tree/master/samples
+- With you metadata and business models ontologies implemented you can generate your API by having the following python file as an entry point:
+
+```python
+import uvicorn
+from core.APIGenerator import Generator
+
+if __name__ == "__main__":
+    APIGen = Generator(showLogs=True)
+    APIGen.load_ontologies(paths=[
+        "Your/Metadata/Ontology/.ttl.owl.rdf"
+    ])
+    APIGen.load_ontologies(paths=[
+        "Your/BusinessModel/Ontology/.ttl.owl.rdf"
+    ])
+    APIGen.serialize_ontologies()
+    api_app = APIGen.generate_api_routes()
+    uvicorn.run(api_app, host="127.0.0.1", port=5000)
+```
+
+
+Change Log
+===============
+0.0.5 (27/10/2025)
+------------------
+FIRST RELEASE
+- First fixes on README file.
+- Added Ontological Framework diagram.
+- Added ontology concrete sample.
+------------------
+

ontologytoapi-0.0.5/README.md

@@ -0,0 +1,54 @@
+# OntologyToAPI
+> This project is an ontology-driven API generator designed for 
+> backend development by transforming structured domain 
+> knowledge into fully functional APIs. The tool accepts ontologies 
+> specified in Turtle (.ttl), Resource Description Framework (.rdf)
+> and Web Ontology Language (.owl).
+
+> [![Publish to PyPI and TestPyPI](https://github.com/JCGCosta/OntologyToAPI/actions/workflows/python-publish.yml/badge.svg)](https://github.com/JCGCosta/OntologyToAPI/actions/workflows/python-publish.yml)
+
+
+## Ontological Framework:
+
+- The following classes, relationships and data properties serve as a semantic blueprint for both metadata and business models.
+
+<img src="https://github.com/JCGCosta/OntologyToAPI/blob/master/OntologicalFramework.jpg?raw=true" alt="AbstractOntologyClasses" title="Abstract Ontology Classes.">
+
+The ontological framework is composed of two main modules:
+
+  - **Metadata Ontology Module:** This module defines the essential classes and properties required to describe the metadata and its sources (e.g. Query to be executed on the CommunicationTechnology).
+  - **BusinessModel Ontology Module:** This module captures the specific business logic and rules governing some operation, it requires an ExternalCode concretization, and it can require any metadata or parameter (To be sent in the API request).
+  - **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).
+
+> From now on you must be ready to go and create your own ontological specification importing the Ontology Modules 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
+
+```bash
+# Now inside the environment install the python package
+pip install ontologytoapi
+```
+
+
+### Step 2: Running
+
+- If you want to see a quick ontology sample in .ttl please access the following link: https://github.com/JCGCosta/OntologyToAPI/tree/master/samples
+- With you metadata and business models ontologies implemented you can generate your API by having the following python file as an entry point:
+
+```python
+import uvicorn
+from core.APIGenerator import Generator
+
+if __name__ == "__main__":
+    APIGen = Generator(showLogs=True)
+    APIGen.load_ontologies(paths=[
+        "Your/Metadata/Ontology/.ttl.owl.rdf"
+    ])
+    APIGen.load_ontologies(paths=[
+        "Your/BusinessModel/Ontology/.ttl.owl.rdf"
+    ])
+    APIGen.serialize_ontologies()
+    api_app = APIGen.generate_api_routes()
+    uvicorn.run(api_app, host="127.0.0.1", port=5000)
+```

ontologytoapi-0.0.5/core/APIGenerator.py

@@ -0,0 +1,99 @@
+from fastapi import FastAPI, UploadFile
+from fastapi.responses import RedirectResponse
+from typing import List
+import pprint, logging
+from pathlib import Path
+from inspect import Signature, Parameter
+from Settings import auto_config as cfg
+from datetime import date
+
+from core.Utility import *
+from core.Ontology import Ontology
+
+UPLOAD_DIR = Path(cfg.UPLOAD_DIR)
+UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
+
+def create_metadata_handler(connector, query: str, name: str):
+    async def handler():
+        try:
+            result = await connector.exec_query(query)
+            return result
+        except Exception as e:
+            logging.exception(f"Error running query for {name}")
+            return {"error": str(e)}
+    return handler
+
+def create_business_model_handler(required_metadata: list, requiresParameters:dict, external_function):
+    async def handler(**kwargs):
+        aggregated_res = {"FromParameters": {**kwargs}, "FromMetadata": {}, "UPLOAD_DIR": UPLOAD_DIR}
+        for md in required_metadata:
+            pkg, name = md.name.split(":")
+            try:
+                aggregated_res["FromMetadata"][name] = await md.hasSource.comm_technology.exec_query(md.hasSource.query)
+            except Exception as e:
+                logging.exception(f"Error running query for {name}")
+                return {"error": str(e)}
+        result = await external_function(aggregated_res)
+        return result
+    params = []
+    for pl, pt in requiresParameters.items(): params.append(Parameter(pl, Parameter.POSITIONAL_OR_KEYWORD, default=None, annotation=pt))
+    handler.__signature__ = Signature(parameters=params)
+    return handler
+
+class APIGenerator:
+    def __init__(self, showLogs: bool = False):
+        self.ontology = Ontology()
+        self.routes = []
+        self.app = FastAPI()
+        logging.basicConfig(
+            level=logging.INFO if showLogs else logging.ERROR,
+            format="%(asctime)s %(levelname)s %(message)s",
+            datefmt="%d-%m-%Y %H:%M:%S"
+        )
+        logging.info(f'The {cfg.UPLOAD_DIR} directory is configured for uploaded files.')
+        @self.app.get("/", include_in_schema=False)
+        async def root():
+            return RedirectResponse(url="/docs")
+
+    def load_ontologies(self, paths: List[str]):
+        for path in paths:
+            if not Path(path).exists():
+                raise FileNotFoundError(f"The path does not exist: {path}")
+            self.ontology.parse_ontology(path=path)
+
+    def serialize_ontologies(self):
+        self.ontology.serialize_metadata()
+        self.ontology.serialize_business_models()
+
+    def generate_api_routes(self) -> FastAPI:
+        logging.info(f'Generating API routes for the available metadata...')
+        for pkg_name, pkg_data in self.ontology.data.items():
+            for md in pkg_data:
+                if not md.hasSource or not md.hasSource.query:
+                    continue  # Skip metadata without source query
+                route_path = f"/{pkg_name}/{md.name.split(':')[-1]}"
+                query = md.hasSource.query
+                db_connector = md.hasSource.comm_technology
+                handler = create_metadata_handler(db_connector, query, md.name)
+                self.app.add_api_route(
+                    path=route_path,
+                    endpoint=handler,
+                    methods=["GET"],
+                    name=md.hasSource.desc,
+                    tags=[f"Metadata ({pkg_name})"],
+                )
+                logging.info(f'Added {md.name} API route...')
+        logging.info(f'Generating API routes for the business models...')
+        for bm_name, bm_dt in self.ontology.bms.items():
+            name = bm_name.split(":")
+            ec_func = import_function_from_file(filepath=bm_dt.externalCode.pythonFile, function_name=bm_dt.externalCode.function)
+            handler = create_business_model_handler(bm_dt.requiresMetadata, bm_dt.requiresParameters, ec_func)
+            self.app.add_api_route(
+                path=f"/{name[0]}/{name[1]}/run",
+                endpoint=handler,
+                methods=["POST"],
+                name=f"This endpoint executes the {bm_dt.name} business model, and retrieve it`s results.",
+                tags=[f"Business Model ({bm_dt.name})"],
+            )
+            logging.info(f'Added {bm_name} running API route...')
+        return self.app

ontologytoapi-0.0.5/core/Connectors/IndentifyConnector.py

@@ -0,0 +1,18 @@
+from core.Connectors.Stateful.SocketConnection import SocketConnection
+from core.Connectors.Stateless.APIConnection import APIConnection
+from core.Connectors.Stateless.MYSQLConnection import MySQLConnection
+from core.Connectors.Stateless.MongoDBConnection import MongoDBConnection
+
+SUPPORTED_CONNECTIONS = {
+    "API": APIConnection,
+    "MYSQL": MySQLConnection,
+    "MONGODB": MongoDBConnection,
+    "Socket": SocketConnection
+}
+
+def identifyConnector(CommunicationTechnology, args):
+    try:
+        connector_class = SUPPORTED_CONNECTIONS[str(CommunicationTechnology)]
+        return connector_class(args)
+    except KeyError as e:
+        raise ValueError(f"Unsupported type or technology: {e}")

ontologytoapi-0.0.5/core/Connectors/Stateful/SocketConnection.py

@@ -0,0 +1,16 @@
+import socket as soc
+
+class SocketConnection:
+    def __init__(self, args):
+        try:
+            self.socket = soc.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.socket.connect((args["hasHost"], args["hasPort"]))
+        except Exception as e:
+            print("Connection failed:", e)
+
+    def exec_query(self, message: str):
+        try:
+            self.socket.sendall(message.encode())
+            return self.socket.recv(8192).decode()
+        except Exception as e:
+            return {'error': str(e)}

ontologytoapi-0.0.5/core/Connectors/Stateless/APIConnection.py

@@ -0,0 +1,12 @@
+import requests as req
+
+class APIConnection:
+    def __init__(self, args):
+        self.baseURL = args["hasRequestURL"]
+
+    def exec_query(self, endpoint_params: str):
+        fullURL = self.baseURL + endpoint_params
+        try:
+            return req.get(fullURL).json()
+        except Exception as e:
+            return {'error': str(e)}

ontologytoapi-0.0.5/core/Connectors/Stateless/MYSQLConnection.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 MySQLConnection:
+    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-0.0.5/core/Connectors/Stateless/MongoDBConnection.py

@@ -0,0 +1,21 @@
+import asyncio
+from pymongo import AsyncMongoClient
+import json, logging
+
+class MongoDBConnection:
+    def __init__(self, args):
+        connString = args["hasConnectionString"].split('/')
+        self.client = AsyncMongoClient("/".join(connString[:-1]))
+        self.db = self.client[connString[-1]]
+
+    async def exec_query(self, collection_query: str):
+        query_info = collection_query.split(".")
+        collection = self.db[query_info[0]]
+        query = json.loads(query_info[1])
+        cursor = collection.find({}, query)
+        results = await cursor.to_list()
+        if not results: return []
+        if "_id" in results[0].keys():
+            for i in results:
+                i["_id"] = str(i["_id"])
+        return results

ontologytoapi-0.0.5/core/DTO/BusinessModel.py

@@ -0,0 +1,11 @@
+from core.DTO.Metadata import Metadata
+from core.DTO.ExternalCode import ExternalCode
+
+from typing import List, Optional
+from pydantic import BaseModel
+
+class BusinessModel(BaseModel):
+    name: str
+    requiresMetadata: Optional[List[Metadata]]
+    requiresParameters: Optional[dict]
+    externalCode: Optional[ExternalCode]

ontologytoapi-0.0.5/core/DTO/ExternalCode.py

@@ -0,0 +1,7 @@
+from typing import List, Optional
+from pydantic import BaseModel
+
+class ExternalCode(BaseModel):
+    pythonFile: str
+    function: str
+    requiresLib: List[str]

ontologytoapi-0.0.5/core/DTO/Metadata.py

@@ -0,0 +1,8 @@
+from core.DTO.Source import Source
+
+from pydantic import BaseModel
+
+class Metadata(BaseModel):
+    name: str
+    type: str
+    hasSource: Source

ontologytoapi-0.0.5/core/DTO/Source.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel
+
+class Source(BaseModel):
+    desc: str
+    query: str
+    comm_technology: object

ontologytoapi-0.0.5/core/Ontology.py

@@ -0,0 +1,78 @@
+from rdflib import Graph, URIRef
+import logging
+import pprint
+
+logging.getLogger("rdflib").setLevel(logging.ERROR)
+
+from core.Queries import *
+from core.DTO.Source import *
+from core.DTO.BusinessModel import *
+
+from core.Connectors.IndentifyConnector import identifyConnector
+from core.Utility import ensure_package_installed
+
+class Ontology:
+    def __init__(self):
+        self.g = Graph()
+        self.data = {}
+        self.bms = {}
+
+    def parse_ontology(self, path: str):
+        if path.endswith('.ttl'):
+            self.g.parse(path, format='turtle')
+        elif path.endswith('.owl') or path.endswith('.rdf'):
+            self.g.parse(path, format='xml')
+        else:
+            raise ValueError(f'File extension must be .ttl or .owl or .rdf ({path} could not be parsed)')
+        logging.info(f'Ontology \"{path}\" parsed successfully.')
+
+    def __repr__(self):
+        return (f"data(\n{pprint.pformat(self.data, indent=2)}\n)\n"
+                f"business_models(\n{pprint.pformat(self.bms, indent=2)}\n)")
+
+    def _get_metadata_by_name(self, name: str):
+        for namespace, content in self.data.items():
+            for metadata in content:
+                if metadata.name == name:
+                    return metadata
+        return None
+
+    def _verify_metadata(self, q: str):
+        md = []
+        for row in self.g.query(q):
+            metadata_obj = self._get_metadata_by_name(self.g.qname(row[1]))
+            if not metadata_obj:
+                raise ValueError(
+                    f'The {self.g.qname(row[1])} metadata which is required by the {self.g.qname(row[0])} could not be found in the ontology.')
+            md.append(metadata_obj)
+        return md
+
+    def serialize_metadata(self):
+        data = {}
+        for row in self.g.query(GET_METADATA_QUERY):
+            args = {self.g.qname(row[0]).split(":")[-1]: row[1] for row in
+                    self.g.query(GET_COMMUNICATION_TECH_ARGS_QUERY + URIRef(row[4]) + ">)}")}
+            comm_tech = identifyConnector(row[5], args)
+            source = Source(desc=row[2], query=row[3], comm_technology=comm_tech)
+            onto_pkg = self.g.qname(row[0]).split(":")[0]
+            if onto_pkg not in data.keys(): data[onto_pkg] = []
+            data[onto_pkg].append(Metadata(name=self.g.qname(row[0]), type=row[1], hasSource=source))
+            logging.info(f'{self.g.qname(row[0])} METADATA serialized successfully;')
+        self.data = data
+
+    def serialize_business_models(self):
+        BMs = {}
+        for ec in self.g.query(GET_EXTERNAL_CODE_FOR_BM_QUERY):
+            bm_name = self.g.qname(ec[0])
+            required_metadata = self._verify_metadata(GET_REQUIRED_MD_FOR_BM_QUERY + URIRef(ec[0]) + ">)}")
+            required_parameters = self.g.query(GET_REQUIRED_PARAMETERS_FOR_BM_QUERY + URIRef(ec[0]) + ">)}")
+            for module in str(ec[3]).split(","): ensure_package_installed(module)
+            BMs[bm_name] = BusinessModel(name=bm_name.split(":")[-1],
+                               requiresMetadata=required_metadata,
+                               requiresParameters={str(l): t for _, l, t in required_parameters},
+                               externalCode=ExternalCode(
+                                    pythonFile=str(ec[2]),
+                                    function=str(ec[4]),
+                                    requiresLib=str(ec[3]).split(",")))
+            logging.info(f'{bm_name} BUSINESS MODEL serialized successfully;')
+        self.bms = BMs

ontologytoapi-0.0.5/core/Queries.py

@@ -0,0 +1,51 @@
+GET_METADATA_QUERY = """
+        SELECT ?m ?t ?d ?q ?ct ?tc
+        WHERE {
+          ?m <http://www.cedri.com/SmartLEM-Metadata#hasSource> ?s .
+          ?m <http://www.cedri.com/SmartLEM-Metadata#hasType> ?t .
+          ?s <http://www.cedri.com/SmartLEM-Metadata#hasQuery> ?q .
+          ?s <http://www.cedri.com/SmartLEM-Metadata#hasDescription> ?d .
+          ?s <http://www.cedri.com/SmartLEM-Metadata#hasCommunicationTechnology> ?ct .
+          ?ct <http://www.cedri.com/SmartLEM-Communications#usesTechnology> ?tc .
+        }
+        """
+
+GET_COMMUNICATION_TECH_ARGS_QUERY = """
+        SELECT ?arg ?argv
+        WHERE {
+          ?s <http://www.cedri.com/SmartLEM-Metadata#hasCommunicationTechnology> ?ct .
+          ?ct ?arg ?argv .
+          FILTER(?arg != <http://www.cedri.com/SmartLEM-Communications#usesTechnology> &&
+          ?arg != <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> &&
+          ?ct = <"""
+
+GET_BM_NAME_QUERY = """
+        SELECT ?bm
+        WHERE {
+          ?bm rdfs:subClassOf <http://www.cedri.com/SmartLEM-BusinessModel#BusinessModel> .
+        }
+        """
+
+GET_REQUIRED_MD_FOR_BM_QUERY = """
+        SELECT ?bm ?rm
+        WHERE {
+          ?bm <http://www.cedri.com/SmartLEM-BusinessModel#requiresMetadata> ?rm .
+          FILTER (?bm = <"""
+
+GET_REQUIRED_PARAMETERS_FOR_BM_QUERY = """
+        SELECT ?bm ?pl ?pt
+        WHERE {
+          ?bm <http://www.cedri.com/SmartLEM-BusinessModel#hasParameter> ?p .
+          ?p <http://www.cedri.com/SmartLEM-BusinessModel#hasParameterLabel> ?pl .
+          ?p <http://www.cedri.com/SmartLEM-BusinessModel#hasParameterType> ?pt .
+          FILTER (?bm = <"""
+
+GET_EXTERNAL_CODE_FOR_BM_QUERY = """
+        SELECT ?bm ?ec ?pf ?rl ?hf
+        WHERE {
+          ?bm <http://www.cedri.com/SmartLEM-BusinessModel#hasExternalCode> ?ec .
+          ?ec <http://www.cedri.com/SmartLEM-ExternalCode#hasPythonFile> ?pf .
+          ?ec <http://www.cedri.com/SmartLEM-ExternalCode#requiresLib> ?rl .
+          ?ec <http://www.cedri.com/SmartLEM-ExternalCode#hasFunction> ?hf .
+        }
+        """

ontologytoapi-0.0.5/core/Utility.py

@@ -0,0 +1,64 @@
+import importlib.util
+import sys
+import subprocess
+import os
+import logging
+from pathlib import Path
+from Settings import auto_config as cfg
+
+def handle_upload_file(uploaded_file):
+    UPLOAD_DIR = Path(cfg.UPLOAD_DIR)
+    if not os.path.exists(UPLOAD_DIR):
+        os.makedirs(UPLOAD_DIR)
+
+    file_path = os.path.join(UPLOAD_DIR, uploaded_file.filename)
+
+    with open(file_path, "wb") as out_file:
+        while chunk := uploaded_file.file.read(1024 * 1024):  # Read in 1 MiB chunks
+            out_file.write(chunk)
+        out_file.close()
+
+    uploaded_file.file.close()
+
+    return file_path
+
+def import_function_from_file(filepath, function_name):
+    # Check if file exists
+    if not os.path.isfile(filepath):
+        raise FileNotFoundError(f"File not found: {filepath}")
+
+    module_name = os.path.splitext(os.path.basename(filepath))[0]
+
+    try:
+        spec = importlib.util.spec_from_file_location(module_name, filepath)
+        if spec is None:
+            raise ImportError(f"Could not load module spec from {filepath}")
+
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[module_name] = module
+        spec.loader.exec_module(module)
+    except Exception as e:
+        raise ImportError(f"Failed to load module '{module_name}': {e}")
+
+    # Check if function exists
+    if not hasattr(module, function_name):
+        raise AttributeError(f"Function '{function_name}' not found in '{filepath}'")
+
+    func = getattr(module, function_name)
+    if not callable(func):
+        raise TypeError(f"'{function_name}' in '{filepath}' is not a callable function")
+
+    return func
+
+def install_package(package_name):
+    try:
+        subprocess.check_call([sys.executable, "-m", "pip", "install", package_name])
+        logging.info(f"Package '{package_name}' installed successfully.")
+    except subprocess.CalledProcessError as e:
+        logging.info(f"Failed to install '{package_name}': {e}")
+
+def ensure_package_installed(package_name):
+    if importlib.util.find_spec(package_name) is None:
+        install_package(package_name)
+    else:
+        logging.info(f"Package '{package_name}' is already installed.")

ontologytoapi-0.0.5/core/__init__.py

@@ -0,0 +1,2 @@
+# Package
+from APIGenerator import APIGenerator

ontologytoapi-0.0.5/ontologytoapi.egg-info/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: ontologytoapi
+Version: 0.0.5
+Summary: Multi purpose API Generator based on an Ontology Framework.
+Home-page: https://github.com/JCGCosta/OntologyToAPI
+Author: Júlio César Guimarães Costa
+Author-email: juliocesargcosta123@gmail.com
+License: MIT License
+Keywords: Ontology,API
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Microsoft :: Windows :: Windows 11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: SQLAlchemy
+Requires-Dist: pydantic
+Requires-Dist: requests
+Requires-Dist: pymongo
+Requires-Dist: rdflib
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: aiomysql
+Requires-Dist: motor
+Requires-Dist: aiofiles
+Requires-Dist: python-multipart
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+# OntologyToAPI
+> This project is an ontology-driven API generator designed for 
+> backend development by transforming structured domain 
+> knowledge into fully functional APIs. The tool accepts ontologies 
+> specified in Turtle (.ttl), Resource Description Framework (.rdf)
+> and Web Ontology Language (.owl).
+
+> [![Publish to PyPI and TestPyPI](https://github.com/JCGCosta/OntologyToAPI/actions/workflows/python-publish.yml/badge.svg)](https://github.com/JCGCosta/OntologyToAPI/actions/workflows/python-publish.yml)
+
+
+## Ontological Framework:
+
+- The following classes, relationships and data properties serve as a semantic blueprint for both metadata and business models.
+
+<img src="https://github.com/JCGCosta/OntologyToAPI/blob/master/OntologicalFramework.jpg?raw=true" alt="AbstractOntologyClasses" title="Abstract Ontology Classes.">
+
+The ontological framework is composed of two main modules:
+
+  - **Metadata Ontology Module:** This module defines the essential classes and properties required to describe the metadata and its sources (e.g. Query to be executed on the CommunicationTechnology).
+  - **BusinessModel Ontology Module:** This module captures the specific business logic and rules governing some operation, it requires an ExternalCode concretization, and it can require any metadata or parameter (To be sent in the API request).
+  - **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).
+
+> From now on you must be ready to go and create your own ontological specification importing the Ontology Modules 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
+
+```bash
+# Now inside the environment install the python package
+pip install ontologytoapi
+```
+
+
+### Step 2: Running
+
+- If you want to see a quick ontology sample in .ttl please access the following link: https://github.com/JCGCosta/OntologyToAPI/tree/master/samples
+- With you metadata and business models ontologies implemented you can generate your API by having the following python file as an entry point:
+
+```python
+import uvicorn
+from core.APIGenerator import Generator
+
+if __name__ == "__main__":
+    APIGen = Generator(showLogs=True)
+    APIGen.load_ontologies(paths=[
+        "Your/Metadata/Ontology/.ttl.owl.rdf"
+    ])
+    APIGen.load_ontologies(paths=[
+        "Your/BusinessModel/Ontology/.ttl.owl.rdf"
+    ])
+    APIGen.serialize_ontologies()
+    api_app = APIGen.generate_api_routes()
+    uvicorn.run(api_app, host="127.0.0.1", port=5000)
+```
+
+
+Change Log
+===============
+0.0.5 (27/10/2025)
+------------------
+FIRST RELEASE
+- First fixes on README file.
+- Added Ontological Framework diagram.
+- Added ontology concrete sample.
+------------------
+

ontologytoapi-0.0.5/ontologytoapi.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+LICENSE
+MANIFEST.in
+README.md
+requirements.txt
+setup.cfg
+setup.py
+core/APIGenerator.py
+core/Ontology.py
+core/Queries.py
+core/Utility.py
+core/__init__.py
+core/Connectors/IndentifyConnector.py
+core/Connectors/Stateful/SocketConnection.py
+core/Connectors/Stateless/APIConnection.py
+core/Connectors/Stateless/MYSQLConnection.py
+core/Connectors/Stateless/MongoDBConnection.py
+core/DTO/BusinessModel.py
+core/DTO/ExternalCode.py
+core/DTO/Metadata.py
+core/DTO/Source.py
+ontologytoapi.egg-info/PKG-INFO
+ontologytoapi.egg-info/SOURCES.txt
+ontologytoapi.egg-info/dependency_links.txt
+ontologytoapi.egg-info/requires.txt
+ontologytoapi.egg-info/top_level.txt

ontologytoapi-0.0.5/ontologytoapi.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ontologytoapi-0.0.5/ontologytoapi.egg-info/requires.txt

@@ -0,0 +1,11 @@
+SQLAlchemy
+pydantic
+requests
+pymongo
+rdflib
+fastapi
+uvicorn
+aiomysql
+motor
+aiofiles
+python-multipart

ontologytoapi-0.0.5/ontologytoapi.egg-info/top_level.txt

@@ -0,0 +1 @@
+core

ontologytoapi-0.0.5/requirements.txt

@@ -0,0 +1,12 @@
+setuptools
+SQLAlchemy~=2.0.41
+pydantic~=2.11.7
+requests~=2.32.4
+pymongo~=4.13.2
+rdflib~=7.1.4
+fastapi~=0.115.14
+uvicorn~=0.35.0
+aiomysql~=0.2.0
+motor~=3.7.1
+aiofiles~=25.1.0
+python-multipart~=0.0.20

ontologytoapi-0.0.5/setup.cfg

@@ -0,0 +1,7 @@
+[metadata]
+description-file = README.md
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

ontologytoapi-0.0.5/setup.py

@@ -0,0 +1,28 @@
+from setuptools import setup, find_packages
+
+classifiers = [
+    'Development Status :: 3 - Alpha',
+    'Intended Audience :: Developers',
+    'Operating System :: Microsoft :: Windows :: Windows 11',
+    'License :: OSI Approved :: MIT License',
+    'Topic :: Software Development :: Libraries :: Python Modules',
+    'Programming Language :: Python :: 3.11'
+]
+
+setup(
+    name='ontologytoapi',
+    version='0.0.5',
+    description='Multi purpose API Generator based on an Ontology Framework.',
+    long_description=
+    f"{open('README.md').read()}\n\n" +
+    f"{open('CHANGELOG.txt').read()}\n\n",
+    long_description_content_type="text/markdown",
+    url='https://github.com/JCGCosta/OntologyToAPI',
+    author='Júlio César Guimarães Costa',
+    author_email='juliocesargcosta123@gmail.com',
+    license='MIT License',
+    classifiers=classifiers,
+    keywords=['Ontology', 'API'],
+    packages=find_packages(),
+    install_requires=["SQLAlchemy","pydantic","requests","pymongo","rdflib","fastapi","uvicorn","aiomysql","motor","aiofiles","python-multipart"]
+)