laia-gen-lib 0.1.0__tar.gz

laia-gen-lib-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.1
+Name: laia-gen-lib
+Version: 0.1.0
+Summary: An AI application generator engine
+Author: Me

laia-gen-lib-0.1.0/laia_gen_lib.egg-info/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.1
+Name: laia-gen-lib
+Version: 0.1.0
+Summary: An AI application generator engine
+Author: Me

laia-gen-lib-0.1.0/laia_gen_lib.egg-info/SOURCES.txt

@@ -0,0 +1,27 @@
+setup.py
+laia_gen_lib.egg-info/PKG-INFO
+laia_gen_lib.egg-info/SOURCES.txt
+laia_gen_lib.egg-info/dependency_links.txt
+laia_gen_lib.egg-info/requires.txt
+laia_gen_lib.egg-info/top_level.txt
+laiagenlib/__init__.py
+laiagenlib/main.py
+laiagenlib/crud/__init__.py
+laiagenlib/crud/crud.py
+laiagenlib/crud/crud_mongo_impl.py
+laiagenlib/crud/schemas.py
+laiagenlib/models/AccessRights.py
+laiagenlib/models/Model.py
+laiagenlib/models/Openapi.py
+laiagenlib/models/Role.py
+laiagenlib/models/Route.py
+laiagenlib/models/__init__.py
+laiagenlib/utils/__init__.py
+laiagenlib/utils/logger.py
+laiagenlib/utils/utils.py
+tests/__init__.py
+tests/models/__init__.py
+tests/models/test_access_rights.py
+tests/models/test_model.py
+tests/models/test_openapi.py
+tests/models/test_role.py

laia-gen-lib-0.1.0/laia_gen_lib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

laia-gen-lib-0.1.0/laia_gen_lib.egg-info/requires.txt

@@ -0,0 +1,3 @@
+pymongo
+pydantic
+datamodel-code-generator

laia-gen-lib-0.1.0/laia_gen_lib.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+laiagenlib
+tests

laia-gen-lib-0.1.0/laiagenlib/__init__.py

@@ -0,0 +1,3 @@
+from . import crud
+from . import models
+from . import utils

laia-gen-lib-0.1.0/laiagenlib/crud/__init__.py

@@ -0,0 +1,2 @@
+from . import crud
+from . import crud_mongo_impl

laia-gen-lib-0.1.0/laiagenlib/crud/crud.py

@@ -0,0 +1,24 @@
+from typing import TypeVar, Optional, Dict
+from pydantic import BaseModel
+
+T = TypeVar('T', bound='BaseModel')
+
+class CRUD:
+
+    def __init__(self, db: Dict[str, any]):
+        self.db = db
+
+    async def get_items(model_name: str, skip: int = 0, limit: int = 10, filters: Optional[dict] = None):
+        pass
+
+    async def get_item(model_name: str, item_id: str):
+        pass
+
+    async def post_item(model_name: str, item: T):
+        pass
+
+    async def put_item(model_name: str, item_id: str, update_fields: dict):
+        pass
+
+    async def delete_item(model_name: str, item_id: str):
+        pass

laia-gen-lib-0.1.0/laiagenlib/crud/crud_mongo_impl.py

@@ -0,0 +1,69 @@
+from typing import TypeVar, Optional, Dict
+from pydantic import BaseModel
+from pymongo.collection import ReturnDocument
+from .schemas import list_serial, individual_serial
+from bson import ObjectId
+from .crud import CRUD
+
+T = TypeVar('T', bound='BaseModel')
+
+class CRUDMongoImpl(CRUD):
+
+    def __init__(self, db: Dict[str, any]):
+        super().__init__(db)
+
+    async def get_items(self, model_name: str, skip: int = 0, limit: int = 10, filters: Optional[dict] = None, orders: Optional[dict] = None):
+        collection = self.db[model_name]
+
+        query = filters or {}
+        sorts = orders or {}
+
+
+        items = collection.find(query, skip=skip, limit=limit, sort=sorts)
+        serialized_items = list_serial(items)
+
+        total_count = collection.count_documents(query)
+        
+        return serialized_items, total_count
+    
+    async def get_item(self, model_name: str, item_id: str):
+        collection = self.db[model_name]
+
+        item = collection.find_one({'_id': ObjectId(item_id)})
+
+        if item:
+            return individual_serial(item)
+        raise ValueError(f"{model_name} with ID {item_id} not found")
+
+    async def post_item(self, model_name: str, item: T):
+        collection = self.db[model_name]
+        item_dict = dict(item)
+        item_dict.pop('id', None)
+        created_result = collection.insert_one(item_dict)
+        inserted_id = created_result.inserted_id
+        item_dict['id'] = str(inserted_id)
+        item_dict.pop('_id', None)
+
+        return item_dict
+
+    async def put_item(self, model_name: str, item_id: str, update_fields: dict):
+        collection = self.db[model_name]
+        update_query = {'$set': update_fields}
+        
+        updated_item = collection.find_one_and_update(
+            {'_id': ObjectId(item_id)},
+            update_query,
+            return_document=ReturnDocument.AFTER,
+        )
+        
+        if updated_item:
+            return individual_serial(updated_item)
+        raise Exception
+
+    async def delete_item(self, model_name: str, item_id: str):
+        collection = self.db[model_name]
+        deleted_item = collection.find_one_and_delete({'_id': ObjectId(item_id)})
+        if deleted_item:
+            return individual_serial(deleted_item)
+        raise Exception
+    

laia-gen-lib-0.1.0/laiagenlib/crud/schemas.py

