liberty-framework 6.0.59__tar.gz → 6.0.61__tar.gz

liberty_framework-6.0.61/MANIFEST.in

@@ -0,0 +1,9 @@
+include requirements.txt
+include LICENSE
+include README.md
+recursive-include liberty *
+recursive-include tests *   
+exclude liberty/config/files/db.properties
+exclude liberty/config/files/encryption.key
+exclude liberty/config/files/secrets.json
+exclude liberty/config/files/secrets.json.enc

{liberty_framework-6.0.59/liberty_framework.egg-info → liberty_framework-6.0.61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: liberty-framework
-Version: 6.0.59
+Version: 6.0.61
 Summary: Liberty Framework
 Author: Franck Blettner
 Author-email: franck.blettner@nomana-it.fr

{liberty_framework-6.0.59/app → liberty_framework-6.0.61/liberty}/alembic/env.py

@@ -8,10 +8,10 @@ from sqlalchemy import create_engine, engine_from_config
 from sqlalchemy import pool
 
 from alembic import context
-from app.config import get_db_properties_path
-from app.setup.models import liberty, nomasx1
-from app.utils.encrypt import Encryption
-from app.utils.jwt import JWT
+from liberty.config import get_db_properties_path
+from liberty.setup.models import liberty, nomasx1
+from liberty.utils.encrypt import Encryption
+from liberty.utils.jwt import JWT
 
 USE_TWOPHASE = False
 

{liberty_framework-6.0.59/app → liberty_framework-6.0.61/liberty}/controllers/api_controller.py

@@ -1,44 +1,44 @@
 from fastapi import HTTPException, Request
-from app.utils.encrypt import Encryption
-from app.utils.jwt import JWT
-from app.services.db_query import Query
-from app.services.api_rest import Rest
+from liberty.utils.encrypt import Encryption
+from liberty.utils.jwt import JWT
+from liberty.services.api_services import API
+from liberty.services.rest_services import Rest
 
 class ApiController:
-    def __init__(self, jwt: JWT):
-        self.queryRest = Query(jwt)
-        self.apiRest = Rest(self.queryRest)
+    def __init__(self, jwt: JWT, api: API = None, rest: Rest = None):
+        self.api = api
+        self.rest = rest
         self.jwt = jwt
 
     async def token(self, req: Request):
-        return await self.queryRest.token(req)
+        return await self.api.token(req)
     
     async def user(self, req: Request):
-        return await self.queryRest.user(req)
+        return await self.api.user(req)
     
     async def check(self, req: Request):
-        return await self.queryRest.check(req)
+        return await self.api.check(req)
     
     async def get(self, req: Request):
-        return await self.queryRest.get(req)
+        return await self.api.get(req)
 
     async def post(self, req: Request):
-        return await self.queryRest.post(req)
+        return await self.api.post(req)
 
     async def put(self, req: Request):
-        return await self.queryRest.post(req)
+        return await self.api.post(req)
 
     async def delete(self, req: Request):
-        return await self.queryRest.post(req)
+        return await self.api.post(req)
 
     async def open(self, req: Request):
-        return await self.queryRest.open(req)
+        return await self.api.open(req)
     
     def get_pool_info(self, req: Request, pool: str):
-        return self.queryRest.get_pool_info(req, pool)
+        return self.api.get_pool_info(req, pool)
 
     async def close(self, req: Request):
-        return await self.queryRest.close(req)
+        return await self.api.close(req)
 
     async def encrypt(self, req: Request):
         try:
@@ -51,31 +51,34 @@ class ApiController:
             raise HTTPException(status_code=500, detail=str(err))
 
     async def audit(self, req: Request, table: str, user: str):
-        return await self.queryRest.audit(req, table, user)    
+        return await self.api.audit(req, table, user)    
     
     async def modules(self, req: Request):
-        return await self.queryRest.modules(req)
+        return await self.api.modules(req)
     
     async def applications(self, req: Request):
-        return await self.queryRest.applications(req)    
+        return await self.api.applications(req)    
 
     async def themes(self, req: Request):
-        return await self.queryRest.themes(req)    
+        return await self.api.themes(req)    
     
     async def push_log(self, req: Request):
-        return await self.apiRest.push_log(req)    
+        return await self.rest.push_log(req)    
 
     async def get_log(self, req: Request):
-        return await self.apiRest.get_log(req) 
+        return await self.rest.get_log(req) 
     
     async def get_log_details(self, req: Request):
-        return await self.apiRest.get_log_details(req) 
+        return await self.rest.get_log_details(req) 
 
     async def ai_prompt(self, req: Request):
-        return await self.apiRest.ai_prompt(req)     
+        return await self.rest.ai_prompt(req)     
     
     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)          
+    async def call_rest(self, req: Request):
+        return await self.rest.call_rest(req)          
+    
+    async def version(self, req: Request):
+        return await self.apiRest.get_version(req)           

{liberty_framework-6.0.59/app → liberty_framework-6.0.61/liberty}/controllers/setup_controller.py

@@ -2,10 +2,10 @@ import logging
 logger = logging.getLogger(__name__)
 
 from fastapi import Request
-from app.controllers.api_controller import ApiController
-from app.utils.jwt import JWT
-from app.setup.services.setup import Setup
-from app.setup.services.alembic import Alembic
+from liberty.controllers.api_controller import ApiController
+from liberty.utils.jwt import JWT
+from liberty.setup.services.setup import Setup
+from liberty.setup.services.alembic import Alembic
 
 class SetupController:
     def __init__(self, apiController: ApiController,  jwt: JWT):

{liberty_framework-6.0.59/app → liberty_framework-6.0.61/liberty}/controllers/socket_controller.py

