liberty-framework 6.0.45__tar.gz → 6.0.46__tar.gz

{liberty_framework-6.0.45/liberty_framework.egg-info → liberty_framework-6.0.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: liberty-framework
-Version: 6.0.45
+Version: 6.0.46
 Summary: Liberty Framework
 Author: Franck Blettner
 Author-email: franck.blettner@nomana-it.fr
@@ -84,6 +84,9 @@ Dynamic: summary
 # 📖 Liberty Framework  
 ### A Scalable and Extensible FastAPI and React Framework for Business Applications  
 
+## Announcements
+- **Release 6.0.46**: Implement call for custom rest api, add drop and create database for framework
+
 🚀 **Liberty Framework** is a powerful, modular, and extensible **FastAPI-based and React-based framework** designed to streamline backend development for business applications. It provides **database management, authentication, real-time socket communication, and more**, making it easy to deploy and scale enterprise solutions.  
 
 - Online demo is available at [https://liberty.nomana-it.fr](https://liberty.nomana-it.fr)

{liberty_framework-6.0.45 → liberty_framework-6.0.46}/README.md

@@ -1,6 +1,9 @@
 # 📖 Liberty Framework  
 ### A Scalable and Extensible FastAPI and React Framework for Business Applications  
 
+## Announcements
+- **Release 6.0.46**: Implement call for custom rest api, add drop and create database for framework
+
 🚀 **Liberty Framework** is a powerful, modular, and extensible **FastAPI-based and React-based framework** designed to streamline backend development for business applications. It provides **database management, authentication, real-time socket communication, and more**, making it easy to deploy and scale enterprise solutions.  
 
 - Online demo is available at [https://liberty.nomana-it.fr](https://liberty.nomana-it.fr)

{liberty_framework-6.0.45 → liberty_framework-6.0.46}/app/controllers/api_controller.py

@@ -76,4 +76,6 @@ class ApiController:
     
     async def ai_welcome(self, req: Request):
         return await self.apiRest.ai_welcome(req)      
-        
+        
+    async def rest(self, req: Request):
+        return await self.apiRest.rest(req)          

{liberty_framework-6.0.45 → liberty_framework-6.0.46}/app/controllers/setup_controller.py

@@ -37,4 +37,10 @@ class SetupController:
         return self.alembic.revision(req)          
     
     def current(self, req: Request):
-        return self.alembic.current(req)           
+        return self.alembic.current(req)           
+    
+    async def create(self, req: Request):
+        return await self.setupRest.create_database(req)    
+    
+    async def drop(self, req: Request):
+        return await self.setupRest.drop_database(req)        

{liberty_framework-6.0.45 → liberty_framework-6.0.46}/app/logs/files/logs-frontend-json.log

@@ -201,3 +201,6 @@
 {"timestamp": "2025-02-20T09:15:08.302464+00:00", "transactionName": "QueryDAO.applications", "level": "info", "method": "GET", "url": "http://localhost:5173/api/fmw/applications", "data": {"message": "Request failed with status code 500: undefined"}, "message": "Framework: Load Applications", "category": "http", "feature": "database-api", "isException": true}
 {"timestamp": "2025-02-20T09:15:08.303872+00:00", "transactionName": "loginUtils.getApplications", "level": "info", "method": null, "url": null, "data": {"status": "error", "items": [{"message": "Request failed with status code 500: undefined"}]}, "message": "Login: Failed to fetch applications", "category": "debug", "feature": "console", "isException": true}
 {"timestamp": "2025-02-20T09:20:53.819597+00:00", "transactionName": "QueryDAO.login", "level": "info", "method": "GET", "url": "http://localhost:5173/api/auth/user?user=admin&pool=libnsx1&mode=session", "data": {"message": "Request failed with status code 500: Error creating pool: Error creating pool: [Errno 8] nodename nor servname provided, or not known"}, "message": "User Login: Get User Properties", "category": "http", "feature": "database-api", "isException": true}
+{"timestamp": "2025-02-26T15:16:17.684769+00:00", "transactionName": "APIDAO.post", "level": "info", "method": "POST", "url": "http://localhost:5173/api/rest?pool=default&mode=session&api=1", "data": null, "message": "REST: Failed POST API call", "category": "http", "feature": "rest-api", "isException": true}
+{"timestamp": "2025-02-26T16:00:40.041233+00:00", "transactionName": "APIDAO.post", "level": "info", "method": "POST", "url": "http://localhost:5173/api/rest?pool=default&mode=session&api=1", "data": null, "message": "REST: Failed POST API call", "category": "http", "feature": "rest-api", "isException": true}
+{"timestamp": "2025-02-26T16:27:09.583000+00:00", "transactionName": "APIDAO.post", "level": "info", "method": "POST", "url": "http://localhost:5173/api/rest?pool=default&mode=session&api=1", "data": null, "message": "REST: Failed POST API call", "category": "http", "feature": "rest-api", "isException": true}

{liberty_framework-6.0.45 → liberty_framework-6.0.46}/app/logs/files/logs-frontend-text.log

@@ -810,3 +810,15 @@ Category: debug, Feature: console, IsException: True
 Method: GET, URL: http://localhost:5173/api/auth/user?user=admin&pool=libnsx1&mode=session
 Category: http, Feature: database-api, IsException: True
 
+[2025-02-26T15:16:17.684769+00:00] [info] APIDAO.post - REST: Failed POST API call
+Method: POST, URL: http://localhost:5173/api/rest?pool=default&mode=session&api=1
+Category: http, Feature: rest-api, IsException: True
+
+[2025-02-26T16:00:40.041233+00:00] [info] APIDAO.post - REST: Failed POST API call
+Method: POST, URL: http://localhost:5173/api/rest?pool=default&mode=session&api=1
+Category: http, Feature: rest-api, IsException: True
+
+[2025-02-26T16:27:09.583000+00:00] [info] APIDAO.post - REST: Failed POST API call
+Method: POST, URL: http://localhost:5173/api/rest?pool=default&mode=session&api=1
+Category: http, Feature: rest-api, IsException: True
+

liberty_framework-6.0.46/app/models/setup.py

@@ -0,0 +1,44 @@
+from pydantic import BaseModel
+
+
+class SetupRequest(BaseModel):
+    host: str
+    port: int
+    database: str
+    user: str
+    password: str
+
+SETUP_ERROR_MESSAGE = "Setup failed"
+SETUP_RESPONSE_DESCRIPTION = "Installation successful"
+SETUP_RESPONSE_EXAMPLE = {
+    "items": [],
+    "status": "success",
+    "count": 0
+}     
+
+class CreateRequest(BaseModel):
+    host: str
+    port: int
+    database: str
+    user: str
+    password: str
+
+CREATE_ERROR_MESSAGE = "Create database failed"
+CREATE_RESPONSE_DESCRIPTION = "Create database successful"
+CREATE_RESPONSE_EXAMPLE = {
+    "items": [],
+    "status": "success",
+    "count": 0
+}     
+
+class DropRequest(BaseModel):
+    database: str
+    user: str
+
+DROP_ERROR_MESSAGE = "Drop database failed"
+DROP_RESPONSE_DESCRIPTION = "Drop Database successful"
+DROP_RESPONSE_EXAMPLE = {
+    "items": [],
+    "status": "success",
+    "count": 0
+}   

{liberty_framework-6.0.45 → liberty_framework-6.0.46}/app/routes/api_routes.py

@@ -230,7 +230,7 @@ def setup_api_routes(app, controller: ApiController, jwt: JWT):
     ):
         return await controller.close(req)
 
-
+    
     @router.get(
         "/db/query",
         response_model=GetSuccessResponse,  # Specify the success response schema
@@ -426,4 +426,66 @@ def setup_api_routes(app, controller: ApiController, jwt: JWT):
         return await controller.ai_welcome(req)   
 
 
+    @router.post(
+        "/rest",
+        response_model=PostSuccessResponse,  # Specify the success response schema
+        responses={
+            200: response_200(PostSuccessResponse, POST_APIDB_RESPONSE_DESCRIPTION, POST_APIDB_RESPONSE_EXAMPLE),
+            400: response_400("Request body cannot be empty."),
+            422: response_422(),
+            500: response_500(PostErrorResponse, POST_APIDB_ERROR_EXAMPLE),
+        },
+        summary="REST - Call Post Api",
+        description="Call a rest api (post).",
+        tags=["Query"],
+    )
+    async def post(
+        req: Request,
+        jwt: str = Depends(jwt.is_valid_jwt),
+        source: QuerySource = Query(None, description="The source to retrieve the query definition. Valid values: `framework`, `query`"),
+        type: QueryType = Query(None, description="The type of query, get data or metadata. Valid values: `table`, `columns`."),
+        pool: str = Query(None, description="The database pool alias to retrieve the query definition. (e.g., `default`, `libnsx1`)"),
+        mode: SessionMode = Query(None, description="The session mode, retrieve data from framework table or pool. Valid values: `framework`, `session`"),
+        query: int = Query(None, description="The query ID to execute. (e.g., `1`, `2`)"),
+        override_pool: Optional[str] = Query(None, description="Override the default pool set in the query definition. (e.g., `default`, `libnsx1`)"),
+        body: Dict[str, Any] = Body(..., description="JSON object with key-value pairs is required.")
+):
+        if not body:  # Check if the body is empty
+            raise HTTPException(
+                status_code=400,
+                detail="Request body cannot be empty. JSON object with key-value pairs is required.",
+            )
+        return await controller.rest(req)
+
+    @router.get(
+        "/rest",
+        response_model=PostSuccessResponse,  # Specify the success response schema
+        responses={
+            200: response_200(PostSuccessResponse, POST_APIDB_RESPONSE_DESCRIPTION, POST_APIDB_RESPONSE_EXAMPLE),
+            400: response_400("Request body cannot be empty."),
+            422: response_422(),
+            500: response_500(PostErrorResponse, POST_APIDB_ERROR_EXAMPLE),
+        },
+        summary="REST - Call Post Api",
+        description="Call a rest api (post).",
+        tags=["Query"],
+    )
+    async def get(
+        req: Request,
+        jwt: str = Depends(jwt.is_valid_jwt),
+        source: QuerySource = Query(None, description="The source to retrieve the query definition. Valid values: `framework`, `query`"),
+        type: QueryType = Query(None, description="The type of query, get data or metadata. Valid values: `table`, `columns`."),
+        pool: str = Query(None, description="The database pool alias to retrieve the query definition. (e.g., `default`, `libnsx1`)"),
+        mode: SessionMode = Query(None, description="The session mode, retrieve data from framework table or pool. Valid values: `framework`, `session`"),
+        query: int = Query(None, description="The query ID to execute. (e.g., `1`, `2`)"),
+        override_pool: Optional[str] = Query(None, description="Override the default pool set in the query definition. (e.g., `default`, `libnsx1`)"),
+        body: Dict[str, Any] = Body(..., description="JSON object with key-value pairs is required.")
+):
+        if not body:  # Check if the body is empty
+            raise HTTPException(
+                status_code=400,
+                detail="Request body cannot be empty. JSON object with key-value pairs is required.",
+            )
+        return await controller.rest(req)
+    
     app.include_router(router, prefix="/api")

{liberty_framework-6.0.45 → liberty_framework-6.0.46}/app/routes/setup_routes.py

@@ -8,7 +8,7 @@ from fastapi import APIRouter, Request
 
 from app.controllers.setup_controller import SetupController
 from app.models.base import ErrorResponse, SuccessResponse, response_200, response_422, response_500
-from app.models.setup import SETUP_ERROR_MESSAGE, SETUP_RESPONSE_DESCRIPTION, SETUP_RESPONSE_EXAMPLE, SetupRequest
+from app.models.setup import CREATE_ERROR_MESSAGE, CREATE_RESPONSE_DESCRIPTION, CREATE_RESPONSE_EXAMPLE, DROP_ERROR_MESSAGE, DROP_RESPONSE_DESCRIPTION, DROP_RESPONSE_EXAMPLE, SETUP_ERROR_MESSAGE, SETUP_RESPONSE_DESCRIPTION, SETUP_RESPONSE_EXAMPLE, CreateRequest, DropRequest, SetupRequest
 
 
 def setup_setup_routes(app, controller: SetupController):
@@ -205,4 +205,42 @@ def setup_setup_routes(app, controller: SetupController):
         ):
         return controller.current(req)
 
-    app.include_router(router, prefix="/api")
+
+    @router.post(
+        "/db/create",
+        summary="DATABASE - Create",
+        description="Create database for new application",
+        tags=["Database"], 
+        response_model=SuccessResponse,
+        responses={
+            200: response_200(SuccessResponse, CREATE_RESPONSE_DESCRIPTION, CREATE_RESPONSE_EXAMPLE),
+            422: response_422(),  
+            500: response_500(ErrorResponse, CREATE_ERROR_MESSAGE),
+        },
+    )
+    async def create(
+        req: Request,
+        body: CreateRequest,
+    ):
+        return await controller.create(req)
+    
+    @router.post(
+        "/db/drop",
+        summary="DATABASE - Drop",
+        description="Drop an existing database",
+        tags=["Database"], 
+        response_model=SuccessResponse,
+        responses={
+            200: response_200(SuccessResponse, DROP_RESPONSE_EXAMPLE, DROP_RESPONSE_DESCRIPTION),
+            422: response_422(),  
+            500: response_500(ErrorResponse, DROP_ERROR_MESSAGE),
+        },
+    )
+    async def drop(
+        req: Request,
+        body: DropRequest,
+    ):
+        return await controller.drop(req)
+    
+    app.include_router(router, prefix="/api")
+

{liberty_framework-6.0.45 → liberty_framework-6.0.46}/app/services/api_rest.py

@@ -1,11 +1,15 @@
 # Description: API REST service for handling REST API requests.
 import logging
 import os
+import re
+from urllib.parse import urljoin, urlparse
 
+from fastapi.responses import JSONResponse
 import httpx
 from pydantic import BaseModel
 
-from app.services.db_query import Query
+from app.services.db_query import Query, SessionMode
+from app.utils.encrypt import Encryption
 logger = logging.getLogger(__name__)
 
 import json
@@ -14,14 +18,12 @@ from datetime import datetime, timezone
 from app.utils.logs import LogHandler
 from app.logs import get_logs_json_path, get_logs_text_path
 
+defaultPool = "default"
+
 class ApiType:
     internal = "INTERNAL"
     external = "EXTERNAL"
 
-class ApiFramework:
-    CreateFrameworkDatabase = "CreateFrameworkDatabase"
-    DropFrameworkDatabase = "DropFrameworkDatabase"
-
 class AIResponse(BaseModel):
     message: str
     is_truncated: bool
@@ -32,6 +34,95 @@ class Rest:
         self.logs_handler = LogHandler()
         self.queryRest = queryRest
 
+    async def rest(self, req: Request):
+        try:
+            query_params = req.query_params
+
+            """Extracts OpenAI API URL and Key from MODULE_ID = 'AI'."""
+            query = {
+                "QUERY": 34,
+                "POOL": query_params.get("mode") == SessionMode.framework and defaultPool or query_params.get("pool"),
+                "CRUD": "GET",
+            }
+            context = {
+                "row_offset": 0,
+                "row_limit": 1000,
+                "where": {"API_ID":query_params.get("api")},
+            }
+            # Get the target query using the framework query method
+            target_query = await self.queryRest.db_pools.get_pool("default").db_dao.get_framework_query(
+                query, self.queryRest.db_pools.get_pool("default").db_type
+            )
+
+            api = await self.queryRest.db_pools.get_pool("default").db_dao.get(target_query, context)
+            rows = api.get("rows")
+
+            if not api.get("rows"):
+                raise ValueError("No API found")
+
+            row = rows[0]  # Extract the first row (dictionary)
+            
+            api_type = row.get("API_SOURCE")
+            method = row.get("API_METHOD")
+            url = row.get("API_URL")
+            user = row.get("API_USER")
+            password = row.get("API_PASSWORD")
+            body = row.get("API_BODY")
+
+            # Convert API_BODY from JSON string format to a Python dictionary
+            body_dict = json.loads(body)  
+
+            # 🔹 Ensure request body is retrieved properly
+            req_body = await req.json()  
+
+            # Perform variable substitution in body
+            body_str = json.dumps(body_dict)  # Convert dictionary to string for replacement
+            for key, value in req_body.items():
+                variable = rf"\${key.upper()}" 
+                body_str = re.sub(variable, str(value), body_str)  
+
+            # Convert back to dictionary
+            parsed_body = json.loads(body_str)
+            if api_type == ApiType.internal:
+                base_url = str(req.base_url) 
+                full_url = urljoin(base_url, url)  
+            else:
+                # Check if `url` is already a full external URL
+                parsed_url = urlparse(url)
+                if parsed_url.scheme and parsed_url.netloc:
+                    full_url = url  # Use the full external URL as is
+                else:
+                    raise ValueError(f"Invalid external URL: {url}")
+
+            # 🔹 Make the API call
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                response = await client.post(full_url, json=parsed_body)
+                if response.status_code == 200:
+                    response_data = response.json()
+                else:
+                    response_data = {
+                        "error": f"Failed request with status code {response.status_code}",
+                        "details": response.text
+                    }
+            response_data = response.json()
+
+            return JSONResponse({
+                "items": response_data,
+                "status": "success",
+                "count": 0,
+            })
+        except Exception as err:
+            message = str(err)
+            return JSONResponse({
+                "items": [{"message": f"Error: {message}"}],
+                "status": "error",
+                "hasMore": False,
+                "limit": context.get("row_limit", 1000),
+                "offset": context.get("row_offset", 0),
+                "count": 0,
+            })
+        
+
 
     async def push_log(self, req: Request):
         """

{liberty_framework-6.0.45 → liberty_framework-6.0.46}/app/setup/services/install.py

@@ -191,3 +191,7 @@ class Install:
         except Exception as e:
             logging.error(f"Update failed: {e}")
 
+
+
+
+        

{liberty_framework-6.0.45 → liberty_framework-6.0.46}/app/setup/services/setup.py

@@ -1,4 +1,6 @@
 import logging
+
+from app.setup.models.liberty import Base
 logger = logging.getLogger(__name__)
 
 from sqlalchemy import create_engine, text
@@ -35,13 +37,6 @@ class Setup:
             admin_password = data.get("admin_password")
             load_data = data.get("load_data", False)
 
-            # Create all tables in the database
-#            for table in Base.metadata.tables.values():
-#                if not table.schema:
-#                    table.schema = database  # 🔹 Assign schema to tables
-#            Base.metadata.create_all(engine)
-#            logging.warning("All tables have been successfully created!")
-
             # Database configuration
             ADMIN_DATABASE_URL = f"postgresql+psycopg2://{user}:{current_password}@{host}:{port}/{admin_database}"
 
@@ -423,4 +418,142 @@ pool_alias=default
                 "items": [{"message": f"Error: {message}"}],
                 "status": "error",
                 "count": 0
-            })
+            })
+        
+
+    async def create_database(self, req: Request):
+        try:
+            data = await req.json()
+            host = data.get("host")
+            port = data.get("port")
+            database = data.get("database")
+            user = data.get("user")
+            password = data.get("password")
+        
+            # Database configuration
+            db_properties_path = get_db_properties_path()
+            config = self.apiController.queryRest.load_db_properties(db_properties_path)
+            # Database configuration
+            ADMIN_DATABASE_URL = f"postgresql+psycopg2://{config["user"]}:{config["password"]}@{config["host"]}:{config["port"]}/{config["database"]}"
+
+                # Create an engine
+            admin_engine = create_engine(ADMIN_DATABASE_URL, isolation_level="AUTOCOMMIT") 
+            with admin_engine.connect() as conn:
+                result = conn.execute(text(f"SELECT 1 FROM pg_database WHERE datname = '{database}'"))
+                db_exists = result.scalar()
+
+                if not db_exists:
+                    logging.warning(f"Creating database '{database}'...")
+                    conn.execute(text(f'CREATE DATABASE "{database}"'))
+                else:
+                    logging.warning(f"Database '{database}' already exists. Skipping creation.")
+                # 🚀 Check if the role exists
+                result = conn.execute(text(f"SELECT 1 FROM pg_roles WHERE rolname = '{user}'"))
+                role_exists = result.scalar()
+
+                if not role_exists:
+                    logging.warning(f"Creating role '{user}' with password...")
+                    conn.execute(text(f"CREATE ROLE {user} WITH LOGIN PASSWORD '{password}'"))
+                else:
+                    logging.warning(f"Role '{user}' already exists. Skipping creation.")
+
+                # 🚀 Grant privileges to the role
+                conn.execute(text(f'GRANT ALL PRIVILEGES ON DATABASE "{database}" TO {user}'))
+                logging.warning(f"Granted privileges to role '{user}' on database '{database}'.")    
+
+            # Create all tables in the database
+            DATABASE_URL = f"postgresql+psycopg2://{user}:{password}@{host}:{port}/{database}"
+            engine = create_engine(DATABASE_URL, echo=False, isolation_level="AUTOCOMMIT") 
+
+            with engine.connect() as conn:
+                result = conn.execute(text(f"SELECT 1 FROM information_schema.schemata WHERE schema_name = '{database}'"))
+                schema_exists = result.scalar()
+
+                if not schema_exists:
+                    logging.warning(f"Creating schema '{user}'...")
+                    conn.execute(text(f'CREATE SCHEMA "{user}" AUTHORIZATION {user}'))
+                else:
+                    logging.warning(f"Schema '{user}' already exists. Skipping creation.")
+
+            for table in Base.metadata.tables.values():
+                if not table.schema:
+                    table.schema = database  
+                    Base.metadata.create_all(engine)
+            
+            logging.warning("All tables have been successfully created!")        
+            # Return the response
+            return JSONResponse({
+                    "items": [],
+                    "status": "success",
+                    "count": 0
+                })
+
+        except Exception as err:
+            message = str(err)
+            return JSONResponse({
+                "items": [{"message": f"Error: {message}"}],
+                "status": "error",
+                "count": 0
+            })            
+        
+    async def drop_database(self, req: Request):
+        try:
+            data = await req.json()
+            database = data.get("database")
+            user = data.get("user")
+        
+            # Database configuration
+            db_properties_path = get_db_properties_path()
+            config = self.apiController.queryRest.load_db_properties(db_properties_path)
+            # Database configuration
+            ADMIN_DATABASE_URL = f"postgresql+psycopg2://{config["user"]}:{config["password"]}@{config["host"]}:{config["port"]}/{config["database"]}"
+
+                # Create an engine
+            admin_engine = create_engine(ADMIN_DATABASE_URL, isolation_level="AUTOCOMMIT") 
+            with admin_engine.connect() as conn:
+                # 🚀 Check if database exists
+                result = conn.execute(text(f"SELECT 1 FROM pg_database WHERE datname = '{database}'"))
+                db_exists = result.scalar()
+
+                if db_exists:
+                    logging.warning(f"Revoking new connections to database '{database}'...")
+                    conn.execute(text(f"UPDATE pg_database SET datallowconn = FALSE WHERE datname = '{database}'"))
+
+                    logging.warning(f"Terminating active connections to database '{database}'...")
+                    conn.execute(text(f"""
+                        SELECT pg_terminate_backend(pg_stat_activity.pid) 
+                        FROM pg_stat_activity 
+                        WHERE pg_stat_activity.datname = '{database}' 
+                        AND pid <> pg_backend_pid();
+                    """))
+
+                    logging.warning(f"Dropping database '{database}'...")
+                    conn.execute(text(f'DROP DATABASE "{database}"'))
+                else:
+                    logging.warning(f"Database '{database}' does not exist. Skipping drop.")
+
+                # 🚀 Check if the role exists
+                result = conn.execute(text(f"SELECT 1 FROM pg_roles WHERE rolname = '{user}'"))
+                role_exists = result.scalar()
+
+                if role_exists:
+                    logging.warning(f"Dropping role '{user}'...")
+                    conn.execute(text(f"DROP ROLE {user}"))
+                else:
+                    logging.warning(f"Role '{user}' does not exist. Skipping drop.")
+            
+            logging.warning("Database successfully dropped!")    
+            # Return the response
+            return JSONResponse({
+                    "items": [],
+                    "status": "success",
+                    "count": 0
+                })
+
+        except Exception as err:
+            message = str(err)
+            return JSONResponse({
+                "items": [{"message": f"Error: {message}"}],
+                "status": "error",
+                "count": 0
+            })                    

{liberty_framework-6.0.45 → liberty_framework-6.0.46/liberty_framework.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: liberty-framework
-Version: 6.0.45
+Version: 6.0.46
 Summary: Liberty Framework
 Author: Franck Blettner
 Author-email: franck.blettner@nomana-it.fr
@@ -84,6 +84,9 @@ Dynamic: summary
 # 📖 Liberty Framework  
 ### A Scalable and Extensible FastAPI and React Framework for Business Applications  
 
+## Announcements
+- **Release 6.0.46**: Implement call for custom rest api, add drop and create database for framework
+
 🚀 **Liberty Framework** is a powerful, modular, and extensible **FastAPI-based and React-based framework** designed to streamline backend development for business applications. It provides **database management, authentication, real-time socket communication, and more**, making it easy to deploy and scale enterprise solutions.  
 
 - Online demo is available at [https://liberty.nomana-it.fr](https://liberty.nomana-it.fr)

{liberty_framework-6.0.45 → liberty_framework-6.0.46}/setup.py

@@ -17,7 +17,7 @@ def read_readme():
 
 setup(
     name="liberty-framework",
-    version="6.0.45",
+    version="6.0.46",
     description="Liberty Framework",
     author="Franck Blettner",
     author_email="franck.blettner@nomana-it.fr",

liberty_framework-6.0.45/app/models/setup.py

@@ -1,17 +0,0 @@
-from pydantic import BaseModel
-
-
-class SetupRequest(BaseModel):
-    host: str
-    port: int
-    database: str
-    user: str
-    password: str
-
-SETUP_ERROR_MESSAGE = "Setup failed"
-SETUP_RESPONSE_DESCRIPTION = "Installation successful"
-SETUP_RESPONSE_EXAMPLE = {
-    "items": [],
-    "status": "success",
-    "count": 0
-}