@@ -0,0 +1,13 @@
+from typing import List, TypeVar, Type
+import json
+
+T = TypeVar('T', bound='BaseModel')
+
+def individual_serial(item: T) -> dict:
+    item['_id'] = str(item['_id'])
+    item['id'] = str(item['_id'])
+    del item['_id']
+    return item
+
+def list_serial(items: List[T]) -> list[dict]:
+    return[individual_serial(item) for item in items]

laia-gen-lib-0.1.0/laiagenlib/main.py

@@ -0,0 +1,33 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from .crud.crud import CRUD
+from .models.Openapi import OpenAPI
+from .utils.utils import create_models_file
+from .utils.logger import _logger
+import os
+
+class LaiaFastApi():
+
+    def __init__(self, openapi, db, crud: CRUD):
+        self.db = db
+        self.crud_instance = crud(db)
+        self.openapi_path = openapi
+        self.openapi = OpenAPI(openapi)
+        self.api = FastAPI()
+        self.api.add_middleware(
+            CORSMiddleware,
+            allow_origins=["*"],
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+
+        models_dir = os.path.join(os.path.dirname(self.openapi_path), "models")
+        if not os.path.exists(models_dir):
+            os.makedirs(models_dir)
+
+        models_path = os.path.join(models_dir, "models.py")
+        create_models_file(self.openapi_path, models_path)
+        self.openapi.create_crud_routes(self.api, self.crud_instance, models_path)
+
+    

laia-gen-lib-0.1.0/laiagenlib/models/AccessRights.py

@@ -0,0 +1,73 @@
+from typing import Dict, Type
+from pydantic import BaseModel
+from ..crud.crud import CRUD
+from ..utils.logger import _logger
+from ..utils.utils import create_element
+
+class AccessRights(BaseModel):
+    role: str
+    model: str
+    operations: Dict[str, int] = {}
+    fields_create: Dict[str, int] = {}
+    fields_edit: Dict[str, int] = {}
+    fields_visible: Dict[str, int] = {}
+
+    @classmethod
+    async def create(cls, new_access_rights: dict, model: Type, user_roles: list, crud_instance: CRUD):
+        _logger.info(f"Creating new AccessRights with values: {new_access_rights}")
+
+        if 'role' in new_access_rights and 'model' in new_access_rights:
+            pass
+        else:
+            raise ValueError("Missing required parameters")
+
+        if new_access_rights.get("model") != model.__name__.lower():
+            raise ValueError("Provided model name does not match the class model name")
+
+        if "admin" not in user_roles:
+            raise PermissionError("Only users with 'admin' role can create access rights")
+        
+        operations = new_access_rights.get("operations", {})
+        valid_operations = {"create", "read", "update", "delete", "search"}
+
+        for operation in operations:
+            if operation not in valid_operations or not isinstance(operations[operation], int):
+                raise ValueError(f"Invalid format for operation {operation}")
+            
+        fields_to_check = ["fields_create", "fields_edit", "fields_visible"]
+
+        for field_type in fields_to_check:
+            fields = new_access_rights.get(field_type, {})
+            if not isinstance(fields, dict):
+                raise ValueError(f"Invalid format for {field_type}")
+            
+            model_fields = []
+            for class_in_hierarchy in model.mro():
+                if hasattr(class_in_hierarchy, '__annotations__'):
+                    model_fields.extend([field for field in class_in_hierarchy.__annotations__ if not field.startswith("_")])
+
+            for field_name, field_value in fields.items():
+                if field_name not in model_fields or not isinstance(field_value, int):
+                    raise ValueError(f"Invalid field {field_name} for {field_type}")
+                
+        existing_access_rights, _ = await crud_instance.get_items(
+            "accessrights", 
+            skip=0, 
+            limit=10, 
+            filters={
+                "model": new_access_rights.get("model"),
+                "role": new_access_rights.get("role")
+            }
+        )
+
+        if existing_access_rights:
+            raise ValueError("AccessRights with the same role and model already exists")
+        
+        try:
+            access_rights = AccessRights(**new_access_rights)
+        except Exception:
+            raise ValueError("Missing required parameters")
+
+        created_accessrights = await create_element(access_rights, crud_instance)
+        _logger.info("AccessRights created successfully")
+        return cls(**created_accessrights)

laia-gen-lib-0.1.0/laiagenlib/models/Model.py

@@ -0,0 +1,165 @@
+from typing import Type, List, Dict, Any
+from pydantic import BaseModel
+from ..utils.utils import create_element
+from ..crud.crud import CRUD
+from .AccessRights import AccessRights
+from ..utils.logger import _logger
+
+class LaiaBaseModel(BaseModel):
+    id: str = ""
+    name: str
+
+    @classmethod
+    async def create(cls, new_element: dict, model: Type, user_roles: list, crud_instance: CRUD):
+        _logger.info(f"Creating new {model.__name__} with values: {new_element}")
+
+        try:
+            element = model(**new_element)
+        except Exception:
+            raise ValueError("Missing required parameters")
+    
+        if "admin" not in user_roles:
+            model_name = model.__name__.lower()
+            access_rights_list = await cls.check_access_rights(model_name, user_roles, "create", crud_instance)
+            await cls.check_fields_permission(model, 'fields_create', new_element, access_rights_list)
+        
+        created_element = await create_element(element, crud_instance)
+
+        if "admin" not in user_roles:
+            allowed_fields = cls.get_allowed_fields(access_rights_list, 'fields_visible')
+            created_element = {field: created_element[field] for field in allowed_fields if field in created_element}
+
+        _logger.info(f"{model.__name__} created successfully")
+        return created_element
+    
+    @classmethod
+    async def update(cls, element_id:str, updated_values: dict, model: Type, user_roles: list, crud_instance: CRUD):
+        _logger.info(f"Updating {model.__name__} with ID: {element_id} and values: {updated_values}")
+
+        model_name = model.__name__.lower()
+
+        if "admin" not in user_roles:
+            access_rights_list = await cls.check_access_rights(model_name, user_roles, "update", crud_instance)
+            await cls.check_fields_permission(model, 'fields_edit', updated_values, access_rights_list)
+
+        try:
+            updated_element = await crud_instance.put_item(model_name, element_id, updated_values)
+        except Exception:
+            raise ValueError(f"{model.__name__} with ID does not exist, or the updating parameters have errors")
+        
+        if "admin" not in user_roles:
+            allowed_fields = cls.get_allowed_fields(access_rights_list, 'fields_visible')
+            updated_element = {field: updated_element[field] for field in allowed_fields if field in updated_element}
+
+        _logger.info(f"{model.__name__} created successfully")
+        return updated_element
+    
+    @classmethod
+    async def delete(cls, element_id: str, model: Type, user_roles: List[str], crud_instance: CRUD):
+        _logger.info(f"Deleting {model.__name__} with ID: {element_id}")
+
+        model_name = model.__name__.lower()
+
+        if "admin" not in user_roles:
+            await cls.check_access_rights(model_name, user_roles, "delete", crud_instance)
+        try:
+            await crud_instance.delete_item(model_name, element_id)
+        except Exception:
+            raise ValueError(f"{model.__name__} with ID does not exist, or there was an error deleting the element")
+
+        _logger.info(f"{model.__name__} deleted successfully")
+
+    @classmethod
+    async def read(cls, element_id: str, model: Type, user_roles: List[str], crud_instance: CRUD):
+        _logger.info(f"Getting {model.__name__} with ID: {element_id}")
+
+        model_name = model.__name__.lower()
+
+        if "admin" not in user_roles:
+            access_rights_list = await cls.check_access_rights(model_name, user_roles, "read", crud_instance)
+        try:
+            item = await crud_instance.get_item(model_name, element_id)
+        except ValueError as e:
+            raise ValueError(str(e))
+
+        if "admin" not in user_roles:
+            allowed_fields = cls.get_allowed_fields(access_rights_list, 'fields_visible')
+            item = {field: item[field] for field in allowed_fields if field in item}
+
+        _logger.info(f"{model.__name__} retrieved successfully")
+        return item
+    
+    @classmethod
+    async def search(cls, filters: dict, model: Type, user_roles: List[str], crud_instance: CRUD):
+        _logger.info(f"Searching {model.__name__} with filters: {filters}")
+
+        model_name = model.__name__.lower()
+
+        if "admin" not in user_roles:
+            await cls.check_access_rights(model_name, user_roles, "search", crud_instance)
+
+        try:
+            items, total_count = await crud_instance.get_items(model_name, filters=filters)
+        except Exception:
+            raise ValueError(f"Error occurred while searching {model.__name__} with filters: {filters}")
+
+        _logger.info(f"{model.__name__} search completed successfully")
+        return items, total_count
+    
+    @classmethod
+    async def check_access_rights(cls, model_name: str, roles: List[str], operation: str, crud_instance: CRUD):
+        access_rights_list = []
+        
+        for role in roles:
+            access_rights, _ = await crud_instance.get_items(
+                "accessrights", 
+                skip=0, 
+                limit=1, 
+                filters={
+                    "model": model_name,
+                    "role": role
+                }
+            )
+
+            if access_rights and access_rights[0]["operations"].get(operation, 0) >= 1:
+                access_rights_list.append(access_rights[0])
+
+        if not access_rights_list:
+            raise PermissionError(f"None of the roles have sufficient permissions for operation '{operation}' on model '{model_name}'")
+
+        return access_rights_list
+    
+    @classmethod
+    async def check_fields_permission(cls, model, fields_type: str, new_element: Dict[str, int], access_rights_list: List[AccessRights]):
+        model_fields = []
+
+        for class_in_hierarchy in model.mro():
+            if hasattr(class_in_hierarchy, '__annotations__'):
+                model_fields.extend([field for field in class_in_hierarchy.__annotations__ if not field.startswith("_")])
+
+        for field_name, field_value in new_element.items():
+            if field_name not in model_fields:
+                raise ValueError(f"Invalid field {field_name}")
+            
+        for field_name, field_value in new_element.items():
+            allowed_by_some_role = False  
+
+            for access_rights in access_rights_list:
+                if access_rights.get(fields_type).get(field_name, {}) == 1:
+                    allowed_by_some_role = True
+                    break  
+
+            if not allowed_by_some_role:
+                raise PermissionError(f"Insufficient permissions to create the field '{field_name}' in any role.")
+
+    @classmethod
+    def get_allowed_fields(cls, access_rights_list: List[AccessRights], fields_type: str):
+        allowed_fields = set()
+
+        for access_rights in access_rights_list:
+            fields = access_rights.get(fields_type, {})
+            for field_name, field_value in fields.items():
+                if field_value == 1:
+                    allowed_fields.add(field_name)
+
+        return allowed_fields

laia-gen-lib-0.1.0/laiagenlib/models/Openapi.py

@@ -0,0 +1,128 @@
+import yaml
+from fastapi import FastAPI, HTTPException, status
+from fastapi.routing import APIRouter
+from typing import TypeVar, Optional
+import re
+from importlib.util import spec_from_file_location, module_from_spec
+from .Route import Route
+from ..crud.crud import CRUD
+from .Model import LaiaBaseModel
+from ..utils.logger import _logger
+
+T = TypeVar('T', bound='LaiaBaseModel')
+
+class OpenAPI:
+    def __init__(self, yaml_path):
+        self.yaml_path = yaml_path
+        self.routes = []
+        self.models = []
+
+        self.parse_yaml()
+
+    def parse_yaml(self):
+        with open(self.yaml_path, 'r') as file:
+            openapi_spec = yaml.safe_load(file)
+
+        if 'paths' in openapi_spec:
+            for path, path_data in openapi_spec['paths'].items():
+                methods = path_data.keys()
+                for method in methods:
+                    if method != "parameters":
+                        summary = path_data[method].get('summary', '')
+                        responses = path_data[method].get('responses', {})
+                        extensions = path_data[method].get('x-', {})
+                        self.routes.append(Route(path, method, summary, responses, extensions))
+
+        if 'components' in openapi_spec:
+            schemas = openapi_spec['components'].get('schemas', {})
+            self.models = list(schemas.keys())
+
+    def create_crud_routes(self, api: FastAPI=None, crud_instance: CRUD=None, models_path: str=""):
+        for model_name in self.models:
+            model_module = self.import_model(models_path)
+            model = getattr(model_module, model_name)
+            model_lowercase = model_name.lower()
+            model_plural = model_lowercase + 's' # TODO: use it for search path
+
+            create_route = None
+            read_route = None
+            update_route = None
+            delete_route = None
+            search_route = None
+
+            for route in self.routes:
+                if route.extensions.get(f'x-create-{model_lowercase}'):
+                    create_route = route.path
+                elif route.extensions.get(f'x-read-{model_lowercase}'):
+                    read_route = route.path
+                elif route.extensions.get(f'x-update-{model_lowercase}'):
+                    update_route = route.path
+                elif route.extensions.get(f'x-delete-{model_lowercase}'):
+                    delete_route = route.path
+                elif route.extensions.get(f'x-search-{model_lowercase}'):
+                    search_route = route.path
+
+            self.CRUD(
+                api=api,
+                model=model,
+                create_route=create_route,
+                read_route=read_route,
+                update_route=update_route,
+                delete_route=delete_route,
+                search_route=search_route
+            )
+
+    def CRUD(self, api: FastAPI, model: T, create_route: Optional[str] = None, read_route: Optional[str] = None, update_route: Optional[str] = None, delete_route: Optional[str] = None, search_route: Optional[str] = None):
+        model_name = model.__name__.lower()
+        router = APIRouter(tags=[model.__name__])
+
+        def replace_placeholder(route: str) -> str:
+            return re.sub(r'\{.*?\}', '{element_id}', route)
+
+        create_route = create_route or f"/{model_name}/"
+        read_route = read_route or f"/{model_name}"+"/{element_id}"
+        update_route = update_route or f"/{model_name}"+"/{element_id}"
+        delete_route = delete_route or f"/{model_name}"+"/{element_id}"
+        search_route = search_route or None # TODO: change to the defined route
+
+
+        @router.post(create_route, response_model=dict)
+        async def create_element(element: model):
+            user_roles=["admin"]
+            try:
+                return await model.create(dict(element), model, user_roles, self.crud_instance)
+            except Exception as e:
+                raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e))
+
+        @router.put(update_route, response_model=dict)
+        async def update_element(element_id: str, values: dict):
+            user_roles=["admin"]
+            try:
+                return await model.update(element_id, values, model, user_roles, self.crud_instance)
+            except Exception as e:
+                raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e))
+        
+        @router.get(read_route, response_model=dict)
+        async def read_element(element_id: str):
+            user_roles=["admin"]
+            try:
+                return await model.read(element_id, model, user_roles, self.crud_instance)
+            except Exception as e:
+                raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e))
+
+        @router.delete(delete_route, response_model=str)
+        async def delete_element(element_id: str):
+            user_roles=["admin"]
+            try:
+                await model.delete(element_id, model, user_roles, self.crud_instance)
+                return f"{model_name} element deleted successfully"
+            except Exception as e:
+                raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e))
+
+        api.include_router(router)
+    
+    def import_model(self, models_path):
+        spec = spec_from_file_location("models", models_path)
+        module = module_from_spec(spec)
+        spec.loader.exec_module(module)
+        return module