@@ -7,7 +7,7 @@ from fastapi.responses import JSONResponse, HTMLResponse
 from typing import Optional
 from socketio import ASGIApp, AsyncServer
 from fastapi import FastAPI
-from app.controllers.api_controller import ApiController
+from liberty.controllers.api_controller import ApiController
 
 class SocketController:
     def __init__(self, io: Optional[AsyncServer] = None):
@@ -66,7 +66,7 @@ class SocketController:
 
         # Pool info (simulate fetching details from a database pool if needed)
         pool_info = []
-        for pool in self.api_controller.queryRest.db_pools.pools.keys():
+        for pool in self.api_controller.api.db_pools.pools.keys():
             pool_info.append(self.api_controller.get_pool_info(request, pool))
 
         applications = list(set(user["app"] for user in self.connected_clients.values()))

{liberty_framework-6.0.59/app → liberty_framework-6.0.61/liberty}/database/base_dao.py

@@ -9,7 +9,7 @@ from sqlalchemy import text
 import re
 from abc import abstractmethod
 import json
-from app.business.postgres import PostgresQuery
+from liberty.business.postgres import PostgresQuery
 
 class BaseDAO:
     def __init__(self, config: dict):

{liberty_framework-6.0.59/app → liberty_framework-6.0.61/liberty}/database/ora_dao.py

@@ -4,9 +4,9 @@ import re
 from sqlalchemy import text
 from sqlalchemy.ext.asyncio import create_async_engine
 from sqlalchemy.ext.asyncio import AsyncSession
-from app.database.base_dao import BaseDAO
-from app.utils.common import PoolConfig
-from app.business.oracle import OracleQuery
+from liberty.database.base_dao import BaseDAO
+from liberty.utils.common import PoolConfig
+from liberty.business.oracle import OracleQuery
 from sqlalchemy.orm import sessionmaker
 from typing import Dict, List
 

{liberty_framework-6.0.59/app → liberty_framework-6.0.61/liberty}/database/pg_dao.py

@@ -3,8 +3,8 @@ logger = logging.getLogger(__name__)
 import re
 from sqlalchemy import text
 from sqlalchemy.ext.asyncio import create_async_engine
-from app.database.base_dao import BaseDAO
-from app.business.postgres import PostgresQuery
+from liberty.database.base_dao import BaseDAO
+from liberty.business.postgres import PostgresQuery
 from typing import Dict, List
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import sessionmaker

{liberty_framework-6.0.59/app → liberty_framework-6.0.61/liberty}/main.py

@@ -2,8 +2,6 @@ import asyncio
 import logging
 import sys
 
-from app.public import get_frontend_assets_path, get_offline_assets_path, get_setup_assets_path
-
 # Configure global logging
 logging.basicConfig(
     level=logging.WARN,  
@@ -12,25 +10,31 @@ logging.basicConfig(
 
 import os
 from fastapi.responses import JSONResponse
-from fastapi import FastAPI, HTTPException, Request
+from fastapi import FastAPI, HTTPException, Query, Request
 from fastapi.staticfiles import StaticFiles
 from fastapi_socketio import SocketManager
-from app.utils.jwt import JWT
-from app.controllers.setup_controller import SetupController
-from app.controllers.api_controller import ApiController
-from app.controllers.socket_controller import SocketController
-from app.routes.api_routes import setup_api_routes
-from app.routes.react_routes import setup_react_routes
-from app.routes.socket_routes import setup_socket_routes
-from app.routes.setup_routes import setup_setup_routes
-from app.config import get_db_properties_path
-from contextlib import asynccontextmanager
 import uvicorn
+from liberty.utils.jwt import JWT
+from liberty.controllers.setup_controller import SetupController
+from liberty.controllers.api_controller import ApiController
+from liberty.controllers.socket_controller import SocketController
+from liberty.routes.api_routes import setup_api_routes
+from liberty.routes.react_routes import setup_react_routes
+from liberty.routes.socket_routes import setup_socket_routes
+from liberty.routes.setup_routes import setup_setup_routes
+from liberty.config import get_db_properties_path
+from contextlib import asynccontextmanager
+from liberty.public import get_frontend_assets_path, get_offline_assets_path, get_setup_assets_path
+from liberty.services.rest_services import Rest
+from liberty.services.api_services import API
+
 
 class BackendAPI:
     def __init__(self):
         self.jwt = JWT()
-        self.api_controller = ApiController(self.jwt)
+        self.api = API(self.jwt)
+        self.rest = Rest(self.api)
+        self.api_controller = ApiController(self.jwt, self.api, self.rest)
         self.socket_controller = SocketController()
         self.setup_controller = SetupController(self.api_controller, self.jwt)
 
@@ -176,7 +180,7 @@ backend_api.setup_sockets(app)
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    query_instance = backend_api.api_controller.queryRest
+    query_instance = backend_api.api_controller.api
     app.mount(
         "/offline/assets",
         StaticFiles(directory=get_offline_assets_path(), html=True),

{liberty_framework-6.0.59/app → liberty_framework-6.0.61/liberty}/models/apidb.py

@@ -144,4 +144,13 @@ ENCRYPT_ERROR_MESSAGE = "Failed to encrypt data: (sqlalchemy.dialects.postgresql
 ENCRYPT_RESPONSE_DESCRIPTION = "Encryption successful"
 ENCRYPT_RESPONSE_EXAMPLE = {
     "encrypted": "ENC:wNMyALbXf....."
+} 
+
+# Define the full response schema
+class VersionResponse(BaseModel):
+    version: str
+VERSION_ERROR_MESSAGE = "Failed to get the framework version"
+VERSION_RESPONSE_DESCRIPTION = "Version retrieved successfully"
+VERSION_RESPONSE_EXAMPLE = {
+    "version": "6.0.59"
 }