laia-gen-lib-0.1.0/laiagenlib/models/Role.py

@@ -0,0 +1,27 @@
+from typing import Dict
+from pydantic import BaseModel
+from ..crud.crud import CRUD
+from ..utils.logger import _logger
+from ..utils.utils import create_element
+
+class Role(BaseModel):
+    name: str
+
+    @classmethod
+    async def create(cls, new_role: dict, user_roles: list, crud_instance: CRUD):
+        _logger.info(f"Creating new Role with values: {new_role}")
+
+        if "name" not in new_role:
+            raise ValueError("Missing required parameter: name")
+
+        role = Role(**new_role)
+        if "admin" not in user_roles:
+            raise PermissionError("Only users with 'admin' role can create new roles")
+
+        existing_roles, _ = await crud_instance.get_items("role", skip=0, limit=10, filters={"name": role.name})
+        if existing_roles:
+            raise ValueError(f"Role with name '{role.name}' already exists")
+        
+        created_role = await create_element(role, crud_instance)
+        _logger.info("Role created successfully")
+        return cls(**created_role)

laia-gen-lib-0.1.0/laiagenlib/models/Route.py

@@ -0,0 +1,10 @@
+class Route:
+    def __init__(self, path, method, summary, responses, extensions):
+        self.path = path
+        self.method = method
+        self.summary = summary
+        self.responses = responses
+        self.extensions = extensions
+
+    def __str__(self):
+        return f"Path: {self.path}, Method: {self.method}, Summary: {self.summary}, Responses: {self.responses}, Extensions: {self.extensions}"

laia-gen-lib-0.1.0/laiagenlib/models/__init__.py

@@ -0,0 +1,5 @@
+from . import AccessRights
+from . import Model
+from . import Openapi
+from . import Role
+from . import Route

laia-gen-lib-0.1.0/laiagenlib/utils/__init__.py

@@ -0,0 +1,2 @@
+from . import logger
+from . import utils

laia-gen-lib-0.1.0/laiagenlib/utils/logger.py

@@ -0,0 +1,34 @@
+import logging
+
+class CustomFormatter(logging.Formatter):
+
+    purple = "\x1b[35;20m"
+    green = "\x1b[32;20m"
+    yellow = "\x1b[33;20m"
+    red = "\x1b[31;20m"
+    bold_red = "\x1b[31;1m"
+    reset = "\x1b[0m"
+    format = "%(asctime)s - (%(filename)s:%(lineno)d) - %(levelname)s - %(message)s "
+
+    FORMATS = {
+        logging.DEBUG: purple + format + reset,
+        logging.INFO: green + format + reset,
+        logging.WARNING: yellow + format + reset,
+        logging.ERROR: red + format + reset,
+        logging.CRITICAL: bold_red + format + reset
+    }
+
+    def format(self, record):
+        log_fmt = self.FORMATS.get(record.levelno, self.format)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+
+_logger = logging.getLogger("LAIA")
+_logger.setLevel(logging.INFO)
+
+ch = logging.StreamHandler()
+ch.setLevel(logging.DEBUG)
+
+ch.setFormatter(CustomFormatter())
+
+_logger.addHandler(ch)

laia-gen-lib-0.1.0/laiagenlib/utils/utils.py

@@ -0,0 +1,41 @@
+from typing import TypeVar
+import subprocess
+import re
+from ..crud.crud import CRUD
+from .logger import _logger
+
+T = TypeVar('T', bound='BaseModel')
+
+def create_models_file(input_file="openapi.yaml", output_file="model.py"):
+    # This function uses the datamodel-code-generator for generating the pydantic models given a openapi.yaml file. 
+    # The generated file is modified so that the pydantic models extend the LaiaBaseModel, this is necessary for 
+    # using the Laia library
+
+    subprocess.run(["datamodel-codegen", "--input", input_file, "--output", output_file], check=True)
+
+    import_statement = """
+# modified by laia-gen-lib:
+
+from laiagenlib.models.Model import LaiaBaseModel"""
+
+    with open(output_file, 'r') as f:
+        model_content = f.read()
+
+    lines = model_content.split('\n')
+    import_index = next((i for i, line in enumerate(lines) if "from __future__ import annotations" in line), None)
+
+    if import_index is not None:
+        lines.insert(import_index + 1, import_statement)
+
+    modified_content = '\n'.join(lines)
+    modified_content = re.sub(r'class\s+(\w+)\(BaseModel\):', r'class \1(LaiaBaseModel):', modified_content)
+
+    with open(output_file, 'w') as f:
+        f.write(modified_content)
+
+    print(f"File '{output_file}' created and modified.")
+
+async def create_element(element: T, crud_instance: CRUD):
+    model_name = element.__class__.__name__.lower()
+
+    return await crud_instance.post_item(model_name, element)

laia-gen-lib-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

laia-gen-lib-0.1.0/setup.py

@@ -0,0 +1,13 @@
+from setuptools import find_packages, setup
+
+setup(
+    name='laia-gen-lib',
+    packages=find_packages(),
+    version='0.1.0',
+    description='An AI application generator engine',
+    author='Me',
+    install_requires=['pymongo', 'pydantic', 'datamodel-code-generator'],
+    setup_requires=['pytest-runner'],
+    tests_require=['pytest', 'pymongo', 'pytest-asyncio'],
+    test_suite='tests',
+)

laia-gen-lib-0.1.0/tests/models/test_access_rights.py

@@ -0,0 +1,155 @@
+import pytest
+import pytest_asyncio
+from pymongo import MongoClient
+from laiagenlib.crud.crud_mongo_impl import CRUDMongoImpl
+from laiagenlib.models.AccessRights import AccessRights
+from laiagenlib.models.Model import LaiaBaseModel
+
+class User(LaiaBaseModel):
+    description: str
+    age: int
+
+@pytest.fixture
+def in_memory_db():
+    client = MongoClient()
+    db = client["testdb"]
+    db.drop_collection("accessrights")
+    return db
+
+@pytest_asyncio.fixture
+async def crud_instance(in_memory_db):
+    return CRUDMongoImpl(in_memory_db)
+
+class TestAccessRights:
+
+    @pytest.mark.asyncio
+    async def test_model_name_different_that_model_raises_exception(self, crud_instance):
+        user_roles = ["admin"]
+        new_access_rights = {
+            "role": "owner",
+            "model": "drone",
+            "operations": {"create": 1, "read": 1},
+            "fields_create": {"description": 1},
+            "fields_edit": {},
+            "fields_visible": {"description": 1}
+        }
+
+        with pytest.raises(ValueError, match="Provided model name does not match the class model name"):
+            await AccessRights.create(new_access_rights, User, user_roles, crud_instance)
+    
+    @pytest.mark.asyncio
+    async def test_create_access_rights_no_admin_permission_raises_exception(self, crud_instance):
+        user_roles = ["user"]
+        new_access_rights = {
+            "role": "userAdmin",
+            "model": "user",
+            "operations": {"create": 1, "read": 1},
+            "fields_create": {"description": 1},
+            "fields_edit": {},
+            "fields_visible": {"description": 1}
+        }
+
+        with pytest.raises(PermissionError, match="Only users with 'admin' role can create access rights"):
+            await AccessRights.create(new_access_rights, User, user_roles, crud_instance)
+
+    @pytest.mark.asyncio
+    async def test_create_access_rights_admin_permission(self, crud_instance):
+        user_roles = ["admin"]
+        new_access_rights = {
+            "role": "userAdmin",
+            "model": "user",
+            "operations": {"create": 1, "read": 1},
+            "fields_create": {"description": 1},
+            "fields_edit": {"name": 1},
+            "fields_visible": {"description": 1}
+        }
+
+        created_access_rights = await AccessRights.create(new_access_rights, User, user_roles, crud_instance)
+
+        assert created_access_rights.role == "userAdmin"
+        assert created_access_rights.model == "user"
+
+    @pytest.mark.asyncio
+    async def test_create_access_rights_admin_permission(self, crud_instance):
+        user_roles = ["admin"]
+        new_access_rights = {
+            "role": "userAdmin",
+            "operations": {"create": 1, "read": 1},
+            "fields_create": {"description": 1},
+            "fields_edit": {"name": 1},
+            "fields_visible": {"description": 1}
+        }
+
+        with pytest.raises(ValueError, match="Missing required parameters"):
+            await AccessRights.create(new_access_rights, User, user_roles, crud_instance)
+
+    @pytest.mark.asyncio
+    async def test_create_access_rights_invalid_operations(self, crud_instance):
+        user_roles = ["admin"]
+        new_access_rights = {
+            "role": "userAdmin",
+            "model": "user",
+            "operations": {"invalid_op": 1},
+            "fields_create": {"description": 1},
+            "fields_edit": {"name": 1},
+            "fields_visible": {"description": 1}
+        }
+
+        with pytest.raises(ValueError, match="Invalid format for operation invalid_op"):
+            await AccessRights.create(new_access_rights, User, user_roles, crud_instance)
+
+    @pytest.mark.asyncio
+    async def test_create_access_rights_invalid_fields_format(self, crud_instance):
+        user_roles = ["admin"]
+        new_access_rights = {
+            "role": "userAdmin",
+            "model": "user",
+            "operations": {"create": 1, "read": 1},
+            "fields_create": "invalid_format",
+            "fields_edit": {"name": 1},
+            "fields_visible": {"description": 1}
+        }
+
+        with pytest.raises(ValueError, match="Invalid format for fields_create"):
+            await AccessRights.create(new_access_rights, User, user_roles, crud_instance)
+
+    @pytest.mark.asyncio
+    async def test_create_access_rights_invalid_field_name(self, crud_instance):
+        user_roles = ["admin"]
+        new_access_rights = {
+            "role": "userAdmin",
+            "model": "user",
+            "operations": {"create": 1, "read": 1},
+            "fields_create": {"invalid_field": 1},
+            "fields_edit": {"name": 1},
+            "fields_visible": {"description": 1}
+        }
+
+        with pytest.raises(ValueError, match="Invalid field invalid_field for fields_create"):
+            await AccessRights.create(new_access_rights, User, user_roles, crud_instance)
+
+    @pytest.mark.asyncio
+    async def test_create_access_rights_already_exists(self, crud_instance):
+        user_roles = ["admin"]
+        existing_access_rights = {
+            "role": "userAdmin",
+            "model": "user",
+            "operations": {"create": 1, "read": 1},
+            "fields_create": {"description": 1},
+            "fields_edit": {"name": 1},
+            "fields_visible": {"description": 1}
+        }
+
+        await AccessRights.create(existing_access_rights, User, user_roles, crud_instance)
+
+        new_access_rights = {
+            "role": "userAdmin",
+            "model": "user",
+            "operations": {"create": 1, "read": 1},
+            "fields_create": {"description": 1},
+            "fields_edit": {"name": 1},
+            "fields_visible": {"description": 1}
+        }
+
+        with pytest.raises(ValueError, match="AccessRights with the same role and model already exists"):
+            await AccessRights.create(new_access_rights, User, user_roles, crud_instance)

laia-gen-lib-0.1.0/tests/models/test_model.py

@@ -0,0 +1,258 @@
+import pytest
+import pytest_asyncio
+from pymongo import MongoClient
+from laiagenlib.crud.crud_mongo_impl import CRUDMongoImpl
+from laiagenlib.models.Model import LaiaBaseModel
+from laiagenlib.models.AccessRights import AccessRights
+from laiagenlib.utils.logger import _logger
+
+class User(LaiaBaseModel):
+    description: str
+    age: int
+
+class Drone(LaiaBaseModel):
+    description: str
+    weight: float
+    max_altitude: float
+    max_speed: float
+
+@pytest.fixture
+def in_memory_db():
+    client = MongoClient()
+    db = client["testdb"]
+    db.drop_collection("user")
+    db.drop_collection("drone")
+    db.drop_collection("accessrights")
+    return db
+
+@pytest_asyncio.fixture
+async def crud_instance(in_memory_db):
+    return CRUDMongoImpl(in_memory_db)
+
+class TestModel:
+
+    @pytest.mark.asyncio
+    async def test_model_created_by_admin(self, crud_instance):
+        user_roles = ["admin"]
+        new_user = {
+            "name": "alba",
+            "description": "This is a description",
+            "age": 21
+        }
+        await User.create(new_user, User, user_roles, crud_instance)
+    
+    @pytest.mark.asyncio
+    async def test_create_element_missing_parameters_raises_exception(self, crud_instance):
+        user_roles = ["admin"]
+        new_user = {
+            "name": "alba",
+            "description": "This is a description",
+        }
+
+        with pytest.raises(ValueError, match="Missing required parameters"):
+            await User.create(new_user, User, user_roles, crud_instance)
+
+    @pytest.mark.asyncio
+    async def test_create_element_missing_access_rights(self, crud_instance):
+        user_roles = ["userAdmin"]
+        new_user = {
+            "name": "alba",
+            "description": "This is a description",
+            "age": 21
+        }
+
+        with pytest.raises(PermissionError, match="None of the roles have sufficient permissions for operation 'create' on model 'user'"):
+            await User.create(new_user, User, user_roles, crud_instance)
+
+    @pytest.mark.asyncio
+    async def test_create_element_missing_access_rights_create_operation(self, crud_instance):
+        new_access_rights = {
+            "role": "userAdmin",
+            "model": "user",
+            "operations": {"read": 1},
+            "fields_create": {"description": 1},
+            "fields_edit": {"name": 1},
+            "fields_visible": {"description": 1}
+        }
+
+        await AccessRights.create(new_access_rights, User, ["admin"], crud_instance)
+        
+        user_roles = ["userAdmin"]
+        new_user = {
+            "name": "alba",
+            "description": "This is a description",
+            "age": 21
+        }
+
+        with pytest.raises(PermissionError, match="None of the roles have sufficient permissions for operation 'create' on model 'user'"):
+            await User.create(new_user, User, user_roles, crud_instance)
+
+    @pytest.mark.asyncio
+    async def test_create_element_missing_access_rights_specific_field(self, crud_instance):
+        new_access_rights = {
+            "role": "userAdmin",
+            "model": "user",
+            "operations": {"create": 1, "read": 1},
+            "fields_create": {"name": 1, "description": 1},
+            "fields_edit": {"name": 1},
+            "fields_visible": {"description": 1}
+        }
+
+        await AccessRights.create(new_access_rights, User, ["admin"], crud_instance)
+        
+        user_roles = ["userAdmin"]
+        new_user = {
+            "name": "alba",
+            "description": "This is a description",
+            "age": 21
+        }
+
+        with pytest.raises(PermissionError, match="Insufficient permissions to create the field 'age' in any role."):
+            await User.create(new_user, User, user_roles, crud_instance)
+
+    @pytest.mark.asyncio
+    async def test_create_element_with_different_role(self, crud_instance):
+        new_access_rights1 = {
+            "role": "userAdmin1",
+            "model": "user",
+            "operations": {"create": 1, "read": 1},
+            "fields_create": {"name": 1, "description": 1},
+            "fields_edit": {"name": 1},
+            "fields_visible": {"description": 1}
+        }
+
+        new_access_rights2 = {
+            "role": "userAdmin2",
+            "model": "user",
+            "operations": {"create": 1, "read": 1},
+            "fields_create": {"name": 1, "description": 1, "age": 1},
+            "fields_edit": {"name": 1},
+            "fields_visible": {"description": 1}
+        }
+
+
+        await AccessRights.create(new_access_rights1, User, ["admin"], crud_instance)
+        await AccessRights.create(new_access_rights2, User, ["admin"], crud_instance)
+        
+        user_roles = ["userAdmin1", "userAdmin2"]
+        new_user = {
+            "name": "alba",
+            "description": "This is a description",
+            "age": 21
+        }
+
+        user = await User.create(new_user, User, user_roles, crud_instance)
+
+        assert user is not None
+        assert user["description"] == "This is a description"
+
+    @pytest.mark.asyncio
+    async def test_model_updated_by_admin(self, crud_instance):
+        user_roles = ["admin"]
+        new_user = {
+            "name": "alba",
+            "description": "This is a description",
+            "age": 21
+        }
+        
+        user = await User.create(new_user, User, user_roles, crud_instance)
+        
+        updated_user = await User.update(user["id"], {"name": "blanca"}, User, user_roles, crud_instance)
+
+        assert updated_user is not None
+        assert updated_user["name"] == "blanca"
+        assert updated_user["description"] == user["description"]
+        assert updated_user["age"] == user["age"]
+        assert updated_user["id"] == user["id"]
+
+    @pytest.mark.asyncio
+    async def test_read_element_missing_access_rights_read_operation(self, crud_instance):
+        new_access_rights = {
+            "role": "userAdmin",
+            "model": "user",
+            "operations": {"create": 1, "update": 1},
+            "fields_create": {"name": 1, "description": 1},
+            "fields_edit": {"name": 1},
+            "fields_visible": {"description": 1}
+        }
+
+        await AccessRights.create(new_access_rights, User, ["admin"], crud_instance)
+        
+        user_roles = ["userAdmin"]
+        new_user = {
+            "name": "alba",
+            "description": "This is a description",
+            "age": 21
+        }
+        
+        user = await User.create(new_user, User, ["admin"], crud_instance)
+
+        with pytest.raises(PermissionError, match="None of the roles have sufficient permissions for operation 'read' on model 'user'"):
+            await User.read(user["id"], User, user_roles, crud_instance)
+
+    @pytest.mark.asyncio
+    async def test_read_element_missing_access_rights_specific_field(self, crud_instance):
+        new_access_rights = {
+            "role": "userAdmin",
+            "model": "user",
+            "operations": {"create": 1, "read": 1, "update": 1},
+            "fields_create": {"name": 1, "description": 1},
+            "fields_edit": {"name": 1},
+            "fields_visible": {"description": 1}
+        }
+
+        await AccessRights.create(new_access_rights, User, ["admin"], crud_instance)
+        
+        user_roles = ["userAdmin"]
+        new_user = {
+            "name": "alba",
+            "description": "This is a description",
+            "age": 21
+        }
+        
+        user = await User.create(new_user, User, ["admin"], crud_instance)
+
+        user_read = await User.read(user["id"], User, user_roles, crud_instance)
+
+        assert user_read == {"description": "This is a description"}
+
+    @pytest.mark.asyncio
+    async def test_delete_element(self, crud_instance): 
+        user_roles = ["admin"]
+        new_user = {
+            "name": "alba",
+            "description": "This is a description",
+            "age": 21
+        }
+        
+        user = await User.create(new_user, User, user_roles, crud_instance)
+
+        await User.delete(user["id"], User, user_roles, crud_instance)
+
+        with pytest.raises(ValueError, match=f"user with ID {user['id']} not found"):
+            await User.read(user["id"], User, user_roles, crud_instance)
+
+    @pytest.mark.asyncio
+    async def test_delete_element_missing_access_rights_delete_operation(self, crud_instance):
+        new_access_rights = {
+            "role": "userAdmin",
+            "model": "user",
+            "operations": {"create": 1, "update": 1},
+            "fields_create": {"name": 1, "description": 1},
+            "fields_edit": {"name": 1},
+            "fields_visible": {"description": 1}
+        }
+
+        await AccessRights.create(new_access_rights, User, ["admin"], crud_instance)
+        
+        user_roles = ["userAdmin"]
+        new_user = {
+            "name": "alba",
+            "description": "This is a description",
+            "age": 21
+        }
+        
+        user = await User.create(new_user, User, ["admin"], crud_instance)
+
+        with pytest.raises(PermissionError, match="None of the roles have sufficient permissions for operation 'delete' on model 'user'"):
+            await User.delete(user["id"], User, user_roles, crud_instance)

laia-gen-lib-0.1.0/tests/models/test_openapi.py

@@ -0,0 +1,26 @@
+import pytest
+import re
+import os
+from laiagenlib.models.Openapi import OpenAPI
+
+@pytest.fixture
+def test_files(request):
+    test_dir = os.path.dirname(os.path.abspath(request.module.__file__))
+    input_file1 = os.path.join(test_dir, "..", "openapi_files", "api.yaml")
+    input_file2 = os.path.join(test_dir, "..", "openapi_files", "api2.yaml")
+    input_file3 = os.path.join(test_dir, "..", "openapi_files", "api3.yaml")
+    yield input_file1, input_file2, input_file3
+
+def test_create_models_file(test_files):
+    input_file1, input_file2, input_file3 = test_files
+
+    parser = OpenAPI(input_file1)
+    assert len(parser.routes) == 8
+
+    parser2 = OpenAPI(input_file2)
+    assert len(parser2.routes) == 6
+
+    parser3 = OpenAPI(input_file3)
+    assert len(parser3.routes) == 1
+
+    

laia-gen-lib-0.1.0/tests/models/test_role.py

@@ -0,0 +1,58 @@
+import pytest
+import pytest_asyncio
+from pymongo import MongoClient
+from laiagenlib.crud.crud_mongo_impl import CRUDMongoImpl
+from laiagenlib.models.Role import Role
+
+@pytest.fixture
+def in_memory_db():
+    client = MongoClient()
+    db = client["testdb"]
+    db.drop_collection("role")
+    return db
+
+@pytest_asyncio.fixture
+async def crud_instance(in_memory_db):
+    return CRUDMongoImpl(in_memory_db)
+
+class TestRole:
+
+    @pytest.mark.asyncio
+    async def test_create_role_without_name_raises_exception(self, crud_instance):
+        user_roles = ["admin"]
+        new_role = {"something": "test_role"}
+
+        with pytest.raises(ValueError, match="Missing required parameter: name"):
+            await Role.create(new_role, user_roles, crud_instance)
+
+    @pytest.mark.asyncio
+    async def test_create_role_admin_permission(self, crud_instance):
+        user_roles = ["admin"]
+        new_role = {"name": "test_role"}
+
+        created_role = await Role.create(new_role, user_roles, crud_instance)
+
+        assert created_role.name == "test_role"
+        
+        found_roles, _ = await crud_instance.get_items("role", filters={"name": "test_role"})
+
+        assert len(found_roles) == 1
+        assert found_roles[0]["name"] == "test_role"
+
+    @pytest.mark.asyncio
+    async def test_create_role_different_permission(self, crud_instance):
+        user_roles = ["user"]
+        new_role = {"name": "test_role"}
+
+        with pytest.raises(PermissionError, match="Only users with 'admin' role can create new roles"):
+            await Role.create(new_role, user_roles, crud_instance)
+
+    @pytest.mark.asyncio
+    async def test_create_role_duplicate_name(self, crud_instance):
+        user_roles = ["admin"]
+        new_role = {"name": "test_role"}
+
+        await Role.create(new_role, user_roles, crud_instance)
+
+        with pytest.raises(ValueError, match=f"Role with name '{new_role['name']}' already exists"):
+            await Role.create(new_role, user_roles, crud_instance)