From 64d1c083e02272c61d809ceae56c5aeb076e3b7e Mon Sep 17 00:00:00 2001 From: ValueOn AG Date: Sat, 26 Apr 2025 02:13:22 +0200 Subject: [PATCH] mvp 1.2 ready for single test --- _SAVE_app copy.py | 194 + app.py | 164 +- connectors/_SAVE_connectorDbJson copy.py | 546 ++ ...t_anthropic.py => connectorAiAnthropic.py} | 132 +- ..._aichat_openai.py => connectorAiOpenai.py} | 82 +- connectors/connectorDbJson.py | 561 ++ connectors/connector_db_json.py | 557 -- env_dev.env | 2 +- env_prod.env | 2 +- modules/_SAVE_gatewayInterface copy.py | 261 + ...{chat_agent_analyst.py => agentAnalyst.py} | 440 +- .../{chat_agent_coder.py => agentCoder.py} | 347 +- ...documentation.py => agentDocumentation.py} | 370 +- ...agent_webcrawler.py => agentWebcrawler.py} | 484 +- modules/auth.py | 99 +- modules/chat.py | 1235 ---- modules/chat_content_extraction.py | 778 --- modules/configuration.py | 86 +- .../{def_attributes.py => defAttributes.py} | 60 +- modules/documentProcessor.py | 887 +++ modules/gatewayInterface.py | 471 ++ modules/{gateway_model.py => gatewayModel.py} | 44 +- modules/gateway_interface.py | 458 -- ...cydom_interface.py => lucydomInterface.py} | 922 +-- modules/{lucydom_model.py => lucydomModel.py} | 100 +- ..._registry.py => workflowAgentsRegistry.py} | 132 +- modules/workflowManager.py | 1236 ++++ notes/changelog.txt | 191 +- notes/{frontend.md => doc_frontend.md} | 0 notes/doc_statemachine_backend.md | 366 ++ notes/doc_statemachine_frontend.md | 453 ++ routes/attributes.py | 74 - routes/mandates.py | 216 - routes/prompts.py | 188 - routes/routeAttributes.py | 74 + routes/{files.py => routeFiles.py} | 167 +- routes/routeMandates.py | 199 + routes/routePrompts.py | 160 + routes/routeUsers.py | 249 + routes/routeWorkflows.py | 667 ++ routes/users.py | 265 - routes/workflows.py | 371 -- static/1_test_document.txt | 10 + static/2_test_image.png | Bin 0 -> 287 bytes static/3_q1_sales_chart.svg | 31 + static/44_LF-Details.png | Bin 253009 -> 0 bytes static/45_LF-Details_summary.txt | 27 - static/46_LF-Details_Summary.txt | 30 - static/47_prompt_a1.txt | 1 - static/48_short_story_french.txt | 138 - static/49_bedtime_story_french.txt | 147 - static/4_q1_sales_data.md | 19 + static/50_bedtime_story_french.txt | 101 - static/51_short_story_french.txt | 177 - static/52_french_childrens_story.txt | 244 - static/53_animal_story_fr.txt | 166 - static/54_animal_story_french.txt | 163 - static/55_children_story.txt | 204 - static/56_children_story.txt | 198 - static/57_children_story.txt | 227 - static/58_kinder_geschichte_ueber_fische.txt | 120 - static/59_bean_recipe.txt | 213 - static/5_sales_trends_analysis.txt | 75 + static/60_triage_definition.txt | 37 - static/61_goal_definition.txt | 37 - static/62_handling_definition.txt | 44 - static/63_triangle_definition.txt | 45 - static/64_translation_result.txt | 37 - static/65_definition_greedy.txt | 39 - static/66_workflow_logs.json | 5822 ----------------- static/67_grid_definition.txt | 44 - static/68_summary.txt | 152 - static/69_nacht_gedicht.txt | 228 - static/6_sales_trends_analysis.txt | 71 + static/70_generated_code.py | 33 - static/71_execution_history.json | 13 - static/72_generated_code.py | 39 - static/73_execution_history.json | 13 - static/74_generated_code.py | 33 - static/75_execution_history.json | 13 - static/76_generated_code.py | 42 - static/77_execution_history.json | 13 - static/78_generated_code.py | 39 - static/79_execution_history.json | 13 - static/7_q2_forecast.svg | 1 + static/8_forecast_apr_jun.svg | 1 + test_workflow1.py | 230 - testcode.py | 66 - stats.py => tool_getStats.py | 0 tool_testBackendSingle.py | 432 ++ tool_testData.py | 1064 +++ tool_testUser.py | 244 + 92 files changed, 10279 insertions(+), 15147 deletions(-) create mode 100644 _SAVE_app copy.py create mode 100644 connectors/_SAVE_connectorDbJson copy.py rename connectors/{connector_aichat_anthropic.py => connectorAiAnthropic.py} (59%) rename connectors/{connector_aichat_openai.py => connectorAiOpenai.py} (59%) create mode 100644 connectors/connectorDbJson.py delete mode 100644 connectors/connector_db_json.py create mode 100644 modules/_SAVE_gatewayInterface copy.py rename modules/{chat_agent_analyst.py => agentAnalyst.py} (56%) rename modules/{chat_agent_coder.py => agentCoder.py} (61%) rename modules/{chat_agent_documentation.py => agentDocumentation.py} (53%) rename modules/{chat_agent_webcrawler.py => agentWebcrawler.py} (56%) delete mode 100644 modules/chat.py delete mode 100644 modules/chat_content_extraction.py rename modules/{def_attributes.py => defAttributes.py} (64%) create mode 100644 modules/documentProcessor.py create mode 100644 modules/gatewayInterface.py rename modules/{gateway_model.py => gatewayModel.py} (68%) delete mode 100644 modules/gateway_interface.py rename modules/{lucydom_interface.py => lucydomInterface.py} (50%) rename modules/{lucydom_model.py => lucydomModel.py} (54%) rename modules/{chat_registry.py => workflowAgentsRegistry.py} (58%) create mode 100644 modules/workflowManager.py rename notes/{frontend.md => doc_frontend.md} (100%) create mode 100644 notes/doc_statemachine_backend.md create mode 100644 notes/doc_statemachine_frontend.md delete mode 100644 routes/attributes.py delete mode 100644 routes/mandates.py delete mode 100644 routes/prompts.py create mode 100644 routes/routeAttributes.py rename routes/{files.py => routeFiles.py} (56%) create mode 100644 routes/routeMandates.py create mode 100644 routes/routePrompts.py create mode 100644 routes/routeUsers.py create mode 100644 routes/routeWorkflows.py delete mode 100644 routes/users.py delete mode 100644 routes/workflows.py create mode 100644 static/1_test_document.txt create mode 100644 static/2_test_image.png create mode 100644 static/3_q1_sales_chart.svg delete mode 100644 static/44_LF-Details.png delete mode 100644 static/45_LF-Details_summary.txt delete mode 100644 static/46_LF-Details_Summary.txt delete mode 100644 static/47_prompt_a1.txt delete mode 100644 static/48_short_story_french.txt delete mode 100644 static/49_bedtime_story_french.txt create mode 100644 static/4_q1_sales_data.md delete mode 100644 static/50_bedtime_story_french.txt delete mode 100644 static/51_short_story_french.txt delete mode 100644 static/52_french_childrens_story.txt delete mode 100644 static/53_animal_story_fr.txt delete mode 100644 static/54_animal_story_french.txt delete mode 100644 static/55_children_story.txt delete mode 100644 static/56_children_story.txt delete mode 100644 static/57_children_story.txt delete mode 100644 static/58_kinder_geschichte_ueber_fische.txt delete mode 100644 static/59_bean_recipe.txt create mode 100644 static/5_sales_trends_analysis.txt delete mode 100644 static/60_triage_definition.txt delete mode 100644 static/61_goal_definition.txt delete mode 100644 static/62_handling_definition.txt delete mode 100644 static/63_triangle_definition.txt delete mode 100644 static/64_translation_result.txt delete mode 100644 static/65_definition_greedy.txt delete mode 100644 static/66_workflow_logs.json delete mode 100644 static/67_grid_definition.txt delete mode 100644 static/68_summary.txt delete mode 100644 static/69_nacht_gedicht.txt create mode 100644 static/6_sales_trends_analysis.txt delete mode 100644 static/70_generated_code.py delete mode 100644 static/71_execution_history.json delete mode 100644 static/72_generated_code.py delete mode 100644 static/73_execution_history.json delete mode 100644 static/74_generated_code.py delete mode 100644 static/75_execution_history.json delete mode 100644 static/76_generated_code.py delete mode 100644 static/77_execution_history.json delete mode 100644 static/78_generated_code.py delete mode 100644 static/79_execution_history.json create mode 100644 static/7_q2_forecast.svg create mode 100644 static/8_forecast_apr_jun.svg delete mode 100644 test_workflow1.py delete mode 100644 testcode.py rename stats.py => tool_getStats.py (100%) create mode 100644 tool_testBackendSingle.py create mode 100644 tool_testData.py create mode 100644 tool_testUser.py diff --git a/_SAVE_app copy.py b/_SAVE_app copy.py new file mode 100644 index 00000000..9b8b6fed --- /dev/null +++ b/_SAVE_app copy.py @@ -0,0 +1,194 @@ +import os +os.environ["NUMEXPR_MAX_THREADS"] = "12" + +from fastapi import FastAPI, HTTPException, Depends, Body, status, Response +from fastapi.middleware.cors import CORSMiddleware +from fastapi.responses import JSONResponse, FileResponse +from fastapi.staticfiles import StaticFiles +from fastapi.security import OAuth2PasswordRequestForm +from contextlib import asynccontextmanager + +from typing import Dict, Any +import logging +from logging.handlers import RotatingFileHandler +from datetime import timedelta +import pathlib + +from modules.configuration import APP_CONFIG + +# Import auth module +from modules.auth import ( + createAccessToken, + getCurrentActiveUser, + getUserContext, + ACCESS_TOKEN_EXPIRE_MINUTES +) + +# Import models - import generically for INITIALIZATION +import modules.gatewayModel as gatewayModel +from modules.gatewayInterface import getGatewayInterface + +def initLogging(): + # Get log level from config (default to INFO if not found) + logLevelName = APP_CONFIG.get("Logging_LOG_LEVEL", "WARNING") + logLevel = getattr(logging, logLevelName) + + # Configure handlers based on config + handlers = [] + + # Add console handler if enabled + if APP_CONFIG.get("Logging_CONSOLE_ENABLED", True): + consoleHandler = logging.StreamHandler() + handlers.append(consoleHandler) + + # Add file handler if enabled + if APP_CONFIG.get("Logging_FILE_ENABLED", True): + logFile = APP_CONFIG.get("Logging_LOG_FILE", "app.log") + rotationSize = int(APP_CONFIG.get("Logging_ROTATION_SIZE", 10485760)) # Default: 10MB + backupCount = int(APP_CONFIG.get("Logging_BACKUP_COUNT", 5)) + + fileHandler = RotatingFileHandler( + logFile, + maxBytes=rotationSize, + backupCount=backupCount + ) + handlers.append(fileHandler) + + # Configure the logger + logging.basicConfig( + level=logLevel, + format=APP_CONFIG.get("Logging_FORMAT", "%(asctime)s - %(levelname)s - %(name)s - %(message)s"), + datefmt=APP_CONFIG.get("Logging_DATE_FORMAT", "%Y-%m-%d %H:%M:%S"), + handlers=handlers + ) + + # Silence noisy third-party libraries - use the same level as the root logger + noisyLoggers = ["httpx", "urllib3", "asyncio", "fastapi.security.oauth2"] + for loggerName in noisyLoggers: + logging.getLogger(loggerName).setLevel(logLevel) + + +# Initialize logging +initLogging() +logger = logging.getLogger(__name__) +instanceLabel = APP_CONFIG.get("APP_ENV_LABEL") + +# Define lifespan context manager for application startup/shutdown events +@asynccontextmanager +async def lifespan(app: FastAPI): + # Startup logic (if any) + logger.info("Application is starting up") + yield + # Shutdown logic + logger.info("Application has been shut down") + +# Parse CORS origins from environment variable +def get_allowed_origins(): + origins_str = APP_CONFIG.get("APP_ALLOWED_ORIGINS", "http://localhost:8080") + # Split by comma and strip whitespace + origins = [origin.strip() for origin in origins_str.split(",")] + logger.info(f"CORS allowed origins: {origins}") + return origins + +# START APP +app = FastAPI( + title="PowerOn | Data Platform API", + description=f"Backend API for the Multi-Agent Platform by ValueOn AG ({instanceLabel})", + lifespan=lifespan +) + +# CORS configuration using environment variables +app.add_middleware( + CORSMiddleware, + allow_origins=get_allowed_origins(), + allow_credentials=True, + allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"], + allow_headers=["*"], + expose_headers=["*"], + max_age=86400 # Increased caching for preflight requests +) + +# Static folder for frontend - work with absolute path +baseDir = pathlib.Path(__file__).parent +staticFolder = baseDir / "static" +os.makedirs(staticFolder, exist_ok=True) +app.mount("/static", StaticFiles(directory=str(staticFolder)), name="static") + +# General Elements +@app.get("/", tags=["General"]) +async def root(): + """API status endpoint""" + return {"status": "online", "message": "Data Platform API is active"} + +@app.get("/api/test", tags=["General"]) +async def getTest(): + return "OK 1.5" + +@app.options("/{fullPath:path}", tags=["General"]) +async def optionsRoute(fullPath: str): + return Response(status_code=200) + +@app.get("/api/environment", tags=["General"]) +async def get_environment(): + """Get environment configuration for frontend""" + return { + "apiBaseUrl": APP_CONFIG.get("APP_API_URL", ""), + "environment": APP_CONFIG.get("APP_ENV", "development"), + "instanceLabel": APP_CONFIG.get("APP_ENV_LABEL", "Development"), + # Add other environment variables the frontend might need + } + +# Token endpoint for login +@app.post("/api/token", response_model=gatewayModel.Token, tags=["General"]) +async def loginForAccessToken(formData: OAuth2PasswordRequestForm = Depends()): + # Initialize Gateway interface without context + gateway = getGatewayInterface() + + # Authenticate user + user = gateway.authenticateUser(formData.username, formData.password) + + if not user: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Invalid username or password", + headers={"WWW-Authenticate": "Bearer"}, + ) + + # Create token with tenant ID + accessTokenExpires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES) + accessToken = createAccessToken( + data={ + "sub": user["username"], + "mandateId": user["mandateId"] + }, + expiresDelta=accessTokenExpires + ) + + return {"accessToken": accessToken, "tokenType": "bearer"} + +# Get user info +@app.get("/api/user/me", response_model=Dict[str, Any], tags=["General"]) +async def readUserMe(currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)): + return currentUser + +# Include all routers +from routes.routeAttributes import router as attributesRouter +app.include_router(attributesRouter) + +from routes.routeMandates import router as mandateRouter +app.include_router(mandateRouter) + +from routes.routeUsers import router as userRouter +app.include_router(userRouter) + +from routes.routeFiles import router as fileRouter +app.include_router(fileRouter) + +from routes.routePrompts import router as promptRouter +app.include_router(promptRouter) + +from routes.routeWorkflows import router as workflowRouter +app.include_router(workflowRouter) + +#if __name__ == "__main__": +# uvicorn.run("app:app", host="0.0.0.0", port=8000, reload=True) \ No newline at end of file diff --git a/app.py b/app.py index dbed6902..d42012fe 100644 --- a/app.py +++ b/app.py @@ -8,7 +8,6 @@ from fastapi.staticfiles import StaticFiles from fastapi.security import OAuth2PasswordRequestForm from contextlib import asynccontextmanager -import uvicorn from typing import Dict, Any import logging from logging.handlers import RotatingFileHandler @@ -16,66 +15,65 @@ from datetime import timedelta import pathlib from modules.configuration import APP_CONFIG -from modules.gateway_interface import get_gateway_interface -# Import auth module -from modules.auth import ( - create_access_token, - get_current_active_user, - get_user_context, - ACCESS_TOKEN_EXPIRE_MINUTES -) - -# Import models - import generically for INITIALIZATION, even if dummy! -import modules.gateway_model as gateway_model - -#from modules.lucydom_interface import get_lucydom_interface as dom_interface - - -def init_logging(): +def initLogging(): # Get log level from config (default to INFO if not found) - log_level_name = APP_CONFIG.get("Logging_LOG_LEVEL", "WARNING") - log_level = getattr(logging, log_level_name) + logLevelName = APP_CONFIG.get("Logging_LOG_LEVEL", "WARNING") + logLevel = getattr(logging, logLevelName) # Configure handlers based on config handlers = [] # Add console handler if enabled if APP_CONFIG.get("Logging_CONSOLE_ENABLED", True): - console_handler = logging.StreamHandler() - handlers.append(console_handler) + consoleHandler = logging.StreamHandler() + handlers.append(consoleHandler) # Add file handler if enabled if APP_CONFIG.get("Logging_FILE_ENABLED", True): - log_file = APP_CONFIG.get("Logging_LOG_FILE", "app.log") - rotation_size = int(APP_CONFIG.get("Logging_ROTATION_SIZE", 10485760)) # Default: 10MB - backup_count = int(APP_CONFIG.get("Logging_BACKUP_COUNT", 5)) + logFile = APP_CONFIG.get("Logging_LOG_FILE", "app.log") + rotationSize = int(APP_CONFIG.get("Logging_ROTATION_SIZE", 10485760)) # Default: 10MB + backupCount = int(APP_CONFIG.get("Logging_BACKUP_COUNT", 5)) - file_handler = RotatingFileHandler( - log_file, - maxBytes=rotation_size, - backupCount=backup_count + fileHandler = RotatingFileHandler( + logFile, + maxBytes=rotationSize, + backupCount=backupCount ) - handlers.append(file_handler) + handlers.append(fileHandler) # Configure the logger logging.basicConfig( - level=log_level, + level=logLevel, format=APP_CONFIG.get("Logging_FORMAT", "%(asctime)s - %(levelname)s - %(name)s - %(message)s"), datefmt=APP_CONFIG.get("Logging_DATE_FORMAT", "%Y-%m-%d %H:%M:%S"), handlers=handlers ) # Silence noisy third-party libraries - use the same level as the root logger - noisy_loggers = ["httpx", "urllib3", "asyncio", "fastapi.security.oauth2"] - for logger_name in noisy_loggers: - logging.getLogger(logger_name).setLevel(log_level) + noisyLoggers = ["httpx", "urllib3", "asyncio", "fastapi.security.oauth2"] + for loggerName in noisyLoggers: + logging.getLogger(loggerName).setLevel(logLevel) # Initialize logging -init_logging() +initLogging() logger = logging.getLogger(__name__) -instance_label = APP_CONFIG.get("APP_ENV_LABEL") +instanceLabel = APP_CONFIG.get("APP_ENV_LABEL") + +# Import auth module +from modules.auth import ( + createAccessToken, + getCurrentActiveUser, + getUserContext, + ACCESS_TOKEN_EXPIRE_MINUTES +) + +# Import models - import generically for INITIALIZATION +import modules.gatewayModel as gatewayModel +from modules.gatewayInterface import getGatewayInterface +gateway = getGatewayInterface() + # Define lifespan context manager for application startup/shutdown events @asynccontextmanager @@ -86,17 +84,25 @@ async def lifespan(app: FastAPI): # Shutdown logic logger.info("Application has been shut down") +# Parse CORS origins from environment variable +def get_allowed_origins(): + origins_str = APP_CONFIG.get("APP_ALLOWED_ORIGINS", "http://localhost:8080") + # Split by comma and strip whitespace + origins = [origin.strip() for origin in origins_str.split(",")] + logger.info(f"CORS allowed origins: {origins}") + return origins + # START APP app = FastAPI( title="PowerOn | Data Platform API", - description=f"Backend API for the Multi-Agent Platform by ValueOn AG ({instance_label})", + description=f"Backend API for the Multi-Agent Platform by ValueOn AG ({instanceLabel})", lifespan=lifespan ) -# CORS configuration for frontend requests +# CORS configuration using environment variables app.add_middleware( CORSMiddleware, - allow_origins=["http://localhost:8080","https://poweron-lucyagents-xxx.germanywestcentral-01.azurewebsites.net"], + allow_origins=get_allowed_origins(), # ["http://localhost:8080","http://localhost:8081"], #get_allowed_origins(), allow_credentials=True, allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"], allow_headers=["*"], @@ -105,16 +111,10 @@ app.add_middleware( ) # Static folder for frontend - work with absolute path -base_dir = pathlib.Path(__file__).parent -static_folder = base_dir / "static" -os.makedirs(static_folder, exist_ok=True) -app.mount("/static", StaticFiles(directory=str(static_folder)), name="static") - -# Add a specific route for favicon.ico -@app.get("/favicon.ico", include_in_schema=False) -async def favicon(): - favicon_path = static_folder / "favicon.ico" - return FileResponse(str(favicon_path)) +baseDir = pathlib.Path(__file__).parent +staticFolder = baseDir / "static" +os.makedirs(staticFolder, exist_ok=True) +app.mount("/static", StaticFiles(directory=str(staticFolder)), name="static") # General Elements @app.get("/", tags=["General"]) @@ -123,22 +123,31 @@ async def root(): return {"status": "online", "message": "Data Platform API is active"} @app.get("/api/test", tags=["General"]) -async def get_test(): +async def getTest(): return "OK 1.5" -@app.options("/{full_path:path}", tags=["General"]) -async def options_route(full_path: str): +@app.options("/{fullPath:path}", tags=["General"]) +async def optionsRoute(fullPath: str): return Response(status_code=200) +@app.get("/api/environment", tags=["General"]) +async def get_environment(): + """Get environment configuration for frontend""" + return { + "apiBaseUrl": APP_CONFIG.get("APP_API_URL", ""), + "environment": APP_CONFIG.get("APP_ENV", "development"), + "instanceLabel": APP_CONFIG.get("APP_ENV_LABEL", "Development"), + # Add other environment variables the frontend might need + } # Token endpoint for login -@app.post("/api/token", response_model=gateway_model.Token, tags=["General"]) -async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()): +@app.post("/api/token", response_model=gatewayModel.Token, tags=["General"]) +async def loginForAccessToken(formData: OAuth2PasswordRequestForm = Depends()): # Initialize Gateway interface without context - gateway = get_gateway_interface() - + gateway = getGatewayInterface() + # Authenticate user - user = gateway.authenticate_user(form_data.username, form_data.password) + user = gateway.authenticateUser(formData.username, formData.password) if not user: raise HTTPException( @@ -148,40 +157,45 @@ async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends( ) # Create token with tenant ID - access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES) - access_token = create_access_token( + accessTokenExpires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES) + accessToken = createAccessToken( data={ "sub": user["username"], - "mandate_id": user["mandate_id"] + "mandateId": user["mandateId"] }, - expires_delta=access_token_expires + expiresDelta=accessTokenExpires ) - return {"access_token": access_token, "token_type": "bearer"} + return {"accessToken": accessToken, "tokenType": "bearer"} # Get user info @app.get("/api/user/me", response_model=Dict[str, Any], tags=["General"]) -async def read_user_me(current_user: Dict[str, Any] = Depends(get_current_active_user)): - return current_user +async def readUserMe(currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)): + return currentUser # Include all routers -from routes.attributes import router as attributes_router -app.include_router(attributes_router) +from routes.routeAttributes import router as attributesRouter +app.include_router(attributesRouter) -from routes.mandates import router as mandate_router -app.include_router(mandate_router) +gateway = getGatewayInterface() -from routes.users import router as user_router -app.include_router(user_router) +from routes.routeMandates import router as mandateRouter +app.include_router(mandateRouter) -from routes.files import router as file_router -app.include_router(file_router) +gateway = getGatewayInterface() -from routes.prompts import router as prompt_router -app.include_router(prompt_router) -from routes.workflows import router as workflow_router -app.include_router(workflow_router) +from routes.routeUsers import router as userRouter +app.include_router(userRouter) + +from routes.routeFiles import router as fileRouter +app.include_router(fileRouter) + +from routes.routePrompts import router as promptRouter +app.include_router(promptRouter) + +from routes.routeWorkflows import router as workflowRouter +app.include_router(workflowRouter) #if __name__ == "__main__": # uvicorn.run("app:app", host="0.0.0.0", port=8000, reload=True) \ No newline at end of file diff --git a/connectors/_SAVE_connectorDbJson copy.py b/connectors/_SAVE_connectorDbJson copy.py new file mode 100644 index 00000000..c92c4074 --- /dev/null +++ b/connectors/_SAVE_connectorDbJson copy.py @@ -0,0 +1,546 @@ +import json +import os +from typing import List, Dict, Any, Optional, Union +import logging + +logger = logging.getLogger(__name__) + +class DatabaseConnector: + """ + A connector for JSON-based data storage. + Provides generic database operations with tenant and user context support. + """ + def __init__(self, dbHost: str, dbDatabase: str, dbUser: str = None, dbPassword: str = None, mandateId: int = None, userId: int = None): + """ + Initializes the JSON database connector. + + Args: + dbHost: Directory for the JSON files + dbDatabase: Database name + dbUser: Username for authentication (optional) + dbPassword: API key for authentication (optional) + mandateId: Context parameter for the tenant + userId: Context parameter for the user + """ + # Store the input parameters + self.dbHost = dbHost + self.dbDatabase = dbDatabase + self.dbUser = dbUser + self.dbPassword = dbPassword + + # Check if context parameters are set + if mandateId is None or userId is None: + raise ValueError("mandateId and userId must be set") + + # Ensure the database directory exists + self.dbFolder = os.path.join(self.dbHost, self.dbDatabase) + os.makedirs(self.dbFolder, exist_ok=True) + + # Cache for loaded data + self._tablesCache = {} + + # Initialize system table + self._systemTableName = "_system" + self._initializeSystemTable() + + # Temporarily store mandateId and userId + self._mandateId = mandateId + self._userId = userId + + # If mandateId or userId are 0, try to use the initial IDs + if mandateId == 0: + initialMandateId = self.getInitialId("mandates") + if initialMandateId is not None: + self._mandateId = initialMandateId + logger.info(f"Using initial mandateId: {initialMandateId} instead of 0") + + if userId == 0: + initialUserId = self.getInitialId("users") + if initialUserId is not None: + self._userId = initialUserId + logger.info(f"Using initial userId: {initialUserId} instead of 0") + + # Set the effective IDs as properties + self.mandateId = self._mandateId + self.userId = self._userId + + logger.info(f"DatabaseConnector initialized for directory: {self.dbFolder}") + logger.debug(f"Context: mandateId={self.mandateId}, userId={self.userId}") + + def _initializeSystemTable(self): + """Initializes the system table if it doesn't exist yet.""" + systemTablePath = self._getTablePath(self._systemTableName) + if not os.path.exists(systemTablePath): + emptySystemTable = {} + self._saveSystemTable(emptySystemTable) + logger.info(f"System table initialized in {systemTablePath}") + else: + # Load existing system table to ensure it's available + self._loadSystemTable() + logger.debug(f"Existing system table loaded from {systemTablePath}") + + def _loadSystemTable(self) -> Dict[str, int]: + """Loads the system table with the initial IDs.""" + systemTablePath = self._getTablePath(self._systemTableName) + try: + if os.path.exists(systemTablePath): + with open(systemTablePath, 'r', encoding='utf-8') as f: + return json.load(f) + else: + return {} + except Exception as e: + logger.error(f"Error loading the system table: {e}") + return {} + + def _saveSystemTable(self, data: Dict[str, int]) -> bool: + """Saves the system table with the initial IDs.""" + systemTablePath = self._getTablePath(self._systemTableName) + try: + with open(systemTablePath, 'w', encoding='utf-8') as f: + json.dump(data, f, indent=2, ensure_ascii=False) + return True + except Exception as e: + logger.error(f"Error saving the system table: {e}") + return False + + def _getTablePath(self, table: str) -> str: + """Returns the full path to a table file""" + return os.path.join(self.dbFolder, f"{table}.json") + + def _loadTable(self, table: str) -> List[Dict[str, Any]]: + """Loads a table from the corresponding JSON file""" + path = self._getTablePath(table) + + # If the table is the system table, load it directly + if table == self._systemTableName: + return [] # The system table is not treated like normal tables + + # If the table is already in the cache, use the cache + if table in self._tablesCache: + return self._tablesCache[table] + + # Otherwise load the file + try: + if os.path.exists(path): + with open(path, 'r', encoding='utf-8') as f: + data = json.load(f) + self._tablesCache[table] = data + + # If data was loaded and no initial ID is registered yet, + # register the ID of the first record (if available) + if data and not self.hasInitialId(table): + if "id" in data[0]: + self._registerInitialId(table, data[0]["id"]) + logger.info(f"Initial ID {data[0]['id']} for table {table} retroactively registered") + + return data + else: + # If the file doesn't exist, create an empty table + logger.info(f"New table {table}") + self._tablesCache[table] = [] + self._saveTable(table, []) + return [] + except Exception as e: + logger.error(f"Error loading table {table}: {e}") + return [] + + def _saveTable(self, table: str, data: List[Dict[str, Any]]) -> bool: + """Saves a table to the corresponding JSON file""" + # The system table is handled specially + if table == self._systemTableName: + return False + + path = self._getTablePath(table) + try: + with open(path, 'w', encoding='utf-8') as f: + json.dump(data, f, indent=2, ensure_ascii=False) + + # Update the cache + self._tablesCache[table] = data + return True + except Exception as e: + logger.error(f"Error saving table {table}: {e}") + return False + + def _filterByContext(self, records: List[Dict[str, Any]]) -> List[Dict[str, Any]]: + """ + Filters records by tenant and user context, + if these fields exist in the record. + """ + filteredRecords = [] + + for record in records: + # Check if mandateId exists in the record and is not null + hasMandate = "mandateId" in record and record["mandateId"] is not None and record["mandateId"] != "" + + # Check if userId exists in the record and is not null + hasUser = "userId" in record and record["userId"] is not None and record["userId"] != "" + + # If both exist, filter accordingly + if hasMandate and hasUser: + if record["mandateId"] == self.mandateId: + filteredRecords.append(record) + # If only mandateId exists + elif hasMandate and not hasUser: + if record["mandateId"] == self.mandateId: + filteredRecords.append(record) + # If neither mandateId nor userId exist, add the record + elif not hasMandate and not hasUser: + filteredRecords.append(record) + + return filteredRecords + + def _applyRecordFilter(self, records: List[Dict[str, Any]], recordFilter: Dict[str, Any] = None) -> List[Dict[str, Any]]: + """Applies a record filter to the records""" + if not recordFilter: + return records + + filteredRecords = [] + + for record in records: + match = True + + for field, value in recordFilter.items(): + # Check if the field exists + if field not in record: + match = False + break + + # If the filter value is an integer string and the record field is an integer + if isinstance(value, str) and value.isdigit() and isinstance(record[field], int): + if record[field] != int(value): + match = False + break + # Otherwise direct comparison + elif record[field] != value: + match = False + break + + if match: + filteredRecords.append(record) + + return filteredRecords + + def _registerInitialId(self, table: str, initialId: int) -> bool: + """ + Registers the initial ID for a table. + + Args: + table: Name of the table + initialId: The initial ID + + Returns: + True on success, False on error + """ + try: + # Load the current system table + systemData = self._loadSystemTable() + + # Only register if not already present + if table not in systemData: + systemData[table] = initialId + success = self._saveSystemTable(systemData) + if success: + logger.info(f"Initial ID {initialId} for table {table} registered") + return success + return True # If already present, this is not an error + except Exception as e: + logger.error(f"Error registering the initial ID for table {table}: {e}") + return False + + def _removeInitialId(self, table: str) -> bool: + """ + Removes the initial ID for a table from the system table. + + Args: + table: Name of the table + + Returns: + True on success, False on error + """ + try: + # Load the current system table + systemData = self._loadSystemTable() + + # Remove the entry if it exists + if table in systemData: + del systemData[table] + success = self._saveSystemTable(systemData) + if success: + logger.info(f"Initial ID for table {table} removed from system table") + return success + return True # If not present, this is not an error + except Exception as e: + logger.error(f"Error removing initial ID for table {table}: {e}") + return False + + # Public API + + def getTables(self) -> List[str]: + """ + Returns a list of all available tables. + + Returns: + List of table names + """ + tables = [] + + try: + for filename in os.listdir(self.dbFolder): + if filename.endswith('.json') and not filename.startswith('_'): + tableName = filename[:-5] # Remove the .json extension + tables.append(tableName) + except Exception as e: + logger.error(f"Error reading the database directory: {e}") + + return tables + + def getFields(self, table: str) -> List[str]: + """ + Returns a list of all fields in a table. + + Args: + table: Name of the table + + Returns: + List of field names + """ + # Load the table data + data = self._loadTable(table) + + if not data: + return [] + + # Take the first record as a reference for the fields + fields = list(data[0].keys()) if data else [] + + return fields + + def getSchema(self, table: str, language: str = None) -> Dict[str, Dict[str, Any]]: + """ + Returns a schema object for a table with data types and labels. + + Args: + table: Name of the table + language: Language for the labels (optional) + + Returns: + Schema object with fields, data types and labels + """ + # Load the table data + data = self._loadTable(table) + + schema = {} + + if not data: + return schema + + # Take the first record as a reference for the fields and data types + firstRecord = data[0] + + for field, value in firstRecord.items(): + # Determine the data type + dataType = type(value).__name__ + + # Create label (default is the field name) + label = field + + schema[field] = { + "type": dataType, + "label": label + } + + return schema + + def getRecordset(self, table: str, fieldFilter: List[str] = None, recordFilter: Dict[str, Any] = None) -> List[Dict[str, Any]]: + """ + Returns a list of records from a table, filtered by criteria. + + Args: + table: Name of the table + fieldFilter: Filter for fields (which fields should be returned) + recordFilter: Filter for records (which records should be returned) + + Returns: + List of filtered records + """ + # Load the table data + data = self._loadTable(table) + + # Filter by tenant and user context + filteredData = self._filterByContext(data) + + # Apply recordFilter if available + if recordFilter: + filteredData = self._applyRecordFilter(filteredData, recordFilter) + + # If fieldFilter is available, reduce the fields + if fieldFilter and isinstance(fieldFilter, list): + result = [] + for record in filteredData: + filteredRecord = {} + for field in fieldFilter: + if field in record: + filteredRecord[field] = record[field] + result.append(filteredRecord) + return result + + return filteredData + + def recordCreate(self, table: str, recordData: Dict[str, Any]) -> Dict[str, Any]: + """ + Creates a new record in the table. + + Args: + table: Name of the table + recordData: Data for the new record + + Returns: + The created record + """ + # Load the table data + data = self._loadTable(table) + + # Add mandateId and userId if not present or 0 + if "mandateId" not in recordData or recordData["mandateId"] == 0: + recordData["mandateId"] = self.mandateId + + if "userId" not in recordData or recordData["userId"] == 0: + recordData["userId"] = self.userId + + # Determine the next ID if not present + if "id" not in recordData: + nextId = 1 + if data: + nextId = max(record["id"] for record in data if "id" in record) + 1 + recordData["id"] = nextId + + # If the table is empty and a system ID should be registered + if not data: + self._registerInitialId(table, recordData["id"]) + logger.info(f"Initial ID {recordData['id']} for table {table} has been registered") + + # Add the new record + data.append(recordData) + + # Save the updated table + if self._saveTable(table, data): + return recordData + else: + raise ValueError(f"Error creating the record in table {table}") + + def recordDelete(self, table: str, recordId: Union[str, int]) -> bool: + """ + Deletes a record from the table. + + Args: + table: Name of the table + recordId: ID of the record to delete + + Returns: + True on success, False on error + """ + # Load table data + data = self._loadTable(table) + + # Search for the record + for i, record in enumerate(data): + if "id" in record and record["id"] == recordId: + # Check if the record belongs to the current mandate + if "mandateId" in record and record["mandateId"] != self.mandateId: + raise ValueError("Not your mandate") + + # Check if it's an initial record + initialId = self.getInitialId(table) + if initialId is not None and initialId == recordId: + # Remove this entry from the system table + self._removeInitialId(table) + logger.info(f"Initial ID {recordId} for table {table} has been removed from the system table") + + # Delete the record + del data[i] + + # Save the updated table + return self._saveTable(table, data) + + # Record not found + return False + + def recordModify(self, table: str, recordId: Union[str, int], recordData: Dict[str, Any]) -> Dict[str, Any]: + """ + Modifies a record in the table. + + Args: + table: Name of the table + recordId: ID of the record to modify + recordData: New data for the record + + Returns: + The updated record + """ + # Load table data + data = self._loadTable(table) + + # Search for the record + for i, record in enumerate(data): + if "id" in record and record["id"] == recordId: + # Check if the record belongs to the current mandate + if "mandateId" in record and record["mandateId"] != self.mandateId: + raise ValueError("Not your mandate") + + # Prevent changing the ID + if "id" in recordData and recordData["id"] != recordId: + raise ValueError(f"The ID of a record in table {table} cannot be changed") + + # Update the record + for key, value in recordData.items(): + data[i][key] = value + + # Save the updated table + if self._saveTable(table, data): + return data[i] + else: + raise ValueError(f"Error updating record in table {table}") + + # Record not found + raise ValueError(f"Record with ID {recordId} not found in table {table}") + + def hasInitialId(self, table: str) -> bool: + """ + Checks if an initial ID is registered for a table. + + Args: + table: Name of the table + + Returns: + True if an initial ID is registered, otherwise False + """ + systemData = self._loadSystemTable() + return table in systemData + + def getInitialId(self, table: str) -> Optional[int]: + """ + Returns the initial ID for a table. + + Args: + table: Name of the table + + Returns: + The initial ID or None if not present + """ + systemData = self._loadSystemTable() + initialId = systemData.get(table) + print("SysTable table",table,"Value",initialId) + if initialId is None: + logger.debug(f"No initial ID found for table {table}") + return initialId + + def getAllInitialIds(self) -> Dict[str, int]: + """ + Returns all registered initial IDs. + + Returns: + Dictionary with table names as keys and initial IDs as values + """ + systemData = self._loadSystemTable() + return systemData.copy() # Return a copy to protect the original \ No newline at end of file diff --git a/connectors/connector_aichat_anthropic.py b/connectors/connectorAiAnthropic.py similarity index 59% rename from connectors/connector_aichat_anthropic.py rename to connectors/connectorAiAnthropic.py index 15728755..4b0b2412 100644 --- a/connectors/connector_aichat_anthropic.py +++ b/connectors/connectorAiAnthropic.py @@ -1,54 +1,52 @@ import logging import httpx -from typing import Dict, Any, List, Optional, Union +from typing import Dict, Any, List, Union from fastapi import HTTPException from modules.configuration import APP_CONFIG # Configure logger logger = logging.getLogger(__name__) -# Load configuration data -def load_config_data(): +def loadConfigData(): + """Load configuration data for Anthropic connector""" return { - "api_key": APP_CONFIG.get('Connector_AiAnthropic_API_SECRET'), - "api_url": APP_CONFIG.get('Connector_AiAnthropic_API_URL'), - "model_name": APP_CONFIG.get('Connector_AiAnthropic_MODEL_NAME'), + "apiKey": APP_CONFIG.get('Connector_AiAnthropic_API_SECRET'), + "apiUrl": APP_CONFIG.get('Connector_AiAnthropic_API_URL'), + "modelName": APP_CONFIG.get('Connector_AiAnthropic_MODEL_NAME'), "temperature": float(APP_CONFIG.get('Connector_AiAnthropic_TEMPERATURE')), - "max_tokens": int(APP_CONFIG.get('Connector_AiAnthropic_MAX_TOKENS')) + "maxTokens": int(APP_CONFIG.get('Connector_AiAnthropic_MAX_TOKENS')) } class ChatService: - """ - Connector for communication with the Anthropic API. - """ + """Connector for communication with the Anthropic API.""" def __init__(self): # Load configuration - self.config = load_config_data() - self.api_key = self.config["api_key"] - self.api_url = self.config["api_url"] - self.model_name = self.config["model_name"] + self.config = loadConfigData() + self.apiKey = self.config["apiKey"] + self.apiUrl = self.config["apiUrl"] + self.modelName = self.config["modelName"] # HttpClient for API calls - self.http_client = httpx.AsyncClient( + self.httpClient = httpx.AsyncClient( timeout=120.0, # Longer timeout for complex requests headers={ - "x-api-key": self.api_key, + "x-api-key": self.apiKey, "anthropic-version": "2023-06-01", # Anthropic API Version "Content-Type": "application/json" } ) - logger.info(f"Anthropic Connector initialized with model: {self.model_name}") + logger.info(f"Anthropic Connector initialized with model: {self.modelName}") - async def call_api(self, messages: List[Dict[str, Any]], temperature: float = None, max_tokens: int = None) -> Dict[str, Any]: + async def callApi(self, messages: List[Dict[str, Any]], temperature: float = None, maxTokens: int = None) -> Dict[str, Any]: """ Calls the Anthropic API with the given messages. Args: messages: List of messages in OpenAI format (role, content) temperature: Temperature for response generation (0.0-1.0) - max_tokens: Maximum number of tokens in the response + maxTokens: Maximum number of tokens in the response Returns: The response converted to OpenAI format @@ -58,25 +56,25 @@ class ChatService: """ try: # Convert OpenAI format to Anthropic format - formatted_messages = self._convert_to_anthropic_format(messages) + formattedMessages = self._convertToAnthropicFormat(messages) # Use parameters from configuration if none were overridden if temperature is None: temperature = self.config.get("temperature", 0.2) - if max_tokens is None: - max_tokens = self.config.get("max_tokens", 2000) + if maxTokens is None: + maxTokens = self.config.get("maxTokens", 2000) # Create Anthropic API payload payload = { - "model": self.model_name, - "messages": formatted_messages, + "model": self.modelName, + "messages": formattedMessages, "temperature": temperature, - "max_tokens": max_tokens + "max_tokens": maxTokens } - response = await self.http_client.post( - self.api_url, + response = await self.httpClient.post( + self.apiUrl, json=payload ) @@ -85,16 +83,16 @@ class ChatService: raise HTTPException(status_code=500, detail="Error communicating with Anthropic API") # Convert response from Anthropic format to OpenAI format - anthropic_response = response.json() - openai_formatted_response = self._convert_to_openai_format(anthropic_response) + anthropicResponse = response.json() + openaiFormattedResponse = self._convertToOpenaiFormat(anthropicResponse) - return openai_formatted_response + return openaiFormattedResponse except Exception as e: logger.error(f"Error calling Anthropic API: {str(e)}") raise HTTPException(status_code=500, detail=f"Error calling Anthropic API: {str(e)}") - def _convert_to_anthropic_format(self, openai_messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]: + def _convertToAnthropicFormat(self, openaiMessages: List[Dict[str, Any]]) -> List[Dict[str, Any]]: """ Converts messages from OpenAI format to Anthropic format. @@ -110,16 +108,16 @@ class ChatService: Note: Anthropic has no direct system message equivalent, so we add system messages to the first user message. """ - anthropic_messages = [] - system_content = "" + anthropicMessages = [] + systemContent = "" # First extract all system messages - for msg in openai_messages: + for msg in openaiMessages: if msg.get("role") == "system": - system_content += msg.get("content", "") + "\n\n" + systemContent += msg.get("content", "") + "\n\n" # Convert the remaining messages - for i, msg in enumerate(openai_messages): + for msg in openaiMessages: role = msg.get("role") content = msg.get("content", "") @@ -128,49 +126,49 @@ class ChatService: continue # For the first user message: prepend system content if available - if role == "user" and system_content and not any(m.get("role") == "user" for m in anthropic_messages): + if role == "user" and systemContent and not any(m.get("role") == "user" for m in anthropicMessages): if isinstance(content, str): - content = system_content + content + content = systemContent + content elif isinstance(content, list): # If content is an array (for multimodal messages) - text_parts = [] + textParts = [] for part in content: if part.get("type") == "text": - text_parts.append(part) + textParts.append(part) - if text_parts: - text_parts[0]["text"] = system_content + text_parts[0].get("text", "") + if textParts: + textParts[0]["text"] = systemContent + textParts[0].get("text", "") # Anthropic only supports "user" and "assistant" roles if role not in ["user", "assistant"]: role = "user" - anthropic_messages.append({"role": role, "content": content}) + anthropicMessages.append({"role": role, "content": content}) - return anthropic_messages + return anthropicMessages - def _convert_to_openai_format(self, anthropic_response: Dict[str, Any]) -> Dict[str, Any]: + def _convertToOpenaiFormat(self, anthropicResponse: Dict[str, Any]) -> Dict[str, Any]: """ Converts a response from Anthropic format to OpenAI format. """ # Extract content from Anthropic response content = "" - if "content" in anthropic_response: - if isinstance(anthropic_response["content"], list): + if "content" in anthropicResponse: + if isinstance(anthropicResponse["content"], list): # Content is a list of parts (in newer API versions) - for part in anthropic_response["content"]: + for part in anthropicResponse["content"]: if part.get("type") == "text": content += part.get("text", "") else: # Direct content as string (in older API versions) - content = anthropic_response["content"] + content = anthropicResponse["content"] # Create OpenAI-formatted response return { - "id": anthropic_response.get("id", ""), + "id": anthropicResponse.get("id", ""), "object": "chat.completion", - "created": anthropic_response.get("created", 0), - "model": anthropic_response.get("model", self.model_name), + "created": anthropicResponse.get("created", 0), + "model": anthropicResponse.get("model", self.modelName), "choices": [ { "message": { @@ -183,33 +181,33 @@ class ChatService: ] } - async def analyze_image(self, image_data: Union[str, bytes], mime_type: str = None, prompt: str = "Describe this image") -> str: + async def analyzeImage(self, imageData: Union[str, bytes], mimeType: str = None, prompt: str = "Describe this image") -> str: """ - Analyzes an image with the OpenAI Vision API. + Analyzes an image using Anthropic's vision capabilities. Args: - image_data: Either a file path (str) or image data (bytes) - mime_type: The MIME type of the image (optional, only for binary data) + imageData: Either a file path (str) or image data (bytes) + mimeType: The MIME type of the image (optional, only for binary data) prompt: The prompt for analysis Returns: - The response from the OpenAI Vision API as text + The analysis response as text """ try: # Distinguish between file path and binary data - if isinstance(image_data, str): + if isinstance(imageData, str): # It's a file path - import filehandling only when needed - from modules import agentservice_filemanager as file_handler - base64_data, auto_mime_type = file_handler.encode_file_to_base64(image_data) - mime_type = mime_type or auto_mime_type + from modules import agentserviceFilemanager as fileHandler + base64Data, autoMimeType = fileHandler.encodeFileToBase64(imageData) + mimeType = mimeType or autoMimeType else: # It's binary data import base64 - base64_data = base64.b64encode(image_data).decode('utf-8') + base64Data = base64.b64encode(imageData).decode('utf-8') # MIME type must be specified for binary data - if not mime_type: + if not mimeType: # Fallback to generic image type - mime_type = "image/png" + mimeType = "image/png" # Prepare the payload for the Vision API messages = [ @@ -220,15 +218,15 @@ class ChatService: { "type": "image_url", "image_url": { - "url": f"data:{mime_type};base64,{base64_data}" + "url": f"data:{mimeType};base64,{base64Data}" } } ] } ] - # Use the existing call_api function with the Vision model - response = await self.call_api(messages) + # Use the existing callApi function with the Vision model + response = await self.callApi(messages) # Extract and return content return response["choices"][0]["message"]["content"] diff --git a/connectors/connector_aichat_openai.py b/connectors/connectorAiOpenai.py similarity index 59% rename from connectors/connector_aichat_openai.py rename to connectors/connectorAiOpenai.py index 7de51e67..e394030d 100644 --- a/connectors/connector_aichat_openai.py +++ b/connectors/connectorAiOpenai.py @@ -1,52 +1,50 @@ import logging import httpx -from typing import Dict, Any, List, Optional, Union +from typing import Dict, Any, List, Union from fastapi import HTTPException from modules.configuration import APP_CONFIG # Configure logger logger = logging.getLogger(__name__) -# Load configuration data -def load_config_data(): +def loadConfigData(): + """Load configuration data for OpenAI connector""" return { - "api_key": APP_CONFIG.get('Connector_AiOpenai_API_SECRET'), - "api_url": APP_CONFIG.get('Connector_AiOpenai_API_URL'), - "model_name": APP_CONFIG.get('Connector_AiOpenai_MODEL_NAME'), + "apiKey": APP_CONFIG.get('Connector_AiOpenai_API_SECRET'), + "apiUrl": APP_CONFIG.get('Connector_AiOpenai_API_URL'), + "modelName": APP_CONFIG.get('Connector_AiOpenai_MODEL_NAME'), "temperature": float(APP_CONFIG.get('Connector_AiOpenai_TEMPERATURE')), - "max_tokens": int(APP_CONFIG.get('Connector_AiOpenai_MAX_TOKENS')) + "maxTokens": int(APP_CONFIG.get('Connector_AiOpenai_MAX_TOKENS')) } class ChatService: - """ - Connector for communication with the OpenAI API. - """ + """Connector for communication with the OpenAI API.""" def __init__(self): # Load configuration - self.config = load_config_data() - self.api_key = self.config["api_key"] - self.api_url = self.config["api_url"] - self.model_name = self.config["model_name"] + self.config = loadConfigData() + self.apiKey = self.config["apiKey"] + self.apiUrl = self.config["apiUrl"] + self.modelName = self.config["modelName"] # HttpClient for API calls - self.http_client = httpx.AsyncClient( + self.httpClient = httpx.AsyncClient( timeout=120.0, # Longer timeout for complex requests headers={ - "Authorization": f"Bearer {self.api_key}", + "Authorization": f"Bearer {self.apiKey}", "Content-Type": "application/json" } ) - logger.info(f"OpenAI Connector initialized with model: {self.model_name}") + logger.info(f"OpenAI Connector initialized with model: {self.modelName}") - async def call_api(self, messages: List[Dict[str, Any]], temperature: float = None, max_tokens: int = None) -> str: + async def callApi(self, messages: List[Dict[str, Any]], temperature: float = None, maxTokens: int = None) -> str: """ Calls the OpenAI API with the given messages. Args: messages: List of messages in OpenAI format (role, content) temperature: Temperature for response generation (0.0-1.0) - max_tokens: Maximum number of tokens in the response + maxTokens: Maximum number of tokens in the response Returns: The response from the OpenAI API @@ -59,18 +57,18 @@ class ChatService: if temperature is None: temperature = self.config.get("temperature", 0.2) - if max_tokens is None: - max_tokens = self.config.get("max_tokens", 2000) + if maxTokens is None: + maxTokens = self.config.get("maxTokens", 2000) payload = { - "model": self.model_name, + "model": self.modelName, "messages": messages, "temperature": temperature, - "max_tokens": max_tokens + "max_tokens": maxTokens } - response = await self.http_client.post( - self.api_url, + response = await self.httpClient.post( + self.apiUrl, json=payload ) @@ -78,8 +76,8 @@ class ChatService: logger.error(f"OpenAI API error: {response.status_code} - {response.text}") raise HTTPException(status_code=500, detail="Error communicating with OpenAI API") - response_json = response.json() - content = response_json["choices"][0]["message"]["content"] + responseJson = response.json() + content = responseJson["choices"][0]["message"]["content"] return content except Exception as e: @@ -88,15 +86,15 @@ class ChatService: async def close(self): """Closes the HTTP client when the application exits""" - await self.http_client.aclose() + await self.httpClient.aclose() - async def analyze_image(self, image_data: Union[str, bytes], mime_type: str = None, prompt: str = "Describe this image") -> str: + async def analyzeImage(self, imageData: Union[str, bytes], mimeType: str = None, prompt: str = "Describe this image") -> str: """ Analyzes an image with the OpenAI Vision API. Args: - image_data: Either a file path (str) or image data (bytes) - mime_type: The MIME type of the image (optional, only for binary data) + imageData: Either a file path (str) or image data (bytes) + mimeType: The MIME type of the image (optional, only for binary data) prompt: The prompt for analysis Returns: @@ -105,19 +103,19 @@ class ChatService: try: logger.debug("Starting image analysis...") # Distinguish between file path and binary data - if isinstance(image_data, str): + if isinstance(imageData, str): # It's a file path - import filehandling only when needed - from modules import agentservice_filemanager as file_handler - base64_data, auto_mime_type = file_handler.encode_file_to_base64(image_data) - mime_type = mime_type or auto_mime_type + from modules import agentserviceFilemanager as fileHandler + base64Data, autoMimeType = fileHandler.encodeFileToBase64(imageData) + mimeType = mimeType or autoMimeType else: # It's binary data import base64 - base64_data = base64.b64encode(image_data).decode('utf-8') + base64Data = base64.b64encode(imageData).decode('utf-8') # MIME type must be specified for binary data - if not mime_type: + if not mimeType: # Fallback to generic image type - mime_type = "image/png" + mimeType = "image/png" # Prepare the payload for the Vision API messages = [ @@ -128,17 +126,17 @@ class ChatService: { "type": "image_url", "image_url": { - "url": f"data:{mime_type};base64,{base64_data}" + "url": f"data:{mimeType};base64,{base64Data}" } } ] } ] - # Use the existing call_api function with the Vision model - response = await self.call_api(messages) + # Use the existing callApi function with the Vision model + response = await self.callApi(messages) - # Extract and return content + # Return content return response except Exception as e: diff --git a/connectors/connectorDbJson.py b/connectors/connectorDbJson.py new file mode 100644 index 00000000..1a7a96cd --- /dev/null +++ b/connectors/connectorDbJson.py @@ -0,0 +1,561 @@ +import json +import os +from typing import List, Dict, Any, Optional, Union +import logging + +logger = logging.getLogger(__name__) + +class DatabaseConnector: + """ + A connector for JSON-based data storage. + Provides generic database operations with tenant and user context support. + """ + def __init__(self, dbHost: str, dbDatabase: str, dbUser: str = None, dbPassword: str = None, + mandateId: int = None, userId: int = None, skipInitialIdLookup: bool = False): + """ + Initializes the JSON database connector. + + Args: + dbHost: Directory for the JSON files + dbDatabase: Database name + dbUser: Username for authentication (optional) + dbPassword: API key for authentication (optional) + mandateId: Context parameter for the tenant + userId: Context parameter for the user + skipInitialIdLookup: When True, skips looking up initial IDs for mandateId and userId + """ + # Store the input parameters + self.dbHost = dbHost + self.dbDatabase = dbDatabase + self.dbUser = dbUser + self.dbPassword = dbPassword + self.skipInitialIdLookup = skipInitialIdLookup + + # Check if context parameters are set + if mandateId is None or userId is None: + raise ValueError("mandateId and userId must be set") + + # Ensure the database directory exists + self.dbFolder = os.path.join(self.dbHost, self.dbDatabase) + os.makedirs(self.dbFolder, exist_ok=True) + + # Cache for loaded data + self._tablesCache = {} + + # Initialize system table + self._systemTableName = "_system" + self._initializeSystemTable() + + # Temporarily store mandateId and userId + self._mandateId = mandateId + self._userId = userId + + # If mandateId or userId are 0 and we're not skipping ID lookup, try to use the initial IDs + if not skipInitialIdLookup: + if mandateId == 0: + initialMandateId = self.getInitialId("mandates") + if initialMandateId is not None: + self._mandateId = initialMandateId + logger.info(f"Using initial mandateId: {initialMandateId} instead of 0") + + if userId == 0: + initialUserId = self.getInitialId("users") + if initialUserId is not None: + self._userId = initialUserId + logger.info(f"Using initial userId: {initialUserId} instead of 0") + + # Set the effective IDs as properties + self.mandateId = self._mandateId + self.userId = self._userId + + logger.info(f"DatabaseConnector initialized for directory: {self.dbFolder}") + logger.debug(f"Context: mandateId={self.mandateId}, userId={self.userId}") + + def _initializeSystemTable(self): + """Initializes the system table if it doesn't exist yet.""" + systemTablePath = self._getTablePath(self._systemTableName) + if not os.path.exists(systemTablePath): + emptySystemTable = {} + self._saveSystemTable(emptySystemTable) + logger.info(f"System table initialized in {systemTablePath}") + else: + # Load existing system table to ensure it's available + self._loadSystemTable() + logger.debug(f"Existing system table loaded from {systemTablePath}") + + def _loadSystemTable(self) -> Dict[str, int]: + """Loads the system table with the initial IDs.""" + # Check if system table is in cache + if f"_{self._systemTableName}" in self._tablesCache: + return self._tablesCache[f"_{self._systemTableName}"] + + systemTablePath = self._getTablePath(self._systemTableName) + try: + if os.path.exists(systemTablePath): + with open(systemTablePath, 'r', encoding='utf-8') as f: + data = json.load(f) + # Store in cache with special prefix to avoid collision with regular tables + self._tablesCache[f"_{self._systemTableName}"] = data + return data + else: + self._tablesCache[f"_{self._systemTableName}"] = {} + return {} + except Exception as e: + logger.error(f"Error loading the system table: {e}") + self._tablesCache[f"_{self._systemTableName}"] = {} + return {} + + def _saveSystemTable(self, data: Dict[str, int]) -> bool: + """Saves the system table with the initial IDs.""" + systemTablePath = self._getTablePath(self._systemTableName) + try: + with open(systemTablePath, 'w', encoding='utf-8') as f: + json.dump(data, f, indent=2, ensure_ascii=False) + # Update cache + self._tablesCache[f"_{self._systemTableName}"] = data + return True + except Exception as e: + logger.error(f"Error saving the system table: {e}") + return False + + def _getTablePath(self, table: str) -> str: + """Returns the full path to a table file""" + return os.path.join(self.dbFolder, f"{table}.json") + + def _loadTable(self, table: str) -> List[Dict[str, Any]]: + """Loads a table from the corresponding JSON file""" + path = self._getTablePath(table) + + # If the table is the system table, load it directly + if table == self._systemTableName: + return [] # The system table is not treated like normal tables + + # If the table is already in the cache, use the cache + if table in self._tablesCache: + return self._tablesCache[table] + + # Otherwise load the file + try: + if os.path.exists(path): + with open(path, 'r', encoding='utf-8') as f: + data = json.load(f) + self._tablesCache[table] = data + + # If data was loaded and no initial ID is registered yet, + # register the ID of the first record (if available) + if data and not self.hasInitialId(table): + if "id" in data[0]: + self._registerInitialId(table, data[0]["id"]) + logger.info(f"Initial ID {data[0]['id']} for table {table} retroactively registered") + + return data + else: + # If the file doesn't exist, create an empty table + logger.info(f"New table {table}") + self._tablesCache[table] = [] + self._saveTable(table, []) + return [] + except Exception as e: + logger.error(f"Error loading table {table}: {e}") + return [] + + def _saveTable(self, table: str, data: List[Dict[str, Any]]) -> bool: + """Saves a table to the corresponding JSON file""" + # The system table is handled specially + if table == self._systemTableName: + return False + + path = self._getTablePath(table) + try: + with open(path, 'w', encoding='utf-8') as f: + json.dump(data, f, indent=2, ensure_ascii=False) + + # Update the cache + self._tablesCache[table] = data + return True + except Exception as e: + logger.error(f"Error saving table {table}: {e}") + return False + + def _filterByContext(self, records: List[Dict[str, Any]]) -> List[Dict[str, Any]]: + """ + Filters records by tenant and user context, + if these fields exist in the record. + """ + filteredRecords = [] + + for record in records: + # Check if mandateId exists in the record and is not null + hasMandate = "mandateId" in record and record["mandateId"] is not None and record["mandateId"] != "" + + # Check if userId exists in the record and is not null + hasUser = "userId" in record and record["userId"] is not None and record["userId"] != "" + + # If both exist, filter accordingly + if hasMandate and hasUser: + if record["mandateId"] == self.mandateId: + filteredRecords.append(record) + # If only mandateId exists + elif hasMandate and not hasUser: + if record["mandateId"] == self.mandateId: + filteredRecords.append(record) + # If neither mandateId nor userId exist, add the record + elif not hasMandate and not hasUser: + filteredRecords.append(record) + + return filteredRecords + + def _applyRecordFilter(self, records: List[Dict[str, Any]], recordFilter: Dict[str, Any] = None) -> List[Dict[str, Any]]: + """Applies a record filter to the records""" + if not recordFilter: + return records + + filteredRecords = [] + + for record in records: + match = True + + for field, value in recordFilter.items(): + # Check if the field exists + if field not in record: + match = False + break + + # If the filter value is an integer string and the record field is an integer + if isinstance(value, str) and value.isdigit() and isinstance(record[field], int): + if record[field] != int(value): + match = False + break + # Otherwise direct comparison + elif record[field] != value: + match = False + break + + if match: + filteredRecords.append(record) + + return filteredRecords + + def _registerInitialId(self, table: str, initialId: int) -> bool: + """ + Registers the initial ID for a table. + + Args: + table: Name of the table + initialId: The initial ID + + Returns: + True on success, False on error + """ + try: + # Load the current system table + systemData = self._loadSystemTable() + + # Only register if not already present + if table not in systemData: + systemData[table] = initialId + success = self._saveSystemTable(systemData) + if success: + logger.info(f"Initial ID {initialId} for table {table} registered") + return success + return True # If already present, this is not an error + except Exception as e: + logger.error(f"Error registering the initial ID for table {table}: {e}") + return False + + def _removeInitialId(self, table: str) -> bool: + """ + Removes the initial ID for a table from the system table. + + Args: + table: Name of the table + + Returns: + True on success, False on error + """ + try: + # Load the current system table + systemData = self._loadSystemTable() + + # Remove the entry if it exists + if table in systemData: + del systemData[table] + success = self._saveSystemTable(systemData) + if success: + logger.info(f"Initial ID for table {table} removed from system table") + return success + return True # If not present, this is not an error + except Exception as e: + logger.error(f"Error removing initial ID for table {table}: {e}") + return False + + # Public API + + def getTables(self) -> List[str]: + """ + Returns a list of all available tables. + + Returns: + List of table names + """ + tables = [] + + try: + for filename in os.listdir(self.dbFolder): + if filename.endswith('.json') and not filename.startswith('_'): + tableName = filename[:-5] # Remove the .json extension + tables.append(tableName) + except Exception as e: + logger.error(f"Error reading the database directory: {e}") + + return tables + + def getFields(self, table: str) -> List[str]: + """ + Returns a list of all fields in a table. + + Args: + table: Name of the table + + Returns: + List of field names + """ + # Load the table data + data = self._loadTable(table) + + if not data: + return [] + + # Take the first record as a reference for the fields + fields = list(data[0].keys()) if data else [] + + return fields + + def getSchema(self, table: str, language: str = None) -> Dict[str, Dict[str, Any]]: + """ + Returns a schema object for a table with data types and labels. + + Args: + table: Name of the table + language: Language for the labels (optional) + + Returns: + Schema object with fields, data types and labels + """ + # Load the table data + data = self._loadTable(table) + + schema = {} + + if not data: + return schema + + # Take the first record as a reference for the fields and data types + firstRecord = data[0] + + for field, value in firstRecord.items(): + # Determine the data type + dataType = type(value).__name__ + + # Create label (default is the field name) + label = field + + schema[field] = { + "type": dataType, + "label": label + } + + return schema + + def getRecordset(self, table: str, fieldFilter: List[str] = None, recordFilter: Dict[str, Any] = None) -> List[Dict[str, Any]]: + """ + Returns a list of records from a table, filtered by criteria. + + Args: + table: Name of the table + fieldFilter: Filter for fields (which fields should be returned) + recordFilter: Filter for records (which records should be returned) + + Returns: + List of filtered records + """ + # Load the table data + data = self._loadTable(table) + + # Filter by tenant and user context + filteredData = self._filterByContext(data) + + # Apply recordFilter if available + if recordFilter: + filteredData = self._applyRecordFilter(filteredData, recordFilter) + + # If fieldFilter is available, reduce the fields + if fieldFilter and isinstance(fieldFilter, list): + result = [] + for record in filteredData: + filteredRecord = {} + for field in fieldFilter: + if field in record: + filteredRecord[field] = record[field] + result.append(filteredRecord) + return result + + return filteredData + + def recordCreate(self, table: str, recordData: Dict[str, Any]) -> Dict[str, Any]: + """ + Creates a new record in the table. + + Args: + table: Name of the table + recordData: Data for the new record + + Returns: + The created record + """ + # Load the table data + data = self._loadTable(table) + + # Add mandateId and userId if not present or 0 + if "mandateId" not in recordData or recordData["mandateId"] == 0: + recordData["mandateId"] = self.mandateId + + if "userId" not in recordData or recordData["userId"] == 0: + recordData["userId"] = self.userId + + # Determine the next ID if not present + if "id" not in recordData: + nextId = 1 + if data: + nextId = max(record["id"] for record in data if "id" in record) + 1 + recordData["id"] = nextId + + # If the table is empty and a system ID should be registered + if not data: + self._registerInitialId(table, recordData["id"]) + logger.info(f"Initial ID {recordData['id']} for table {table} has been registered") + + # Add the new record + data.append(recordData) + + # Save the updated table + if self._saveTable(table, data): + return recordData + else: + raise ValueError(f"Error creating the record in table {table}") + + def recordDelete(self, table: str, recordId: Union[str, int]) -> bool: + """ + Deletes a record from the table. + + Args: + table: Name of the table + recordId: ID of the record to delete + + Returns: + True on success, False on error + """ + # Load table data + data = self._loadTable(table) + + # Search for the record + for i, record in enumerate(data): + if "id" in record and record["id"] == recordId: + # Check if the record belongs to the current mandate + if "mandateId" in record and record["mandateId"] != self.mandateId: + raise ValueError("Not your mandate") + + # Check if it's an initial record + initialId = self.getInitialId(table) + if initialId is not None and initialId == recordId: + # Remove this entry from the system table + self._removeInitialId(table) + logger.info(f"Initial ID {recordId} for table {table} has been removed from the system table") + + # Delete the record + del data[i] + + # Save the updated table + return self._saveTable(table, data) + + # Record not found + return False + + def recordModify(self, table: str, recordId: Union[str, int], recordData: Dict[str, Any]) -> Dict[str, Any]: + """ + Modifies a record in the table. + + Args: + table: Name of the table + recordId: ID of the record to modify + recordData: New data for the record + + Returns: + The updated record + """ + # Load table data + data = self._loadTable(table) + + # Search for the record + for i, record in enumerate(data): + if "id" in record and record["id"] == recordId: + # Check if the record belongs to the current mandate + if "mandateId" in record and record["mandateId"] != self.mandateId: + raise ValueError("Not your mandate") + + # Prevent changing the ID + if "id" in recordData and recordData["id"] != recordId: + raise ValueError(f"The ID of a record in table {table} cannot be changed") + + # Update the record + for key, value in recordData.items(): + data[i][key] = value + + # Save the updated table + if self._saveTable(table, data): + return data[i] + else: + raise ValueError(f"Error updating record in table {table}") + + # Record not found + raise ValueError(f"Record with ID {recordId} not found in table {table}") + + def hasInitialId(self, table: str) -> bool: + """ + Checks if an initial ID is registered for a table. + + Args: + table: Name of the table + + Returns: + True if an initial ID is registered, otherwise False + """ + systemData = self._loadSystemTable() + return table in systemData + + def getInitialId(self, table: str) -> Optional[int]: + """ + Returns the initial ID for a table. + + Args: + table: Name of the table + + Returns: + The initial ID or None if not present + """ + systemData = self._loadSystemTable() + initialId = systemData.get(table) + logger.debug(f"Database '{self.dbDatabase}': Initial ID for table '{table}' is {initialId}") + if initialId is None: + logger.debug(f"No initial ID found for table {table}") + return initialId + + def getAllInitialIds(self) -> Dict[str, int]: + """ + Returns all registered initial IDs. + + Returns: + Dictionary with table names as keys and initial IDs as values + """ + systemData = self._loadSystemTable() + return systemData.copy() # Return a copy to protect the original \ No newline at end of file diff --git a/connectors/connector_db_json.py b/connectors/connector_db_json.py deleted file mode 100644 index 919c2bfa..00000000 --- a/connectors/connector_db_json.py +++ /dev/null @@ -1,557 +0,0 @@ -import json -import os -from typing import List, Dict, Any, Optional, Union -import logging -from datetime import datetime - - -logger = logging.getLogger(__name__) - - -class DatabaseConnector: - """ - A connector for JSON-based data storage. - Provides generic database operations. - """ - def __init__(self, db_host: str, db_database: str, db_user: str = None, db_password: str = None, mandate_id: int = None, user_id: int = None): - """ - Initializes the JSON database connector. - - Args: - db_host: Directory for the JSON files - db_database = Database name - db_user: Username for authentication (optional) - db_password: API key for authentication (optional) - mandate_id: Context parameter for the tenant - user_id: Context parameter for the user - """ - # Store the input parameters - self.db_host = db_host - self.db_database = db_database - self.db_user = db_user - self.db_password = db_password - - # Check if context parameters are set - if mandate_id is None or user_id is None: - raise ValueError("mandate_id and user_id must be set") - - # Ensure the database directory exists - self.db_folder=os.path.join(self.db_host,self.db_database) - os.makedirs(self.db_folder, exist_ok=True) - - # Cache for loaded data - self._tables_cache = {} - - # Initialize system table - self._system_table_name = "_system" - self._initialize_system_table() - - # Temporarily store mandate_id and user_id - self._mandate_id = mandate_id - self._user_id = user_id - - # If mandate_id or user_id are 0, try to use the initial IDs - if mandate_id == 0: - initial_mandate_id = self.get_initial_id("mandates") - if initial_mandate_id is not None: - self._mandate_id = initial_mandate_id - logger.info(f"Using initial mandate_id: {initial_mandate_id} instead of 0") - - if user_id == 0: - initial_user_id = self.get_initial_id("users") - if initial_user_id is not None: - self._user_id = initial_user_id - logger.info(f"Using initial user_id: {initial_user_id} instead of 0") - - # Set the effective IDs as properties - self.mandate_id = self._mandate_id - self.user_id = self._user_id - - logger.info(f"DatabaseConnector initialized for directory: {self.db_folder}") - logger.debug(f"Context: mandate_id={self.mandate_id}, user_id={self.user_id}") - - def _initialize_system_table(self): - """Initializes the system table if it doesn't exist yet.""" - system_table_path = self._get_table_path(self._system_table_name) - if not os.path.exists(system_table_path): - empty_system_table = {} - self._save_system_table(empty_system_table) - logger.info(f"System table initialized in {system_table_path}") - - def _load_system_table(self) -> Dict[str, int]: - """Loads the system table with the initial IDs.""" - system_table_path = self._get_table_path(self._system_table_name) - try: - if os.path.exists(system_table_path): - with open(system_table_path, 'r', encoding='utf-8') as f: - return json.load(f) - else: - return {} - except Exception as e: - logger.error(f"Error loading the system table: {e}") - return {} - - def _save_system_table(self, data: Dict[str, int]) -> bool: - """Saves the system table with the initial IDs.""" - system_table_path = self._get_table_path(self._system_table_name) - try: - with open(system_table_path, 'w', encoding='utf-8') as f: - json.dump(data, f, indent=2, ensure_ascii=False) - return True - except Exception as e: - logger.error(f"Error saving the system table: {e}") - return False - - def _get_table_path(self, table: str) -> str: - """Returns the full path to a table file""" - return os.path.join(self.db_folder, f"{table}.json") - - def _load_table(self, table: str) -> List[Dict[str, Any]]: - """Loads a table from the corresponding JSON file""" - path = self._get_table_path(table) - - # If the table is the system table, load it directly - if table == self._system_table_name: - return [] # The system table is not treated like normal tables - - # If the table is already in the cache, use the cache - if table in self._tables_cache: - # logger.info(f"Loading table {table} from cache") - return self._tables_cache[table] - - # Otherwise load the file - try: - if os.path.exists(path): - # logger.info(f"Loading table {table} from JSON {path}") - with open(path, 'r', encoding='utf-8') as f: - data = json.load(f) - self._tables_cache[table] = data - - # If data was loaded and no initial ID is registered yet, - # register the ID of the first record (if available) - if data and not self.has_initial_id(table): - if "id" in data[0]: - self._register_initial_id(table, data[0]["id"]) - logger.info(f"Initial ID {data[0]['id']} for table {table} retroactively registered") - - return data - else: - # If the file doesn't exist, create an empty table - logger.info(f"New table {table}") - self._tables_cache[table] = [] - self._save_table(table, []) - return [] - except Exception as e: - logger.error(f"Error loading table {table}: {e}") - return [] - - def _save_table(self, table: str, data: List[Dict[str, Any]]) -> bool: - """Saves a table to the corresponding JSON file""" - # The system table is handled specially - if table == self._system_table_name: - return False - - path = self._get_table_path(table) - try: - with open(path, 'w', encoding='utf-8') as f: - json.dump(data, f, indent=2, ensure_ascii=False) - - # Update the cache - self._tables_cache[table] = data - return True - except Exception as e: - logger.error(f"Error saving table {table}: {e}") - return False - - def _filter_by_context(self, records: List[Dict[str, Any]]) -> List[Dict[str, Any]]: - """ - Filters records by tenant and user context, - if these fields exist in the record. - """ - filtered_records = [] - - for record in records: - # Check if mandate_id exists in the record and is not null - has_mandate = "mandate_id" in record and record["mandate_id"] is not None and record["mandate_id"] != "" - - # Check if user_id exists in the record and is not null - has_user = "user_id" in record and record["user_id"] is not None and record["user_id"] != "" - - # If both exist, filter accordingly - if has_mandate and has_user: - if record["mandate_id"] == self.mandate_id: - filtered_records.append(record) - # If only mandate_id exists - elif has_mandate and not has_user: - if record["mandate_id"] == self.mandate_id: - filtered_records.append(record) - # If neither mandate_id nor user_id exist, add the record - elif not has_mandate and not has_user: - filtered_records.append(record) - - return filtered_records - - def _apply_record_filter(self, records: List[Dict[str, Any]], record_filter: Dict[str, Any] = None) -> List[Dict[str, Any]]: - """Applies a record filter to the records""" - - if not record_filter: - return records - - filtered_records = [] - - for record in records: - match = True - - for field, value in record_filter.items(): - # Check if the field exists - if field not in record: - match = False - break - - # If the filter value is an integer string and the record field is an integer - if isinstance(value, str) and value.isdigit() and isinstance(record[field], int): - if record[field] != int(value): - match = False - break - # Otherwise direct comparison - elif record[field] != value: - match = False - break - - if match: - filtered_records.append(record) - - return filtered_records - - def _register_initial_id(self, table: str, initial_id: int) -> bool: - """ - Registers the initial ID for a table. - - Args: - table: Name of the table - initial_id: The initial ID - - Returns: - True on success, False on error - """ - try: - # Load the current system table - system_data = self._load_system_table() - - # Only register if not already present - if table not in system_data: - system_data[table] = initial_id - success = self._save_system_table(system_data) - if success: - logger.info(f"Initial ID {initial_id} for table {table} registered") - return success - return True # If already present, this is not an error - except Exception as e: - logger.error(f"Error registering the initial ID for table {table}: {e}") - return False - - def _remove_initial_id(self, table: str) -> bool: - """ - Removes the initial ID for a table from the system table. - - Args: - table: Name of the table - - Returns: - True on success, False on error - """ - try: - # Load the current system table - system_data = self._load_system_table() - - # Remove the entry if it exists - if table in system_data: - del system_data[table] - success = self._save_system_table(system_data) - if success: - logger.info(f"Initial ID for table {table} removed from system table") - return success - return True # If not present, this is not an error - except Exception as e: - logger.error(f"Error removing initial ID for table {table}: {e}") - return False - - - # Public API - - def get_tables(self, filter_criteria: Dict[str, Any] = None) -> List[str]: - """ - Returns a list of all available tables. - - Args: - filter_criteria: Optional filter criteria (not implemented) - - Returns: - List of table names - """ - - tables = [] - - try: - for filename in os.listdir(self.db_folder): - if filename.endswith('.json') and not filename.startswith('_'): - table_name = filename[:-5] # Remove the .json extension - tables.append(table_name) - except Exception as e: - logger.error(f"Error reading the database directory: {e}") - - return tables - - def get_fields(self, table: str, filter_criteria: Dict[str, Any] = None) -> List[str]: - """ - Returns a list of all fields in a table. - - Args: - table: Name of the table - filter_criteria: Optional filter criteria (not implemented) - - Returns: - List of field names - """ - # Load the table data - data = self._load_table(table) - - if not data: - return [] - - # Take the first record as a reference for the fields - fields = list(data[0].keys()) if data else [] - - return fields - - def get_schema(self, table: str, language: str = None, filter_criteria: Dict[str, Any] = None) -> Dict[str, Dict[str, Any]]: - """ - Returns a schema object for a table with data types and labels. - - Args: - table: Name of the table - language: Language for the labels (optional) - filter_criteria: Optional filter criteria (not implemented) - - Returns: - Schema object with fields, data types and labels - """ - # Load the table data - data = self._load_table(table) - - schema = {} - - if not data: - return schema - - # Take the first record as a reference for the fields and data types - first_record = data[0] - - for field, value in first_record.items(): - # Determine the data type - data_type = type(value).__name__ - - # Create label (default is the field name) - label = field - - # If model_info is available, try to get the label from the model - # Implementation depends on the actual model - - schema[field] = { - "type": data_type, - "label": label - } - - return schema - - def get_recordset(self, table: str, field_filter: Dict[str, Any] = None, record_filter: Dict[str, Any] = None) -> List[Dict[str, Any]]: - """ - Returns a list of records from a table, filtered by criteria. - - Args: - table: Name of the table - field_filter: Filter for fields (which fields should be returned) - record_filter: Filter for records (which records should be returned) - - Returns: - List of filtered records - """ - # Load the table data - data = self._load_table(table) - - # Filter by tenant and user context - filtered_data = self._filter_by_context(data) - - # Apply record_filter if available - if record_filter: - filtered_data = self._apply_record_filter(filtered_data, record_filter) - - # If field_filter is available, reduce the fields - if field_filter and isinstance(field_filter, list): - result = [] - for record in filtered_data: - filtered_record = {} - for field in field_filter: - if field in record: - filtered_record[field] = record[field] - result.append(filtered_record) - return result - - return filtered_data - - def record_create(self, table: str, record_data: Dict[str, Any]) -> Dict[str, Any]: - """ - Creates a new record in the table. - - Args: - table: Name of the table - record_data: Data for the new record - - Returns: - The created record - """ - # Load the table data - data = self._load_table(table) - - # Add mandate_id and user_id if not present or 0 - if "mandate_id" not in record_data or record_data["mandate_id"] == 0: - record_data["mandate_id"] = self.mandate_id - - if "user_id" not in record_data or record_data["user_id"] == 0: - record_data["user_id"] = self.user_id - - # Determine the next ID if not present - if "id" not in record_data: - next_id = 1 - if data: - next_id = max(record["id"] for record in data if "id" in record) + 1 - record_data["id"] = next_id - - # If the table is empty and a system ID should be registered - if not data: - self._register_initial_id(table, record_data["id"]) - logger.info(f"Initial ID {record_data['id']} for table {table} has been registered") - - # Add the new record - data.append(record_data) - - # Save the updated table - if self._save_table(table, data): - return record_data - else: - raise ValueError(f"Error creating the record in table {table}") - - def record_delete(self, table: str, record_id: Union[str, int]) -> bool: - """ - Deletes a record from the table. - - Args: - table: Name of the table - record_id: ID of the record to delete - - Returns: - True on success, False on error - """ - # Load table data - data = self._load_table(table) - - # Search for the record - for i, record in enumerate(data): - if "id" in record and record["id"] == record_id: - # Check if the record belongs to the current mandate - if "mandate_id" in record and record["mandate_id"] != self.mandate_id: - raise ValueError("Not your mandate") - - # Check if it's an initial record - initial_id = self.get_initial_id(table) - if initial_id is not None and initial_id == record_id: - # Remove this entry from the system table - self._remove_initial_id(table) - logger.info(f"Initial ID {record_id} for table {table} has been removed from the system table") - - # Delete the record - del data[i] - - # Save the updated table - return self._save_table(table, data) - - # Record not found - return False - - def record_modify(self, table: str, record_id: Union[str, int], record_data: Dict[str, Any]) -> Dict[str, Any]: - """ - Modifies a record in the table. - - Args: - table: Name of the table - record_id: ID of the record to modify - record_data: New data for the record - - Returns: - The updated record - """ - # Load table data - data = self._load_table(table) - - # Search for the record - for i, record in enumerate(data): - if "id" in record and record["id"] == record_id: - # Check if the record belongs to the current mandate - if "mandate_id" in record and record["mandate_id"] != self.mandate_id: - raise ValueError("Not your mandate") - - # Prevent changing the ID - if "id" in record_data and record_data["id"] != record_id: - raise ValueError(f"The ID of a record in table {table} cannot be changed") - - # Update the record - for key, value in record_data.items(): - data[i][key] = value - - # Save the updated table - if self._save_table(table, data): - return data[i] - else: - raise ValueError(f"Error updating record in table {table}") - - # Record not found - raise ValueError(f"Record with ID {record_id} not found in table {table}") - - def has_initial_id(self, table: str) -> bool: - """ - Checks if an initial ID is registered for a table. - - Args: - table: Name of the table - - Returns: - True if an initial ID is registered, otherwise False - """ - system_data = self._load_system_table() - return table in system_data - - def get_initial_id(self, table: str) -> Optional[int]: - """ - Returns the initial ID for a table. - - Args: - table: Name of the table - - Returns: - The initial ID or None if not present - """ - system_data = self._load_system_table() - initial_id = system_data.get(table) - if initial_id is None: - logger.debug(f"No initial ID found for table {table}") - return initial_id - - def get_all_initial_ids(self) -> Dict[str, int]: - """ - Returns all registered initial IDs. - - Returns: - Dictionary with table names as keys and initial IDs as values - """ - system_data = self._load_system_table() - return system_data.copy() # Return a copy to protect the original \ No newline at end of file diff --git a/env_dev.env b/env_dev.env index ceb7d14f..98f8d545 100644 --- a/env_dev.env +++ b/env_dev.env @@ -22,4 +22,4 @@ APP_JWT_SECRET_SECRET=dev_jwt_secret_token APP_TOKEN_EXPIRY=300 # CORS Configuration -APP_ALLOWED_ORIGINS=["http://localhost:8080","http://localhost:3000"] +APP_ALLOWED_ORIGINS="http://localhost:8080","http://localhost:3000" diff --git a/env_prod.env b/env_prod.env index e9b7e129..e9c5efd6 100644 --- a/env_prod.env +++ b/env_prod.env @@ -22,4 +22,4 @@ APP_JWT_SECRET_SECRET=dev_jwt_secret_token APP_TOKEN_EXPIRY=300 # CORS Configuration -APP_ALLOWED_ORIGINS=["http://localhost:8080","http://localhost:3000"] +APP_ALLOWED_ORIGINS="http://localhost:8080","http://localhost:3000" diff --git a/modules/_SAVE_gatewayInterface copy.py b/modules/_SAVE_gatewayInterface copy.py new file mode 100644 index 00000000..ae497abc --- /dev/null +++ b/modules/_SAVE_gatewayInterface copy.py @@ -0,0 +1,261 @@ +""" +Interface to the Gateway system. +Manages users and mandates for authentication. +""" + +import os +import logging +from typing import Dict, Any, List, Optional, Union +import importlib +from passlib.context import CryptContext + +from connectors.connectorDbJson import DatabaseConnector +from modules.configuration import APP_CONFIG + +logger = logging.getLogger(__name__) + +# Password-Hashing +pwdContext = CryptContext(schemes=["argon2"], deprecated="auto") + + +class GatewayInterface: + """ + Interface to the Gateway system. + Manages users and mandates. + """ + + def __init__(self, mandateId: int = None, userId: int = None): + """ + Initializes the Gateway Interface with optional mandate and user context. + + Args: + mandateId: ID of the current mandate (optional) + userId: ID of the current user (optional) + """ + # Context can be empty during initialization + self.mandateId = mandateId + self.userId = userId + + # Import data model module + try: + self.modelModule = importlib.import_module("modules.gatewayModel") + logger.info("gatewayModel successfully imported") + except ImportError as e: + logger.error(f"Error importing gatewayModel: {e}") + raise + + # Initialize database + self._initializeDatabase() + + def _initializeDatabase(self): + """ + Initializes the database with minimal objects + """ + + self.db = DatabaseConnector( + dbHost=APP_CONFIG.get("DB_SYSTEM_HOST"), + dbDatabase=APP_CONFIG.get("DB_SYSTEM_DATABASE"), + dbUser=APP_CONFIG.get("DB_SYSTEM_USER"), + dbPassword=APP_CONFIG.get("DB_SYSTEM_PASSWORD_SECRET"), + mandateId=self.mandateId if self.mandateId else 0, + userId=self.userId if self.userId else 0 + ) + + # Create Root mandate if needed + existingMandateId = self.getInitialId("mandates") + mandates = self.db.getRecordset("mandates") + if existingMandateId is None or not mandates: + logger.info("Creating Root mandate") + rootMandate = { + "name": "Root", + "language": "de" + } + createdMandate = self.db.recordCreate("mandates", rootMandate) + logger.info(f"Root mandate created with ID {createdMandate['id']}") + + # Update mandate context + self.mandateId = createdMandate['id'] + self.userId = createdMandate['userId'] + + # Recreate connector with correct context + self.db = DatabaseConnector( + dbHost=APP_CONFIG.get("DB_SYSTEM_HOST"), + dbDatabase=APP_CONFIG.get("DB_SYSTEM_DATABASE"), + dbUser=APP_CONFIG.get("DB_SYSTEM_USER"), + dbPassword=APP_CONFIG.get("DB_SYSTEM_PASSWORD_SECRET"), + mandateId=self.mandateId, + userId=self.userId + ) + + # Create Admin user if needed + existingUserId = self.getInitialId("users") + users = self.db.getRecordset("users") + if existingUserId is None or not users: + logger.info("Creating Admin user") + adminUser = { + "mandateId": self.mandateId, + "username": "admin", + "email": "admin@example.com", + "fullName": "Administrator", + "disabled": False, + "language": "de", + "privilege": "sysadmin", # SysAdmin privilege + "hashedPassword": self._getPasswordHash("admin") # Use a secure password in production! + } + createdUser = self.db.recordCreate("users", adminUser) + logger.info(f"Admin user created with ID {createdUser['id']}") + + # Update user context + self.userId = createdUser['id'] + + # Recreate connector with correct context + self.db = DatabaseConnector( + dbHost=APP_CONFIG.get("DB_SYSTEM_HOST"), + dbDatabase=APP_CONFIG.get("DB_SYSTEM_DATABASE"), + dbUser=APP_CONFIG.get("DB_SYSTEM_USER"), + dbPassword=APP_CONFIG.get("DB_SYSTEM_PASSWORD_SECRET"), + mandateId=self.mandateId, + userId=self.userId + ) + + def getInitialId(self, table: str) -> Optional[int]: + """Returns the initial ID for a table""" + return self.db.getInitialId(table) + + def _getPasswordHash(self, password: str) -> str: + """Creates a hash for a password""" + return pwdContext.hash(password) + + def _verifyPassword(self, plainPassword: str, hashedPassword: str) -> bool: + """Checks if the password matches the hash""" + return pwdContext.verify(plainPassword, hashedPassword) + + def _getCurrentTimestamp(self) -> str: + """Returns the current timestamp in ISO format""" + from datetime import datetime + return datetime.now().isoformat() + + # Mandate methods + + def getAllMandates(self) -> List[Dict[str, Any]]: + """Returns all mandates""" + return self.db.getRecordset("mandates") + + def getMandate(self, mandateId: int) -> Optional[Dict[str, Any]]: + """Returns a mandate by its ID""" + mandates = self.db.getRecordset("mandates", recordFilter={"id": mandateId}) + if mandates: + return mandates[0] + return None + + def createMandate(self, name: str, language: str = "de") -> Dict[str, Any]: + """Creates a new mandate""" + mandateData = { + "name": name, + "language": language + } + + return self.db.recordCreate("mandates", mandateData) + + # User methods + + def getAllUsers(self) -> List[Dict[str, Any]]: + """Returns all users""" + users = self.db.getRecordset("users") + # Remove password hashes from the response + for user in users: + if "hashedPassword" in user: + del user["hashedPassword"] + return users + + def getUsersByMandate(self, mandateId: int) -> List[Dict[str, Any]]: + """ + Returns all users of a specific mandate + + Args: + mandateId: The ID of the mandate + + Returns: + List[Dict[str, Any]]: List of users in the mandate + """ + users = self.db.getRecordset("users", recordFilter={"mandateId": mandateId}) + # Remove password hashes from the response + for user in users: + if "hashedPassword" in user: + del user["hashedPassword"] + return users + + def getUserByUsername(self, username: str) -> Optional[Dict[str, Any]]: + """Returns a user by username""" + users = self.db.getRecordset("users") + for user in users: + if user.get("username") == username: + return user + return None + + def getUser(self, userId: int) -> Optional[Dict[str, Any]]: + """Returns a user by ID""" + users = self.db.getRecordset("users", recordFilter={"id": userId}) + if users: + user = users[0] + # Remove password hash from the API response + if "hashedPassword" in user: + userCopy = user.copy() + del userCopy["hashedPassword"] + return userCopy + return user + return None + + def authenticateUser(self, username: str, password: str) -> Optional[Dict[str, Any]]: + """ + Authenticates a user by username and password + + Args: + username: The username + password: The password + + Returns: + Optional[Dict[str, Any]]: The user data or None if authentication fails + """ + user = self.getUserByUsername(username) + + if not user: + return None + + if not self._verifyPassword(password, user.get("hashedPassword", "")): + return None + + # Check if the user is disabled + if user.get("disabled", False): + return None + + # Create a copy without password hash + authenticatedUser = {**user} + if "hashedPassword" in authenticatedUser: + del authenticatedUser["hashedPassword"] + + return authenticatedUser + + +# Singleton factory for GatewayInterface instances per context +_gatewayInterfaces = {} + +def getGatewayInterface(mandateId: int = None, userId: int = None) -> GatewayInterface: + """ + Returns a GatewayInterface instance for the specified context. + Reuses existing instances. + + Args: + mandateId: ID of the mandate + userId: ID of the user + + Returns: + GatewayInterface instance + """ + contextKey = f"{mandateId}_{userId}" + if contextKey not in _gatewayInterfaces: + _gatewayInterfaces[contextKey] = GatewayInterface(mandateId, userId) + return _gatewayInterfaces[contextKey] + +# Initialize the interface +getGatewayInterface() \ No newline at end of file diff --git a/modules/chat_agent_analyst.py b/modules/agentAnalyst.py similarity index 56% rename from modules/chat_agent_analyst.py rename to modules/agentAnalyst.py index e2c9cb98..181dba42 100644 --- a/modules/chat_agent_analyst.py +++ b/modules/agentAnalyst.py @@ -12,7 +12,7 @@ import pandas as pd import matplotlib.pyplot as plt import seaborn as sns -from modules.chat_registry import AgentBase +from modules.workflowAgentsRegistry import AgentBase logger = logging.getLogger(__name__) @@ -25,26 +25,26 @@ class AgentAnalyst(AgentBase): self.name = "analyst" self.description = "Analyzes data using AI-powered insights and visualizations, produce diagrams and visualizations" self.capabilities = [ - "data_analysis", + "dataAnalysis", "statistics", "visualization", - "data_interpretation", - "report_generation" + "dataInterpretation", + "reportGeneration" ] # Set default visualization settings plt.style.use('seaborn-v0_8-whitegrid') - def set_dependencies(self, mydom=None): + def setDependencies(self, mydom=None): """Set external dependencies for the agent.""" self.mydom = mydom - async def process_task(self, task: Dict[str, Any]) -> Dict[str, Any]: + async def processTask(self, task: Dict[str, Any]) -> Dict[str, Any]: """ Process a task by focusing on required outputs and using AI to generate them. Args: - task: Task dictionary with prompt, input_documents, output_specifications + task: Task dictionary with prompt, inputDocuments, outputSpecifications Returns: Dictionary with feedback and documents @@ -52,8 +52,8 @@ class AgentAnalyst(AgentBase): try: # Extract task information prompt = task.get("prompt", "") - input_documents = task.get("input_documents", []) - output_specs = task.get("output_specifications", []) + inputDocuments = task.get("inputDocuments", []) + outputSpecs = task.get("outputSpecifications", []) # Check AI service if not self.mydom: @@ -62,52 +62,52 @@ class AgentAnalyst(AgentBase): "documents": [] } - # Extract data from documents - focusing only on data_extracted - datasets, document_context = self._extract_data(input_documents) + # Extract data from documents - focusing only on dataExtracted + datasets, documentContext = self._extractData(inputDocuments) # Generate task analysis to understand what's needed - analysis_plan = await self._analyze_task(prompt, document_context, datasets, output_specs) + analysisPlan = await self._analyzeTask(prompt, documentContext, datasets, outputSpecs) # Generate all required output documents documents = [] # If no output specs provided, create default analysis outputs - if not output_specs: - output_specs = [] + if not outputSpecs: + outputSpecs = [] # Process each output specification - for spec in output_specs: - output_label = spec.get("label", "") - output_description = spec.get("description", "") + for spec in outputSpecs: + outputLabel = spec.get("label", "") + outputDescription = spec.get("description", "") # Determine type based on file extension - output_type = output_label.split('.')[-1].lower() if '.' in output_label else "txt" + outputType = outputLabel.split('.')[-1].lower() if '.' in outputLabel else "txt" # Generate appropriate content based on output type - if output_type in ['png', 'jpg', 'jpeg', 'svg']: + if outputType in ['png', 'jpg', 'jpeg', 'svg']: # Create visualization - document = await self._create_visualization( - datasets, prompt, output_label, analysis_plan, output_description + document = await self._createVisualization( + datasets, prompt, outputLabel, analysisPlan, outputDescription ) documents.append(document) - elif output_type in ['csv', 'json', 'xlsx']: + elif outputType in ['csv', 'json', 'xlsx']: # Create data document - document = await self._create_data_document( - datasets, prompt, output_label, analysis_plan, output_description + document = await self._createDataDocument( + datasets, prompt, outputLabel, analysisPlan, outputDescription ) documents.append(document) else: # Create text document (report, analysis, etc.) - document = await self._create_text_document( - datasets, document_context, prompt, output_label, - output_type, analysis_plan, output_description + document = await self._createTextDocument( + datasets, documentContext, prompt, outputLabel, + outputType, analysisPlan, outputDescription ) documents.append(document) # Generate feedback - feedback = f"{analysis_plan.get('analysis_approach')}" - if analysis_plan.get("key_insights"): - feedback += f"\n\n{analysis_plan.get('key_insights')}" + feedback = f"{analysisPlan.get('analysisApproach')}" + if analysisPlan.get("keyInsights"): + feedback += f"\n\n{analysisPlan.get('keyInsights')}" return { "feedback": feedback, @@ -121,9 +121,9 @@ class AgentAnalyst(AgentBase): "documents": [] } - def _extract_data(self, documents: List[Dict[str, Any]]) -> tuple: + def _extractData(self, documents: List[Dict[str, Any]]) -> tuple: """ - Extract data from documents, focusing on data_extracted fields. + Extract data from documents, focusing on dataExtracted fields. Args: documents: List of input documents @@ -132,70 +132,70 @@ class AgentAnalyst(AgentBase): Tuple of (datasets dictionary, document context text) """ datasets = {} - document_context = "" + documentContext = "" # Process each document for doc in documents: - doc_name = doc.get("name", "unnamed") + docName = doc.get("name", "unnamed") if doc.get("ext"): - doc_name = f"{doc_name}.{doc.get('ext')}" + docName = f"{docName}.{doc.get('ext')}" - document_context += f"\n\n--- {doc_name} ---\n" + documentContext += f"\n\n--- {docName} ---\n" # Process contents for content in doc.get("contents", []): - # Focus only on data_extracted - if content.get("data_extracted"): - extracted_text = content.get("data_extracted", "") - document_context += extracted_text + # Focus only on dataExtracted + if content.get("dataExtracted"): + extractedText = content.get("dataExtracted", "") + documentContext += extractedText # Try to parse as structured data if appropriate - if doc_name.lower().endswith(('.csv', '.tsv')): + if docName.lower().endswith(('.csv', '.tsv')): try: - df = pd.read_csv(io.StringIO(extracted_text)) - datasets[doc_name] = df + df = pd.read_csv(io.StringIO(extractedText)) + datasets[docName] = df except: pass - elif doc_name.lower().endswith('.json'): + elif docName.lower().endswith('.json'): try: - json_data = json.loads(extracted_text) - if isinstance(json_data, list): - df = pd.DataFrame(json_data) - datasets[doc_name] = df - elif isinstance(json_data, dict): + jsonData = json.loads(extractedText) + if isinstance(jsonData, list): + df = pd.DataFrame(jsonData) + datasets[docName] = df + elif isinstance(jsonData, dict): # Handle nested JSON structures - if any(isinstance(v, list) for v in json_data.values()): - for key, value in json_data.items(): + if any(isinstance(v, list) for v in jsonData.values()): + for key, value in jsonData.items(): if isinstance(value, list) and len(value) > 0: df = pd.DataFrame(value) - datasets[f"{doc_name}:{key}"] = df + datasets[f"{docName}:{key}"] = df else: - df = pd.DataFrame([json_data]) - datasets[doc_name] = df + df = pd.DataFrame([jsonData]) + datasets[docName] = df except: pass # Try to detect tabular data in text content - if doc_name not in datasets and len(extracted_text.splitlines()) > 2: - lines = extracted_text.splitlines() + if docName not in datasets and len(extractedText.splitlines()) > 2: + lines = extractedText.splitlines() if any(',' in line for line in lines[:5]): try: - df = pd.read_csv(io.StringIO(extracted_text)) + df = pd.read_csv(io.StringIO(extractedText)) if len(df.columns) > 1: - datasets[doc_name] = df + datasets[docName] = df except: pass elif any('\t' in line for line in lines[:5]): try: - df = pd.read_csv(io.StringIO(extracted_text), sep='\t') + df = pd.read_csv(io.StringIO(extractedText), sep='\t') if len(df.columns) > 1: - datasets[doc_name] = df + datasets[docName] = df except: pass - return datasets, document_context + return datasets, documentContext - async def _analyze_task(self, prompt: str, context: str, datasets: Dict, output_specs: List) -> Dict: + async def _analyzeTask(self, prompt: str, context: str, datasets: Dict, outputSpecs: List) -> Dict: """ Use AI to analyze the task and create a plan for analysis. @@ -203,106 +203,106 @@ class AgentAnalyst(AgentBase): prompt: The task prompt context: Document context text datasets: Dictionary of extracted datasets - output_specs: Output specifications + outputSpecs: Output specifications Returns: Analysis plan dictionary """ # Prepare dataset information - dataset_info = {} + datasetInfo = {} for name, df in datasets.items(): try: - dataset_info[name] = { + datasetInfo[name] = { "shape": df.shape, "columns": df.columns.tolist(), "dtypes": {col: str(df[col].dtype) for col in df.columns}, "sample": df.head(3).to_dict(orient='records') } except: - dataset_info[name] = {"error": "Could not process dataset"} + datasetInfo[name] = {"error": "Could not process dataset"} - analysis_prompt = f""" + analysisPrompt = f""" Analyze this data analysis task and create a plan. TASK: {prompt} AVAILABLE DATA: - {json.dumps(dataset_info, indent=2)} + {json.dumps(datasetInfo, indent=2)} DOCUMENT CONTEXT: {context[:1000]}... (truncated) OUTPUT REQUIREMENTS: - {json.dumps(output_specs, indent=2)} + {json.dumps(outputSpecs, indent=2)} Create a detailed analysis plan in JSON format with the following structure: {{ - "analysis_type": "statistical|trend|comparative|predictive|cluster|general", - "key_questions": ["question1", "question2"], - "recommended_visualizations": [{{ + "analysisType": "statistical|trend|comparative|predictive|cluster|general", + "keyQuestions": ["question1", "question2"], + "recommendedVisualizations": [{{ "type": "chart_type", - "data_source": "dataset_name", + "dataSource": "dataset_name", "variables": ["col1", "col2"], "purpose": "explanation" }}], - "key_insights": "brief summary of initial insights", - "analysis_approach": "brief description of recommended approach" + "keyInsights": "brief summary of initial insights", + "analysisApproach": "brief description of recommended approach" }} Only return valid JSON. No preamble or explanations. """ try: - response = await self.mydom.call_ai([ + response = await self.mydom.callAi([ {"role": "system", "content": "You are a data analysis expert. Respond with valid JSON only."}, - {"role": "user", "content": analysis_prompt} - ], produce_user_answer = True) + {"role": "user", "content": analysisPrompt} + ], produceUserAnswer = True) # Extract JSON from response - json_start = response.find('{') - json_end = response.rfind('}') + 1 + jsonStart = response.find('{') + jsonEnd = response.rfind('}') + 1 - if json_start >= 0 and json_end > json_start: - plan = json.loads(response[json_start:json_end]) + if jsonStart >= 0 and jsonEnd > jsonStart: + plan = json.loads(response[jsonStart:jsonEnd]) return plan else: # Fallback if JSON not found return { - "analysis_type": "general", - "key_questions": ["What insights can be extracted from this data?"], - "recommended_visualizations": [], - "key_insights": "Analysis plan could not be created", - "analysis_approach": "General exploratory analysis" + "analysisType": "general", + "keyQuestions": ["What insights can be extracted from this data?"], + "recommendedVisualizations": [], + "keyInsights": "Analysis plan could not be created", + "analysisApproach": "General exploratory analysis" } except Exception as e: logger.warning(f"Error creating analysis plan: {str(e)}") return { - "analysis_type": "general", - "key_questions": ["What insights can be extracted from this data?"], - "recommended_visualizations": [], - "key_insights": "Analysis plan could not be created", - "analysis_approach": "General exploratory analysis" + "analysisType": "general", + "keyQuestions": ["What insights can be extracted from this data?"], + "recommendedVisualizations": [], + "keyInsights": "Analysis plan could not be created", + "analysisApproach": "General exploratory analysis" } - async def _create_visualization(self, datasets: Dict, prompt: str, output_label: str, - analysis_plan: Dict, description: str) -> Dict: + async def _createVisualization(self, datasets: Dict, prompt: str, outputLabel: str, + analysisPlan: Dict, description: str) -> Dict: """ Create visualization document using AI guidance. Args: datasets: Dictionary of datasets prompt: Original task prompt - output_label: Output filename - analysis_plan: Analysis plan from AI + outputLabel: Output filename + analysisPlan: Analysis plan from AI description: Output description Returns: Visualization document """ # Determine format from filename - format_type = output_label.split('.')[-1].lower() - if format_type not in ['png', 'jpg', 'jpeg', 'svg']: - format_type = 'png' + formatType = outputLabel.split('.')[-1].lower() + if formatType not in ['png', 'jpg', 'jpeg', 'svg']: + formatType = 'png' # If no datasets available, create error message image if not datasets: @@ -310,58 +310,58 @@ class AgentAnalyst(AgentBase): plt.text(0.5, 0.5, "No data available for visualization", ha='center', va='center', fontsize=14) plt.tight_layout() - img_data = self._get_image_base64(format_type) + imgData = self._getImageBase64(formatType) plt.close() return { - "label": output_label, - "content": img_data, + "label": outputLabel, + "content": imgData, "metadata": { - "content_type": f"image/{format_type}" + "contentType": f"image/{formatType}" } } # Get recommended visualization from plan - recommended_viz = analysis_plan.get("recommended_visualizations", []) + recommendedViz = analysisPlan.get("recommendedVisualizations", []) # Prepare dataset info for the first dataset if none specified - if not recommended_viz and datasets: + if not recommendedViz and datasets: name, df = next(iter(datasets.items())) - recommended_viz = [{ + recommendedViz = [{ "type": "auto", - "data_source": name, + "dataSource": name, "variables": df.columns.tolist()[:5], "purpose": "general analysis" }] # Create visualization code prompt - viz_prompt = f""" + vizPrompt = f""" Generate Python matplotlib/seaborn code to create a visualization for: TASK: {prompt} VISUALIZATION REQUIREMENTS: - - Output format: {format_type} - - Filename: {output_label} + - Output format: {formatType} + - Filename: {outputLabel} - Description: {description} RECOMMENDED VISUALIZATION: - {json.dumps(recommended_viz, indent=2)} + {json.dumps(recommendedViz, indent=2)} AVAILABLE DATASETS: """ # Add dataset info for recommended sources - for viz in recommended_viz: - data_source = viz.get("data_source") - if data_source in datasets: - df = datasets[data_source] - viz_prompt += f"\nDataset '{data_source}':\n" - viz_prompt += f"- Shape: {df.shape}\n" - viz_prompt += f"- Columns: {df.columns.tolist()}\n" - viz_prompt += f"- Sample data: {df.head(3).to_dict(orient='records')}\n" + for viz in recommendedViz: + dataSource = viz.get("dataSource") + if dataSource in datasets: + df = datasets[dataSource] + vizPrompt += f"\nDataset '{dataSource}':\n" + vizPrompt += f"- Shape: {df.shape}\n" + vizPrompt += f"- Columns: {df.columns.tolist()}\n" + vizPrompt += f"- Sample data: {df.head(3).to_dict(orient='records')}\n" - viz_prompt += """ + vizPrompt += """ Generate ONLY Python code that: 1. Uses matplotlib and/or seaborn to create a clear visualization 2. Sets figure size to (10, 6) @@ -374,19 +374,19 @@ class AgentAnalyst(AgentBase): try: # Get visualization code from AI - viz_code = await self.mydom.call_ai([ + vizCode = await self.mydom.callAi([ {"role": "system", "content": "You are a data visualization expert. Provide only executable Python code."}, - {"role": "user", "content": viz_prompt} - ], produce_user_answer = True) + {"role": "user", "content": vizPrompt} + ], produceUserAnswer = True) # Clean code - viz_code = viz_code.replace("```python", "").replace("```", "").strip() + vizCode = vizCode.replace("```python", "").replace("```", "").strip() # Execute visualization code plt.figure(figsize=(10, 6)) # Make local variables available to the code - local_vars = { + localVars = { "plt": plt, "sns": sns, "pd": pd, @@ -396,27 +396,27 @@ class AgentAnalyst(AgentBase): # Add datasets to local variables for name, df in datasets.items(): # Create a sanitized variable name - var_name = ''.join(c if c.isalnum() else '_' for c in name) - local_vars[var_name] = df + varName = ''.join(c if c.isalnum() else '_' for c in name) + localVars[varName] = df # Also add with standard names for simpler code - if "df" not in local_vars: - local_vars["df"] = df - elif "df2" not in local_vars: - local_vars["df2"] = df + if "df" not in localVars: + localVars["df"] = df + elif "df2" not in localVars: + localVars["df2"] = df # Execute the visualization code - exec(viz_code, globals(), local_vars) + exec(vizCode, globals(), localVars) # Capture the image - img_data = self._get_image_base64(format_type) + imgData = self._getImageBase64(formatType) plt.close() return { - "label": output_label, - "content": img_data, + "label": outputLabel, + "content": imgData, "metadata": { - "content_type": f"image/{format_type}" + "contentType": f"image/{formatType}" } } @@ -428,70 +428,70 @@ class AgentAnalyst(AgentBase): plt.text(0.5, 0.5, f"Visualization error: {str(e)}", ha='center', va='center', fontsize=12) plt.tight_layout() - img_data = self._get_image_base64(format_type) + imgData = self._getImageBase64(formatType) plt.close() return { - "label": output_label, - "content": img_data, + "label": outputLabel, + "content": imgData, "metadata": { - "content_type": f"image/{format_type}" + "contentType": f"image/{formatType}" } } - async def _create_data_document(self, datasets: Dict, prompt: str, output_label: str, - analysis_plan: Dict, description: str) -> Dict: + async def _createDataDocument(self, datasets: Dict, prompt: str, outputLabel: str, + analysisPlan: Dict, description: str) -> Dict: """ Create a data document (e.g., CSV, JSON) based on analysis. Args: datasets: Dictionary of datasets prompt: Original task prompt - output_label: Output filename - analysis_plan: Analysis plan from AI + outputLabel: Output filename + analysisPlan: Analysis plan from AI description: Output description Returns: Data document """ # Determine format from filename - format_type = output_label.split('.')[-1].lower() + formatType = outputLabel.split('.')[-1].lower() # If no datasets available, return error message if not datasets: return { - "label": output_label, - "content": f"No data available for processing into {format_type} format.", + "label": outputLabel, + "content": f"No data available for processing into {formatType} format.", "metadata": { - "content_type": "text/plain" + "contentType": "text/plain" } } # Generate data processing instructions - data_prompt = f""" - Create Python code to process datasets and generate a {format_type} file for: + dataPrompt = f""" + Create Python code to process datasets and generate a {formatType} file for: TASK: {prompt} OUTPUT REQUIREMENTS: - - Format: {format_type} - - Filename: {output_label} + - Format: {formatType} + - Filename: {outputLabel} - Description: {description} ANALYSIS CONTEXT: - {json.dumps(analysis_plan, indent=2)} + {json.dumps(analysisPlan, indent=2)} AVAILABLE DATASETS: """ # Add dataset info for name, df in datasets.items(): - data_prompt += f"\nDataset '{name}':\n" - data_prompt += f"- Shape: {df.shape}\n" - data_prompt += f"- Columns: {df.columns.tolist()}\n" - data_prompt += f"- Sample data: {df.head(3).to_dict(orient='records')}\n" + dataPrompt += f"\nDataset '{name}':\n" + dataPrompt += f"- Shape: {df.shape}\n" + dataPrompt += f"- Columns: {df.columns.tolist()}\n" + dataPrompt += f"- Sample data: {df.head(3).to_dict(orient='records')}\n" - data_prompt += """ + dataPrompt += """ Generate Python code that: 1. Processes the available dataset(s) 2. Performs necessary transformations, aggregations, or calculations @@ -503,46 +503,46 @@ class AgentAnalyst(AgentBase): try: # Get data processing code from AI - data_code = await self.mydom.call_ai([ + dataCode = await self.mydom.callAi([ {"role": "system", "content": "You are a data processing expert. Provide only executable Python code."}, - {"role": "user", "content": data_prompt} - ], produce_user_answer = True) + {"role": "user", "content": dataPrompt} + ], produceUserAnswer = True) # Clean code - data_code = data_code.replace("```python", "").replace("```", "").strip() + dataCode = dataCode.replace("```python", "").replace("```", "").strip() # Setup execution environment - local_vars = {"pd": pd, "np": __import__('numpy'), "io": io} + localVars = {"pd": pd, "np": __import__('numpy'), "io": io} # Add datasets to local variables for name, df in datasets.items(): # Create a sanitized variable name - var_name = ''.join(c if c.isalnum() else '_' for c in name) - local_vars[var_name] = df + varName = ''.join(c if c.isalnum() else '_' for c in name) + localVars[varName] = df # Also add with standard names for simpler code - if "df" not in local_vars: - local_vars["df"] = df - elif "df2" not in local_vars: - local_vars["df2"] = df + if "df" not in localVars: + localVars["df"] = df + elif "df2" not in localVars: + localVars["df2"] = df # Execute the code - exec(data_code, globals(), local_vars) + exec(dataCode, globals(), localVars) # Get the result - result = local_vars.get("result", "No output was generated.") + result = localVars.get("result", "No output was generated.") # Determine content type - content_type = "text/csv" if format_type == "csv" else \ - "application/json" if format_type == "json" else \ - "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" if format_type == "xlsx" else \ + contentType = "text/csv" if formatType == "csv" else \ + "application/json" if formatType == "json" else \ + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" if formatType == "xlsx" else \ "text/plain" return { - "label": output_label, + "label": outputLabel, "content": result, "metadata": { - "content_type": content_type + "contentType": contentType } } @@ -550,16 +550,16 @@ class AgentAnalyst(AgentBase): logger.error(f"Error creating data document: {str(e)}", exc_info=True) return { - "label": output_label, - "content": f"Error generating {format_type} document: {str(e)}", + "label": outputLabel, + "content": f"Error generating {formatType} document: {str(e)}", "metadata": { - "content_type": "text/plain" + "contentType": "text/plain" } } - async def _create_text_document(self, datasets: Dict, context: str, prompt: str, - output_label: str, format_type: str, - analysis_plan: Dict, description: str) -> Dict: + async def _createTextDocument(self, datasets: Dict, context: str, prompt: str, + outputLabel: str, formatType: str, + analysisPlan: Dict, description: str) -> Dict: """ Create a text document (report, analysis, etc.) based on analysis. @@ -567,52 +567,52 @@ class AgentAnalyst(AgentBase): datasets: Dictionary of datasets context: Document context text prompt: Original task prompt - output_label: Output filename - format_type: Output format type - analysis_plan: Analysis plan from AI + outputLabel: Output filename + formatType: Output format type + analysisPlan: Analysis plan from AI description: Output description Returns: Text document """ # Create dataset summaries - dataset_summaries = [] + datasetSummaries = [] for name, df in datasets.items(): summary = f"Dataset: {name}\n" summary += f"- Shape: {df.shape[0]} rows, {df.shape[1]} columns\n" summary += f"- Columns: {', '.join(df.columns.tolist())}\n" # Basic statistics for numeric columns - numeric_cols = df.select_dtypes(include=['number']).columns - if len(numeric_cols) > 0: + numericCols = df.select_dtypes(include=['number']).columns + if len(numericCols) > 0: summary += "- Numeric Columns Stats:\n" - for col in numeric_cols[:3]: # Limit to first 3 + for col in numericCols[:3]: # Limit to first 3 stats = df[col].describe() summary += f" - {col}: min={stats['min']:.2f}, max={stats['max']:.2f}, mean={stats['mean']:.2f}\n" - dataset_summaries.append(summary) + datasetSummaries.append(summary) # Determine content type based on format - content_type = "text/markdown" if format_type in ["md", "markdown"] else \ - "text/html" if format_type == "html" else \ + contentType = "text/markdown" if formatType in ["md", "markdown"] else \ + "text/html" if formatType == "html" else \ "text/plain" # Generate analysis prompt - analysis_prompt = f""" - Create a detailed {format_type} document for: + analysisPrompt = f""" + Create a detailed {formatType} document for: TASK: {prompt} OUTPUT REQUIREMENTS: - - Format: {format_type} - - Filename: {output_label} + - Format: {formatType} + - Filename: {outputLabel} - Description: {description} ANALYSIS CONTEXT: - {json.dumps(analysis_plan, indent=2)} + {json.dumps(analysisPlan, indent=2)} DATASET SUMMARIES: - {"".join(dataset_summaries)} + {"".join(datasetSummaries)} DOCUMENT CONTEXT: {context[:2000]}... (truncated) @@ -629,22 +629,22 @@ class AgentAnalyst(AgentBase): try: # Get document content from AI - document_content = await self.mydom.call_ai([ - {"role": "system", "content": f"You are a data analysis expert creating a {format_type} document."}, - {"role": "user", "content": analysis_prompt} - ], produce_user_answer = True) + documentContent = await self.mydom.callAi([ + {"role": "system", "content": f"You are a data analysis expert creating a {formatType} document."}, + {"role": "user", "content": analysisPrompt} + ], produceUserAnswer = True) # Clean HTML or Markdown if needed - if format_type in ["md", "markdown"] and not document_content.strip().startswith("#"): - document_content = f"# Analysis Report\n\n{document_content}" - elif format_type == "html" and not "{document_content}" + if formatType in ["md", "markdown"] and not documentContent.strip().startswith("#"): + documentContent = f"# Analysis Report\n\n{documentContent}" + elif formatType == "html" and not "{documentContent}" return { - "label": output_label, - "content": document_content, + "label": outputLabel, + "content": documentContent, "metadata": { - "content_type": content_type + "contentType": contentType } } @@ -652,43 +652,43 @@ class AgentAnalyst(AgentBase): logger.error(f"Error creating text document: {str(e)}", exc_info=True) # Create a simple error document - if format_type in ["md", "markdown"]: + if formatType in ["md", "markdown"]: content = f"# Error in Analysis\n\nThere was an error generating the analysis: {str(e)}" - elif format_type == "html": + elif formatType == "html": content = f"

Error in Analysis

There was an error generating the analysis: {str(e)}

" else: content = f"Error in Analysis\n\nThere was an error generating the analysis: {str(e)}" return { - "label": output_label, + "label": outputLabel, "content": content, "metadata": { - "content_type": content_type + "contentType": contentType } } - def _get_image_base64(self, format_type: str = 'png') -> str: + def _getImageBase64(self, formatType: str = 'png') -> str: """ Convert current matplotlib figure to base64 string. Args: - format_type: Image format + formatType: Image format Returns: Base64 encoded string of the image """ buffer = io.BytesIO() - plt.savefig(buffer, format=format_type, dpi=100) + plt.savefig(buffer, format=formatType, dpi=100) buffer.seek(0) - image_data = buffer.getvalue() + imageData = buffer.getvalue() buffer.close() # Convert to base64 - image_base64 = base64.b64encode(image_data).decode('utf-8') - return image_base64 + imageBase64 = base64.b64encode(imageData).decode('utf-8') + return imageBase64 # Factory function for the Analyst agent -def get_analyst_agent(): +def getAgentAnalyst(): """Returns an instance of the Analyst agent.""" return AgentAnalyst() \ No newline at end of file diff --git a/modules/chat_agent_coder.py b/modules/agentCoder.py similarity index 61% rename from modules/chat_agent_coder.py rename to modules/agentCoder.py index 8070fc8f..215c37cf 100644 --- a/modules/chat_agent_coder.py +++ b/modules/agentCoder.py @@ -11,7 +11,7 @@ import shutil import sys from typing import Dict, Any, List, Tuple -from modules.chat_registry import AgentBase +from modules.workflowAgentsRegistry import AgentBase from modules.configuration import APP_CONFIG logger = logging.getLogger(__name__) @@ -33,30 +33,30 @@ class AgentCoder(AgentBase): ] # Executor settings - self.executor_timeout = int(APP_CONFIG.get("Agent_Coder_EXECUTION_TIMEOUT")) # seconds - self.execution_retry_limit = int(APP_CONFIG.get("Agent_Coder_EXECUTION_RETRY")) # max retries - self.temp_dir = None + self.executorTimeout = int(APP_CONFIG.get("Agent_Coder_EXECUTION_TIMEOUT")) # seconds + self.executionRetryLimit = int(APP_CONFIG.get("Agent_Coder_EXECUTION_RETRY")) # max retries + self.tempDir = None - def set_dependencies(self, mydom=None): + def setDependencies(self, mydom=None): """Set external dependencies for the agent.""" self.mydom = mydom - async def process_task(self, task: Dict[str, Any]) -> Dict[str, Any]: + async def processTask(self, task: Dict[str, Any]) -> Dict[str, Any]: """ Process a task and perform code development/execution. First checks if the task can be completed without code execution, then falls back to code generation if needed. Args: - task: Task dictionary with prompt, input_documents, output_specifications + task: Task dictionary with prompt, inputDocuments, outputSpecifications Returns: Dictionary with feedback and documents """ # 1. Extract task information prompt = task.get("prompt", "") - input_documents = task.get("input_documents", []) - output_specs = task.get("output_specifications", []) + inputDocuments = task.get("inputDocuments", []) + outputSpecs = task.get("outputSpecifications", []) # Check if AI service is available if not self.mydom: @@ -67,59 +67,59 @@ class AgentCoder(AgentBase): } # 2. Extract data from documents in separate categories - document_data = [] # For raw file data (for code execution) - content_data = [] # For content data (later use) - content_extraction = [] # For AI-extracted data (for quick completion) + documentData = [] # For raw file data (for code execution) + contentData = [] # For content data (later use) + contentExtraction = [] # For AI-extracted data (for quick completion) - for doc in input_documents: + for doc in inputDocuments: # Create proper filename from name and ext filename = f"{doc.get('name')}.{doc.get('ext')}" if doc.get('ext') else doc.get('name') - # Add main document data to document_data if it exists - doc_data = doc.get('data', '') - if doc_data: - is_base64 = True # Assume base64 encoded for document data - document_data.append([filename, doc_data, is_base64]) + # Add main document data to documentData if it exists + docData = doc.get('data', '') + if docData: + isBase64 = True # Assume base64 encoded for document data + documentData.append([filename, docData, isBase64]) # Process contents for different uses if doc.get('contents'): for content in doc.get('contents', []): - content_name = content.get('name', 'unnamed') + contentName = content.get('name', 'unnamed') # For AI-extracted data (quick completion) - if content.get('data_extracted'): - content_extraction.append({ + if content.get('dataExtracted'): + contentExtraction.append({ "filename": filename, - "content_name": content_name, - "content_data": content.get('data_extracted', ''), - "content_type": content.get('content_type', ''), + "contentName": contentName, + "contentData": content.get('dataExtracted', ''), + "contentType": content.get('contentType', ''), "summary": content.get('summary', '') }) # For raw content data if content.get('data'): - raw_data = content.get('data', '') - is_base64 = content.get('metadata', {}).get('base64_encoded', False) - content_data.append({ + rawData = content.get('data', '') + isBase64 = content.get('metadata', {}).get('base64Encoded', False) + contentData.append({ "filename": filename, - "content_name": content_name, - "data": raw_data, - "is_base64": is_base64, - "content_type": content.get('content_type', '') + "contentName": contentName, + "data": rawData, + "isBase64": isBase64, + "contentType": content.get('contentType', '') }) - # Also add to document_data for code execution if not already added - if not doc_data or doc_data != raw_data: - document_data.append([filename, raw_data, is_base64]) + # Also add to documentData for code execution if not already added + if not docData or docData != rawData: + documentData.append([filename, rawData, isBase64]) # 3. Check if task can be completed without code execution - quick_completion = await self._check_quick_completion(prompt, content_extraction, output_specs) + quickCompletion = await self._checkQuickCompletion(prompt, contentExtraction, outputSpecs) - if quick_completion and quick_completion.get("complete") == 1: + if quickCompletion and quickCompletion.get("complete") == 1: logger.info("Task completed without code execution") return { - "feedback": quick_completion.get("prompt", "Task completed successfully."), - "documents": quick_completion.get("documents", []) + "feedback": quickCompletion.get("prompt", "Task completed successfully."), + "documents": quickCompletion.get("documents", []) } else: logger.debug(f"Code to generate, no quick check") @@ -128,7 +128,7 @@ class AgentCoder(AgentBase): logger.info("Generating code to solve the task") # 4. Generate code using AI - code, requirements = await self._generate_code(prompt) + code, requirements = await self._generateCode(prompt) if not code: return { @@ -136,53 +136,53 @@ class AgentCoder(AgentBase): "documents": [] } - # 5. Replace the placeholder with actual input_files data - document_data_json = repr(document_data) - code_with_data = code.replace("input_files = \"=== JSONLOAD ===\"", f"input_files = {document_data_json}") + # 5. Replace the placeholder with actual inputFiles data + documentDataJson = repr(documentData) + codeWithData = code.replace("inputFiles = \"=== JSONLOAD ===\"", f"inputFiles = {documentDataJson}") # 6. Execute code with retry logic - retry_count = 0 - max_retries = self.execution_retry_limit - execution_history = [] + retryCount = 0 + maxRetries = self.executionRetryLimit + executionHistory = [] - while retry_count <= max_retries: - execution_result = self._execute_code(code_with_data, requirements) - execution_history.append({ - "attempt": retry_count + 1, - "code": code_with_data, - "result": execution_result + while retryCount <= maxRetries: + executionResult = self._executeCode(codeWithData, requirements) + executionHistory.append({ + "attempt": retryCount + 1, + "code": codeWithData, + "result": executionResult }) # Check if execution was successful - if execution_result.get("success", False): - logger.info(f"Code execution succeeded on attempt {retry_count + 1}") + if executionResult.get("success", False): + logger.info(f"Code execution succeeded on attempt {retryCount + 1}") break # If we've reached max retries, exit the loop - if retry_count >= max_retries: - logger.info(f"Reached maximum retry limit ({max_retries}). Giving up.") + if retryCount >= maxRetries: + logger.info(f"Reached maximum retry limit ({maxRetries}). Giving up.") break # Log the error and attempt to improve the code - error = execution_result.get("error", "Unknown error") - logger.info(f"Execution attempt {retry_count + 1} failed: {error}. Attempting to improve code.") + error = executionResult.get("error", "Unknown error") + logger.info(f"Execution attempt {retryCount + 1} failed: {error}. Attempting to improve code.") # Generate improved code based on error - improved_code, improved_requirements = await self._improve_code( - original_code=code_with_data, + improvedCode, improvedRequirements = await self._improveCode( + originalCode=codeWithData, error=error, - execution_result=execution_result, - attempt=retry_count + 1 + executionResult=executionResult, + attempt=retryCount + 1 ) - if improved_code: - code_with_data = improved_code - requirements = improved_requirements - logger.info(f"Code improved for retry {retry_count + 2}") + if improvedCode: + codeWithData = improvedCode + requirements = improvedRequirements + logger.info(f"Code improved for retry {retryCount + 2}") else: logger.warning("Failed to improve code, using original code for retry") - retry_count += 1 + retryCount += 1 # 7. Process results and create output documents documents = [] @@ -190,32 +190,32 @@ class AgentCoder(AgentBase): # Always add the final code document documents.append({ "label": "generated_code.py", - "content": code_with_data + "content": codeWithData }) # Add execution history document - execution_history_str = json.dumps(execution_history, indent=2) + executionHistoryStr = json.dumps(executionHistory, indent=2) documents.append({ "label": "execution_history.json", - "content": execution_history_str + "content": executionHistoryStr }) # Create documents based on execution results - if execution_result.get("success", False): - result_data = execution_result.get("result") + if executionResult.get("success", False): + resultData = executionResult.get("result") # Create documents based on output specifications - if output_specs: - for spec in output_specs: + if outputSpecs: + for spec in outputSpecs: label = spec.get("label", "output.txt") # Extract content from result if available content = "" - if isinstance(result_data, dict) and label in result_data: - content = result_data[label] + if isinstance(resultData, dict) and label in resultData: + content = resultData[label] else: # Default to execution output - content = execution_result.get("output", "") + content = executionResult.get("output", "") documents.append({ "label": label, @@ -225,23 +225,23 @@ class AgentCoder(AgentBase): # No output specs, create default output document documents.append({ "label": "execution_output.txt", - "content": execution_result.get("output", "") + "content": executionResult.get("output", "") }) - if retry_count > 0: - feedback = f"Code executed successfully after {retry_count + 1} attempts. Generated output files based on specifications." + if retryCount > 0: + feedback = f"Code executed successfully after {retryCount + 1} attempts. Generated output files based on specifications." else: feedback = "Code executed successfully. Generated output files based on specifications." else: # Execution failed - error = execution_result.get("error", "Unknown error") + error = executionResult.get("error", "Unknown error") documents.append({ "label": "execution_error.txt", "content": f"Error executing code:\n\n{error}" }) - if retry_count > 0: - feedback = f"Error during code execution after {retry_count + 1} attempts: {error}" + if retryCount > 0: + feedback = f"Error during code execution after {retryCount + 1} attempts: {error}" else: feedback = f"Error during code execution: {error}" @@ -250,31 +250,31 @@ class AgentCoder(AgentBase): "documents": documents } - async def _improve_code(self, original_code: str, error: str, execution_result: Dict[str, Any], attempt: int) -> Tuple[str, List[str]]: + async def _improveCode(self, originalCode: str, error: str, executionResult: Dict[str, Any], attempt: int) -> Tuple[str, List[str]]: """ Improve code based on execution error. Args: - original_code: The code that failed to execute + originalCode: The code that failed to execute error: The error message - execution_result: Complete execution result dictionary + executionResult: Complete execution result dictionary attempt: Current attempt number Returns: - Tuple of (improved_code, requirements) + Tuple of (improvedCode, requirements) """ # Create prompt for code improvement - improvement_prompt = f""" + improvementPrompt = f""" Fix the following Python code that failed during execution. This is attempt {attempt} to fix the code. ORIGINAL CODE: -{original_code} +{originalCode} ERROR MESSAGE: {error} STDOUT: -{execution_result.get('output', '')} +{executionResult.get('output', '')} INSTRUCTIONS: 1. Fix all errors identified in the error message @@ -284,13 +284,13 @@ INSTRUCTIONS: - Error handling and edge cases - Resource management (file handles, etc.) - Syntax errors and typos -4. Keep the input_files handling logic intact +4. Keep the inputFiles handling logic intact 5. Maintain the same overall structure and purpose OUTPUT: - Your improved code MUST still define a 'result' variable as a dictionary - Each output file should be a key in the result dictionary -- DO NOT remove the input_files assignment line structure +- DO NOT remove the inputFiles assignment line structure REQUIREMENTS: Required packages should be specified as: @@ -303,66 +303,66 @@ Return ONLY Python code without explanations or markdown. # Call AI service messages = [ {"role": "system", "content": "You are an expert Python code debugger. Provide only fixed Python code without explanations or formatting."}, - {"role": "user", "content": improvement_prompt} + {"role": "user", "content": improvementPrompt} ] try: - improved_content = await self.mydom.call_ai(messages, temperature=0.2) + improvedContent = await self.mydom.callAi(messages, temperature=0.2) # Extract code and requirements - improved_code = self._clean_code(improved_content) + improvedCode = self._cleanCode(improvedContent) # Extract requirements requirements = [] - for line in improved_code.split('\n'): + for line in improvedCode.split('\n'): if line.strip().startswith("# REQUIREMENTS:"): - req_str = line.replace("# REQUIREMENTS:", "").strip() - requirements = [r.strip() for r in req_str.split(',') if r.strip()] + reqStr = line.replace("# REQUIREMENTS:", "").strip() + requirements = [r.strip() for r in reqStr.split(',') if r.strip()] break - return improved_code, requirements + return improvedCode, requirements except Exception as e: logger.error(f"Error improving code: {str(e)}") return None, [] - async def _check_quick_completion(self, prompt: str, content_extraction: List[Dict], output_specs: List[Dict]) -> Dict: + async def _checkQuickCompletion(self, prompt: str, contentExtraction: List[Dict], outputSpecs: List[Dict]) -> Dict: """ Check if the task can be completed without writing and executing code. Args: prompt: The task prompt - content_extraction: List of extracted content data with content_name and data_extracted - output_specs: List of output specifications + contentExtraction: List of extracted content data with contentName and dataExtracted + outputSpecs: List of output specifications Returns: Dictionary with completion status and results, or None if no quick completion """ # If no data or no output specs, can't do a quick completion - if not content_extraction or not output_specs: + if not contentExtraction or not outputSpecs: return None # Create a prompt for the AI to check if this can be completed directly - specs_json = json.dumps(output_specs) - data_json = json.dumps(content_extraction) + specsJson = json.dumps(outputSpecs) + dataJson = json.dumps(contentExtraction) - check_prompt = f""" + checkPrompt = f""" Analyze this task and determine if it can be completed directly without writing code. TASK: {prompt} EXTRACTED DATA AVAILABLE: -{data_json} +{dataJson} Each entry in the extracted data contains: - filename: The source file name -- content_name: The specific content section name -- content_data: The AI-extracted text from the content -- content_type: The type of content (text, csv, etc.) +- contentName: The specific content section name +- contentData: The AI-extracted text from the content +- contentType: The type of content (text, csv, etc.) - summary: A brief summary of the content REQUIRED OUTPUT: -{specs_json} +{specsJson} If the task can be completed directly with the available extracted data, respond with: {{"complete": 1, "prompt": "Brief explanation of the solution", "documents": [ @@ -376,26 +376,26 @@ Only return valid JSON. Your entire response must be parseable as JSON. """ # Call AI service - logger.debug(f"Checking if task can be completed without code execution: {check_prompt}") + logger.debug(f"Checking if task can be completed without code execution: {checkPrompt}") messages = [ {"role": "system", "content": "You are an AI assistant that determines if tasks require code execution. Reply with JSON only."}, - {"role": "user", "content": check_prompt} + {"role": "user", "content": checkPrompt} ] try: # Use a lower temperature for more deterministic response - response = await self.mydom.call_ai(messages, produce_user_answer = True, temperature=0.1) + response = await self.mydom.callAi(messages, produceUserAnswer = True, temperature=0.1) # Parse response as JSON if response: try: # Find JSON in response if there's any text around it - json_start = response.find('{') - json_end = response.rfind('}') + 1 + jsonStart = response.find('{') + jsonEnd = response.rfind('}') + 1 - if json_start >= 0 and json_end > json_start: - json_str = response[json_start:json_end] - result = json.loads(json_str) + if jsonStart >= 0 and jsonEnd > jsonStart: + jsonStr = response[jsonStart:jsonEnd] + result = json.loads(jsonStr) # Check if this is a proper response if "complete" in result: @@ -410,28 +410,27 @@ Only return valid JSON. Your entire response must be parseable as JSON. # Default to requiring code execution return None - async def _generate_code(self, prompt: str) -> Tuple[str, List[str]]: + async def _generateCode(self, prompt: str) -> Tuple[str, List[str]]: """ - Generate Python code from a prompt with the input_files placeholder. + Generate Python code from a prompt with the inputFiles placeholder. Args: prompt: The task prompt - input_files: List of [filename, data, is_base64] items Returns: Tuple of (code, requirements) """ # Create prompt for code generation - ai_prompt = f""" + aiPrompt = f""" Generate Python code to solve the following task: TASK: {prompt} INPUT FILES: -- 'input_files' variable is provided as [[filename, data, is_base64], ...] -- For text files (is_base64=False): use data directly as string -- For binary files (is_base64=True): use base64.b64decode(data) +- 'inputFiles' variable is provided as [[filename, data, isBase64], ...] +- For text files (isBase64=False): use data directly as string +- For binary files (isBase64=True): use base64.b64decode(data) CODE QUALITY: - Use explicit type conversions where needed (int/float/str) @@ -446,7 +445,7 @@ OUTPUT: - For example: result = {{"output.txt": "output text", "results.json": json_string}} Your code must start with: -input_files = "=== JSONLOAD ===" # DO NOT CHANGE THIS LINE +inputFiles = "=== JSONLOAD ===" # DO NOT CHANGE THIS LINE REQUIREMENTS: Required packages should be specified as: @@ -460,25 +459,25 @@ Return ONLY Python code without explanations or markdown. # Call AI service messages = [ {"role": "system", "content": "You are a Python code generator. Provide only valid Python code without explanations or formatting."}, - {"role": "user", "content": ai_prompt} + {"role": "user", "content": aiPrompt} ] - generated_content = await self.mydom.call_ai(messages, temperature=0.1) + generatedContent = await self.mydom.callAi(messages, temperature=0.1) # Extract code and requirements - code = self._clean_code(generated_content) + code = self._cleanCode(generatedContent) # Extract requirements requirements = [] for line in code.split('\n'): if line.strip().startswith("# REQUIREMENTS:"): - req_str = line.replace("# REQUIREMENTS:", "").strip() - requirements = [r.strip() for r in req_str.split(',') if r.strip()] + reqStr = line.replace("# REQUIREMENTS:", "").strip() + requirements = [r.strip() for r in reqStr.split(',') if r.strip()] break return code, requirements - def _execute_code(self, code: str, requirements: List[str] = None) -> Dict[str, Any]: + def _executeCode(self, code: str, requirements: List[str] = None) -> Dict[str, Any]: """ Execute Python code in a virtual environment. Integrated executor functionality. @@ -492,24 +491,24 @@ Return ONLY Python code without explanations or markdown. """ try: # 1. Create temp directory and virtual environment - self.temp_dir = tempfile.mkdtemp(prefix="code_exec_") - venv_path = os.path.join(self.temp_dir, "venv") + self.tempDir = tempfile.mkdtemp(prefix="code_exec_") + venvPath = os.path.join(self.tempDir, "venv") # Create venv - logger.debug(f"Creating virtual environment at {venv_path}") - subprocess.run([sys.executable, "-m", "venv", venv_path], + logger.debug(f"Creating virtual environment at {venvPath}") + subprocess.run([sys.executable, "-m", "venv", venvPath], check=True, capture_output=True) # Get Python executable path - python_exe = os.path.join(venv_path, "Scripts", "python.exe") if os.name == 'nt' else os.path.join(venv_path, "bin", "python") + pythonExe = os.path.join(venvPath, "Scripts", "python.exe") if os.name == 'nt' else os.path.join(venvPath, "bin", "python") # 2. Install requirements if provided if requirements: logger.info(f"Installing requirements: {requirements}") # Create requirements.txt - req_file = os.path.join(self.temp_dir, "requirements.txt") - with open(req_file, "w") as f: + reqFile = os.path.join(self.tempDir, "requirements.txt") + with open(reqFile, "w") as f: f.write("\n".join(requirements)) x="\n".join(requirements) @@ -517,38 +516,38 @@ Return ONLY Python code without explanations or markdown. # Install requirements try: - pip_result = subprocess.run( - [python_exe, "-m", "pip", "install", "-r", req_file], + pipResult = subprocess.run( + [pythonExe, "-m", "pip", "install", "-r", reqFile], capture_output=True, text=True, timeout=int(APP_CONFIG.get("Agent_Coder_INSTALL_TIMEOUT")) ) - if pip_result.returncode != 0: - logger.debug(f"Error installing requirements: {pip_result.stderr}") + if pipResult.returncode != 0: + logger.debug(f"Error installing requirements: {pipResult.stderr}") else: logger.debug(f"Requirements installed successfully") # Log installed packages if in debug mode if logger.isEnabledFor(logging.DEBUG): - pip_list = subprocess.run( - [python_exe, "-m", "pip", "list"], + pipList = subprocess.run( + [pythonExe, "-m", "pip", "list"], capture_output=True, text=True ) - logger.debug(f"Installed packages:\n{pip_list.stdout}") + logger.debug(f"Installed packages:\n{pipList.stdout}") except Exception as e: logger.debug(f"Exception during requirements installation: {str(e)}") # 3. Write code to file - code_file = os.path.join(self.temp_dir, "code.py") - with open(code_file, "w", encoding="utf-8") as f: + codeFile = os.path.join(self.tempDir, "code.py") + with open(codeFile, "w", encoding="utf-8") as f: f.write(code) # 4. Execute code - logger.debug(f"Executing code with timeout of {self.executor_timeout} seconds. Code: {code}") + logger.debug(f"Executing code with timeout of {self.executorTimeout} seconds. Code: {code}") process = subprocess.run( - [python_exe, code_file], - timeout=self.executor_timeout, + [pythonExe, codeFile], + timeout=self.executorTimeout, capture_output=True, text=True ) @@ -558,7 +557,7 @@ Return ONLY Python code without explanations or markdown. stderr = process.stderr # Try to extract result from stdout - result_data = None + resultData = None if process.returncode == 0: try: # Find the last line that might be JSON @@ -566,8 +565,8 @@ Return ONLY Python code without explanations or markdown. line = line.strip() if line and line[0] in '{[' and line[-1] in '}]': try: - result_data = json.loads(line) - logger.debug(f"Extracted result data from stdout: {type(result_data)}") + resultData = json.loads(line) + logger.debug(f"Extracted result data from stdout: {type(resultData)}") break except json.JSONDecodeError: continue @@ -579,18 +578,18 @@ Return ONLY Python code without explanations or markdown. "success": process.returncode == 0, "output": stdout, "error": stderr if process.returncode != 0 else "", - "result": result_data, - "exit_code": process.returncode + "result": resultData, + "exitCode": process.returncode } except subprocess.TimeoutExpired: - logger.error(f"Execution timed out after {self.executor_timeout} seconds") + logger.error(f"Execution timed out after {self.executorTimeout} seconds") return { "success": False, "output": "", - "error": f"Execution timed out after {self.executor_timeout} seconds", + "error": f"Execution timed out after {self.executorTimeout} seconds", "result": None, - "exit_code": -1 + "exitCode": -1 } except Exception as e: logger.error(f"Execution error: {str(e)}") @@ -599,44 +598,44 @@ Return ONLY Python code without explanations or markdown. "output": "", "error": f"Execution error: {str(e)}", "result": None, - "exit_code": -1 + "exitCode": -1 } finally: # Clean up resources - self._cleanup_execution() + self._cleanupExecution() - def _cleanup_execution(self): + def _cleanupExecution(self): """Clean up temporary resources from code execution.""" - if self.temp_dir and os.path.exists(self.temp_dir): + if self.tempDir and os.path.exists(self.tempDir): try: - logger.debug(f"Cleaning up temporary directory: {self.temp_dir}") - shutil.rmtree(self.temp_dir) - self.temp_dir = None + logger.debug(f"Cleaning up temporary directory: {self.tempDir}") + shutil.rmtree(self.tempDir) + self.tempDir = None except Exception as e: logger.warning(f"Error cleaning up temp directory: {str(e)}") - def _clean_code(self, code: str) -> str: + def _cleanCode(self, code: str) -> str: """Remove any markdown formatting or explanations.""" # Remove code block markers code = code.replace("```python", "").replace("```", "") # Remove explanations before or after code lines = code.strip().split('\n') - start_index = 0 - end_index = len(lines) + startIndex = 0 + endIndex = len(lines) # Find start of actual code for i, line in enumerate(lines): - if line.strip().startswith("input_files =") or line.strip().startswith("# REQUIREMENTS:"): - start_index = i + if line.strip().startswith("inputFiles =") or line.strip().startswith("# REQUIREMENTS:"): + startIndex = i break # Clean code - cleaned_code = '\n'.join(lines[start_index:end_index]) - return cleaned_code.strip() + cleanedCode = '\n'.join(lines[startIndex:endIndex]) + return cleanedCode.strip() # Factory function for the Coder agent -def get_coder_agent(): +def getAgentCoder(): """Returns an instance of the Coder agent.""" return AgentCoder() \ No newline at end of file diff --git a/modules/chat_agent_documentation.py b/modules/agentDocumentation.py similarity index 53% rename from modules/chat_agent_documentation.py rename to modules/agentDocumentation.py index 3ae98b58..831b8ddd 100644 --- a/modules/chat_agent_documentation.py +++ b/modules/agentDocumentation.py @@ -7,7 +7,7 @@ import logging import json from typing import Dict, Any, List -from modules.chat_registry import AgentBase +from modules.workflowAgentsRegistry import AgentBase logger = logging.getLogger(__name__) @@ -27,16 +27,16 @@ class AgentDocumentation(AgentBase): "knowledge_organization" ] - def set_dependencies(self, mydom=None): + def setDependencies(self, mydom=None): """Set external dependencies for the agent.""" self.mydom = mydom - async def process_task(self, task: Dict[str, Any]) -> Dict[str, Any]: + async def processTask(self, task: Dict[str, Any]) -> Dict[str, Any]: """ Process a task by focusing on required outputs and using AI to generate them. Args: - task: Task dictionary with prompt, input_documents, output_specifications + task: Task dictionary with prompt, inputDocuments, outputSpecifications Returns: Dictionary with feedback and documents @@ -44,8 +44,8 @@ class AgentDocumentation(AgentBase): try: # Extract task information prompt = task.get("prompt", "") - input_documents = task.get("input_documents", []) - output_specs = task.get("output_specifications", []) + inputDocuments = task.get("inputDocuments", []) + outputSpecs = task.get("outputSpecifications", []) # Check AI service if not self.mydom: @@ -54,43 +54,43 @@ class AgentDocumentation(AgentBase): "documents": [] } - # Extract context from input documents - focusing only on data_extracted - document_context = self._extract_document_context(input_documents) + # Extract context from input documents - focusing only on dataExtracted + documentContext = self._extractDocumentContext(inputDocuments) # Create task analysis to understand the requirements - documentation_plan = await self._analyze_task(prompt, document_context, output_specs) + documentationPlan = await self._analyzeTask(prompt, documentContext, outputSpecs) # Generate all required output documents documents = [] # If no output specs provided, create default document - if not output_specs: - default_format = documentation_plan.get("recommended_format", "markdown") - default_title = documentation_plan.get("title", "Documentation") - safe_title = self._sanitize_filename(default_title) + if not outputSpecs: + defaultFormat = documentationPlan.get("recommendedFormat", "markdown") + defaultTitle = documentationPlan.get("title", "Documentation") + safeTitle = self._sanitizeFilename(defaultTitle) - output_specs = [ - {"label": f"{safe_title}.{default_format}", "description": "Comprehensive documentation"} + outputSpecs = [ + {"label": f"{safeTitle}.{defaultFormat}", "description": "Comprehensive documentation"} ] # Process each output specification - for spec in output_specs: - output_label = spec.get("label", "") - output_description = spec.get("description", "") + for spec in outputSpecs: + outputLabel = spec.get("label", "") + outputDescription = spec.get("description", "") # Generate the document using multi-step approach - document = await self._create_document_multi_step( + document = await self._createDocumentMultiStep( prompt, - document_context, - output_label, - output_description, - documentation_plan + documentContext, + outputLabel, + outputDescription, + documentationPlan ) documents.append(document) # Generate feedback - feedback = documentation_plan.get("feedback", f"Created {len(documents)} documents based on your requirements.") + feedback = documentationPlan.get("feedback", f"Created {len(documents)} documents based on your requirements.") return { "feedback": feedback, @@ -104,9 +104,9 @@ class AgentDocumentation(AgentBase): "documents": [] } - def _extract_document_context(self, documents: List[Dict[str, Any]]) -> str: + def _extractDocumentContext(self, documents: List[Dict[str, Any]]) -> str: """ - Extract context from input documents, focusing on data_extracted. + Extract context from input documents, focusing on dataExtracted. Args: documents: List of document objects @@ -114,23 +114,23 @@ class AgentDocumentation(AgentBase): Returns: Extracted context as text """ - context_parts = [] + contextParts = [] for doc in documents: - doc_name = doc.get("name", "unnamed") + docName = doc.get("name", "unnamed") if doc.get("ext"): - doc_name = f"{doc_name}.{doc.get('ext')}" + docName = f"{docName}.{doc.get('ext')}" - context_parts.append(f"\n\n--- {doc_name} ---\n") + contextParts.append(f"\n\n--- {docName} ---\n") - # Process contents for data_extracted + # Process contents for dataExtracted for content in doc.get("contents", []): - if content.get("data_extracted"): - context_parts.append(content.get("data_extracted", "")) + if content.get("dataExtracted"): + contextParts.append(content.get("dataExtracted", "")) - return "\n".join(context_parts) + return "\n".join(contextParts) - def _sanitize_filename(self, filename: str) -> str: + def _sanitizeFilename(self, filename: str) -> str: """ Sanitize a filename by removing invalid characters. @@ -141,8 +141,8 @@ class AgentDocumentation(AgentBase): Sanitized filename """ # Replace invalid characters with underscores - invalid_chars = r'<>:"/\|?*' - for char in invalid_chars: + invalidChars = r'<>:"/\|?*' + for char in invalidChars: filename = filename.replace(char, '_') # Trim filename if too long @@ -151,19 +151,19 @@ class AgentDocumentation(AgentBase): return filename - async def _analyze_task(self, prompt: str, context: str, output_specs: List) -> Dict: + async def _analyzeTask(self, prompt: str, context: str, outputSpecs: List) -> Dict: """ Use AI to analyze the task and create a documentation plan. Args: prompt: The task prompt context: Document context - output_specs: Output specifications + outputSpecs: Output specifications Returns: Documentation plan dictionary """ - analysis_prompt = f""" + analysisPrompt = f""" Analyze this documentation task and create a detailed plan. TASK: {prompt} @@ -172,28 +172,28 @@ class AgentDocumentation(AgentBase): {context[:1000]}... (truncated) OUTPUT REQUIREMENTS: - {json.dumps(output_specs, indent=2)} + {json.dumps(outputSpecs, indent=2)} Create a detailed documentation plan in JSON format with the following structure: {{ "title": "Document Title", - "document_type": "report|manual|guide|whitepaper|etc", + "documentType": "report|manual|guide|whitepaper|etc", "audience": "technical|general|executive|etc", - "detailed_structure": [ + "detailedStructure": [ {{ "title": "Chapter/Section Title", - "key_points": ["point1", "point2", ...], + "keyPoints": ["point1", "point2", ...], "subsections": ["subsection1", "subsection2", ...], "importance": "high|medium|low", - "estimated_length": "short|medium|long" + "estimatedLength": "short|medium|long" }}, ... more sections ... ], - "key_topics": ["topic1", "topic2", ...], + "keyTopics": ["topic1", "topic2", ...], "tone": "formal|conversational|instructional|etc", - "recommended_format": "markdown|html|text|etc", - "formatting_requirements": ["requirement1", "requirement2", ...], - "executive_summary": "Brief description of what the document will cover", + "recommendedFormat": "markdown|html|text|etc", + "formattingRequirements": ["requirement1", "requirement2", ...], + "executiveSummary": "Brief description of what the document will cover", "feedback": "Brief message explaining the documentation approach" }} @@ -201,52 +201,52 @@ class AgentDocumentation(AgentBase): """ try: - response = await self.mydom.call_ai([ + response = await self.mydom.callAi([ {"role": "system", "content": "You are a documentation expert. Respond with valid JSON only."}, - {"role": "user", "content": analysis_prompt} + {"role": "user", "content": analysisPrompt} ]) # Extract JSON from response - json_start = response.find('{') - json_end = response.rfind('}') + 1 + jsonStart = response.find('{') + jsonEnd = response.rfind('}') + 1 - if json_start >= 0 and json_end > json_start: - plan = json.loads(response[json_start:json_end]) + if jsonStart >= 0 and jsonEnd > jsonStart: + plan = json.loads(response[jsonStart:jsonEnd]) return plan else: # Fallback if JSON not found return { "title": "Documentation", - "document_type": "report", + "documentType": "report", "audience": "general", - "detailed_structure": [ + "detailedStructure": [ { "title": "Introduction", - "key_points": ["Purpose", "Scope"], + "keyPoints": ["Purpose", "Scope"], "subsections": [], "importance": "high", - "estimated_length": "short" + "estimatedLength": "short" }, { "title": "Main Content", - "key_points": ["Core Information"], + "keyPoints": ["Core Information"], "subsections": ["Key Findings", "Analysis"], "importance": "high", - "estimated_length": "long" + "estimatedLength": "long" }, { "title": "Conclusion", - "key_points": ["Summary", "Next Steps"], + "keyPoints": ["Summary", "Next Steps"], "subsections": [], "importance": "medium", - "estimated_length": "short" + "estimatedLength": "short" } ], - "key_topics": ["General Information"], + "keyTopics": ["General Information"], "tone": "formal", - "recommended_format": "markdown", - "formatting_requirements": ["Clear headings", "Professional formatting"], - "executive_summary": "A comprehensive documentation covering the requested topics.", + "recommendedFormat": "markdown", + "formattingRequirements": ["Clear headings", "Professional formatting"], + "executiveSummary": "A comprehensive documentation covering the requested topics.", "feedback": "Created documentation based on your requirements." } @@ -254,59 +254,59 @@ class AgentDocumentation(AgentBase): logger.warning(f"Error creating documentation plan: {str(e)}") return { "title": "Documentation", - "document_type": "report", + "documentType": "report", "audience": "general", - "detailed_structure": [ + "detailedStructure": [ { "title": "Introduction", - "key_points": ["Purpose", "Scope"], + "keyPoints": ["Purpose", "Scope"], "subsections": [], "importance": "high", - "estimated_length": "short" + "estimatedLength": "short" }, { "title": "Main Content", - "key_points": ["Core Information"], + "keyPoints": ["Core Information"], "subsections": ["Key Findings", "Analysis"], "importance": "high", - "estimated_length": "long" + "estimatedLength": "long" }, { "title": "Conclusion", - "key_points": ["Summary", "Next Steps"], + "keyPoints": ["Summary", "Next Steps"], "subsections": [], "importance": "medium", - "estimated_length": "short" + "estimatedLength": "short" } ], - "key_topics": ["General Information"], + "keyTopics": ["General Information"], "tone": "formal", - "recommended_format": "markdown", - "formatting_requirements": ["Clear headings", "Professional formatting"], - "executive_summary": "A comprehensive documentation covering the requested topics.", + "recommendedFormat": "markdown", + "formattingRequirements": ["Clear headings", "Professional formatting"], + "executiveSummary": "A comprehensive documentation covering the requested topics.", "feedback": "Created documentation based on your requirements." } - async def _create_document_multi_step(self, prompt: str, context: str, output_label: str, - output_description: str, documentation_plan: Dict) -> Dict: + async def _createDocumentMultiStep(self, prompt: str, context: str, outputLabel: str, + outputDescription: str, documentationPlan: Dict) -> Dict: """ Create a document using a multi-step approach with separate AI calls for each section. Args: prompt: Original task prompt context: Document context - output_label: Output filename - output_description: Description of desired output - documentation_plan: Documentation plan from AI + outputLabel: Output filename + outputDescription: Description of desired output + documentationPlan: Documentation plan from AI Returns: Document object """ # Determine format from filename - format_type = output_label.split('.')[-1].lower() if '.' in output_label else "md" + formatType = outputLabel.split('.')[-1].lower() if '.' in outputLabel else "md" - # Map format to content_type - content_type_map = { + # Map format to contentType + contentTypeMap = { "md": "text/markdown", "markdown": "text/markdown", "html": "text/html", @@ -316,49 +316,49 @@ class AgentDocumentation(AgentBase): "csv": "text/csv" } - content_type = content_type_map.get(format_type, "text/plain") + contentType = contentTypeMap.get(formatType, "text/plain") # Get document information - title = documentation_plan.get("title", "Documentation") - document_type = documentation_plan.get("document_type", "document") - audience = documentation_plan.get("audience", "general") - tone = documentation_plan.get("tone", "formal") - key_topics = documentation_plan.get("key_topics", []) - formatting_requirements = documentation_plan.get("formatting_requirements", []) + title = documentationPlan.get("title", "Documentation") + documentType = documentationPlan.get("documentType", "document") + audience = documentationPlan.get("audience", "general") + tone = documentationPlan.get("tone", "formal") + keyTopics = documentationPlan.get("keyTopics", []) + formattingRequirements = documentationPlan.get("formattingRequirements", []) # Get the detailed structure - detailed_structure = documentation_plan.get("detailed_structure", []) - if not detailed_structure: + detailedStructure = documentationPlan.get("detailedStructure", []) + if not detailedStructure: # Fallback structure if none provided - detailed_structure = [ + detailedStructure = [ { "title": "Introduction", - "key_points": ["Purpose", "Scope"], + "keyPoints": ["Purpose", "Scope"], "importance": "high" }, { "title": "Main Content", - "key_points": ["Core Information"], + "keyPoints": ["Core Information"], "importance": "high" }, { "title": "Conclusion", - "key_points": ["Summary", "Next Steps"], + "keyPoints": ["Summary", "Next Steps"], "importance": "medium" } ] try: # Step 1: Generate document introduction - intro_prompt = f""" - Create the introduction for a {document_type} titled "{title}". + introPrompt = f""" + Create the introduction for a {documentType} titled "{title}". DOCUMENT OVERVIEW: - - Type: {document_type} + - Type: {documentType} - Audience: {audience} - Tone: {tone} - - Key Topics: {', '.join(key_topics)} - - Format: {format_type} + - Key Topics: {', '.join(keyTopics)} + - Format: {formatType} TASK CONTEXT: {prompt} @@ -368,23 +368,23 @@ class AgentDocumentation(AgentBase): 3. Outline what the reader will find in the document 4. Set the appropriate tone for the {audience} audience - The introduction should be professional and engaging, formatted according to {format_type} standards. + The introduction should be professional and engaging, formatted according to {formatType} standards. """ - introduction = await self.mydom.call_ai([ - {"role": "system", "content": f"You are a documentation expert creating an introduction in {format_type} format."}, - {"role": "user", "content": intro_prompt} - ], produce_user_answer = True) + introduction = await self.mydom.callAi([ + {"role": "system", "content": f"You are a documentation expert creating an introduction in {formatType} format."}, + {"role": "user", "content": introPrompt} + ], produceUserAnswer = True) # Step 2: Generate executive summary (if applicable) - if document_type in ["report", "whitepaper", "case study"]: - summary_prompt = f""" - Create an executive summary for a {document_type} titled "{title}". + if documentType in ["report", "whitepaper", "case study"]: + summaryPrompt = f""" + Create an executive summary for a {documentType} titled "{title}". DOCUMENT OVERVIEW: - - Type: {document_type} + - Type: {documentType} - Audience: {audience} - - Key Topics: {', '.join(key_topics)} + - Key Topics: {', '.join(keyTopics)} TASK CONTEXT: {prompt} @@ -392,44 +392,44 @@ class AgentDocumentation(AgentBase): 1. Provide a concise overview of the entire document 2. Highlight key findings, recommendations, or conclusions 3. Be suitable for executives or busy readers who may only read this section - 4. Be professionally formatted according to {format_type} standards + 4. Be professionally formatted according to {formatType} standards Keep the summary focused and impactful, approximately 200-300 words. """ - executive_summary = await self.mydom.call_ai([ - {"role": "system", "content": f"You are a documentation expert creating an executive summary in {format_type} format."}, - {"role": "user", "content": summary_prompt} - ], produce_user_answer = True) + executiveSummary = await self.mydom.callAi([ + {"role": "system", "content": f"You are a documentation expert creating an executive summary in {formatType} format."}, + {"role": "user", "content": summaryPrompt} + ], produceUserAnswer = True) else: - executive_summary = "" + executiveSummary = "" # Step 3: Generate each section sections = [] - for section in detailed_structure: - section_title = section.get("title", "Section") - key_points = section.get("key_points", []) + for section in detailedStructure: + sectionTitle = section.get("title", "Section") + keyPoints = section.get("keyPoints", []) subsections = section.get("subsections", []) importance = section.get("importance", "medium") # Adjust depth based on importance - detail_level = "high" if importance == "high" else "medium" + detailLevel = "high" if importance == "high" else "medium" - section_prompt = f""" - Create the "{section_title}" section for a {document_type} titled "{title}". + sectionPrompt = f""" + Create the "{sectionTitle}" section for a {documentType} titled "{title}". SECTION DETAILS: - - Title: {section_title} - - Key Points to Cover: {', '.join(key_points)} + - Title: {sectionTitle} + - Key Points to Cover: {', '.join(keyPoints)} - Subsections: {', '.join(subsections)} - - Detail Level: {detail_level} + - Detail Level: {detailLevel} DOCUMENT CONTEXT: - - Type: {document_type} + - Type: {documentType} - Audience: {audience} - Tone: {tone} - - Format: {format_type} + - Format: {formatType} TASK CONTEXT: {prompt} @@ -441,27 +441,27 @@ class AgentDocumentation(AgentBase): 2. Cover all the key points listed 3. Include the specified subsections with appropriate headings 4. Maintain a {tone} tone suitable for the {audience} audience - 5. Be properly formatted according to {format_type} standards + 5. Be properly formatted according to {formatType} standards 6. Include specific examples, data, or evidence where appropriate Be thorough in your coverage of this section, providing substantive content. """ - section_content = await self.mydom.call_ai([ - {"role": "system", "content": f"You are a documentation expert creating detailed content for the {section_title} section."}, - {"role": "user", "content": section_prompt} - ], produce_user_answer = True) + sectionContent = await self.mydom.callAi([ + {"role": "system", "content": f"You are a documentation expert creating detailed content for the {sectionTitle} section."}, + {"role": "user", "content": sectionPrompt} + ], produceUserAnswer = True) - sections.append(section_content) + sections.append(sectionContent) # Step 4: Generate conclusion - conclusion_prompt = f""" - Create the conclusion for a {document_type} titled "{title}". + conclusionPrompt = f""" + Create the conclusion for a {documentType} titled "{title}". DOCUMENT OVERVIEW: - - Type: {document_type} + - Type: {documentType} - Audience: {audience} - - Key Topics: {', '.join(key_topics)} + - Key Topics: {', '.join(keyTopics)} TASK CONTEXT: {prompt} @@ -471,71 +471,71 @@ class AgentDocumentation(AgentBase): 3. Include any relevant recommendations or next steps 4. Leave the reader with a clear understanding of the document's significance - The conclusion should be professional and impactful, formatted according to {format_type} standards. + The conclusion should be professional and impactful, formatted according to {formatType} standards. """ - conclusion = await self.mydom.call_ai([ - {"role": "system", "content": f"You are a documentation expert creating a conclusion in {format_type} format."}, - {"role": "user", "content": conclusion_prompt} - ], produce_user_answer = True) + conclusion = await self.mydom.callAi([ + {"role": "system", "content": f"You are a documentation expert creating a conclusion in {formatType} format."}, + {"role": "user", "content": conclusionPrompt} + ], produceUserAnswer = True) # Step 5: Assemble the complete document - if format_type in ["md", "markdown"]: + if formatType in ["md", "markdown"]: # Markdown format - document_content = f"# {title}\n\n" + documentContent = f"# {title}\n\n" - if executive_summary: - document_content += f"## Executive Summary\n\n{executive_summary}\n\n" + if executiveSummary: + documentContent += f"## Executive Summary\n\n{executiveSummary}\n\n" - document_content += f"{introduction}\n\n" + documentContent += f"{introduction}\n\n" - for i, section_content in enumerate(sections): + for i, sectionContent in enumerate(sections): # Ensure section starts with heading if not already - section_title = detailed_structure[i].get("title", f"Section {i+1}") - if not section_content.strip().startswith("#"): - document_content += f"## {section_title}\n\n" - document_content += f"{section_content}\n\n" + sectionTitle = detailedStructure[i].get("title", f"Section {i+1}") + if not sectionContent.strip().startswith("#"): + documentContent += f"## {sectionTitle}\n\n" + documentContent += f"{sectionContent}\n\n" - document_content += f"## Conclusion\n\n{conclusion}\n" + documentContent += f"## Conclusion\n\n{conclusion}\n" - elif format_type == "html": + elif formatType == "html": # HTML format - document_content = f"\n\n{title}\n\n\n" - document_content += f"

{title}

\n\n" + documentContent = f"\n\n{title}\n\n\n" + documentContent += f"

{title}

\n\n" - if executive_summary: - document_content += f"

Executive Summary

\n
{executive_summary}
\n\n" + if executiveSummary: + documentContent += f"

Executive Summary

\n
{executiveSummary}
\n\n" - document_content += f"
{introduction}
\n\n" + documentContent += f"
{introduction}
\n\n" - for i, section_content in enumerate(sections): - section_title = detailed_structure[i].get("title", f"Section {i+1}") - document_content += f"

{section_title}

\n
{section_content}
\n\n" + for i, sectionContent in enumerate(sections): + sectionTitle = detailedStructure[i].get("title", f"Section {i+1}") + documentContent += f"

{sectionTitle}

\n
{sectionContent}
\n\n" - document_content += f"

Conclusion

\n
{conclusion}
\n" - document_content += "\n" + documentContent += f"

Conclusion

\n
{conclusion}
\n" + documentContent += "\n" else: # Plain text format - document_content = f"{title}\n{'=' * len(title)}\n\n" + documentContent = f"{title}\n{'=' * len(title)}\n\n" - if executive_summary: - document_content += f"EXECUTIVE SUMMARY\n{'-' * 17}\n\n{executive_summary}\n\n" + if executiveSummary: + documentContent += f"EXECUTIVE SUMMARY\n{'-' * 17}\n\n{executiveSummary}\n\n" - document_content += f"{introduction}\n\n" + documentContent += f"{introduction}\n\n" - for i, section_content in enumerate(sections): - section_title = detailed_structure[i].get("title", f"Section {i+1}") - document_content += f"{section_title}\n{'-' * len(section_title)}\n\n{section_content}\n\n" + for i, sectionContent in enumerate(sections): + sectionTitle = detailedStructure[i].get("title", f"Section {i+1}") + documentContent += f"{sectionTitle}\n{'-' * len(sectionTitle)}\n\n{sectionContent}\n\n" - document_content += f"CONCLUSION\n{'-' * 10}\n\n{conclusion}\n" + documentContent += f"CONCLUSION\n{'-' * 10}\n\n{conclusion}\n" # Create document object return { - "label": output_label, - "content": document_content, + "label": outputLabel, + "content": documentContent, "metadata": { - "content_type": content_type + "contentType": contentType } } @@ -543,23 +543,23 @@ class AgentDocumentation(AgentBase): logger.error(f"Error creating document: {str(e)}", exc_info=True) # Create a simple error document - if format_type in ["md", "markdown"]: + if formatType in ["md", "markdown"]: content = f"# Error in Documentation\n\nThere was an error generating the documentation: {str(e)}" - elif format_type == "html": + elif formatType == "html": content = f"

Error in Documentation

There was an error generating the documentation: {str(e)}

" else: content = f"Error in Documentation\n\nThere was an error generating the documentation: {str(e)}" return { - "label": output_label, + "label": outputLabel, "content": content, "metadata": { - "content_type": content_type + "contentType": contentType } } # Factory function for the Documentation agent -def get_documentation_agent(): +def getAgentDocumentation(): """Returns an instance of the Documentation agent.""" return AgentDocumentation() \ No newline at end of file diff --git a/modules/chat_agent_webcrawler.py b/modules/agentWebcrawler.py similarity index 56% rename from modules/chat_agent_webcrawler.py rename to modules/agentWebcrawler.py index f78857cc..05cbe0b5 100644 --- a/modules/chat_agent_webcrawler.py +++ b/modules/agentWebcrawler.py @@ -14,7 +14,7 @@ from bs4 import BeautifulSoup import requests import markdown -from modules.chat_registry import AgentBase +from modules.workflowAgentsRegistry import AgentBase from modules.configuration import APP_CONFIG logger = logging.getLogger(__name__) @@ -28,31 +28,31 @@ class AgentWebcrawler(AgentBase): self.name = "webcrawler" self.description = "Conducts web research and collects information from online sources" self.capabilities = [ - "web_search", - "information_retrieval", - "data_collection", - "search_results_analysis", - "webpage_content_extraction" + "webSearch", + "informationRetrieval", + "dataCollection", + "searchResultsAnalysis", + "webpageContentExtraction" ] # Web crawling configuration - self.max_url = int(APP_CONFIG.get("Agent_Webcrawler_MAX_URLS", "5")) - self.max_search_terms = int(APP_CONFIG.get("Agent_Webcrawler_MAX_SEARCH_KEYWORDS", "3")) - self.max_results = int(APP_CONFIG.get("Agent_Webcrawler_MAX_SEARCH_RESULTS", "5")) + self.maxUrl = int(APP_CONFIG.get("Agent_Webcrawler_MAX_URLS", "5")) + self.maxSearchTerms = int(APP_CONFIG.get("Agent_Webcrawler_MAX_SEARCH_KEYWORDS", "3")) + self.maxResults = int(APP_CONFIG.get("Agent_Webcrawler_MAX_SEARCH_RESULTS", "5")) self.timeout = int(APP_CONFIG.get("Agent_Webcrawler_TIMEOUT", "30")) - self.search_engine = APP_CONFIG.get("Agent_Webcrawler_SEARCH_ENGINE", "https://html.duckduckgo.com/html/?q=") - self.user_agent = APP_CONFIG.get("Agent_Webcrawler_USER_AGENT", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36") + self.searchEngine = APP_CONFIG.get("Agent_Webcrawler_SEARCH_ENGINE", "https://html.duckduckgo.com/html/?q=") + self.userAgent = APP_CONFIG.get("Agent_Webcrawler_USER_AGENT", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36") - def set_dependencies(self, mydom=None): + def setDependencies(self, mydom=None): """Set external dependencies for the agent.""" self.mydom = mydom - async def process_task(self, task: Dict[str, Any]) -> Dict[str, Any]: + async def processTask(self, task: Dict[str, Any]) -> Dict[str, Any]: """ Process a task by focusing on required outputs and using AI to guide the research process. Args: - task: Task dictionary with prompt, input_documents, output_specifications + task: Task dictionary with prompt, inputDocuments, outputSpecifications Returns: Dictionary with feedback and documents @@ -60,7 +60,7 @@ class AgentWebcrawler(AgentBase): try: # Extract task information prompt = task.get("prompt", "") - output_specs = task.get("output_specifications", []) + outputSpecs = task.get("outputSpecifications", []) # Check AI service if not self.mydom: @@ -70,28 +70,28 @@ class AgentWebcrawler(AgentBase): } # Create research plan - research_plan = await self._create_research_plan(prompt) + researchPlan = await self._createResearchPlan(prompt) # Check if this is truly a web research task - if not research_plan.get("requires_web_research", True): + if not researchPlan.get("requiresWebResearch", True): return { "feedback": "This task doesn't appear to require web research. Please try a different agent.", "documents": [] } # Gather raw material through web research - raw_results = await self._gather_research_material(research_plan) + rawResults = await self._gatherResearchMaterial(researchPlan) # Format results into requested output documents - documents = await self._create_output_documents( + documents = await self._createOutputDocuments( prompt, - raw_results, - output_specs, - research_plan + rawResults, + outputSpecs, + researchPlan ) # Generate feedback - feedback = research_plan.get("feedback", f"I conducted web research on '{prompt[:50]}...' and gathered information from {len(raw_results)} relevant sources.") + feedback = researchPlan.get("feedback", f"I conducted web research on '{prompt[:50]}...' and gathered information from {len(rawResults)} relevant sources.") return { "feedback": feedback, @@ -105,7 +105,7 @@ class AgentWebcrawler(AgentBase): "documents": [] } - async def _create_research_plan(self, prompt: str) -> Dict[str, Any]: + async def _createResearchPlan(self, prompt: str) -> Dict[str, Any]: """ Use AI to create a detailed research plan. @@ -115,17 +115,17 @@ class AgentWebcrawler(AgentBase): Returns: Research plan dictionary """ - research_prompt = f""" + researchPrompt = f""" Create a detailed web research plan for this task: "{prompt}" Analyze the request carefully and create a structured plan in JSON format with the following elements: {{ - "requires_web_research": true/false, # Whether this genuinely requires web research - "research_questions": ["question1", "question2", ...], # 2-4 specific questions to answer - "search_terms": ["term1", "term2", ...], # Up to {self.max_search_terms} effective search terms - "direct_urls": ["url1", "url2", ...], # Any URLs directly mentioned in the request (up to {self.max_url}) - "expected_sources": ["type1", "type2", ...], # Types of sources that would be most valuable - "content_focus": "what specific content to extract or focus on", + "requiresWebResearch": true/false, # Whether this genuinely requires web research + "researchQuestions": ["question1", "question2", ...], # 2-4 specific questions to answer + "searchTerms": ["term1", "term2", ...], # Up to {self.maxSearchTerms} effective search terms + "directUrls": ["url1", "url2", ...], # Any URLs directly mentioned in the request (up to {self.maxUrl}) + "expectedSources": ["type1", "type2", ...], # Types of sources that would be most valuable + "contentFocus": "what specific content to extract or focus on", "feedback": "explanation of how the research will be conducted" }} @@ -134,37 +134,37 @@ class AgentWebcrawler(AgentBase): try: # Get research plan from AI - response = await self.mydom.call_ai([ + response = await self.mydom.callAi([ {"role": "system", "content": "You are a web research planning expert. Create precise research plans in JSON format only."}, - {"role": "user", "content": research_prompt} + {"role": "user", "content": researchPrompt} ]) # Extract JSON - json_start = response.find('{') - json_end = response.rfind('}') + 1 + jsonStart = response.find('{') + jsonEnd = response.rfind('}') + 1 - if json_start >= 0 and json_end > json_start: - plan = json.loads(response[json_start:json_end]) + if jsonStart >= 0 and jsonEnd > jsonStart: + plan = json.loads(response[jsonStart:jsonEnd]) # Ensure we have the expected fields with defaults if missing - if "search_terms" not in plan: - plan["search_terms"] = [prompt] - if "direct_urls" not in plan: - plan["direct_urls"] = [] - if "research_questions" not in plan: - plan["research_questions"] = ["What information can be found about this topic?"] + if "searchTerms" not in plan: + plan["searchTerms"] = [prompt] + if "directUrls" not in plan: + plan["directUrls"] = [] + if "researchQuestions" not in plan: + plan["researchQuestions"] = ["What information can be found about this topic?"] return plan else: # Fallback plan logger.warning(f"Not able creating research plan, generating fallback plan") return { - "requires_web_research": True, - "research_questions": ["What information can be found about this topic?"], - "search_terms": [prompt], - "direct_urls": [], - "expected_sources": ["Web pages", "Articles"], - "content_focus": "Relevant information about the topic", + "requiresWebResearch": True, + "researchQuestions": ["What information can be found about this topic?"], + "searchTerms": [prompt], + "directUrls": [], + "expectedSources": ["Web pages", "Articles"], + "contentFocus": "Relevant information about the topic", "feedback": f"I'll conduct web research on '{prompt}' and gather relevant information." } @@ -172,45 +172,45 @@ class AgentWebcrawler(AgentBase): logger.warning(f"Error creating research plan: {str(e)}") # Simple fallback plan return { - "requires_web_research": True, - "research_questions": ["What information can be found about this topic?"], - "search_terms": [prompt], - "direct_urls": [], - "expected_sources": ["Web pages", "Articles"], - "content_focus": "Relevant information about the topic", + "requiresWebResearch": True, + "researchQuestions": ["What information can be found about this topic?"], + "searchTerms": [prompt], + "directUrls": [], + "expectedSources": ["Web pages", "Articles"], + "contentFocus": "Relevant information about the topic", "feedback": f"I'll conduct web research on '{prompt}' and gather relevant information." } - async def _gather_research_material(self, research_plan: Dict[str, Any]) -> List[Dict[str, Any]]: + async def _gatherResearchMaterial(self, researchPlan: Dict[str, Any]) -> List[Dict[str, Any]]: """ Gather research material based on the research plan. Args: - research_plan: Research plan dictionary + researchPlan: Research plan dictionary Returns: List of research results """ - all_results = [] + allResults = [] # Process direct URLs - direct_urls = research_plan.get("direct_urls", [])[:self.max_url] - for url in direct_urls: + directUrls = researchPlan.get("directUrls", [])[:self.maxUrl] + for url in directUrls: logger.info(f"Processing direct URL: {url}") try: # Fetch and extract content - soup = self._read_url(url) + soup = self._readUrl(url) if soup: # Extract title and content - title = self._extract_title(soup, url) - content = self._extract_main_content(soup) + title = self._extractTitle(soup, url) + content = self._extractMainContent(soup) # Add to results - all_results.append({ + allResults.append({ "title": title, "url": url, - "source_type": "direct_url", + "sourceType": "directUrl", "content": content, "summary": "" # Will be filled later }) @@ -218,48 +218,48 @@ class AgentWebcrawler(AgentBase): logger.warning(f"Error processing URL {url}: {str(e)}") # Process search terms - search_terms = research_plan.get("search_terms", [])[:self.max_search_terms] - for term in search_terms: + searchTerms = researchPlan.get("searchTerms", [])[:self.maxSearchTerms] + for term in searchTerms: logger.info(f"Searching for: {term}") try: # Perform search - search_results = self._search_web(term) + searchResults = self._searchWeb(term) # Process each search result - for result in search_results: + for result in searchResults: # Check if URL is already in results - if not any(r["url"] == result["url"] for r in all_results): - all_results.append({ + if not any(r["url"] == result["url"] for r in allResults): + allResults.append({ "title": result["title"], "url": result["url"], - "source_type": "search_result", + "sourceType": "searchResult", "content": result["data"], "snippet": result["snippet"], "summary": "" # Will be filled later }) # Stop if we've reached the maximum results - if len(all_results) >= self.max_results: + if len(allResults) >= self.maxResults: break except Exception as e: logger.warning(f"Error searching for {term}: {str(e)}") # Stop if we've reached the maximum results - if len(all_results) >= self.max_results: + if len(allResults) >= self.maxResults: break # Create summaries in parallel for all results - all_results = await self._summarize_all_results(all_results, research_plan) + allResults = await self._summarizeAllResults(allResults, researchPlan) - return all_results + return allResults - async def _summarize_all_results(self, results: List[Dict[str, Any]], research_plan: Dict[str, Any]) -> List[Dict[str, Any]]: + async def _summarizeAllResults(self, results: List[Dict[str, Any]], researchPlan: Dict[str, Any]) -> List[Dict[str, Any]]: """ Create summaries for all research results. Args: results: List of research results - research_plan: Research plan with questions and focus + researchPlan: Research plan with questions and focus Returns: Results with added summaries @@ -269,16 +269,16 @@ class AgentWebcrawler(AgentBase): try: # Limit content length to avoid token issues - content = self._limit_text(result.get("content", ""), max_chars=8000) - research_questions = research_plan.get("research_questions", ["What relevant information does this page contain?"]) - content_focus = research_plan.get("content_focus", "Relevant information") + content = self._limitText(result.get("content", ""), maxChars=8000) + researchQuestions = researchPlan.get("researchQuestions", ["What relevant information does this page contain?"]) + contentFocus = researchPlan.get("contentFocus", "Relevant information") # Create summary using AI - summary_prompt = f""" + summaryPrompt = f""" Summarize this web page content based on these research questions: - {', '.join(research_questions)} + {', '.join(researchQuestions)} - Focus on: {content_focus} + Focus on: {contentFocus} Web page: {result['url']} Title: {result['title']} @@ -296,9 +296,9 @@ class AgentWebcrawler(AgentBase): """ if self.mydom: - summary = await self.mydom.call_ai([ + summary = await self.mydom.callAi([ {"role": "system", "content": "You summarize web content accurately and concisely, focusing only on what is actually in the content."}, - {"role": "user", "content": summary_prompt} + {"role": "user", "content": summaryPrompt} ]) # Store the summary @@ -314,24 +314,24 @@ class AgentWebcrawler(AgentBase): return results - async def _create_output_documents(self, prompt: str, results: List[Dict[str, Any]], - output_specs: List[Dict[str, Any]], research_plan: Dict[str, Any]) -> List[Dict[str, Any]]: + async def _createOutputDocuments(self, prompt: str, results: List[Dict[str, Any]], + outputSpecs: List[Dict[str, Any]], researchPlan: Dict[str, Any]) -> List[Dict[str, Any]]: """ Create output documents based on research results and specifications. Args: prompt: Original research prompt results: List of research results - output_specs: Output specifications - research_plan: Research plan + outputSpecs: Output specifications + researchPlan: Research plan Returns: List of output documents """ # If no output specs provided, create default output - if not output_specs: - output_specs = [{ - "label": "web_research_results.md", + if not outputSpecs: + outputSpecs = [{ + "label": "webResearchResults.md", "description": "Comprehensive web research results" }] @@ -339,66 +339,66 @@ class AgentWebcrawler(AgentBase): documents = [] # Process each output specification - for spec in output_specs: - output_label = spec.get("label", "") - output_description = spec.get("description", "") + for spec in outputSpecs: + outputLabel = spec.get("label", "") + outputDescription = spec.get("description", "") # Determine format based on file extension - format_type = self._determine_format_type(output_label) + formatType = self._determineFormatType(outputLabel) # Create appropriate document based on format - if format_type == "json": + if formatType == "json": # JSON output - structured data - document = await self._create_json_document(prompt, results, research_plan, output_label) - elif format_type == "csv": + document = await self._createJsonDocument(prompt, results, researchPlan, outputLabel) + elif formatType == "csv": # CSV output - tabular data - document = await self._create_csv_document(results, output_label) + document = await self._createCsvDocument(results, outputLabel) else: # Text-based output (markdown, html, text) - narrative report - document = await self._create_narrative_document( - prompt, results, research_plan, format_type, output_label, output_description + document = await self._createNarrativeDocument( + prompt, results, researchPlan, formatType, outputLabel, outputDescription ) documents.append(document) return documents - async def _create_narrative_document(self, prompt: str, results: List[Dict[str, Any]], - research_plan: Dict[str, Any], format_type: str, - output_label: str, output_description: str) -> Dict[str, Any]: + async def _createNarrativeDocument(self, prompt: str, results: List[Dict[str, Any]], + researchPlan: Dict[str, Any], formatType: str, + outputLabel: str, outputDescription: str) -> Dict[str, Any]: """ Create a narrative document (markdown, html, text) from research results. Args: prompt: Original research prompt results: Research results - research_plan: Research plan - format_type: Output format (markdown, html, text) - output_label: Output filename - output_description: Output description + researchPlan: Research plan + formatType: Output format (markdown, html, text) + outputLabel: Output filename + outputDescription: Output description Returns: Document object """ # Create content based on format - if format_type == "markdown": - content_type = "text/markdown" - template_format = "markdown" - elif format_type == "html": - content_type = "text/html" - template_format = "html" + if formatType == "markdown": + contentType = "text/markdown" + templateFormat = "markdown" + elif formatType == "html": + contentType = "text/html" + templateFormat = "html" else: - content_type = "text/plain" - template_format = "text" + contentType = "text/plain" + templateFormat = "text" # Prepare research context - research_questions = research_plan.get("research_questions", []) - search_terms = research_plan.get("search_terms", []) + researchQuestions = researchPlan.get("researchQuestions", []) + searchTerms = researchPlan.get("searchTerms", []) # Create document structure based on results - sources_summary = [] + sourcesSummary = [] for result in results: - sources_summary.append({ + sourcesSummary.append({ "title": result.get("title", "Untitled"), "url": result.get("url", ""), "summary": result.get("summary", ""), @@ -406,35 +406,35 @@ class AgentWebcrawler(AgentBase): }) # Truncate content for prompt - sources_json = json.dumps(sources_summary, indent=2) - if len(sources_json) > 10000: + sourcesJson = json.dumps(sourcesSummary, indent=2) + if len(sourcesJson) > 10000: # Logic to truncate each summary while preserving structure - for i in range(len(sources_summary)): - if len(sources_json) <= 10000: + for i in range(len(sourcesSummary)): + if len(sourcesJson) <= 10000: break # Gradually truncate summaries - sources_summary[i]["summary"] = sources_summary[i]["summary"][:500] + "..." - sources_json = json.dumps(sources_summary, indent=2) + sourcesSummary[i]["summary"] = sourcesSummary[i]["summary"][:500] + "..." + sourcesJson = json.dumps(sourcesSummary, indent=2) # Create report prompt - report_prompt = f""" - Create a comprehensive {format_type} research report based on the following web research: + reportPrompt = f""" + Create a comprehensive {formatType} research report based on the following web research: TASK: {prompt} RESEARCH QUESTIONS: - {', '.join(research_questions)} + {', '.join(researchQuestions)} SEARCH TERMS USED: - {', '.join(search_terms)} + {', '.join(searchTerms)} SOURCES AND FINDINGS: - {sources_json} + {sourcesJson} REPORT DETAILS: - - Format: {template_format} - - Filename: {output_label} - - Description: {output_description} + - Format: {templateFormat} + - Filename: {outputLabel} + - Description: {outputDescription} Create a well-structured report that: 1. Includes an executive summary of key findings @@ -442,188 +442,188 @@ class AgentWebcrawler(AgentBase): 3. Integrates information from all relevant sources 4. Cites sources appropriately for each piece of information 5. Provides a comprehensive synthesis of the research - 6. Is formatted professionally and appropriately for {template_format} + 6. Is formatted professionally and appropriately for {templateFormat} The report should be scholarly, accurate, and focused on the original research task. """ try: # Generate report with AI - report_content = await self.mydom.call_ai([ - {"role": "system", "content": f"You create professional research reports in {template_format} format."}, - {"role": "user", "content": report_prompt} + reportContent = await self.mydom.callAi([ + {"role": "system", "content": f"You create professional research reports in {templateFormat} format."}, + {"role": "user", "content": reportPrompt} ]) # Convert to HTML if needed - if format_type == "html" and not report_content.lower().startswith("Web Research Results{report_content}" + if not reportContent.lower().startswith("Web Research Results{reportContent}" return { - "label": output_label, - "content": report_content, + "label": outputLabel, + "content": reportContent, "metadata": { - "content_type": content_type + "contentType": contentType } } except Exception as e: logger.error(f"Error creating narrative document: {str(e)}") # Create error document - if format_type == "markdown": + if formatType == "markdown": content = f"# Web Research Error\n\nAn error occurred: {str(e)}" - elif format_type == "html": + elif formatType == "html": content = f"

Web Research Error

An error occurred: {str(e)}

" else: content = f"WEB RESEARCH ERROR\n\nAn error occurred: {str(e)}" return { - "label": output_label, + "label": outputLabel, "content": content, "metadata": { - "content_type": content_type + "contentType": contentType } } - async def _create_json_document(self, prompt: str, results: List[Dict[str, Any]], - research_plan: Dict[str, Any], output_label: str) -> Dict[str, Any]: + async def _createJsonDocument(self, prompt: str, results: List[Dict[str, Any]], + researchPlan: Dict[str, Any], outputLabel: str) -> Dict[str, Any]: """ Create a JSON document from research results. Args: prompt: Original research prompt results: Research results - research_plan: Research plan - output_label: Output filename + researchPlan: Research plan + outputLabel: Output filename Returns: Document object """ try: # Create structured data - sources_data = [] + sourcesData = [] for result in results: - sources_data.append({ + sourcesData.append({ "title": result.get("title", "Untitled"), "url": result.get("url", ""), "summary": result.get("summary", ""), "snippet": result.get("snippet", ""), - "source_type": result.get("source_type", "") + "sourceType": result.get("sourceType", "") }) # Create metadata metadata = { "query": prompt, "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"), - "research_questions": research_plan.get("research_questions", []), - "search_terms": research_plan.get("search_terms", []) + "researchQuestions": researchPlan.get("researchQuestions", []), + "searchTerms": researchPlan.get("searchTerms", []) } # Compile complete report object - json_content = { + jsonContent = { "metadata": metadata, - "summary": research_plan.get("feedback", "Web research results"), - "sources": sources_data + "summary": researchPlan.get("feedback", "Web research results"), + "sources": sourcesData } # Convert to JSON string - content = json.dumps(json_content, indent=2) + content = json.dumps(jsonContent, indent=2) return { - "label": output_label, + "label": outputLabel, "content": content, "metadata": { - "content_type": "application/json" + "contentType": "application/json" } } except Exception as e: logger.error(f"Error creating JSON document: {str(e)}") return { - "label": output_label, + "label": outputLabel, "content": json.dumps({"error": str(e)}), "metadata": { - "content_type": "application/json" + "contentType": "application/json" } } - async def _create_csv_document(self, results: List[Dict[str, Any]], output_label: str) -> Dict[str, Any]: + async def _createCsvDocument(self, results: List[Dict[str, Any]], outputLabel: str) -> Dict[str, Any]: """ Create a CSV document from research results. Args: results: Research results - output_label: Output filename + outputLabel: Output filename Returns: Document object """ try: # Create CSV header - csv_lines = ["Title,URL,Source Type,Snippet"] + csvLines = ["Title,URL,Source Type,Snippet"] # Add results for result in results: # Escape CSV fields title = result.get("title", "").replace('"', '""') url = result.get("url", "").replace('"', '""') - source_type = result.get("source_type", "").replace('"', '""') + sourceType = result.get("sourceType", "").replace('"', '""') snippet = result.get("snippet", "").replace('"', '""') - csv_lines.append(f'"{title}","{url}","{source_type}","{snippet}"') + csvLines.append(f'"{title}","{url}","{sourceType}","{snippet}"') # Combine into CSV content - content = "\n".join(csv_lines) + content = "\n".join(csvLines) return { - "label": output_label, + "label": outputLabel, "content": content, "metadata": { - "content_type": "text/csv" + "contentType": "text/csv" } } except Exception as e: logger.error(f"Error creating CSV document: {str(e)}") return { - "label": output_label, + "label": outputLabel, "content": "Error,Error\nFailed to create CSV,{0}".format(str(e)), "metadata": { - "content_type": "text/csv" + "contentType": "text/csv" } } - def _determine_format_type(self, output_label: str) -> str: + def _determineFormatType(self, outputLabel: str) -> str: """ Determine the format type based on the filename. Args: - output_label: Output filename + outputLabel: Output filename Returns: Format type (markdown, html, text, json, csv) """ - output_label_lower = output_label.lower() + outputLabelLower = outputLabel.lower() - if output_label_lower.endswith(".md"): + if outputLabelLower.endswith(".md"): return "markdown" - elif output_label_lower.endswith(".html"): + elif outputLabelLower.endswith(".html"): return "html" - elif output_label_lower.endswith(".txt"): + elif outputLabelLower.endswith(".txt"): return "text" - elif output_label_lower.endswith(".json"): + elif outputLabelLower.endswith(".json"): return "json" - elif output_label_lower.endswith(".csv"): + elif outputLabelLower.endswith(".csv"): return "csv" else: # Default to markdown return "markdown" - def _search_web(self, query: str) -> List[Dict[str, str]]: + def _searchWeb(self, query: str) -> List[Dict[str, str]]: """ Conduct a web search and return the results. @@ -633,11 +633,11 @@ class AgentWebcrawler(AgentBase): Returns: List of search results """ - formatted_query = quote_plus(query) - url = f"{self.search_engine}{formatted_query}" + formattedQuery = quote_plus(query) + url = f"{self.searchEngine}{formattedQuery}" - search_results_soup = self._read_url(url) - if not search_results_soup or not search_results_soup.select('.result'): + searchResultsSoup = self._readUrl(url) + if not searchResultsSoup or not searchResultsSoup.select('.result'): logger.warning(f"No search results found for: {query}") return [] @@ -645,59 +645,59 @@ class AgentWebcrawler(AgentBase): results = [] # Find all result containers - result_elements = search_results_soup.select('.result') + resultElements = searchResultsSoup.select('.result') - for result in result_elements: + for result in resultElements: # Extract title - title_element = result.select_one('.result__a') - title = title_element.text.strip() if title_element else 'No title' + titleElement = result.select_one('.result__a') + title = titleElement.text.strip() if titleElement else 'No title' # Extract URL (DuckDuckGo uses redirects) - url_element = title_element.get('href') if title_element else '' - extracted_url = 'No URL' + urlElement = titleElement.get('href') if titleElement else '' + extractedUrl = 'No URL' - if url_element: + if urlElement: # Extract actual URL from DuckDuckGo's redirect - if url_element.startswith('/d.js?q='): - start = url_element.find('?q=') + 3 - end = url_element.find('&', start) if '&' in url_element[start:] else None - extracted_url = unquote(url_element[start:end]) + if urlElement.startswith('/d.js?q='): + start = urlElement.find('?q=') + 3 + end = urlElement.find('&', start) if '&' in urlElement[start:] else None + extractedUrl = unquote(urlElement[start:end]) # Ensure URL has correct protocol prefix - if not extracted_url.startswith(('http://', 'https://')): - if not extracted_url.startswith('//'): - extracted_url = 'https://' + extracted_url + if not extractedUrl.startswith(('http://', 'https://')): + if not extractedUrl.startswith('//'): + extractedUrl = 'https://' + extractedUrl else: - extracted_url = 'https:' + extracted_url + extractedUrl = 'https:' + extractedUrl else: - extracted_url = url_element + extractedUrl = urlElement # Extract snippet directly from search results page - snippet_element = result.select_one('.result__snippet') - snippet = snippet_element.text.strip() if snippet_element else 'No description' + snippetElement = result.select_one('.result__snippet') + snippet = snippetElement.text.strip() if snippetElement else 'No description' # Get actual page content try: - target_page_soup = self._read_url(extracted_url) - content = self._extract_main_content(target_page_soup) + targetPageSoup = self._readUrl(extractedUrl) + content = self._extractMainContent(targetPageSoup) except Exception as e: - logger.warning(f"Error extracting content from {extracted_url}: {str(e)}") + logger.warning(f"Error extracting content from {extractedUrl}: {str(e)}") content = f"Error extracting content: {str(e)}" results.append({ 'title': title, - 'url': extracted_url, + 'url': extractedUrl, 'snippet': snippet, 'data': content }) # Limit number of results - if len(results) >= self.max_results: + if len(results) >= self.maxResults: break return results - def _read_url(self, url: str) -> BeautifulSoup: + def _readUrl(self, url: str) -> BeautifulSoup: """ Read a URL and return a BeautifulSoup parser for the content. @@ -711,7 +711,7 @@ class AgentWebcrawler(AgentBase): return None headers = { - 'User-Agent': self.user_agent, + 'User-Agent': self.userAgent, 'Accept': 'text/html,application/xhtml+xml,application/xml', 'Accept-Language': 'en-US,en;q=0.9', } @@ -723,10 +723,10 @@ class AgentWebcrawler(AgentBase): # Handling for status 202 if response.status_code == 202: # Retry with backoff - backoff_times = [0.5, 1.0, 2.0, 5.0] + backoffTimes = [0.5, 1.0, 2.0, 5.0] - for wait_time in backoff_times: - time.sleep(wait_time) + for waitTime in backoffTimes: + time.sleep(waitTime) response = requests.get(url, headers=headers, timeout=self.timeout) if response.status_code != 202: @@ -742,7 +742,7 @@ class AgentWebcrawler(AgentBase): logger.error(f"Error reading URL {url}: {str(e)}") return None - def _extract_title(self, soup: BeautifulSoup, url: str) -> str: + def _extractTitle(self, soup: BeautifulSoup, url: str) -> str: """ Extract the title from a webpage. @@ -757,24 +757,24 @@ class AgentWebcrawler(AgentBase): return f"Error with {url}" # Extract title from title tag - title_tag = soup.find('title') - title = title_tag.text.strip() if title_tag else "No title" + titleTag = soup.find('title') + title = titleTag.text.strip() if titleTag else "No title" # Alternative: Also look for h1 tags if title tag is missing if title == "No title": - h1_tag = soup.find('h1') - if h1_tag: - title = h1_tag.text.strip() + h1Tag = soup.find('h1') + if h1Tag: + title = h1Tag.text.strip() return title - def _extract_main_content(self, soup: BeautifulSoup, max_chars: int = 10000) -> str: + def _extractMainContent(self, soup: BeautifulSoup, maxChars: int = 10000) -> str: """ Extract the main content from an HTML page. Args: soup: BeautifulSoup object of the webpage - max_chars: Maximum number of characters + maxChars: Maximum number of characters Returns: Extracted main content as a string @@ -783,34 +783,34 @@ class AgentWebcrawler(AgentBase): return "" # Try to find main content elements in priority order - main_content = None + mainContent = None for selector in ['main', 'article', '#content', '.content', '#main', '.main']: content = soup.select_one(selector) if content: - main_content = content + mainContent = content break # If no main content found, use the body - if not main_content: - main_content = soup.find('body') or soup + if not mainContent: + mainContent = soup.find('body') or soup # Remove script, style, nav, footer elements that don't contribute to main content - for element in main_content.select('script, style, nav, footer, header, aside, .sidebar, #sidebar, .comments, #comments, .advertisement, .ads, iframe'): + for element in mainContent.select('script, style, nav, footer, header, aside, .sidebar, #sidebar, .comments, #comments, .advertisement, .ads, iframe'): element.extract() # Extract text content - text_content = main_content.get_text(separator=' ', strip=True) + textContent = mainContent.get_text(separator=' ', strip=True) - # Limit to max_chars - return text_content[:max_chars] + # Limit to maxChars + return textContent[:maxChars] - def _limit_text(self, text: str, max_chars: int = 10000) -> str: + def _limitText(self, text: str, maxChars: int = 10000) -> str: """ Limit text to a maximum number of characters. Args: text: Input text - max_chars: Maximum number of characters + maxChars: Maximum number of characters Returns: Limited text @@ -819,14 +819,14 @@ class AgentWebcrawler(AgentBase): return "" # If text is already under the limit, return unchanged - if len(text) <= max_chars: + if len(text) <= maxChars: return text - # Otherwise limit text to max_chars - return text[:max_chars] + "... [Content truncated due to length]" + # Otherwise limit text to maxChars + return text[:maxChars] + "... [Content truncated due to length]" # Factory function for the Webcrawler agent -def get_webcrawler_agent(): +def getAgentWebcrawler(): """Returns an instance of the Webcrawler agent.""" return AgentWebcrawler() \ No newline at end of file diff --git a/modules/auth.py b/modules/auth.py index 26366d40..6fdf7e2f 100644 --- a/modules/auth.py +++ b/modules/auth.py @@ -1,3 +1,8 @@ +""" +Authentication module for backend API. +Handles JWT-based authentication, token generation, and user context. +""" + from datetime import datetime, timedelta, timezone from typing import Optional, Dict, Any, Tuple from fastapi import Depends, HTTPException, status @@ -5,7 +10,7 @@ from fastapi.security import OAuth2PasswordBearer from jose import JWTError, jwt import logging -from modules.gateway_interface import get_gateway_interface +from modules.gatewayInterface import getGatewayInterface from modules.configuration import APP_CONFIG # Get Config Data @@ -13,39 +18,36 @@ SECRET_KEY = APP_CONFIG.get("APP_JWT_SECRET_SECRET") ALGORITHM = APP_CONFIG.get("Auth_ALGORITHM") ACCESS_TOKEN_EXPIRE_MINUTES = int(APP_CONFIG.get("APP_TOKEN_EXPIRY")) - # OAuth2 Setup -oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token") +oauth2Scheme = OAuth2PasswordBearer(tokenUrl="token") # Logger logger = logging.getLogger(__name__) - -def create_access_token(data: dict, expires_delta: Optional[timedelta] = None) -> str: +def createAccessToken(data: dict, expiresDelta: Optional[timedelta] = None) -> str: """ Creates a JWT Access Token. Args: data: Data to encode (usually user ID or username) - expires_delta: Validity duration of the token (optional) + expiresDelta: Validity duration of the token (optional) Returns: JWT Token as string """ - to_encode = data.copy() + toEncode = data.copy() - if expires_delta: - expire = datetime.now(timezone.utc) + expires_delta + if expiresDelta: + expire = datetime.now(timezone.utc) + expiresDelta else: expire = datetime.now(timezone.utc) + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES) - to_encode.update({"exp": expire}) - encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM) + toEncode.update({"exp": expire}) + encodedJwt = jwt.encode(toEncode, SECRET_KEY, algorithm=ALGORITHM) - return encoded_jwt + return encodedJwt - -async def get_current_user(token: str = Depends(oauth2_scheme)) -> Dict[str, Any]: +async def getCurrentUser(token: str = Depends(oauth2Scheme)) -> Dict[str, Any]: """ Extracts and validates the current user from the JWT token. @@ -58,7 +60,7 @@ async def get_current_user(token: str = Depends(oauth2_scheme)) -> Dict[str, Any Raises: HTTPException: For invalid token or user """ - credentials_exception = HTTPException( + credentialsException = HTTPException( status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid authentication credentials", headers={"WWW-Authenticate": "Bearer"}, @@ -71,24 +73,24 @@ async def get_current_user(token: str = Depends(oauth2_scheme)) -> Dict[str, Any # Extract username from token username: str = payload.get("sub") if username is None: - raise credentials_exception + raise credentialsException # Extract mandate ID from token (if present) - mandate_id: int = payload.get("mandate_id", 1) # Default: Root mandate + mandateId: int = payload.get("mandateId", 1) # Default: Root mandate except JWTError: logger.warning("Invalid JWT Token") - raise credentials_exception + raise credentialsException # Initialize Gateway Interface without context - gateway = get_gateway_interface() + gateway = getGatewayInterface() # Retrieve user from database - user = gateway.get_user_by_username(username) + user = gateway.getUserByUsername(username) if user is None: logger.warning(f"User {username} not found") - raise credentials_exception + raise credentialsException if user.get("disabled", False): logger.warning(f"User {username} is disabled") @@ -96,13 +98,12 @@ async def get_current_user(token: str = Depends(oauth2_scheme)) -> Dict[str, Any return user - -async def get_current_active_user(current_user: Dict[str, Any] = Depends(get_current_user)) -> Dict[str, Any]: +async def getCurrentActiveUser(currentUser: Dict[str, Any] = Depends(getCurrentUser)) -> Dict[str, Any]: """ Ensures that the user is active. Args: - current_user: Current user data + currentUser: Current user data Returns: User data @@ -110,50 +111,48 @@ async def get_current_active_user(current_user: Dict[str, Any] = Depends(get_cur Raises: HTTPException: If the user is disabled """ - if current_user.get("disabled", False): + if currentUser.get("disabled", False): raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="User is disabled") - return current_user + return currentUser - -async def get_user_context(current_user: Dict[str, Any]) -> Tuple[int, int]: +async def getUserContext(currentUser: Dict[str, Any]) -> Tuple[int, int]: """ Extracts the mandate ID and user ID from the current user. Enhanced with better logging. Args: - current_user: The current user + currentUser: The current user Returns: - Tuple of (mandate_id, user_id) + Tuple of (mandateId, userId) """ # Default values - default_mandate_id = 0 - default_user_id = 0 + defaultMandateId = 0 + defaultUserId = 0 - # Extract mandate_id - mandate_id = current_user.get("mandate_id", None) - if mandate_id is None: - logger.warning(f"No mandate_id found in current_user, using default: {default_mandate_id}") - mandate_id = default_mandate_id + # Extract mandateId + mandateId = currentUser.get("mandateId", None) + if mandateId is None: + logger.warning(f"No mandateId found in currentUser, using default: {defaultMandateId}") + mandateId = defaultMandateId else: try: - mandate_id = int(mandate_id) + mandateId = int(mandateId) except (ValueError, TypeError): - logger.error(f"Invalid mandate_id value: {mandate_id}, using default: {default_mandate_id}") - mandate_id = default_mandate_id + logger.error(f"Invalid mandateId value: {mandateId}, using default: {defaultMandateId}") + mandateId = defaultMandateId - # Extract user_id - user_id = current_user.get("id", None) - if user_id is None: - logger.warning(f"No user_id found in current_user, using default: {default_user_id}") - user_id = default_user_id + # Extract userId + userId = currentUser.get("id", None) + if userId is None: + logger.warning(f"No userId found in currentUser, using default: {defaultUserId}") + userId = defaultUserId else: try: - user_id = int(user_id) + userId = int(userId) except (ValueError, TypeError): - logger.error(f"Invalid user_id value: {user_id}, using default: {default_user_id}") - user_id = default_user_id + logger.error(f"Invalid userId value: {userId}, using default: {defaultUserId}") + userId = defaultUserId - # logger.info(f"User context: mandate_id={mandate_id}, user_id={user_id}") - return mandate_id, user_id \ No newline at end of file + return mandateId, userId \ No newline at end of file diff --git a/modules/chat.py b/modules/chat.py deleted file mode 100644 index fb577818..00000000 --- a/modules/chat.py +++ /dev/null @@ -1,1235 +0,0 @@ -""" -ChatManager Module for managing AI-Chat workflows. -Implements a compact and modular architecture for processing -user requests, agent execution, and result formatting. -""" - -import asyncio -import os -import logging -import json -import re -import uuid -import base64 -from datetime import datetime -from typing import Dict, Any, List, Optional, Union - -# Required imports -from modules.chat_registry import get_agent_registry -from modules.lucydom_interface import get_lucydom_interface as dom_interface -from modules.chat_content_extraction import get_document_contents - -# Configure logger -logger = logging.getLogger(__name__) - -# Global settings for the workflow management -GLOBAL_WorkflowLabels = { - "system_name": "AI Assistant", # Default system name for logs - "workflow_status_messages": { - "init": "Workflow initialized", - "running": "Running workflow", - "waiting": "Waiting for input", - "completed": "Workflow completed", - "error": "Error in workflow" - } -} - -class ChatManager: - """ - Manages the processing of chat requests, agent execution, and - the integration of results into the workflow. - """ - - def __init__(self, mandate_id: int, user_id: int): - """ - Initializes the ChatManager with mandate and user context. - - Args: - mandate_id: ID of the current mandate - user_id: ID of the current user - """ - self.mandate_id = mandate_id - self.user_id = user_id - self.mydom = dom_interface(mandate_id, user_id) - self.agent_registry = get_agent_registry() - self.agent_registry.set_mydom(self.mydom) - - ### Chat Management - - async def chat_run(self, user_input: Dict[str, Any], workflow_id: Optional[str] = None) -> Dict[str, Any]: - """ - Main function for integrating user requests into the workflow. Only initial part, then handover to session as coroutine to finish for frontend - """ - # 1. Initialize workflow or load existing one - workflow = self.workflow_init(workflow_id) - self.log_add(workflow, "Starting workflow processing", level="info", progress=0) - asyncio.create_task(self.chat_session(user_input, workflow)) - return workflow - - - async def chat_session(self, user_input: Dict[str, Any], workflow: Dict[str, Any]) -> Dict[str, Any]: - """ - Session in the background as event - """ - - # 2. Transform user input into a message object and save in workflow - message_user = await self.chat_message_to_workflow("user", "", user_input, workflow) - - # 3. Create project manager prompt and analyze response - self.log_add(workflow, "Analyzing request and planning work", level="info", progress=10) - project_manager_response = await self.chat_prompt(message_user, workflow) - obj_final_documents = project_manager_response.get("obj_final_documents", []) - obj_workplan = project_manager_response.get("obj_workplan", []) - obj_user_response = project_manager_response.get("obj_user_response", "") - - # Get detected language and set it in the mydom interface - user_language = project_manager_response.get("user_language", "en") - self.mydom.set_user_language(user_language) - - # 4. Save the response as a message in the workflow and add log entries - response_message = { - "role": "assistant", - "agent_name": "project_manager", - "content": obj_user_response - } - self.message_add(workflow, response_message) - - self.log_add(workflow, f"Planned outputs: {len(obj_final_documents)} documents", level="info", progress=20) - self.log_add(workflow, f"Work plan created with {len(obj_workplan)} steps", level="info", progress=25) - - # 5. Execute agents according to work plan - obj_results = [] - if obj_workplan: - total_tasks = len(obj_workplan) - for task_index, task in enumerate(obj_workplan): - agent_name = task.get("agent", "unknown") - progress_value = 30 + int((task_index / total_tasks) * 60) # Progress from 30% to 90% - - progress_msg = f"Running task {task_index+1}/{total_tasks}: {agent_name}" - self.log_add(workflow, progress_msg, level="info", progress=progress_value) - - task_results = await self.agent_processing(task, workflow) - obj_results.extend(task_results) - - # Log completion of this task - self.log_add( - workflow, - f"Completed task {task_index+1}/{total_tasks}: {agent_name}", - level="info", - progress=progress_value + (60/total_tasks)/2 - ) - - # 6. Create the final response with relevant documents from obj_final_documents - self.log_add(workflow, "Creating final response", level="info", progress=90) - final_message = await self.chat_final_message(obj_user_response, obj_final_documents, obj_results) - self.message_add(workflow, final_message) - - # 7. Finalize the workflow - self.workflow_finish(workflow) - self.log_add(workflow, "Workflow completed successfully", level="info", progress=100) - - - async def chat_prompt(self, message_user: Dict[str, Any], workflow: Dict[str, Any]) -> Dict[str, Any]: - """ - Creates the prompt for the project manager and processes the response. - - Args: - message_user: Message object with user request - workflow: Current workflow object - - Returns: - Project manager's response with obj_final_documents, obj_workplan and obj_user_response - """ - # Get available agents with their capabilities - available_agents = self.agent_profiles() - - # Create a workflow summary - workflow_summary = await self.workflow_summarize(workflow, message_user) - - # Create a list of currently available documents from user input or previously generated documents - available_documents = self.available_documents_get(workflow, message_user) - available_docs_str = json.dumps(available_documents, indent=2) - - # Create the prompt for the project manager with language detection requirement - prompt = f""" -Based on the user request and the provided documents, please analyze the requirements and create a processing plan. -Also, identify the language of the user's request and include it in your response. - - -{message_user.get('content')} - - -# Previous conversation history: - -{workflow_summary} - - -# Available documents (currently in workflow): - -{available_docs_str} - - -# Available agents and their capabilities: - -{self.parse_json2text(available_agents)} - - -Please analyze the request and create: - -1. A list of required result documents (obj_final_documents) -2. A plan for executing agents (obj_workplan) -3. A clear response to the user explaining what you're doing (obj_user_response) -4. Identified language of the user's request (user_language) - -## IMPORTANT RULES FOR THE WORKPLAN: -1. Each input document must either already exist (provided by the user or previously created by an agent) or be created by an agent before it's used. -2. If necessary, convert input documents to a suitable format using agents when the type doesn't match. -3. Do not define document inputs that don't exist or haven't been generated beforehand. -4. Create a logical sequence - earlier agents can create documents that are later used as inputs. -5. If the user has provided documents but hasn't clearly stated what they want, try to act according to the context. - -Your answer must be strictly in the JSON_OUTPUT format, with no additions before or after the JSON object. - -JSON_OUTPUT = {{ - "obj_final_documents": ["label",...], # document label in the format 'filename.ext' - "obj_workplan": [ - {{ - "agent": "agent_name", # Name of an available agent - "prompt": "Specific instructions to the agent, that he knows what to do with which documents and which output to provide." - "output_documents": [ - "label":"document label in the format 'filename.ext'", - "prompt":"AI prompt to describe the content of the file" - ], - "input_documents": [ - "label":"document label in the format 'filename.ext'", - "file_id":id, # if refering to an existing document, provide file_id to select the correct file - "content_part":"", # provide empty string, if all document contents to consider, otherwise the content_part of the document to focus on - "prompt":"AI prompt to describe what data to extract from the file." - ], # If no input documents are needed, include "input_documents" as an empty list - }} - # Multiple agent tasks can be added here and should build logically on each other - ], - "obj_user_response": "Information to the user about how his request will be solved, in the language of the user's request.", - "user_language": "en" # Language code (e.g., en, de, fr, es) based on the user's request -}} - -## RULES for input_documents: -1. The user request refers to documents where "file_source" in available documents is "user". Those documents are in the focus for input -2. In case of redundant label in available documents, use document with highest sequence_nr if not specified differently - -## STRICT RULES FOR document "label": -1. Every document label MUST include a proper file extension that matches the content type. -2. Use standard extensions like: - - ".txt" for text files - - ".md" for markdown files - - ".csv" for comma-separated values - - ".json" for JSON data - - ".html" for HTML content - - ".jpg" or ".png" for images - - ".docx" for Word documents - - ".xlsx" for Excel files - - ".pdf" for PDF documents -3. Use descriptive filenames that indicate the document's purpose (e.g., "analysis_report.txt" rather than just "report.txt") -4. If you use label for an existing file -""" - - # Call the AI service through mydom for language support - logger.debug(f"PROJECT MANAGER Planning prompt: {prompt}") - project_manager_output = await self.mydom.call_ai([ - { - "role": "system", - "content": "You are an experienced project manager who analyzes user requests and creates work plans. You pay very careful attention to ensure that all document dependencies are correct and that no non-existent documents are defined as inputs. The output follows strictly the specified format." - }, - { - "role": "user", - "content": prompt - } - ]) - - # Parse the JSON response - logger.debug(f"PROJECT MANAGER Planning answer: parse_json_response{project_manager_output}") - return self.parse_json_response(project_manager_output) - - async def chat_message_to_workflow(self, role: str, agent_name: str, chat_message: Dict[str, Any], workflow: Dict[str, Any]) -> Dict[str, Any]: - """ - Integrates user inputs into a Message object including files with complete contents. - - Args: - role: Role of the message sender ('user' or 'assistant') - agent_name: Name of the agent, if message is from an agent - chat_message: Input data with "prompt"=str, "list_file_id"=[] - workflow: Current workflow object - - Returns: - Message object with content and documents including contents - """ - logger.info(f"Message from {role} {agent_name} sent with {len(chat_message.get('list_file_id', []))} documents") - logger.debug(f"message = {self.parse_json2text(chat_message)}.") - - # Check message content - message_content = chat_message.get("prompt", "") - if isinstance(message_content, dict) and "content" in message_content: - message_content = message_content["content"] - - # If message content is empty, no chat - if role=="user" and (message_content is None or message_content.strip() == ""): - logger.warning(f"Empty message, no chat") - message_content = "(No user input received)" - - # Process additional files with complete contents - additional_fileids = chat_message.get("list_file_id", []) - additional_files = await self.process_file_ids(additional_fileids) - - # Create message object - message_object = { - "role": role, - "agent_name": agent_name, - "content": message_content, - "documents": additional_files - } - - message_object = self.message_add(workflow, message_object) - logger.debug(f"message_user = {self.parse_json2text(message_object)}.") - return message_object - - async def chat_final_message(self, obj_user_response: str, obj_final_documents: List[Dict[str, Any]], obj_results: List[Dict[str, Any]]) -> Dict[str, Any]: - """ - Creates the final response message with review of proposed and delivered. - - Args: - obj_user_response: Initial text response to the user - obj_final_documents: List of expected response documents - obj_results: List of generated result documents - - Returns: - Complete message object with content and relevant documents - """ - # Find documents that match the obj_final_documents requirements - matching_documents = [] - - if len(obj_final_documents)>0: - for answer_label in obj_final_documents: - # Find matching document in results - for doc in obj_results: - doc_name = self.get_filename(doc) - # Check if this document matches the answer specification - if doc_name == answer_label: - content_ref = [] - for c in doc.get("contents"): - content_ref.append(c.get("summary")) - doc_ref = { - "label": doc_name, - "content_summary": content_ref - } - matching_documents.append(doc_ref) - break - - # Use the mydom for language-aware AI calls - final_prompt = await self.mydom.call_ai([ - {"role": "system", "content": "You are a project manager, who delivers results to a user."}, - {"role": "user", "content": f""" - Give the final short feedback to the user with reference to the initial statement (obj_user_response). Inform him about the list of files_delivered. You do not need to send the files, this is handled separately. If in the list of files_delivered there might miss some files_promised, just give a comment on this, otherwise task is now completed successful. - - Here the data: - obj_user_response = {self.parse_json2text(obj_user_response)} - files_promised = {self.parse_json2text(matching_documents)} - files_delivered = {self.parse_json2text(obj_user_response)} - """ - } - ], produce_user_answer=True) - - # Create basic message structure with proper fields - logger.debug(f"FINAL PROMPT = {self.parse_json2text(final_prompt)}.") - final_message = { - "role": "assistant", - "agent_name": "project_manager", - "content": final_prompt, - "documents": [] # DO NOT include the results documents, already with agents - } - - logger.debug(f"FINAL MESSAGE = {self.parse_json2text(final_message)}.") - return final_message - - - ### Workflow - - def workflow_init(self, workflow_id: Optional[str] = None) -> Dict[str, Any]: - """ - Initializes a workflow or loads an existing one with round counting. - - Args: - workflow_id: Optional - ID of the workflow to load - - Returns: - Initialized workflow object - """ - current_time = datetime.now().isoformat() - - if workflow_id is None or not self.mydom.get_workflow(workflow_id): - # Create new workflow - new_workflow_id = str(uuid.uuid4()) if workflow_id is None else workflow_id - workflow = { - "id": new_workflow_id, - "mandate_id": self.mandate_id, - "user_id": self.user_id, - "name": f"Workflow {new_workflow_id[:8]}", - "started_at": current_time, - "messages": [], # Empty list - will be filled with references - "message_ids": [], # Initialize empty message_ids list - "logs": [], - "data_stats": {}, - "current_round": 1, - "status": "running", - "last_activity": current_time, - } - - # Save to database - only the workflow metadata - workflow_db = { - "id": workflow["id"], - "mandate_id": workflow["mandate_id"], - "user_id": workflow["user_id"], - "name": workflow["name"], - "started_at": workflow["started_at"], - "status": workflow["status"], - "data_stats": workflow["data_stats"], - "current_round": workflow["current_round"], - "last_activity": workflow["last_activity"], - "message_ids": workflow["message_ids"] # Include message_ids - } - self.mydom.create_workflow(workflow_db) - - self.log_add(workflow, GLOBAL_WorkflowLabels["workflow_status_messages"]["init"], level="info", progress=0) - return workflow - else: - # Load existing workflow - workflow = self.mydom.load_workflow_state(workflow_id) - - # Ensure message_ids exists - if "message_ids" not in workflow: - # Initialize from existing messages - workflow["message_ids"] = [msg["id"] for msg in workflow.get("messages", [])] - - # Update in database - self.mydom.update_workflow(workflow_id, {"message_ids": workflow["message_ids"]}) - - # Update status and increment round counter - workflow["status"] = "running" - workflow["last_activity"] = current_time - - # Increment current_round if it exists, otherwise set it to 1 - if "current_round" in workflow: - workflow["current_round"] += 1 - else: - workflow["current_round"] = 1 - - # Update in database - only the relevant workflow fields - workflow_update = { - "status": workflow["status"], - "last_activity": workflow["last_activity"], - "current_round": workflow["current_round"] - } - self.mydom.update_workflow(workflow_id, workflow_update) - - self.log_add(workflow, GLOBAL_WorkflowLabels["workflow_status_messages"]["running"], level="info", progress=0) - return workflow - - def workflow_finish(self, workflow: Dict[str, Any]) -> Dict[str, Any]: - """ - Finalizes a workflow and sets the status to 'completed'. - - Args: - workflow: Workflow object - - Returns: - Updated workflow object - """ - # Prepare workflow update data - workflow_update = { - "status": "completed", - "last_activity": datetime.now().isoformat(), - } - - # Update the workflow object in memory - workflow["status"] = workflow_update["status"] - workflow["last_activity"] = workflow_update["last_activity"] - - # Save workflow state to database - only relevant fields, not the messages list - self.mydom.update_workflow(workflow["id"], workflow_update) - - self.log_add(workflow, GLOBAL_WorkflowLabels["workflow_status_messages"]["completed"], level="info", progress=100) - return workflow - - async def workflow_summarize(self, workflow: Dict[str, Any], message_user: Dict[str, Any]) -> str: - """ - Creates a summary of the workflow without the current user message. - - Args: - workflow: Workflow object - message_user: Current user message - - Returns: - Summary of the workflow - """ - if not workflow or "messages" not in workflow or not workflow["messages"]: - return "" # first message - - # Go through messages in reverse order (newest first) - messages = sorted(workflow["messages"], key=lambda m: m.get("sequence_no", 0), reverse=False) - - summary_parts = [] - for message in messages: - if message["id"] != message_user["id"]: - message_summary = await self.message_summarize(message) - summary_parts.append(message_summary) - - return "\n\n".join(summary_parts) - - - - ### Agents - - def agent_profiles(self) -> List[Dict[str, Any]]: - """ - Gets information about all available agents. - - Returns: - List with information about all available agents - """ - return self.agent_registry.get_agent_infos() - - async def agent_input_documents(self, doc_input_list: List[Dict[str, Any]], workflow: Dict[str, Any]) -> List[Dict[str, Any]]: - """ - Prepares input documents for an agent, sorted with newest first. - - Args: - doc_input_list: List of required input documents as specified by the project manager - workflow: Workflow object - - Returns: - Prepared input documents for the agent, sorted with newest first - """ - prepared_inputs = [] - - # Sort workflow messages by sequence number (descending) - sorted_messages = sorted( - workflow.get("messages", []), - key=lambda m: m.get("sequence_no", 0), - reverse=True - ) - - for doc_spec in doc_input_list: - doc_filename = doc_spec.get("label","") - doc_file_id = doc_spec.get("file_id","") - - found_doc = None - # Search for the document in sorted workflow messages (newest first) - for message in sorted_messages: - for doc in message.get("documents", []): - if (doc_file_id!="" and doc_file_id==doc.get("file_id")) or (doc_filename!="" and self.get_filename(doc) == doc_filename): - found_doc = doc - break - if found_doc: - break - if found_doc: - # Process document for agent based on the specification - processed_doc = await self.process_document_for_agent(found_doc, doc_spec) - - prepared_inputs.append(processed_doc) - else: - logger.warning(f"Document with label '{doc_filename}', file_id '{doc_file_id}' not found in workflow") - - return prepared_inputs - - async def process_document_for_agent(self, document: Dict[str, Any], doc_spec: Dict[str, Any]) -> Dict[str, Any]: - """ - Processes a document for an agent based on the document specification. - Uses AI to extract relevant content from the document based on the specification. - - Args: - document: The document to process - doc_spec: The document specification from the project manager - - Returns: - Processed document with AI-extracted content - """ - processed_doc = document.copy() - part_spec = doc_spec.get("content_part","") - - # Process each content item in the document - if "contents" in processed_doc: - processed_contents = [] - - for content in processed_doc["contents"]: - - # Check if part required - if part_spec != "" and part_spec != content.get("name"): - continue - - # Get the data from the content - data = content.get("data", "") - processed_content = content.copy() - - # Check if content data is base64 encoded - is_base64 = content.get("metadata", {}).get("base64_encoded", False) - - try: - # Use the AI service to process the document content according to the prompt from the project manager for the document specification - summary = doc_spec.get("prompt", "Extract the relevant information from this document") - ai_prompt = f""" -# Please process the following document content according to this instruction: - -{summary} - - -# Document content: - -{data} - - -# Extract and provide only the relevant information as requested. -""" - - # Call the AI service through mydom for language support - processed_data = await self.mydom.call_ai([ - {"role": "system", "content": "You are a document processing assistant. Extract only the relevant information as requested."}, - {"role": "user", "content": ai_prompt} - ]) - - # DO NOT change the original data field - # processed_content["data"] unchanged - processed_content["data_extracted"] = processed_data - processed_content["metadata"]["ai_processed"] = True - - except Exception as e: - logger.error(f"Error processing document content with AI: {str(e)}") - # Fall back to original content if AI processing fails - processed_content["data_extracted"] = "(no information)" - - processed_contents.append(processed_content) - - processed_doc["contents"] = processed_contents - - return processed_doc - - async def agent_processing(self, task: Dict[str, Any], workflow: Dict[str, Any]) -> List[Dict[str, Any]]: - """ - Process a single agent task from the workflow. - Optimized for the task-based approach where all agents implement process_task. - - Args: - task: The task definition containing agent name, prompt, and document specifications - workflow: The current workflow object - - Returns: - List of document objects created by the agent - """ - # 1. Extract task information - agent_name = task.get("agent") - agent_prompt = task.get("prompt", "") - - # Log the current step - output_labels = [d.get("label", "unknown") for d in task.get("output_documents", [])] - step_info = f"Agent '{agent_name}' to create {', '.join(output_labels)}." - self.log_add(workflow, step_info, level="info") - - # Check if prompt is empty - if agent_prompt == "": - logger.warning("Empty prompt, no task to do") - return [] - - # Get agent from registry - agent = self.agent_registry.get_agent(agent_name) - if not agent: - logger.error(f"Agent '{agent_name}' not found") - return [] - - # Prepare output document specifications - output_specs = [] - for doc in task.get("output_documents", []): - output_spec = { - "label": doc.get("label"), - "description": doc.get("prompt", "") - } - output_specs.append(output_spec) - - # Prepare input documents for the agent - input_documents = await self.agent_input_documents(task.get('input_documents', []), workflow) - - # Create a standardized task object for the agent - agent_task = { - "task_id": str(uuid.uuid4()), - "workflow_id": workflow.get("id"), - "prompt": agent_prompt, - "input_documents": input_documents, - "output_specifications": output_specs, - "context": { - "workflow_round": workflow.get("current_round", 1), - "agent_type": agent_name, - "timestamp": datetime.now().isoformat(), - "language": self.mydom.user_language # Pass language to agent - } - } - - # Execute the agent with the standardized task - try: - # Process the task using the agent's standardized interface - logger.debug("TASK: "+self.parse_json2text(agent_task)) - logger.debug(f"Agent '{agent_name}' AI service available: {agent.mydom is not None}") - - agent_results = await agent.process_task(agent_task) - - logger.debug(f"Agent '{agent_name}' completed task. RESULT: {self.parse_json2text(agent_results)}") - - # Log the agent response - self.log_add( - workflow, - f"Agent '{agent_name}' completed task. Feedback: {agent_results.get('feedback', 'No feedback provided')}", - level="info" - ) - - # Store produced files and prepare input object for message - agent_inputs = { - "prompt": agent_results.get("feedback", ""), - "list_file_id": self.agent_save_documents(agent_results) - } - - # Create a message in the workflow with the agent's response - agent_message = await self.chat_message_to_workflow("assistant", agent_name, agent_inputs, workflow) - logger.debug(f"Agent result = {self.parse_json2text(agent_message)}.") - - return agent_message.get("documents", []) - - except Exception as e: - error_msg = f"Error executing agent '{agent_name}': {str(e)}" - logger.error(error_msg, exc_info=True) # Add exc_info=True to get full traceback - self.log_add(workflow, error_msg, level="error") - return [] - - def agent_save_documents(self, agent_results: Dict[str, Any]) -> List[int]: - """ - Saves all documents from agent results as files and returns a list of file IDs. - Enhanced to handle the standardized document format from agents. - - Args: - agent_results: Dictionary containing agent feedback and documents - - Returns: - List of file IDs for the saved documents - """ - file_ids = [] - - # Extract documents from agent results - documents = agent_results.get("documents", []) - - for doc in documents: - try: - # Extract label (filename) and content - label = doc.get("label", "unnamed_file.txt") - content = doc.get("content", "") - - # Split label into name and extension - name, ext = os.path.splitext(label) - if ext.startswith('.'): - ext = ext[1:] # Remove leading dot - elif not ext: - # If no extension is provided, default to .txt for text content - ext = "txt" - label = f"{label}.{ext}" - - # Determine if content is base64 encoded - is_base64 = False - if isinstance(content, dict) and content.get("metadata", {}).get("base64_encoded", False): - is_base64 = True - content = content.get("data", "") - - # Convert content to bytes - if isinstance(content, str): - if is_base64: - # Decode base64 to bytes - try: - file_content = base64.b64decode(content) - except Exception as e: - logger.warning(f"Failed to decode base64 content: {str(e)}") - file_content = content.encode('utf-8') - else: - # Convert text to bytes - file_content = content.encode('utf-8') - else: - # Already bytes - file_content = content - - # Save file to database - file_meta = self.mydom.save_uploaded_file(file_content, label) - - if file_meta and "id" in file_meta: - file_id = file_meta["id"] - file_ids.append(file_id) - logger.info(f"Saved document '{label}' with file ID: {file_id}") - else: - logger.warning(f"Failed to save document '{label}'") - - except Exception as e: - logger.error(f"Error saving document from agent results: {str(e)}") - # Continue with other documents instead of failing - continue - - return file_ids - - - ### Messages - - def message_add(self, workflow: Dict[str, Any], message: Dict[str, Any]) -> Dict[str, Any]: - """ - Adds a message to the workflow and updates last_activity. - Saves the message in the database and updates the workflow with references. - - Args: - workflow: Workflow object - message: Message to be saved - - Returns: - Added message - """ - current_time = datetime.now().isoformat() - - # Ensure messages list exists - if "messages" not in workflow: - workflow["messages"] = [] - - # Generate new message ID if not present - if "id" not in message: - message["id"] = f"msg_{str(uuid.uuid4())}" - - # Add workflow ID and timestamps - message["workflow_id"] = workflow["id"] - message["started_at"] = current_time - message["finished_at"] = current_time - - # Set sequence number - message["sequence_no"] = len(workflow["messages"]) + 1 - - # Ensure required fields are present - if "role" not in message: - # Set a default role based on agent_name - message["role"] = "assistant" if message.get("agent_name") else "user" - - if "agent_name" not in message: - message["agent_name"] = "" - - # Set status - message["status"] = "completed" - - # Add message to workflow - workflow["messages"].append(message) - - # Ensure message_ids list exists - if "message_ids" not in workflow: - workflow["message_ids"] = [] - - # Add message ID to the message_ids list - workflow["message_ids"].append(message["id"]) - - # Update workflow status - workflow["last_activity"] = current_time - - # Save to database - first the message itself - self.mydom.create_workflow_message(message) - - # Then save the workflow with updated references - workflow_update = { - "last_activity": current_time, - "message_ids": workflow["message_ids"] # Update the message_ids field - } - self.mydom.update_workflow(workflow["id"], workflow_update) - - return message - - async def message_summarize(self, message: Dict[str, Any]) -> str: - """ - Creates a summary of a message including its documents. - - Args: - message: Message to summarize - - Returns: - Summary of the message - """ - role = message.get("role", "undefined") - agent_name = message.get("agent_name", "") - content = message.get("content", "") - - try: - # Use the mydom for language-aware AI calls - content_summary = await self.mydom.call_ai([ - {"role": "system", "content": f"You are a chat message summarizer. Create a very concise summary (2-3 sentences, maximum 300 characters)"}, - {"role": "user", "content": content} - ]) - except Exception as e: - logger.error(f"Error creating summary: {str(e)}") - content_summary = content[:200] + "..." - - # Summarize documents - docs_summary = "" - if "documents" in message and message["documents"]: - docs_list = [] - for i, doc in enumerate(message["documents"]): - doc_name = self.get_filename(doc) - docs_list.append(doc_name) - if docs_list: - docs_summary = "\nDocuments:" + "\n- ".join(docs_list) - - return f"[{role} {agent_name}]: {content_summary}{docs_summary}" - - async def message_summarize_content(self, content: Dict[str, Any]) -> str: - """ - Generates a summary for a content item using AI. - - Args: - content: Content item to summarize (already processed by get_document_contents) - - Returns: - Brief summary of the content - """ - # Extract relevant information - data = content.get("data", "") - content_type = content.get("content_type", "text/plain") - is_text = content.get("metadata", {}).get("is_text", False) - - try: - # Use the mydom for language-aware AI calls - summary = await self.mydom.call_ai([ - {"role": "system", "content": "You are a content summarizer. Create very concise summary (1-2 sentences, maximum 200 characters) about this file."}, - {"role": "user", "content": f"Summarize this {content_type} content briefly:\n\n{data}"} - ]) - return summary - - except Exception as e: - logger.error(f"Error generating content summary: {str(e)}") - return f"Text content ({content_type})" - - - ### Documents - - async def process_file_ids(self, file_ids: List[int]) -> List[Dict[str, Any]]: - """ - Processes a list of File-IDs and returns the corresponding file objects as a list of Document objects. - Loads all contents directly and adds summaries to each content item. - - Args: - file_ids: List of file IDs - - Returns: - List of Document objects with contents and summaries - """ - documents = [] - logger.info(f"Processing {len(file_ids)} files") - - for file_id in file_ids: - try: - # Check if the file exists - file = self.mydom.get_file(file_id) - if not file: - logger.warning(f"File with ID {file_id} not found") - continue - - # Check if file belongs to the current mandate - if file.get("mandate_id") != self.mandate_id: - logger.warning(f"File {file_id} does not belong to mandate {self.mandate_id}") - continue - - # Load file content - file_content = self.mydom.get_file_data(file_id) - if file_content is None: - logger.warning(f"No content found for file with ID {file_id}") - continue - - # Create document - file_name_ext = file.get("name") - document = { - "id": f"doc_{str(uuid.uuid4())}", - "file_id": file_id, - "name": os.path.splitext(file_name_ext)[0] if os.path.splitext(file_name_ext)[0] else "noname", - "ext": os.path.splitext(file_name_ext)[1][1:] if os.path.splitext(file_name_ext)[1] else "bin", - "data": base64.b64encode(file_content).decode('utf-8'), # Add file data as base64 - "contents": [] - } - - # Extract contents - contents = get_document_contents(file, file_content) - - # Add summaries to each content item - for content in contents: - content["summary"] = await self.message_summarize_content(content) - - document["contents"] = contents - - logger.info(f"File {file.get('name', 'unnamed')} (ID: {file_id}) loaded with {len(contents)} contents and summaries") - documents.append(document) - - except Exception as e: - logger.error(f"Error processing file {file_id}: {str(e)}") - # Continue with remaining files instead of failing - continue - - return documents - - def available_documents_get(self, workflow: Dict[str, Any], message_user: Dict[str, Any]) -> List[Dict[str, Any]]: - """ - Determines all currently available documents from user input and already generated documents. - - Args: - message_user: Current message from the user - workflow: Current workflow object - - Returns: - List with information about all available documents, sorted by message sequence_nr in descending order - """ - available_docs = [] - - if "messages" in workflow and workflow["messages"]: - for message in workflow["messages"]: - message_id = message.get("id", "unknown") - sequence_nr = message.get("sequence_no", 0) - - # Determine source - source = "user" if message_id == message_user.get("id") else "workflow" - - # Process documents in this message - if "documents" in message and message["documents"]: - for doc in message["documents"]: - # Get filename using our helper method - filename = self.get_filename(doc) - file_id = doc.get("file_id") - - # Extract summaries from all contents - content_summaries = [] - for content in doc.get("contents", []): - content_summaries.append({ - "content_part": content.get("name","noname"), - "metadata": content.get("metadata",""), - "summary": content.get("summary","No summary"), - }) - - # Create document info - doc_info = { - "sequence_nr": sequence_nr, - "file_source": source, - "file_id": file_id, - "message_id": message_id, - "label": filename, - "content_summary_list": content_summaries, - } - available_docs.append(doc_info) - - # Sort by message sequence_nr in descending order (newest first) - available_docs.sort(key=lambda x: x["sequence_nr"], reverse=True) - - logger.info(f"Available documents: {len(available_docs)}") - return available_docs - - def save_document_to_file(self, document: Dict[str, Any]) -> Optional[int]: - """ - Saves a Document as a file in the database and returns the File-ID. - - Args: - document: Document object with contents - - Returns: - File-ID or None on error - """ - try: - if not document or "contents" not in document or not document["contents"]: - logger.warning("Document has no contents to save") - return None - - # Take the first content as main content - main_content = document["contents"][0] - name = main_content.get("name", "document") - content_type = main_content.get("content_type", "text/plain") - data = main_content.get("data", b"") - - # Ensure binary data - if isinstance(data, str): - data = data.encode('utf-8') - - # Save file in the database - file_meta = self.mydom.save_uploaded_file(data, name) - if file_meta and "id" in file_meta: - # Update the Document with the File-ID - document["file_id"] = file_meta["id"] - return file_meta["id"] - - return None - except Exception as e: - logger.error(f"Error saving document as file: {str(e)}") - return None - - def add_document_to_message(self, message: Dict[str, Any], document: Dict[str, Any]) -> Dict[str, Any]: - """ - Adds a Document to a message. - - Args: - message: Message to which the document should be added - document: Document to add - - Returns: - Updated message - """ - # Ensure the documents list exists - if "documents" not in message: - message["documents"] = [] - - # Add Document - message["documents"].append(document) - - return message - - - ### Tools - - def get_filename(self, document: Dict[str, Any]) -> str: - """ - Gets the filename from a document by combining name and extension. - - Args: - document: Document object - - Returns: - Filename with extension - """ - name = document.get("name", "unnamed") - ext = document.get("ext", "") - if ext: - return f"{name}.{ext}" - return name - - def log_add(self, workflow: Dict[str, Any], message: str, level: str = "info", - progress: Optional[int] = None) -> str: - """ - Adds a log entry to the workflow and also logs it in the logger. - Enhanced with standardized formatting and workflow status tracking. - - Args: - workflow: Workflow object - message: Log message - level: Log level (info, warning, error) - progress: Optional - Progress value (0-100) - - Returns: - ID of the created log entry - """ - # Ensure logs list exists - if "logs" not in workflow: - workflow["logs"] = [] - - # Generate log ID - log_id = f"log_{str(uuid.uuid4())}" - - # Get workflow status - workflow_status = workflow.get("status", "running") - - # Set agent_name from global settings - agent_name = GLOBAL_WorkflowLabels.get("system_name", "AI Assistant") - - # Create log entry - log_entry = { - "id": log_id, - "workflow_id": workflow["id"], - "message": message, - "type": level, - "timestamp": datetime.now().isoformat(), - "agent_name": agent_name, - "status": workflow_status - } - - # Add progress if provided - if progress is not None: - log_entry["progress"] = progress - - # Add log to workflow - workflow["logs"].append(log_entry) - - # Save in database - self.mydom.create_workflow_log(log_entry) - - # Also log in logger - if level == "info": - logger.info(f"Workflow {workflow['id']}: {message}") - elif level == "warning": - logger.warning(f"Workflow {workflow['id']}: {message}") - elif level == "error": - logger.error(f"Workflow {workflow['id']}: {message}") - - return log_id - - def parse_json2text(self, json_obj: Any) -> str: - """ - Converts a JSON object to a readable text representation. - - Args: - json_obj: JSON object to convert - - Returns: - Formatted text representation - """ - if not json_obj: - return "No data available" - - try: - # Format with indentation for better readability - return json.dumps(json_obj, indent=2, ensure_ascii=False) - except Exception as e: - logger.error(f"Error in JSON conversion: {str(e)}") - return str(json_obj) - - def parse_json_response(self, response_text: str) -> Dict[str, Any]: - """ - Parses the JSON response from a text. - - Args: - response_text: Text with JSON content - - Returns: - Parsed JSON data - """ - try: - # Extract JSON from the text (if mixed with other content) - json_start = response_text.find('{') - json_end = response_text.rfind('}') + 1 - - if json_start >= 0 and json_end > json_start: - json_str = response_text[json_start:json_end] - return json.loads(json_str) - else: - # Try to parse the entire text - return json.loads(response_text) - except json.JSONDecodeError as e: - logger.error(f"JSON parsing error: {str(e)}") - # Fallback: Return empty structure - return { - "obj_final_documents": [], - "obj_workplan": [], - "obj_user_response": "Sorry, I could not parse your data.", - "user_language": "en" - } - - -# Singleton factory for the ChatManager -_chat_managers = {} - -def get_chat_manager(mandate_id: int = 0, user_id: int = 0) -> ChatManager: - """ - Returns a ChatManager for the specified context. - Reuses existing instances. - - Args: - mandate_id: ID of the mandate - user_id: ID of the user - - Returns: - ChatManager instance - """ - context_key = f"{mandate_id}_{user_id}" - if context_key not in _chat_managers: - _chat_managers[context_key] = ChatManager(mandate_id, user_id) - return _chat_managers[context_key] \ No newline at end of file diff --git a/modules/chat_content_extraction.py b/modules/chat_content_extraction.py deleted file mode 100644 index 27d0829e..00000000 --- a/modules/chat_content_extraction.py +++ /dev/null @@ -1,778 +0,0 @@ -""" -Module for extracting content from various file formats. -Provides specialized functions for processing text, PDF, Office documents, images, etc. -""" - -import logging -import os -import io -from typing import Dict, Any, List, Optional, Union, Tuple -import base64 - -# Configure logger -logger = logging.getLogger(__name__) - -# Optional imports - only loaded when needed -pdf_extractor_loaded = False -office_extractor_loaded = False -image_processor_loaded = False - -def get_document_contents(file_metadata: Dict[str, Any], file_content: bytes) -> List[Dict[str, Any]]: - """ - Main function for extracting content from a file based on its MIME type. - Delegates to specialized extraction functions. - - Args: - file_metadata: File metadata (Name, MIME type, etc.) - file_content: Binary data of the file - - Returns: - List of Document-Content objects with metadata and is_text flag - """ - try: - mime_type = file_metadata.get("mime_type", "application/octet-stream") - file_name = file_metadata.get("name", "unknown") - - logger.info(f"Extracting content from file '{file_name}' (MIME type: {mime_type})") - - # Extract content based on MIME type - contents = [] - - # Text-based formats - if mime_type.startswith("text/") or mime_type in [ - "application/json", - "application/xml", - "application/javascript", - "application/x-python" - ]: - contents.extend(extract_text_content(file_name, file_content, mime_type)) - - # CSV Format - elif mime_type == "text/csv": - contents.extend(extract_csv_content(file_name, file_content)) - - # Images - elif mime_type.startswith("image/"): - contents.extend(extract_image_content(file_name, file_content, mime_type)) - - # PDF Documents - elif mime_type == "application/pdf": - contents.extend(extract_pdf_content(file_name, file_content)) - - # Word Documents - elif mime_type in [ - "application/vnd.openxmlformats-officedocument.wordprocessingml.document", - "application/msword" - ]: - contents.extend(extract_word_content(file_name, file_content, mime_type)) - - # Excel Documents - elif mime_type in [ - "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", - "application/vnd.ms-excel" - ]: - contents.extend(extract_excel_content(file_name, file_content, mime_type)) - - # PowerPoint Documents - elif mime_type in [ - "application/vnd.openxmlformats-officedocument.presentationml.presentation", - "application/vnd.ms-powerpoint" - ]: - contents.extend(extract_powerpoint_content(file_name, file_content, mime_type)) - - # Binary data as fallback for unknown formats - else: - contents.extend(extract_binary_content(file_name, file_content, mime_type)) - - # Fallback when no content could be extracted - if not contents: - logger.warning(f"No content extracted from file '{file_name}', using binary fallback") - contents.append({ - "sequence_nr": 1, - "name": '1_undefined', - "ext": os.path.splitext(file_name)[1][1:] if os.path.splitext(file_name)[1] else "bin", - "content_type": mime_type, - "data": file_content, - "metadata": { - "is_text": False - } - }) - - # Add generic attributes for all documents - for content in contents: - if isinstance(content.get("data"), bytes): - content["data"] = base64.b64encode(content["data"]).decode('utf-8') - # Add base64 flag - if "metadata" not in content: - content["metadata"] = {} - content["metadata"]["base64_encoded"] = True - - logger.info(f"Successfully extracted {len(contents)} content items from file '{file_name}'") - return contents - - except Exception as e: - logger.error(f"Error during content extraction: {str(e)}") - # Fallback on error - return original data - return [{ - "sequence_nr": 1, - "name": file_metadata.get("name", "unknown"), - "ext": os.path.splitext(file_metadata.get("name", ""))[1][1:] if os.path.splitext(file_metadata.get("name", ""))[1] else "bin", - "content_type": file_metadata.get("mime_type", "application/octet-stream"), - "data": file_content, - "metadata": { - "is_text": False - } - }] - - -def _load_pdf_extractor(): - """Loads PDF extraction libraries when needed""" - global pdf_extractor_loaded - if not pdf_extractor_loaded: - try: - global PyPDF2, fitz - import PyPDF2 - import fitz # PyMuPDF for more extensive PDF processing - pdf_extractor_loaded = True - logger.info("PDF extraction libraries successfully loaded") - except ImportError as e: - logger.warning(f"PDF extraction libraries could not be loaded: {e}") - -def _load_office_extractor(): - """Loads Office document extraction libraries when needed""" - global office_extractor_loaded - if not office_extractor_loaded: - try: - global docx, openpyxl - import docx # python-docx for Word documents - import openpyxl # for Excel files - office_extractor_loaded = True - logger.info("Office extraction libraries successfully loaded") - except ImportError as e: - logger.warning(f"Office extraction libraries could not be loaded: {e}") - -def _load_image_processor(): - """Loads image processing libraries when needed""" - global image_processor_loaded - if not image_processor_loaded: - try: - global PIL, Image - from PIL import Image - image_processor_loaded = True - logger.info("Image processing libraries successfully loaded") - except ImportError as e: - logger.warning(f"Image processing libraries could not be loaded: {e}") - -def extract_text_content(file_name: str, file_content: bytes, mime_type: str) -> List[Dict[str, Any]]: - """ - Extracts text from text files. - - Args: - file_name: Name of the file - file_content: Binary data of the file - mime_type: MIME type of the file - - Returns: - List of Text-Content objects with metadata.is_text = True - """ - try: - # Keep original file extension - file_extension = os.path.splitext(file_name)[1][1:] if os.path.splitext(file_name)[1] else "txt" - - # Extract text content - text_content = file_content.decode('utf-8') - return [{ - "sequence_nr": 1, - "name": "1_text", # Simplified naming - "ext": file_extension, - "content_type": "text", - "data": text_content, - "metadata": { - "is_text": True - } - }] - except UnicodeDecodeError: - logger.warning(f"Could not decode text from file '{file_name}' as UTF-8, trying alternative encodings") - try: - # Try alternative encodings - for encoding in ['latin-1', 'cp1252', 'iso-8859-1']: - try: - text_content = file_content.decode(encoding) - logger.info(f"Text successfully decoded with encoding {encoding}") - return [{ - "sequence_nr": 1, - "name": "1_text", # Simplified naming - "ext": file_extension, - "content_type": "text", - "data": text_content, - "metadata": { - "is_text": True, - "encoding": encoding - } - }] - except UnicodeDecodeError: - continue - - # Fallback to binary data if no encoding works - logger.warning(f"Could not decode text, using binary data") - return [{ - "sequence_nr": 1, - "name": "1_binary", # Simplified naming - "ext": file_extension, - "content_type": mime_type, - "data": file_content, - "metadata": { - "is_text": False - } - }] - except Exception as e: - logger.error(f"Error in alternative text decoding: {str(e)}") - # Return binary data as fallback - return [{ - "sequence_nr": 1, - "name": "1_binary", # Simplified naming - "ext": file_extension, - "content_type": mime_type, - "data": file_content, - "metadata": { - "is_text": False - } - }] - -def extract_csv_content(file_name: str, file_content: bytes) -> List[Dict[str, Any]]: - """ - Extracts content from CSV files. - - Args: - file_name: Name of the file - file_content: Binary data of the file - - Returns: - List of CSV-Content objects with metadata.is_text = True - """ - try: - # Extract text content - csv_content = file_content.decode('utf-8') - return [{ - "sequence_nr": 1, - "name": "1_csv", # Simplified naming - "ext": "csv", - "content_type": "csv", - "data": csv_content, - "metadata": { - "is_text": True, - "format": "csv" - } - }] - except UnicodeDecodeError: - logger.warning(f"Could not decode CSV from file '{file_name}' as UTF-8, trying alternative encodings") - try: - # Try alternative encodings for CSV - for encoding in ['latin-1', 'cp1252', 'iso-8859-1']: - try: - csv_content = file_content.decode(encoding) - logger.info(f"CSV successfully decoded with encoding {encoding}") - return [{ - "sequence_nr": 1, - "name": "1_csv", # Simplified naming - "ext": "csv", - "content_type": "csv", - "data": csv_content, - "metadata": { - "is_text": True, - "encoding": encoding, - "format": "csv" - } - }] - except UnicodeDecodeError: - continue - - # Fallback to binary data - return [{ - "sequence_nr": 1, - "name": "1_binary", # Simplified naming - "ext": "csv", - "content_type": "text/csv", - "data": file_content, - "metadata": { - "is_text": False - } - }] - except Exception as e: - logger.error(f"Error in alternative CSV decoding: {str(e)}") - return [{ - "sequence_nr": 1, - "name": "1_binary", # Simplified naming - "ext": "csv", - "content_type": "text/csv", - "data": file_content, - "metadata": { - "is_text": False - } - }] - -def extract_image_content(file_name: str, file_content: bytes, mime_type: str) -> List[Dict[str, Any]]: - """ - Extracts content from image files and optionally generates metadata descriptions. - - Args: - file_name: Name of the file - file_content: Binary data of the file - mime_type: MIME type of the file - - Returns: - List of Image-Content objects with metadata.is_text = False - """ - - # Extract file extension from MIME type or filename - file_extension = mime_type.split('/')[-1] - if file_extension == "jpeg": - file_extension = "jpg" - - # If possible, analyze image and extract metadata - image_metadata = { - "is_text": False, - "format": "image" - } - image_description = None - - try: - _load_image_processor() - if image_processor_loaded and file_content and len(file_content) > 0: - with io.BytesIO(file_content) as img_stream: - try: - img = Image.open(img_stream) - # Check if the image was actually loaded - img.verify() - # To safely continue working, reload - img_stream.seek(0) - img = Image.open(img_stream) - image_metadata.update({ - "format": img.format, - "mode": img.mode, - "width": img.width, - "height": img.height - }) - # Extract EXIF data if available - if hasattr(img, '_getexif') and callable(img._getexif): - exif = img._getexif() - if exif: - exif_data = {} - for tag_id, value in exif.items(): - exif_data[f"tag_{tag_id}"] = str(value) - image_metadata["exif"] = exif_data - - # Generate image description - image_description = f"Image ({img.width}x{img.height}, {img.format}, {img.mode})" - except Exception as inner_e: - logger.warning(f"Error processing image: {str(inner_e)}") - image_metadata["error"] = str(inner_e) - image_description = f"Image (unable to process: {str(inner_e)})" - except Exception as e: - logger.warning(f"Could not extract image metadata: {str(e)}") - image_metadata["error"] = str(e) - - - # Return image content - contents = [{ - "sequence_nr": 1, - "name": "1_image", # Simplified naming - "ext": file_extension, - "content_type": "image", - "data": file_content, - "metadata": image_metadata - }] - - # If image description available, add as additional text content - if image_description: - contents.append({ - "sequence_nr": 2, - "name": "2_text_image_info", # Simplified naming with label - "ext": "txt", - "content_type": "text", - "data": image_description, - "metadata": { - "is_text": True, - "image_description": True - } - }) - - return contents - -def extract_pdf_content(file_name: str, file_content: bytes) -> List[Dict[str, Any]]: - """ - Extracts text and images from PDF files. - - Args: - file_name: Name of the file - file_content: Binary data of the file - - Returns: - List of PDF-Content objects (text and images) with metadata.is_text flag - """ - contents = [] - extracted_content_found = False - - try: - # Load PDF extraction libraries - _load_pdf_extractor() - if not pdf_extractor_loaded: - logger.warning("PDF extraction not possible: Libraries not available") - # Add original file as binary content - contents.append({ - "sequence_nr": 1, - "name": "1_pdf", # Simplified naming - "ext": "pdf", - "content_type": "application/pdf", - "data": file_content, - "metadata": { - "is_text": False, - "format": "pdf" - } - }) - return contents - - # Extract text with PyPDF2 - extracted_text = "" - pdf_metadata = {} - with io.BytesIO(file_content) as pdf_stream: - pdf_reader = PyPDF2.PdfReader(pdf_stream) - - # Extract metadata - pdf_info = pdf_reader.metadata or {} - for key, value in pdf_info.items(): - if key.startswith('/'): - pdf_metadata[key[1:]] = value - else: - pdf_metadata[key] = value - - # Extract text from all pages - for page_num in range(len(pdf_reader.pages)): - page = pdf_reader.pages[page_num] - page_text = page.extract_text() - if page_text: - extracted_text += f"--- Page {page_num + 1} ---\n{page_text}\n\n" - - # If text was found, add as separate content - if extracted_text.strip(): - extracted_content_found = True - contents.append({ - "sequence_nr": len(contents) + 1, - "name": f"{len(contents) + 1}_text", # Simplified naming - "ext": "txt", - "content_type": "text", - "data": extracted_text, - "metadata": { - "is_text": True, - "source": "pdf", - "pages": len(pdf_reader.pages), - "pdf_metadata": pdf_metadata - } - }) - - # Extract images with PyMuPDF (fitz) - try: - with io.BytesIO(file_content) as pdf_stream: - doc = fitz.open(stream=pdf_stream, filetype="pdf") - image_count = 0 - - for page_num in range(len(doc)): - page = doc[page_num] - image_list = page.get_images(full=True) - - for img_index, img_info in enumerate(image_list): - try: - image_count += 1 - xref = img_info[0] - base_image = doc.extract_image(xref) - image_bytes = base_image["image"] - image_ext = base_image["ext"] - - # Add image as content - extracted_content_found = True - contents.append({ - "sequence_nr": len(contents) + 1, - "name": f"{len(contents) + 1}_image_page{page_num+1}_{img_index+1}", # Simplified naming with label - "ext": image_ext, - "content_type": f"image/{image_ext}", - "data": image_bytes, - "metadata": { - "is_text": False, - "source": "pdf", - "page": page_num + 1, - "index": img_index - } - }) - except Exception as img_e: - logger.warning(f"Error extracting image {img_index} on page {page_num + 1}: {str(img_e)}") - - # Close document - doc.close() - - except Exception as img_extract_e: - logger.warning(f"Error extracting images from PDF: {str(img_extract_e)}") - - except Exception as e: - logger.error(f"Error in PDF extraction: {str(e)}") - - # If no content was extracted, add the original PDF - if not extracted_content_found: - contents.append({ - "sequence_nr": 1, - "name": "1_pdf", # Simplified naming - "ext": "pdf", - "content_type": "application/pdf", - "data": file_content, - "metadata": { - "is_text": False, - "format": "pdf" - } - }) - - return contents - -def extract_word_content(file_name: str, file_content: bytes, mime_type: str) -> List[Dict[str, Any]]: - """ - Extracts text and images from Word documents. - - Args: - file_name: Name of the file - file_content: Binary data of the file - mime_type: MIME type of the file - - Returns: - List of Word-Content objects (text and possibly images) with metadata.is_text flag - """ - contents = [] - extracted_content_found = False - - # Determine file extension - file_extension = "docx" if mime_type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document" else "doc" - - try: - # Load Office extraction libraries - _load_office_extractor() - if not office_extractor_loaded: - logger.warning("Word extraction not possible: Libraries not available") - # Add original file as binary content - contents.append({ - "sequence_nr": 1, - "name": "1_word", # Simplified naming - "ext": file_extension, - "content_type": mime_type, - "data": file_content, - "metadata": { - "is_text": False, - "format": "word" - } - }) - return contents - - # Only supports DOCX (newer format) - if mime_type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document": - with io.BytesIO(file_content) as docx_stream: - doc = docx.Document(docx_stream) - - # Extract text - full_text = [] - for para in doc.paragraphs: - full_text.append(para.text) - - # Extract tables - for table in doc.tables: - for row in table.rows: - row_text = [] - for cell in row.cells: - row_text.append(cell.text) - full_text.append(" | ".join(row_text)) - - extracted_text = "\n\n".join(full_text) - - # Add extracted text as content - if extracted_text.strip(): - extracted_content_found = True - contents.append({ - "sequence_nr": 1, - "name": "1_text", # Simplified naming - "ext": "txt", - "content_type": "text", - "data": extracted_text, - "metadata": { - "is_text": True, - "source": "docx", - "paragraph_count": len(doc.paragraphs), - "table_count": len(doc.tables) - } - }) - else: - logger.warning(f"Extraction from old Word format (DOC) not supported") - - except Exception as e: - logger.error(f"Error in Word extraction: {str(e)}") - - # If no content was extracted, add the original document - if not extracted_content_found: - contents.append({ - "sequence_nr": 1, - "name": "1_word", # Simplified naming - "ext": file_extension, - "content_type": mime_type, - "data": file_content, - "metadata": { - "is_text": False, - "format": "word" - } - }) - - return contents - -def extract_excel_content(file_name: str, file_content: bytes, mime_type: str) -> List[Dict[str, Any]]: - """ - Extracts table data from Excel files. - - Args: - file_name: Name of the file - file_content: Binary data of the file - mime_type: MIME type of the file - - Returns: - List of Excel-Content objects with metadata.is_text flag - """ - contents = [] - extracted_content_found = False - - # Determine file extension - file_extension = "xlsx" if mime_type == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" else "xls" - - try: - # Load Office extraction libraries - _load_office_extractor() - if not office_extractor_loaded: - logger.warning("Excel extraction not possible: Libraries not available") - # Add original file as binary content - contents.append({ - "sequence_nr": 1, - "name": "1_excel", # Simplified naming - "ext": file_extension, - "content_type": mime_type, - "data": file_content, - "metadata": { - "is_text": False, - "format": "excel" - } - }) - return contents - - # Only supports XLSX (newer format) - if mime_type == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": - with io.BytesIO(file_content) as xlsx_stream: - workbook = openpyxl.load_workbook(xlsx_stream, data_only=True) - - # Extract each worksheet as separate CSV content - for sheet_index, sheet_name in enumerate(workbook.sheetnames): - sheet = workbook[sheet_name] - - # Format data as CSV - csv_rows = [] - for row in sheet.iter_rows(): - csv_row = [] - for cell in row: - value = cell.value - if value is None: - csv_row.append("") - else: - csv_row.append(str(value).replace('"', '""')) - csv_rows.append(','.join(f'"{cell}"' for cell in csv_row)) - - csv_content = "\n".join(csv_rows) - - # Add as CSV content - if csv_content.strip(): - extracted_content_found = True - sheet_safe_name = sheet_name.replace(" ", "_").replace("/", "_").replace("\\", "_") - contents.append({ - "sequence_nr": len(contents) + 1, - "name": f"{len(contents) + 1}_csv_{sheet_safe_name}", # Simplified naming with sheet label - "ext": "csv", - "content_type": "csv", - "data": csv_content, - "metadata": { - "is_text": True, - "source": "xlsx", - "sheet": sheet_name, - "format": "csv" - } - }) - else: - logger.warning(f"Extraction from old Excel format (XLS) not supported") - - except Exception as e: - logger.error(f"Error in Excel extraction: {str(e)}") - - # If no content was extracted, add the original document - if not extracted_content_found: - contents.append({ - "sequence_nr": 1, - "name": "1_excel", # Simplified naming - "ext": file_extension, - "content_type": mime_type, - "data": file_content, - "metadata": { - "is_text": False, - "format": "excel" - } - }) - - return contents - -def extract_powerpoint_content(file_name: str, file_content: bytes, mime_type: str) -> List[Dict[str, Any]]: - """ - Extracts content from PowerPoint presentations. - - Args: - file_name: Name of the file - file_content: Binary data of the file - mime_type: MIME type of the file - - Returns: - List of PowerPoint-Content objects with metadata.is_text = False - """ - # For PowerPoint, we currently only return the original binary file - # A complete extraction would require more specialized libraries - file_extension = "pptx" if mime_type == "application/vnd.openxmlformats-officedocument.presentationml.presentation" else "ppt" - return [{ - "sequence_nr": 1, - "name": "1_powerpoint", # Simplified naming - "ext": file_extension, - "content_type": mime_type, - "data": file_content, - "metadata": { - "is_text": False, - "format": "powerpoint" - } - }] - -def extract_binary_content(file_name: str, file_content: bytes, mime_type: str) -> List[Dict[str, Any]]: - """ - Fallback for binary files where no specific extraction is possible. - - Args: - file_name: Name of the file - file_content: Binary data of the file - mime_type: MIME type of the file - - Returns: - List with a binary Content object with metadata.is_text = False - """ - file_extension = os.path.splitext(file_name)[1][1:] if os.path.splitext(file_name)[1] else "bin" - return [{ - "sequence_nr": 1, - "name": "1_binary", # Simplified naming - "ext": file_extension, - "content_type": mime_type, - "data": file_content, - "metadata": { - "is_text": False, - "format": "binary" - } - }] \ No newline at end of file diff --git a/modules/configuration.py b/modules/configuration.py index 7021ddd3..f7e9b81f 100644 --- a/modules/configuration.py +++ b/modules/configuration.py @@ -20,40 +20,40 @@ class Configuration: def __init__(self): """Initialize the configuration object""" self._data = {} - self._config_file_path = None - self._env_file_path = None - self._config_mtime = 0 - self._env_mtime = 0 + self._configFilePath = None + self._envFilePath = None + self._configMtime = 0 + self._envMtime = 0 self.refresh() def refresh(self): """Reload configuration from files""" - self._load_config() - self._load_env() + self._loadConfig() + self._loadEnv() logger.info("Configuration refreshed") - def _load_config(self): + def _loadConfig(self): """Load configuration from config.ini file in flattened format""" # Find config.ini file (look in current directory and parent directory) - config_path = Path('config.ini') - if not config_path.exists(): + configPath = Path('config.ini') + if not configPath.exists(): # Try in parent directory - config_path = Path('../config.ini') - if not config_path.exists(): - logger.warning(f"Configuration file not found at {config_path.absolute()}") + configPath = Path('../config.ini') + if not configPath.exists(): + logger.warning(f"Configuration file not found at {configPath.absolute()}") return - self._config_file_path = config_path - current_mtime = os.path.getmtime(config_path) + self._configFilePath = configPath + currentMtime = os.path.getmtime(configPath) # Skip if file hasn't changed - if current_mtime <= self._config_mtime: + if currentMtime <= self._configMtime: return - self._config_mtime = current_mtime + self._configMtime = currentMtime try: - with open(config_path, 'r') as f: + with open(configPath, 'r') as f: for line in f: line = line.strip() # Skip empty lines and comments @@ -73,28 +73,28 @@ class Configuration: except Exception as e: logger.error(f"Error loading configuration: {e}") - def _load_env(self): + def _loadEnv(self): """Load environment variables from .env file""" # Find .env file (look in current directory and parent directory) - env_path = Path('.env') - if not env_path.exists(): + envPath = Path('.env') + if not envPath.exists(): # Try in parent directory - env_path = Path('../.env') - if not env_path.exists(): - logger.warning(f"Environment file not found at {env_path.absolute()}") + envPath = Path('../.env') + if not envPath.exists(): + logger.warning(f"Environment file not found at {envPath.absolute()}") return - self._env_file_path = env_path - current_mtime = os.path.getmtime(env_path) + self._envFilePath = envPath + currentMtime = os.path.getmtime(envPath) # Skip if file hasn't changed - if current_mtime <= self._env_mtime: + if currentMtime <= self._envMtime: return - self._env_mtime = current_mtime + self._envMtime = currentMtime try: - with open(env_path, 'r') as f: + with open(envPath, 'r') as f: for line in f: line = line.strip() # Skip empty lines and comments @@ -110,7 +110,7 @@ class Configuration: # Add directly to data dictionary self._data[key] = value - logger.info(f"Loaded environment variables from {env_path.absolute()}") + logger.info(f"Loaded environment variables from {envPath.absolute()}") # Also load system environment variables (don't override existing) for key, value in os.environ.items(): @@ -120,35 +120,35 @@ class Configuration: except Exception as e: logger.error(f"Error loading environment variables: {e}") - def check_for_updates(self): + def checkForUpdates(self): """Check if configuration files have changed and reload if necessary""" - if self._config_file_path and os.path.exists(self._config_file_path): - current_mtime = os.path.getmtime(self._config_file_path) - if current_mtime > self._config_mtime: + if self._configFilePath and os.path.exists(self._configFilePath): + currentMtime = os.path.getmtime(self._configFilePath) + if currentMtime > self._configMtime: logger.info("Config file has changed, reloading...") - self._load_config() + self._loadConfig() - if self._env_file_path and os.path.exists(self._env_file_path): - current_mtime = os.path.getmtime(self._env_file_path) - if current_mtime > self._env_mtime: + if self._envFilePath and os.path.exists(self._envFilePath): + currentMtime = os.path.getmtime(self._envFilePath) + if currentMtime > self._envMtime: logger.info("Environment file has changed, reloading...") - self._load_env() + self._loadEnv() def get(self, key: str, default: Any = None) -> Any: """Get configuration value with optional default""" - self.check_for_updates() # Check for file changes + self.checkForUpdates() # Check for file changes if key in self._data: value = self._data[key] # Handle secrets (keys ending with _SECRET) if key.endswith("_SECRET"): - return handle_secret(value) + return handleSecret(value) return value return default def __getattr__(self, name: str) -> Any: """Enable attribute-style access to configuration""" - self.check_for_updates() # Check for file changes + self.checkForUpdates() # Check for file changes value = self.get(name) if value is None: @@ -157,14 +157,14 @@ class Configuration: def __dir__(self) -> list: """Support auto-completion of attributes""" - self.check_for_updates() # Check for file changes + self.checkForUpdates() # Check for file changes return list(self._data.keys()) + super().__dir__() def set(self, key: str, value: Any) -> None: """Set a configuration value (for testing/overrides)""" self._data[key] = value -def handle_secret(value: str) -> str: +def handleSecret(value: str) -> str: """ Handle secret values. Currently just returns the plain text value, but can be enhanced to provide actual decryption in the future. diff --git a/modules/def_attributes.py b/modules/defAttributes.py similarity index 64% rename from modules/def_attributes.py rename to modules/defAttributes.py index 6a60019c..731ecfd9 100644 --- a/modules/def_attributes.py +++ b/modules/defAttributes.py @@ -8,16 +8,16 @@ class AttributeDefinition(BaseModel): type: str required: bool = False placeholder: Optional[str] = None - default_value: Optional[Any] = None + defaultValue: Optional[Any] = None options: Optional[List[Dict[str, Any]]] = None editable: bool = True visible: bool = True order: int = 0 validation: Optional[Dict[str, Any]] = None - help_text: Optional[str] = None + helpText: Optional[str] = None # Helper classes for type mapping -type_mappings = { +typeMappings = { "int": "number", "str": "string", "float": "number", @@ -31,59 +31,59 @@ type_mappings = { } # Special field types based on naming conventions -special_field_types = { +specialFieldTypes = { "content": "textarea", "description": "textarea", "instructions": "textarea", "password": "password", "email": "email", - "workspace_id": "select", - "agent_id": "select", + "workspaceId": "select", + "agentId": "select", "type": "select" } # Function to convert a Pydantic model into attribute definitions -def get_model_attributes(model_class, user_language="de"): +def getModelAttributes(modelClass, userLanguage="de"): """ Converts a Pydantic model into a list of AttributeDefinition objects """ attributes = [] # Go through all fields in the model - for i, (field_name, field) in enumerate(model_class.__fields__.items()): + for i, (fieldName, field) in enumerate(modelClass.__fields__.items()): # Skip internal fields - if field_name.startswith('_') or field_name in ["label", "field_labels"]: + if fieldName.startswith('_') or fieldName in ["label", "fieldLabels"]: continue # Determine the field type - field_type = type_mappings.get(str(field.type_), "string") + fieldType = typeMappings.get(str(field.type_), "string") # Check for special field types - if field_name in special_field_types: - field_type = special_field_types[field_name] + if fieldName in specialFieldTypes: + fieldType = specialFieldTypes[fieldName] # Get the label (if available) - field_label = field_name.replace('_', ' ').capitalize() - if hasattr(model_class, 'field_labels') and field_name in model_class.field_labels: - label_obj = model_class.field_labels[field_name] - field_label = label_obj.get_label(user_language) + fieldLabel = fieldName.replace('_', ' ').capitalize() + if hasattr(modelClass, 'fieldLabels') and fieldName in modelClass.fieldLabels: + labelObj = modelClass.fieldLabels[fieldName] + fieldLabel = labelObj.getLabel(userLanguage) # Determine default values and required status required = field.required - default_value = field.default if not field.required else None + defaultValue = field.default if not field.required else None # Check for validation rules validation = None if field.validators: - validation = {"has_validators": True} + validation = {"hasValidators": True} # Placeholder text - placeholder = f"Please enter {field_label}" + placeholder = f"Please enter {fieldLabel}" # Special options for Select fields options = None - if field_type == "select": - if field_name == "type" and model_class.__name__ == "Agent": + if fieldType == "select": + if fieldName == "type" and modelClass.__name__ == "Agent": options = [ {"value": "Analysis", "label": "Analysis"}, {"value": "Transformation", "label": "Transformation"}, @@ -103,21 +103,21 @@ def get_model_attributes(model_class, user_language="de"): description = field.schema.description # Create attribute definition - attr_def = AttributeDefinition( - name=field_name, - label=field_label, - type=field_type, + attrDef = AttributeDefinition( + name=fieldName, + label=fieldLabel, + type=fieldType, required=required, placeholder=placeholder, - default_value=default_value, + defaultValue=defaultValue, options=options, - editable=field_name not in ["id", "mandate_id", "user_id", "created_at", "upload_date"], - visible=field_name not in ["hashed_password", "mandate_id", "user_id"], + editable=fieldName not in ["id", "mandateId", "userId", "createdAt", "uploadDate"], + visible=fieldName not in ["hashedPassword", "mandateId", "userId"], order=i, validation=validation, - help_text=description or "" # Set empty string as default value if no description found + helpText=description or "" # Set empty string as default value if no description found ) - attributes.append(attr_def) + attributes.append(attrDef) return attributes \ No newline at end of file diff --git a/modules/documentProcessor.py b/modules/documentProcessor.py new file mode 100644 index 00000000..de81a64c --- /dev/null +++ b/modules/documentProcessor.py @@ -0,0 +1,887 @@ +""" +Module for extracting content from various file formats. +Provides specialized functions for processing text, PDF, Office documents, images, etc. +""" + +import logging +import os +import io +from typing import Dict, Any, List, Optional, Union, Tuple +import base64 + +# Configure logger +logger = logging.getLogger(__name__) + +# Optional imports - only loaded when needed +pdfExtractorLoaded = False +officeExtractorLoaded = False +imageProcessorLoaded = False + +def getDocumentContents(fileMetadata: Dict[str, Any], fileContent: bytes) -> List[Dict[str, Any]]: + """ + Main function for extracting content from a file based on its MIME type. + Delegates to specialized extraction functions. + + Args: + fileMetadata: File metadata (Name, MIME type, etc.) + fileContent: Binary data of the file + + Returns: + List of Document-Content objects with metadata and isText flag + """ + try: + mimeType = fileMetadata.get("mimeType", "application/octet-stream") + fileName = fileMetadata.get("name", "unknown") + + logger.info(f"Extracting content from file '{fileName}' (MIME type: {mimeType})") + + # Extract content based on MIME type + contents = [] + + # Text-based formats + if mimeType.startswith("text/") or mimeType in [ + "application/json", + "application/xml", + "application/javascript", + "application/x-python" + ]: + contents.extend(extractTextContent(fileName, fileContent, mimeType)) + + # CSV Format + elif mimeType == "text/csv": + contents.extend(extractCsvContent(fileName, fileContent)) + + # SVG Files + elif mimeType == "image/svg+xml": + contents.extend(extractSvgContent(fileName, fileContent)) + + # Images + elif mimeType.startswith("image/"): + contents.extend(extractImageContent(fileName, fileContent, mimeType)) + + # PDF Documents + elif mimeType == "application/pdf": + contents.extend(extractPdfContent(fileName, fileContent)) + + # Word Documents + elif mimeType in [ + "application/vnd.openxmlformats-officedocument.wordprocessingml.document", + "application/msword" + ]: + contents.extend(extractWordContent(fileName, fileContent, mimeType)) + + # Excel Documents + elif mimeType in [ + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", + "application/vnd.ms-excel" + ]: + contents.extend(extractExcelContent(fileName, fileContent, mimeType)) + + # PowerPoint Documents + elif mimeType in [ + "application/vnd.openxmlformats-officedocument.presentationml.presentation", + "application/vnd.ms-powerpoint" + ]: + contents.extend(extractPowerpointContent(fileName, fileContent, mimeType)) + + # Binary data as fallback for unknown formats + else: + contents.extend(extractBinaryContent(fileName, fileContent, mimeType)) + + # Fallback when no content could be extracted + if not contents: + logger.warning(f"No content extracted from file '{fileName}', using binary fallback") + contents.append({ + "sequenceNr": 1, + "name": '1_undefined', + "ext": os.path.splitext(fileName)[1][1:] if os.path.splitext(fileName)[1] else "bin", + "contentType": mimeType, + "data": fileContent, + "metadata": { + "isText": False + } + }) + + # Add generic attributes for all documents + for content in contents: + if isinstance(content.get("data"), bytes): + content["data"] = base64.b64encode(content["data"]).decode('utf-8') + # Add base64 flag + if "metadata" not in content: + content["metadata"] = {} + content["metadata"]["base64Encoded"] = True + + logger.info(f"Successfully extracted {len(contents)} content items from file '{fileName}'") + return contents + + except Exception as e: + logger.error(f"Error during content extraction: {str(e)}") + # Fallback on error - return original data + return [{ + "sequenceNr": 1, + "name": fileMetadata.get("name", "unknown"), + "ext": os.path.splitext(fileMetadata.get("name", ""))[1][1:] if os.path.splitext(fileMetadata.get("name", ""))[1] else "bin", + "contentType": fileMetadata.get("mimeType", "application/octet-stream"), + "data": fileContent, + "metadata": { + "isText": False + } + }] + + +def _loadPdfExtractor(): + """Loads PDF extraction libraries when needed""" + global pdfExtractorLoaded + if not pdfExtractorLoaded: + try: + global PyPDF2, fitz + import PyPDF2 + import fitz # PyMuPDF for more extensive PDF processing + pdfExtractorLoaded = True + logger.info("PDF extraction libraries successfully loaded") + except ImportError as e: + logger.warning(f"PDF extraction libraries could not be loaded: {e}") + +def _loadOfficeExtractor(): + """Loads Office document extraction libraries when needed""" + global officeExtractorLoaded + if not officeExtractorLoaded: + try: + global docx, openpyxl + import docx # python-docx for Word documents + import openpyxl # for Excel files + officeExtractorLoaded = True + logger.info("Office extraction libraries successfully loaded") + except ImportError as e: + logger.warning(f"Office extraction libraries could not be loaded: {e}") + +def _loadImageProcessor(): + """Loads image processing libraries when needed""" + global imageProcessorLoaded + if not imageProcessorLoaded: + try: + global PIL, Image + from PIL import Image + imageProcessorLoaded = True + logger.info("Image processing libraries successfully loaded") + except ImportError as e: + logger.warning(f"Image processing libraries could not be loaded: {e}") + +def extractTextContent(fileName: str, fileContent: bytes, mimeType: str) -> List[Dict[str, Any]]: + """ + Extracts text from text files. + + Args: + fileName: Name of the file + fileContent: Binary data of the file + mimeType: MIME type of the file + + Returns: + List of Text-Content objects with metadata.isText = True + """ + try: + # Keep original file extension + fileExtension = os.path.splitext(fileName)[1][1:] if os.path.splitext(fileName)[1] else "txt" + + # Extract text content + textContent = fileContent.decode('utf-8') + return [{ + "sequenceNr": 1, + "name": "1_text", # Simplified naming + "ext": fileExtension, + "contentType": "text", + "data": textContent, + "metadata": { + "isText": True + } + }] + except UnicodeDecodeError: + logger.warning(f"Could not decode text from file '{fileName}' as UTF-8, trying alternative encodings") + try: + # Try alternative encodings + for encoding in ['latin-1', 'cp1252', 'iso-8859-1']: + try: + textContent = fileContent.decode(encoding) + logger.info(f"Text successfully decoded with encoding {encoding}") + return [{ + "sequenceNr": 1, + "name": "1_text", # Simplified naming + "ext": fileExtension, + "contentType": "text", + "data": textContent, + "metadata": { + "isText": True, + "encoding": encoding + } + }] + except UnicodeDecodeError: + continue + + # Fallback to binary data if no encoding works + logger.warning(f"Could not decode text, using binary data") + return [{ + "sequenceNr": 1, + "name": "1_binary", # Simplified naming + "ext": fileExtension, + "contentType": mimeType, + "data": fileContent, + "metadata": { + "isText": False + } + }] + except Exception as e: + logger.error(f"Error in alternative text decoding: {str(e)}") + # Return binary data as fallback + return [{ + "sequenceNr": 1, + "name": "1_binary", # Simplified naming + "ext": fileExtension, + "contentType": mimeType, + "data": fileContent, + "metadata": { + "isText": False + } + }] + +def extractCsvContent(fileName: str, fileContent: bytes) -> List[Dict[str, Any]]: + """ + Extracts content from CSV files. + + Args: + fileName: Name of the file + fileContent: Binary data of the file + + Returns: + List of CSV-Content objects with metadata.isText = True + """ + try: + # Extract text content + csvContent = fileContent.decode('utf-8') + return [{ + "sequenceNr": 1, + "name": "1_csv", # Simplified naming + "ext": "csv", + "contentType": "csv", + "data": csvContent, + "metadata": { + "isText": True, + "format": "csv" + } + }] + except UnicodeDecodeError: + logger.warning(f"Could not decode CSV from file '{fileName}' as UTF-8, trying alternative encodings") + try: + # Try alternative encodings for CSV + for encoding in ['latin-1', 'cp1252', 'iso-8859-1']: + try: + csvContent = fileContent.decode(encoding) + logger.info(f"CSV successfully decoded with encoding {encoding}") + return [{ + "sequenceNr": 1, + "name": "1_csv", # Simplified naming + "ext": "csv", + "contentType": "csv", + "data": csvContent, + "metadata": { + "isText": True, + "encoding": encoding, + "format": "csv" + } + }] + except UnicodeDecodeError: + continue + + # Fallback to binary data + return [{ + "sequenceNr": 1, + "name": "1_binary", # Simplified naming + "ext": "csv", + "contentType": "text/csv", + "data": fileContent, + "metadata": { + "isText": False + } + }] + except Exception as e: + logger.error(f"Error in alternative CSV decoding: {str(e)}") + return [{ + "sequenceNr": 1, + "name": "1_binary", # Simplified naming + "ext": "csv", + "contentType": "text/csv", + "data": fileContent, + "metadata": { + "isText": False + } + }] + +def extractSvgContent(fileName: str, fileContent: bytes) -> List[Dict[str, Any]]: + """ + Extracts content from SVG files. + + Args: + fileName: Name of the file + fileContent: Binary data of the file + + Returns: + List of SVG-Content objects with dual text/image metadata + """ + contents = [] + + try: + # Extract SVG as text content (XML) + svgText = fileContent.decode('utf-8') + + # Check if it's actually SVG by looking for the SVG tag + if " List[Dict[str, Any]]: + """ + Extracts content from image files and optionally generates metadata descriptions. + + Args: + fileName: Name of the file + fileContent: Binary data of the file + mimeType: MIME type of the file + + Returns: + List of Image-Content objects with metadata.isText = False + """ + + # Extract file extension from MIME type or filename + fileExtension = mimeType.split('/')[-1] + if fileExtension == "jpeg": + fileExtension = "jpg" + + # If possible, analyze image and extract metadata + imageMetadata = { + "isText": False, + "format": "image" + } + imageDescription = None + + try: + _loadImageProcessor() + if imageProcessorLoaded and fileContent and len(fileContent) > 0: + with io.BytesIO(fileContent) as imgStream: + try: + img = Image.open(imgStream) + # Check if the image was actually loaded + img.verify() + # To safely continue working, reload + imgStream.seek(0) + img = Image.open(imgStream) + imageMetadata.update({ + "format": img.format, + "mode": img.mode, + "width": img.width, + "height": img.height + }) + # Extract EXIF data if available + if hasattr(img, '_getexif') and callable(img._getexif): + exif = img._getexif() + if exif: + exifData = {} + for tagId, value in exif.items(): + exifData[f"tag_{tagId}"] = str(value) + imageMetadata["exif"] = exifData + + # Generate image description + imageDescription = f"Image ({img.width}x{img.height}, {img.format}, {img.mode})" + except Exception as innerE: + logger.warning(f"Error processing image: {str(innerE)}") + imageMetadata["error"] = str(innerE) + imageDescription = f"Image (unable to process: {str(innerE)})" + except Exception as e: + logger.warning(f"Could not extract image metadata: {str(e)}") + imageMetadata["error"] = str(e) + + + # Return image content + contents = [{ + "sequenceNr": 1, + "name": "1_image", # Simplified naming + "ext": fileExtension, + "contentType": "image", + "data": fileContent, + "metadata": imageMetadata + }] + + # If image description available, add as additional text content + if imageDescription: + contents.append({ + "sequenceNr": 2, + "name": "2_text_image_info", # Simplified naming with label + "ext": "txt", + "contentType": "text", + "data": imageDescription, + "metadata": { + "isText": True, + "imageDescription": True + } + }) + + return contents + +def extractPdfContent(fileName: str, fileContent: bytes) -> List[Dict[str, Any]]: + """ + Extracts text and images from PDF files. + + Args: + fileName: Name of the file + fileContent: Binary data of the file + + Returns: + List of PDF-Content objects (text and images) with metadata.isText flag + """ + contents = [] + extractedContentFound = False + + try: + # Load PDF extraction libraries + _loadPdfExtractor() + if not pdfExtractorLoaded: + logger.warning("PDF extraction not possible: Libraries not available") + # Add original file as binary content + contents.append({ + "sequenceNr": 1, + "name": "1_pdf", # Simplified naming + "ext": "pdf", + "contentType": "application/pdf", + "data": fileContent, + "metadata": { + "isText": False, + "format": "pdf" + } + }) + return contents + + # Extract text with PyPDF2 + extractedText = "" + pdfMetadata = {} + with io.BytesIO(fileContent) as pdfStream: + pdfReader = PyPDF2.PdfReader(pdfStream) + + # Extract metadata + pdfInfo = pdfReader.metadata or {} + for key, value in pdfInfo.items(): + if key.startswith('/'): + pdfMetadata[key[1:]] = value + else: + pdfMetadata[key] = value + + # Extract text from all pages + for pageNum in range(len(pdfReader.pages)): + page = pdfReader.pages[pageNum] + pageText = page.extract_text() + if pageText: + extractedText += f"--- Page {pageNum + 1} ---\n{pageText}\n\n" + + # If text was found, add as separate content + if extractedText.strip(): + extractedContentFound = True + contents.append({ + "sequenceNr": len(contents) + 1, + "name": f"{len(contents) + 1}_text", # Simplified naming + "ext": "txt", + "contentType": "text", + "data": extractedText, + "metadata": { + "isText": True, + "source": "pdf", + "pages": len(pdfReader.pages), + "pdfMetadata": pdfMetadata + } + }) + + # Extract images with PyMuPDF (fitz) + try: + with io.BytesIO(fileContent) as pdfStream: + doc = fitz.open(stream=pdfStream, filetype="pdf") + imageCount = 0 + + for pageNum in range(len(doc)): + page = doc[pageNum] + imageList = page.get_images(full=True) + + for imgIndex, imgInfo in enumerate(imageList): + try: + imageCount += 1 + xref = imgInfo[0] + baseImage = doc.extract_image(xref) + imageBytes = baseImage["image"] + imageExt = baseImage["ext"] + + # Add image as content + extractedContentFound = True + contents.append({ + "sequenceNr": len(contents) + 1, + "name": f"{len(contents) + 1}_image_page{pageNum+1}_{imgIndex+1}", # Simplified naming with label + "ext": imageExt, + "contentType": f"image/{imageExt}", + "data": imageBytes, + "metadata": { + "isText": False, + "source": "pdf", + "page": pageNum + 1, + "index": imgIndex + } + }) + except Exception as imgE: + logger.warning(f"Error extracting image {imgIndex} on page {pageNum + 1}: {str(imgE)}") + + # Close document + doc.close() + + except Exception as imgExtractE: + logger.warning(f"Error extracting images from PDF: {str(imgExtractE)}") + + except Exception as e: + logger.error(f"Error in PDF extraction: {str(e)}") + + # If no content was extracted, add the original PDF + if not extractedContentFound: + contents.append({ + "sequenceNr": 1, + "name": "1_pdf", # Simplified naming + "ext": "pdf", + "contentType": "application/pdf", + "data": fileContent, + "metadata": { + "isText": False, + "format": "pdf" + } + }) + + return contents + +def extractWordContent(fileName: str, fileContent: bytes, mimeType: str) -> List[Dict[str, Any]]: + """ + Extracts text and images from Word documents. + + Args: + fileName: Name of the file + fileContent: Binary data of the file + mimeType: MIME type of the file + + Returns: + List of Word-Content objects (text and possibly images) with metadata.isText flag + """ + contents = [] + extractedContentFound = False + + # Determine file extension + fileExtension = "docx" if mimeType == "application/vnd.openxmlformats-officedocument.wordprocessingml.document" else "doc" + + try: + # Load Office extraction libraries + _loadOfficeExtractor() + if not officeExtractorLoaded: + logger.warning("Word extraction not possible: Libraries not available") + # Add original file as binary content + contents.append({ + "sequenceNr": 1, + "name": "1_word", # Simplified naming + "ext": fileExtension, + "contentType": mimeType, + "data": fileContent, + "metadata": { + "isText": False, + "format": "word" + } + }) + return contents + + # Only supports DOCX (newer format) + if mimeType == "application/vnd.openxmlformats-officedocument.wordprocessingml.document": + with io.BytesIO(fileContent) as docxStream: + doc = docx.Document(docxStream) + + # Extract text + fullText = [] + for para in doc.paragraphs: + fullText.append(para.text) + + # Extract tables + for table in doc.tables: + for row in table.rows: + rowText = [] + for cell in row.cells: + rowText.append(cell.text) + fullText.append(" | ".join(rowText)) + + extractedText = "\n\n".join(fullText) + + # Add extracted text as content + if extractedText.strip(): + extractedContentFound = True + contents.append({ + "sequenceNr": 1, + "name": "1_text", # Simplified naming + "ext": "txt", + "contentType": "text", + "data": extractedText, + "metadata": { + "isText": True, + "source": "docx", + "paragraphCount": len(doc.paragraphs), + "tableCount": len(doc.tables) + } + }) + else: + logger.warning(f"Extraction from old Word format (DOC) not supported") + + except Exception as e: + logger.error(f"Error in Word extraction: {str(e)}") + + # If no content was extracted, add the original document + if not extractedContentFound: + contents.append({ + "sequenceNr": 1, + "name": "1_word", # Simplified naming + "ext": fileExtension, + "contentType": mimeType, + "data": fileContent, + "metadata": { + "isText": False, + "format": "word" + } + }) + + return contents + +def extractExcelContent(fileName: str, fileContent: bytes, mimeType: str) -> List[Dict[str, Any]]: + """ + Extracts table data from Excel files. + + Args: + fileName: Name of the file + fileContent: Binary data of the file + mimeType: MIME type of the file + + Returns: + List of Excel-Content objects with metadata.isText flag + """ + contents = [] + extractedContentFound = False + + # Determine file extension + fileExtension = "xlsx" if mimeType == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" else "xls" + + try: + # Load Office extraction libraries + _loadOfficeExtractor() + if not officeExtractorLoaded: + logger.warning("Excel extraction not possible: Libraries not available") + # Add original file as binary content + contents.append({ + "sequenceNr": 1, + "name": "1_excel", # Simplified naming + "ext": fileExtension, + "contentType": mimeType, + "data": fileContent, + "metadata": { + "isText": False, + "format": "excel" + } + }) + return contents + + # Only supports XLSX (newer format) + if mimeType == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": + with io.BytesIO(fileContent) as xlsxStream: + workbook = openpyxl.load_workbook(xlsxStream, data_only=True) + + # Extract each worksheet as separate CSV content + for sheetIndex, sheetName in enumerate(workbook.sheetnames): + sheet = workbook[sheetName] + + # Format data as CSV + csvRows = [] + for row in sheet.iter_rows(): + csvRow = [] + for cell in row: + value = cell.value + if value is None: + csvRow.append("") + else: + csvRow.append(str(value).replace('"', '""')) + csvRows.append(','.join(f'"{cell}"' for cell in csvRow)) + + csvContent = "\n".join(csvRows) + + # Add as CSV content + if csvContent.strip(): + extractedContentFound = True + sheetSafeName = sheetName.replace(" ", "_").replace("/", "_").replace("\\", "_") + contents.append({ + "sequenceNr": len(contents) + 1, + "name": f"{len(contents) + 1}_csv_{sheetSafeName}", # Simplified naming with sheet label + "ext": "csv", + "contentType": "csv", + "data": csvContent, + "metadata": { + "isText": True, + "source": "xlsx", + "sheet": sheetName, + "format": "csv" + } + }) + else: + logger.warning(f"Extraction from old Excel format (XLS) not supported") + + except Exception as e: + logger.error(f"Error in Excel extraction: {str(e)}") + + # If no content was extracted, add the original document + if not extractedContentFound: + contents.append({ + "sequenceNr": 1, + "name": "1_excel", # Simplified naming + "ext": fileExtension, + "contentType": mimeType, + "data": fileContent, + "metadata": { + "isText": False, + "format": "excel" + } + }) + + return contents + +def extractPowerpointContent(fileName: str, fileContent: bytes, mimeType: str) -> List[Dict[str, Any]]: + """ + Extracts content from PowerPoint presentations. + + Args: + fileName: Name of the file + fileContent: Binary data of the file + mimeType: MIME type of the file + + Returns: + List of PowerPoint-Content objects with metadata.isText = False + """ + # For PowerPoint, we currently only return the original binary file + # A complete extraction would require more specialized libraries + fileExtension = "pptx" if mimeType == "application/vnd.openxmlformats-officedocument.presentationml.presentation" else "ppt" + return [{ + "sequenceNr": 1, + "name": "1_powerpoint", # Simplified naming + "ext": fileExtension, + "contentType": mimeType, + "data": fileContent, + "metadata": { + "isText": False, + "format": "powerpoint" + } + }] + +def extractBinaryContent(fileName: str, fileContent: bytes, mimeType: str) -> List[Dict[str, Any]]: + """ + Fallback for binary files where no specific extraction is possible. + + Args: + fileName: Name of the file + fileContent: Binary data of the file + mimeType: MIME type of the file + + Returns: + List with a binary Content object with metadata.isText = False + """ + fileExtension = os.path.splitext(fileName)[1][1:] if os.path.splitext(fileName)[1] else "bin" + return [{ + "sequenceNr": 1, + "name": "1_binary", # Simplified naming + "ext": fileExtension, + "contentType": mimeType, + "data": fileContent, + "metadata": { + "isText": False, + "format": "binary" + } + }] \ No newline at end of file diff --git a/modules/gatewayInterface.py b/modules/gatewayInterface.py new file mode 100644 index 00000000..3e1120c7 --- /dev/null +++ b/modules/gatewayInterface.py @@ -0,0 +1,471 @@ +""" +Interface to the Gateway system. +Manages users and mandates for authentication. +""" + +import os +import logging +from typing import Dict, Any, List, Optional, Union +import importlib +from passlib.context import CryptContext + +from connectors.connectorDbJson import DatabaseConnector +from modules.configuration import APP_CONFIG + +logger = logging.getLogger(__name__) + +# Password-Hashing +pwdContext = CryptContext(schemes=["argon2"], deprecated="auto") + + +class GatewayInterface: + """ + Interface to the Gateway system. + Manages users and mandates. + """ + + def __init__(self, mandateId: int = None, userId: int = None): + """ + Initializes the Gateway Interface with optional mandate and user context. + + Args: + mandateId: ID of the current mandate (optional) + userId: ID of the current user (optional) + """ + # Context can be empty during initialization + self.mandateId = mandateId + self.userId = userId + + # Import data model module + try: + self.modelModule = importlib.import_module("modules.gatewayModel") + logger.info("gatewayModel successfully imported") + except ImportError as e: + logger.error(f"Error importing gatewayModel: {e}") + raise + + # Initialize database + self._initializeDatabase() + + def _initializeDatabase(self): + """ + Initializes the database with minimal objects + """ + + self.db = DatabaseConnector( + dbHost=APP_CONFIG.get("DB_SYSTEM_HOST"), + dbDatabase=APP_CONFIG.get("DB_SYSTEM_DATABASE"), + dbUser=APP_CONFIG.get("DB_SYSTEM_USER"), + dbPassword=APP_CONFIG.get("DB_SYSTEM_PASSWORD_SECRET"), + mandateId=self.mandateId if self.mandateId else 0, + userId=self.userId if self.userId else 0 + ) + + # Create Root mandate if needed + existingMandateId = self.getInitialId("mandates") + mandates = self.db.getRecordset("mandates") + if existingMandateId is None or not mandates: + logger.info("Creating Root mandate") + rootMandate = { + "name": "Root", + "language": "de" + } + createdMandate = self.db.recordCreate("mandates", rootMandate) + logger.info(f"Root mandate created with ID {createdMandate['id']}") + + # Update mandate context + self.mandateId = createdMandate['id'] + self.userId = createdMandate['userId'] + + # Recreate connector with correct context + self.db = DatabaseConnector( + dbHost=APP_CONFIG.get("DB_SYSTEM_HOST"), + dbDatabase=APP_CONFIG.get("DB_SYSTEM_DATABASE"), + dbUser=APP_CONFIG.get("DB_SYSTEM_USER"), + dbPassword=APP_CONFIG.get("DB_SYSTEM_PASSWORD_SECRET"), + mandateId=self.mandateId, + userId=self.userId + ) + + # Create Admin user if needed + existingUserId = self.getInitialId("users") + users = self.db.getRecordset("users") + if existingUserId is None or not users: + logger.info("Creating Admin user") + adminUser = { + "mandateId": self.mandateId, + "username": "admin", + "email": "admin@example.com", + "fullName": "Administrator", + "disabled": False, + "language": "de", + "privilege": "sysadmin", # SysAdmin privilege + "hashedPassword": self._getPasswordHash("admin") # Use a secure password in production! + } + createdUser = self.db.recordCreate("users", adminUser) + logger.info(f"Admin user created with ID {createdUser['id']}") + + # Update user context + self.userId = createdUser['id'] + + # Recreate connector with correct context + self.db = DatabaseConnector( + dbHost=APP_CONFIG.get("DB_SYSTEM_HOST"), + dbDatabase=APP_CONFIG.get("DB_SYSTEM_DATABASE"), + dbUser=APP_CONFIG.get("DB_SYSTEM_USER"), + dbPassword=APP_CONFIG.get("DB_SYSTEM_PASSWORD_SECRET"), + mandateId=self.mandateId, + userId=self.userId + ) + + def getInitialId(self, table: str) -> Optional[int]: + """Returns the initial ID for a table""" + return self.db.getInitialId(table) + + def _getPasswordHash(self, password: str) -> str: + """Creates a hash for a password""" + return pwdContext.hash(password) + + def _verifyPassword(self, plainPassword: str, hashedPassword: str) -> bool: + """Checks if the password matches the hash""" + return pwdContext.verify(plainPassword, hashedPassword) + + def _getCurrentTimestamp(self) -> str: + """Returns the current timestamp in ISO format""" + from datetime import datetime + return datetime.now().isoformat() + + # Mandate methods + + def getAllMandates(self) -> List[Dict[str, Any]]: + """Returns all mandates""" + return self.db.getRecordset("mandates") + + def getMandate(self, mandateId: int) -> Optional[Dict[str, Any]]: + """Returns a mandate by its ID""" + mandates = self.db.getRecordset("mandates", recordFilter={"id": mandateId}) + if mandates: + return mandates[0] + return None + + def createMandate(self, name: str, language: str = "de") -> Dict[str, Any]: + """Creates a new mandate""" + mandateData = { + "name": name, + "language": language + } + + return self.db.recordCreate("mandates", mandateData) + + def updateMandate(self, mandateId: int, mandateData: Dict[str, Any]) -> Dict[str, Any]: + """ + Updates an existing mandate + + Args: + mandateId: The ID of the mandate to update + mandateData: The mandate data to update + + Returns: + Dict[str, Any]: The updated mandate data + + Raises: + ValueError: If the mandate is not found + """ + # Check if the mandate exists + mandate = self.getMandate(mandateId) + if not mandate: + raise ValueError(f"Mandate with ID {mandateId} not found") + + # Update the mandate + updatedMandate = self.db.recordModify("mandates", mandateId, mandateData) + + return updatedMandate + + def deleteMandate(self, mandateId: int) -> bool: + """ + Deletes a mandate and all associated users and data + + Args: + mandateId: The ID of the mandate to delete + + Returns: + bool: True if the mandate was successfully deleted, otherwise False + """ + # Check if the mandate exists + mandate = self.getMandate(mandateId) + if not mandate: + return False + + # Check if it's the initial mandate + initialMandateId = self.getInitialId("mandates") + if initialMandateId is not None and mandateId == initialMandateId: + logger.warning(f"Attempt to delete the Root mandate was prevented") + return False + + # Find all users of the mandate + users = self.getUsersByMandate(mandateId) + + # Delete all users of the mandate and their associated data + for user in users: + self.deleteUser(user["id"]) + + # Delete the mandate + success = self.db.recordDelete("mandates", mandateId) + + if success: + logger.info(f"Mandate with ID {mandateId} was successfully deleted") + else: + logger.error(f"Error deleting mandate with ID {mandateId}") + + return success + + # User methods + + def getAllUsers(self) -> List[Dict[str, Any]]: + """Returns all users""" + users = self.db.getRecordset("users") + # Remove password hashes from the response + for user in users: + if "hashedPassword" in user: + del user["hashedPassword"] + return users + + def getUsersByMandate(self, mandateId: int) -> List[Dict[str, Any]]: + """ + Returns all users of a specific mandate + + Args: + mandateId: The ID of the mandate + + Returns: + List[Dict[str, Any]]: List of users in the mandate + """ + users = self.db.getRecordset("users", recordFilter={"mandateId": mandateId}) + # Remove password hashes from the response + for user in users: + if "hashedPassword" in user: + del user["hashedPassword"] + return users + + def getUserByUsername(self, username: str) -> Optional[Dict[str, Any]]: + """Returns a user by username""" + users = self.db.getRecordset("users") + for user in users: + if user.get("username") == username: + return user + return None + + def getUser(self, userId: int) -> Optional[Dict[str, Any]]: + """Returns a user by ID""" + users = self.db.getRecordset("users", recordFilter={"id": userId}) + if users: + user = users[0] + # Remove password hash from the API response + if "hashedPassword" in user: + userCopy = user.copy() + del userCopy["hashedPassword"] + return userCopy + return user + return None + + def createUser(self, username: str, password: str, email: str = None, + fullName: str = None, language: str = "de", mandateId: int = None, + disabled: bool = False, privilege: str = "user") -> Dict[str, Any]: + """ + Creates a new user + + Args: + username: The username + password: The password + email: The email address (optional) + fullName: The full name (optional) + language: The preferred language (default: "de") + mandateId: The ID of the mandate (optional) + disabled: Whether the user is disabled (default: False) + privilege: The privilege level (default: "user") + + Returns: + Dict[str, Any]: The created user data + + Raises: + ValueError: If the username already exists + """ + # Check if the username already exists + existingUser = self.getUserByUsername(username) + if existingUser: + raise ValueError(f"User '{username}' already exists") + + # Use the provided mandateId or the current context + userMandateId = mandateId if mandateId is not None else self.mandateId + + userData = { + "mandateId": userMandateId, + "username": username, + "email": email, + "fullName": fullName, + "disabled": disabled, + "language": language, + "privilege": privilege, + "hashedPassword": self._getPasswordHash(password) + } + + createdUser = self.db.recordCreate("users", userData) + + # Remove password hash from the response + if "hashedPassword" in createdUser: + del createdUser["hashedPassword"] + + return createdUser + + def authenticateUser(self, username: str, password: str) -> Optional[Dict[str, Any]]: + """ + Authenticates a user by username and password + + Args: + username: The username + password: The password + + Returns: + Optional[Dict[str, Any]]: The user data or None if authentication fails + """ + user = self.getUserByUsername(username) + + if not user: + return None + + if not self._verifyPassword(password, user.get("hashedPassword", "")): + return None + + # Check if the user is disabled + if user.get("disabled", False): + return None + + # Create a copy without password hash + authenticatedUser = {**user} + if "hashedPassword" in authenticatedUser: + del authenticatedUser["hashedPassword"] + + return authenticatedUser + + def updateUser(self, userId: int, userData: Dict[str, Any]) -> Dict[str, Any]: + """ + Updates a user + + Args: + userId: The ID of the user to update + userData: The user data to update + + Returns: + Dict[str, Any]: The updated user data + + Raises: + ValueError: If the user is not found + """ + # Get the current user with password hash (directly from DB) + users = self.db.getRecordset("users", recordFilter={"id": userId}) + if not users: + raise ValueError(f"User with ID {userId} not found") + + user = users[0] + + # If the password is being changed, hash it + if "password" in userData: + userData["hashedPassword"] = self._getPasswordHash(userData["password"]) + del userData["password"] + + # Update the user + updatedUser = self.db.recordModify("users", userId, userData) + + # Remove password hash from the response + if "hashedPassword" in updatedUser: + del updatedUser["hashedPassword"] + + return updatedUser + + def disableUser(self, userId: int) -> Dict[str, Any]: + """Disables a user""" + return self.updateUser(userId, {"disabled": True}) + + def enableUser(self, userId: int) -> Dict[str, Any]: + """Enables a user""" + return self.updateUser(userId, {"disabled": False}) + + def _deleteUserReferencedData(self, userId: int) -> None: + """ + Deletes all data associated with a user + + Args: + userId: The ID of the user + """ + # Here all tables are searched and all entries referencing this user are deleted + + # Delete user attributes + try: + attributes = self.db.getRecordset("attributes", recordFilter={"userId": userId}) + for attribute in attributes: + self.db.recordDelete("attributes", attribute["id"]) + except Exception as e: + logger.error(f"Error deleting attributes for user {userId}: {e}") + + # Other tables that might reference the user + # (Depending on the application's database structure) + + logger.info(f"All referenced data for user {userId} has been deleted") + + def deleteUser(self, userId: int) -> bool: + """ + Deletes a user and all associated data + + Args: + userId: The ID of the user to delete + + Returns: + bool: True if the user was successfully deleted, otherwise False + """ + # Check if the user exists + users = self.db.getRecordset("users", recordFilter={"id": userId}) + if not users: + return False + + # Check if it's the initial user + initialUserId = self.getInitialId("users") + if initialUserId is not None and userId == initialUserId: + logger.warning("Attempt to delete the Root Admin was prevented") + return False + + # Delete all data associated with the user + self._deleteUserReferencedData(userId) + + # Delete the user + success = self.db.recordDelete("users", userId) + + if success: + logger.info(f"User with ID {userId} was successfully deleted") + else: + logger.error(f"Error deleting user with ID {userId}") + + return success + + +# Singleton factory for GatewayInterface instances per context +_gatewayInterfaces = {} + +def getGatewayInterface(mandateId: int = None, userId: int = None) -> GatewayInterface: + """ + Returns a GatewayInterface instance for the specified context. + Reuses existing instances. + + Args: + mandateId: ID of the mandate + userId: ID of the user + + Returns: + GatewayInterface instance + """ + contextKey = f"{mandateId}_{userId}" + if contextKey not in _gatewayInterfaces: + _gatewayInterfaces[contextKey] = GatewayInterface(mandateId, userId) + return _gatewayInterfaces[contextKey] + +# Initialize the interface +getGatewayInterface() \ No newline at end of file diff --git a/modules/gateway_model.py b/modules/gatewayModel.py similarity index 68% rename from modules/gateway_model.py rename to modules/gatewayModel.py index 52f3e0ea..83d759c7 100644 --- a/modules/gateway_model.py +++ b/modules/gatewayModel.py @@ -1,5 +1,9 @@ +""" +Data models for the gateway system. +""" from pydantic import BaseModel, Field from typing import List, Dict, Any, Optional +from datetime import datetime class Label(BaseModel): @@ -7,7 +11,7 @@ class Label(BaseModel): default: str translations: Dict[str, str] = {} - def get_label(self, language: str = None): + def getLabel(self, language: str = None): """Returns the label in the specified language, or the default value if not available""" if language and language in self.translations: return self.translations[language] @@ -26,7 +30,7 @@ class Mandate(BaseModel): ) # Labels for attributes - field_labels: Dict[str, Label] = { + fieldLabels: Dict[str, Label] = { "id": Label(default="ID", translations={}), "name": Label(default="Name of the mandate", translations={"en": "Mandate name", "fr": "Nom du mandat"}), "language": Label(default="Language", translations={"en": "Language", "fr": "Langue"}) @@ -35,10 +39,10 @@ class Mandate(BaseModel): class User(BaseModel): """Data model for a user""" id: int = Field(description="Unique ID of the user") - mandate_id: int = Field(description="ID of the associated mandate") + mandateId: int = Field(description="ID of the associated mandate") username: str = Field(description="Username for login") email: Optional[str] = Field(None, description="Email address of the user") - full_name: Optional[str] = Field(None, description="Full name of the user") + fullName: Optional[str] = Field(None, description="Full name of the user") language: str = Field(description="Preferred language of the user") disabled: Optional[bool] = Field(False, description="Indicates whether the user is disabled") privilege: str = Field(description="Permission level") #sysadmin,admin,user @@ -49,12 +53,12 @@ class User(BaseModel): ) # Labels for attributes - field_labels: Dict[str, Label] = { + fieldLabels: Dict[str, Label] = { "id": Label(default="ID", translations={}), - "mandate_id": Label(default="Mandate ID", translations={"en": "Mandate ID", "fr": "ID de mandat"}), + "mandateId": Label(default="Mandate ID", translations={"en": "Mandate ID", "fr": "ID de mandat"}), "username": Label(default="Username", translations={"en": "Username", "fr": "Nom d'utilisateur"}), "email": Label(default="Email", translations={"en": "Email", "fr": "E-mail"}), - "full_name": Label(default="Full name", translations={"en": "Full name", "fr": "Nom complet"}), + "fullName": Label(default="Full name", translations={"en": "Full name", "fr": "Nom complet"}), "language": Label(default="Language", translations={"en": "Language", "fr": "Langue"}), "disabled": Label(default="Disabled", translations={"en": "Disabled", "fr": "Désactivé"}), "privilege": Label(default="Permission level", translations={"en": "Access level", "fr": "Niveau d'accès"}), @@ -63,7 +67,7 @@ class User(BaseModel): class UserInDB(User): """Extended user class with password hash""" - hashed_password: str = Field(description="Hash of the user password") + hashedPassword: str = Field(description="Hash of the user password") label: Label = Field( default=Label(default="User Access", translations={"en": "User Access", "fr": "Accès de l'utilisateur"}), @@ -71,23 +75,29 @@ class UserInDB(User): ) # Additional label for the password field - field_labels: Dict[str, Label] = { - "hashed_password": Label(default="Password hash", translations={"en": "Password hash", "fr": "Hachage de mot de passe"}) + fieldLabels: Dict[str, Label] = { + "hashedPassword": Label(default="Password hash", translations={"en": "Password hash", "fr": "Hachage de mot de passe"}) } class Token(BaseModel): """Data model for an authentication token""" - access_token: str = Field(description="The issued access token") - token_type: str = Field(description="Type of token (usually 'bearer')") - + accessToken: str = Field(description="The issued access token") + tokenType: str = Field(description="Type of token (usually 'bearer')") label: Label = Field( default=Label(default="Token", translations={"en": "Token", "fr": "Jeton"}), description="Label for the class" ) # Labels for attributes - field_labels: Dict[str, Label] = { - "access_token": Label(default="Access token", translations={"en": "Access token", "fr": "Jeton d'accès"}), - "token_type": Label(default="Token type", translations={"en": "Token type", "fr": "Type de jeton"}) - } \ No newline at end of file + fieldLabels: Dict[str, Label] = { + "accessToken": Label(default="Access token", translations={"en": "Access token", "fr": "Jeton d'accès"}), + "tokenType": Label(default="Token type", translations={"en": "Token type", "fr": "Type de jeton"}) + } + + +class TokenData(BaseModel): + """Data for token decoding and validation""" + username: Optional[str] = None + mandateId: Optional[int] = None + exp: Optional[datetime] = None \ No newline at end of file diff --git a/modules/gateway_interface.py b/modules/gateway_interface.py deleted file mode 100644 index 73a59379..00000000 --- a/modules/gateway_interface.py +++ /dev/null @@ -1,458 +0,0 @@ -import os -import logging -from typing import Dict, Any, List, Optional, Union -import importlib -from passlib.context import CryptContext - -from connectors.connector_db_json import DatabaseConnector -from modules.configuration import APP_CONFIG - -logger = logging.getLogger(__name__) - -# Password-Hashing -pwd_context = CryptContext(schemes=["argon2"], deprecated="auto") - - -class GatewayInterface: - """ - Interface to the Gateway system. - Manages users and mandates. - """ - - def __init__(self, mandate_id: int = None, user_id: int = None): - """ - Initializes the Gateway Interface with optional mandate and user context. - - Args: - mandate_id: ID of the current mandate (optional) - user_id: ID of the current user (optional) - """ - # Context can be empty during initialization - self.mandate_id = mandate_id - self.user_id = user_id - - # Import data model module - try: - self.model_module = importlib.import_module("modules.gateway_model") - logger.info("gateway_model successfully imported") - except ImportError as e: - logger.error(f"Error importing gateway_model: {e}") - raise - - # Initialize database - self._initialize_database() - - def _initialize_database(self): - """ - Initializes the database with minimal objects - """ - - self.db = DatabaseConnector( - db_host=APP_CONFIG.get("DB_SYSTEM_HOST"), - db_database=APP_CONFIG.get("DB_SYSTEM_DATABASE"), - db_user=APP_CONFIG.get("DB_SYSTEM_USER"), - db_password=APP_CONFIG.get("DB_SYSTEM_PASSWORD_SECRET"), - mandate_id=self.mandate_id if self.mandate_id else 0, - user_id=self.user_id if self.user_id else 0 - ) - - # Create Root mandate if needed - existing_mandate_id = self.get_initial_id("mandates") - mandates = self.db.get_recordset("mandates") - if existing_mandate_id is None or not mandates: - logger.info("Creating Root mandate") - root_mandate = { - "name": "Root", - "language": "de" - } - created_mandate = self.db.record_create("mandates", root_mandate) - logger.info(f"Root mandate created with ID {created_mandate['id']}") - - # Update mandate context - self.mandate_id = created_mandate['id'] - self.user_id = created_mandate['user_id'] - - # Recreate connector with correct context - self.db = DatabaseConnector( - db_host=APP_CONFIG.get("DB_SYSTEM_HOST"), - db_database=APP_CONFIG.get("DB_SYSTEM_DATABASE"), - db_user=APP_CONFIG.get("DB_SYSTEM_USER"), - db_password=APP_CONFIG.get("DB_SYSTEM_PASSWORD_SECRET"), - mandate_id=self.mandate_id, - user_id=self.user_id - ) - - # Create Admin user if needed - existing_user_id = self.get_initial_id("users") - users = self.db.get_recordset("users") - if existing_user_id is None or not users: - logger.info("Creating Admin user") - admin_user = { - "mandate_id": self.mandate_id, - "username": "admin", - "email": "admin@example.com", - "full_name": "Administrator", - "disabled": False, - "language": "de", - "privilege": "sysadmin", # SysAdmin privilege - "hashed_password": self._get_password_hash("admin") # Use a secure password in production! - } - created_user = self.db.record_create("users", admin_user) - logger.info(f"Admin user created with ID {created_user['id']}") - - # Update user context - self.user_id = created_user['id'] - - # Recreate connector with correct context - self.db = DatabaseConnector( - db_host=APP_CONFIG.get("DB_SYSTEM_HOST"), - db_database=APP_CONFIG.get("DB_SYSTEM_DATABASE"), - db_user=APP_CONFIG.get("DB_SYSTEM_USER"), - db_password=APP_CONFIG.get("DB_SYSTEM_PASSWORD_SECRET"), - mandate_id=self.mandate_id, - user_id=self.user_id ) - - def get_initial_id(self, table: str) -> Optional[int]: - """Returns the initial ID for a table""" - return self.db.get_initial_id(table) - - def _get_password_hash(self, password: str) -> str: - """Creates a hash for a password""" - return pwd_context.hash(password) - - def _verify_password(self, plain_password: str, hashed_password: str) -> bool: - """Checks if the password matches the hash""" - return pwd_context.verify(plain_password, hashed_password) - - def _get_current_timestamp(self) -> str: - """Returns the current timestamp in ISO format""" - from datetime import datetime - return datetime.now().isoformat() - - # Mandate methods - - def get_all_mandates(self) -> List[Dict[str, Any]]: - """Returns all mandates""" - return self.db.get_recordset("mandates") - - def get_mandate(self, mandate_id: int) -> Optional[Dict[str, Any]]: - """Returns a mandate by its ID""" - mandates = self.db.get_recordset("mandates", record_filter={"id": mandate_id}) - if mandates: - return mandates[0] - return None - - def create_mandate(self, name: str, language: str = "de") -> Dict[str, Any]: - """Creates a new mandate""" - mandate_data = { - "name": name, - "language": language - } - - return self.db.record_create("mandates", mandate_data) - - def update_mandate(self, mandate_id: int, mandate_data: Dict[str, Any]) -> Dict[str, Any]: - """ - Updates an existing mandate - - Args: - mandate_id: The ID of the mandate to update - mandate_data: The mandate data to update - - Returns: - Dict[str, Any]: The updated mandate data - - Raises: - ValueError: If the mandate is not found - """ - # Check if the mandate exists - mandate = self.get_mandate(mandate_id) - if not mandate: - raise ValueError(f"Mandate with ID {mandate_id} not found") - - # Update the mandate - updated_mandate = self.db.record_modify("mandates", mandate_id, mandate_data) - - return updated_mandate - - def delete_mandate(self, mandate_id: int) -> bool: - """ - Deletes a mandate and all associated users and data - - Args: - mandate_id: The ID of the mandate to delete - - Returns: - bool: True if the mandate was successfully deleted, otherwise False - """ - # Check if the mandate exists - mandate = self.get_mandate(mandate_id) - if not mandate: - return False - - # Check if it's the initial mandate - initial_mandate_id = self.get_initial_id("mandates") - if initial_mandate_id is not None and mandate_id == initial_mandate_id: - logger.warning(f"Attempt to delete the Root mandate was prevented") - return False - - # Find all users of the mandate - users = self.get_users_by_mandate(mandate_id) - - # Delete all users of the mandate and their associated data - for user in users: - self.delete_user(user["id"]) - - # Delete the mandate - success = self.db.record_delete("mandates", mandate_id) - - if success: - logger.info(f"Mandate with ID {mandate_id} was successfully deleted") - else: - logger.error(f"Error deleting mandate with ID {mandate_id}") - - return success - - # User methods - - def get_all_users(self) -> List[Dict[str, Any]]: - """Returns all users""" - users = self.db.get_recordset("users") - # Remove password hashes from the response - for user in users: - if "hashed_password" in user: - del user["hashed_password"] - return users - - def get_users_by_mandate(self, mandate_id: int) -> List[Dict[str, Any]]: - """ - Returns all users of a specific mandate - - Args: - mandate_id: The ID of the mandate - - Returns: - List[Dict[str, Any]]: List of users in the mandate - """ - users = self.db.get_recordset("users", record_filter={"mandate_id": mandate_id}) - # Remove password hashes from the response - for user in users: - if "hashed_password" in user: - del user["hashed_password"] - return users - - def get_user_by_username(self, username: str) -> Optional[Dict[str, Any]]: - """Returns a user by username""" - users = self.db.get_recordset("users") - for user in users: - if user.get("username") == username: - return user - return None - - def get_user(self, user_id: int) -> Optional[Dict[str, Any]]: - """Returns a user by ID""" - users = self.db.get_recordset("users", record_filter={"id": user_id}) - if users: - user = users[0] - # Remove password hash from the API response - if "hashed_password" in user: - user_copy = user.copy() - del user_copy["hashed_password"] - return user_copy - return user - return None - - def create_user(self, username: str, password: str, email: str = None, - full_name: str = None, language: str = "de", mandate_id: int = None, - disabled: bool = False, privilege: str = "user") -> Dict[str, Any]: - """ - Creates a new user - - Args: - username: The username - password: The password - email: The email address (optional) - full_name: The full name (optional) - language: The preferred language (default: "de") - mandate_id: The ID of the mandate (optional) - disabled: Whether the user is disabled (default: False) - privilege: The privilege level (default: "user") - - Returns: - Dict[str, Any]: The created user data - - Raises: - ValueError: If the username already exists - """ - # Check if the username already exists - existing_user = self.get_user_by_username(username) - if existing_user: - raise ValueError(f"User '{username}' already exists") - - # Use the provided mandate_id or the current context - user_mandate_id = mandate_id if mandate_id is not None else self.mandate_id - - user_data = { - "mandate_id": user_mandate_id, - "username": username, - "email": email, - "full_name": full_name, - "disabled": disabled, - "language": language, - "privilege": privilege, - "hashed_password": self._get_password_hash(password) - } - - created_user = self.db.record_create("users", user_data) - - # Remove password hash from the response - if "hashed_password" in created_user: - del created_user["hashed_password"] - - return created_user - - def authenticate_user(self, username: str, password: str) -> Optional[Dict[str, Any]]: - """ - Authenticates a user by username and password - - Args: - username: The username - password: The password - - Returns: - Optional[Dict[str, Any]]: The user data or None if authentication fails - """ - user = self.get_user_by_username(username) - - if not user: - return None - - if not self._verify_password(password, user.get("hashed_password", "")): - return None - - # Check if the user is disabled - if user.get("disabled", False): - return None - - # Create a copy without password hash - authenticated_user = {**user} - if "hashed_password" in authenticated_user: - del authenticated_user["hashed_password"] - - return authenticated_user - - def update_user(self, user_id: int, user_data: Dict[str, Any]) -> Dict[str, Any]: - """ - Updates a user - - Args: - user_id: The ID of the user to update - user_data: The user data to update - - Returns: - Dict[str, Any]: The updated user data - - Raises: - ValueError: If the user is not found - """ - # Get the current user with password hash (directly from DB) - users = self.db.get_recordset("users", record_filter={"id": user_id}) - if not users: - raise ValueError(f"User with ID {user_id} not found") - - user = users[0] - - # If the password is being changed, hash it - if "password" in user_data: - user_data["hashed_password"] = self._get_password_hash(user_data["password"]) - del user_data["password"] - - # Update the user - updated_user = self.db.record_modify("users", user_id, user_data) - - # Remove password hash from the response - if "hashed_password" in updated_user: - del updated_user["hashed_password"] - - return updated_user - - def disable_user(self, user_id: int) -> Dict[str, Any]: - """Disables a user""" - return self.update_user(user_id, {"disabled": True}) - - def enable_user(self, user_id: int) -> Dict[str, Any]: - """Enables a user""" - return self.update_user(user_id, {"disabled": False}) - - def _delete_user_referenced_data(self, user_id: int) -> None: - """ - Deletes all data associated with a user - - Args: - user_id: The ID of the user - """ - # Here all tables are searched and all entries referencing this user are deleted - - # Delete user attributes - try: - attributes = self.db.get_recordset("attributes", record_filter={"user_id": user_id}) - for attribute in attributes: - self.db.record_delete("attributes", attribute["id"]) - except Exception as e: - logger.error(f"Error deleting attributes for user {user_id}: {e}") - - # Other tables that might reference the user - # (Depending on the application's database structure) - - logger.info(f"All referenced data for user {user_id} has been deleted") - - def delete_user(self, user_id: int) -> bool: - """ - Deletes a user and all associated data - - Args: - user_id: The ID of the user to delete - - Returns: - bool: True if the user was successfully deleted, otherwise False - """ - # Check if the user exists - users = self.db.get_recordset("users", record_filter={"id": user_id}) - if not users: - return False - - # Check if it's the initial user - initial_user_id = self.get_initial_id("users") - if initial_user_id is not None and user_id == initial_user_id: - logger.warning("Attempt to delete the Root Admin was prevented") - return False - - # Delete all data associated with the user - self._delete_user_referenced_data(user_id) - - # Delete the user - success = self.db.record_delete("users", user_id) - - if success: - logger.info(f"User with ID {user_id} was successfully deleted") - else: - logger.error(f"Error deleting user with ID {user_id}") - - return success - - -# Singleton Factory for GatewayInterface instances per context -_gateway_interfaces = {} - -def get_gateway_interface(mandate_id: int = None, user_id: int = None) -> GatewayInterface: - """ - Returns a GatewayInterface instance for the specified context. - Reuses existing instances. - """ - context_key = f"{mandate_id}_{user_id}" - if context_key not in _gateway_interfaces: - _gateway_interfaces[context_key] = GatewayInterface(mandate_id, user_id) - return _gateway_interfaces[context_key] - -# Init -get_gateway_interface() \ No newline at end of file diff --git a/modules/lucydom_interface.py b/modules/lucydomInterface.py similarity index 50% rename from modules/lucydom_interface.py rename to modules/lucydomInterface.py index aa983c7f..957723a3 100644 --- a/modules/lucydom_interface.py +++ b/modules/lucydomInterface.py @@ -13,8 +13,8 @@ import importlib import hashlib # DYNAMIC PART: Connectors to the Interface -from connectors.connector_db_json import DatabaseConnector -from connectors.connector_aichat_openai import ChatService +from connectors.connectorDbJson import DatabaseConnector +from connectors.connectorAiOpenai import ChatService # Basic Configurations from modules.configuration import APP_CONFIG @@ -48,117 +48,118 @@ class LucyDOMInterface: Uses the JSON connector for data access. """ - def __init__(self, mandate_id: int, user_id: int): + def __init__(self, mandateId: int, userId: int): """ Initializes the LucyDOM Interface with mandate and user context. Args: - mandate_id: ID of the current mandate - user_id: ID of the current user + mandateId: ID of the current mandate + userId: ID of the current user """ - self.mandate_id = mandate_id - self.user_id = user_id + self.mandateId = mandateId + self.userId = userId # Add language settings - self.user_language = "en" # Default user language - self.ai_service = None # Will be set externally + self.userLanguage = "en" # Default user language + self.aiService = None # Will be set externally # Import data model module try: - self.model_module = importlib.import_module("modules.lucydom_model") - logger.info("lucydom_model successfully imported") + self.modelModule = importlib.import_module("modules.lucydomModel") + logger.info("lucydomModel successfully imported") except ImportError as e: - logger.error(f"Error importing lucydom_model: {e}") + logger.error(f"Error importing lucydomModel: {e}") raise # Initialize database if needed - self._initialize_database() + self._initializeDatabase() - def _initialize_database(self): + def _initializeDatabase(self): """ Initializes the database with minimal objects for the logged-in user in the mandate, if it doesn't exist yet. No initialization without a valid user. Creates an initial dataset for each table defined in the data model. """ - effective_mandate_id = self.mandate_id - effective_user_id = self.user_id - if effective_mandate_id is None or effective_user_id is None: + effectiveMandateId = self.mandateId + effectiveUserId = self.userId + if effectiveMandateId is None or effectiveUserId is None: #data available return self.db = DatabaseConnector( - db_host=APP_CONFIG.get("DB_LUCYDOM_HOST"), - db_database=APP_CONFIG.get("DB_LUCYDOM_DATABASE"), - db_user=APP_CONFIG.get("DB_LUCYDOM_USER"), - db_password=APP_CONFIG.get("DB_LUCYDOM_PASSWORD_SECRET"), - mandate_id=self.mandate_id, - user_id=self.user_id + dbHost=APP_CONFIG.get("DB_LUCYDOM_HOST"), + dbDatabase=APP_CONFIG.get("DB_LUCYDOM_DATABASE"), + dbUser=APP_CONFIG.get("DB_LUCYDOM_USER"), + dbPassword=APP_CONFIG.get("DB_LUCYDOM_PASSWORD_SECRET"), + mandateId=self.mandateId, + userId=self.userId, + skipInitialIdLookup=True ) # Initialize standard prompts for different areas - prompts = self.db.get_recordset("prompts") + prompts = self.db.getRecordset("prompts") if not prompts: logger.info("Creating standard prompts") # Define standard prompts - standard_prompts = [ + standardPrompts = [ { - "mandate_id": effective_mandate_id, - "user_id": effective_user_id, + "mandateId": effectiveMandateId, + "userId": effectiveUserId, "content": "Research the current market trends and developments in [TOPIC]. Collect information about leading companies, innovative products or services, and current challenges. Present the results in a structured overview with relevant data and sources.", "name": "Web Research: Market Research" }, { - "mandate_id": effective_mandate_id, - "user_id": effective_user_id, + "mandateId": effectiveMandateId, + "userId": effectiveUserId, "content": "Analyze the attached dataset on [TOPIC] and identify the most important trends, patterns, and anomalies. Perform statistical calculations to support your findings. Present the results in a clearly structured analysis and draw relevant conclusions.", "name": "Analysis: Data Analysis" }, { - "mandate_id": effective_mandate_id, - "user_id": effective_user_id, + "mandateId": effectiveMandateId, + "userId": effectiveUserId, "content": "Create a detailed protocol of our meeting on [TOPIC]. Capture all discussed points, decisions made, and agreed measures. Structure the protocol clearly with agenda items, participant list, and clear responsibilities for follow-up actions.", "name": "Protocol: Meeting Minutes" }, { - "mandate_id": effective_mandate_id, - "user_id": effective_user_id, + "mandateId": effectiveMandateId, + "userId": effectiveUserId, "content": "Develop a UI/UX design concept for [APPLICATION/WEBSITE]. Consider the target audience, main functions, and brand identity. Describe the visual design, navigation, interaction patterns, and information architecture. Explain how the design optimizes user-friendliness and user experience.", "name": "Design: UI/UX Design" } ] # Create prompts - for prompt_data in standard_prompts: - created_prompt = self.db.record_create("prompts", prompt_data) - logger.info(f"Prompt '{prompt_data.get('name', 'Standard')}' was created with ID {created_prompt['id']}") + for promptData in standardPrompts: + createdPrompt = self.db.recordCreate("prompts", promptData) + logger.info(f"Prompt '{promptData.get('name', 'Standard')}' was created with ID {createdPrompt['id']}") # Language support methods - def set_user_language(self, language_code: str): + def setUserLanguage(self, languageCode: str): """Set the user's preferred language""" - self.user_language = language_code - logger.info(f"User language set to: {language_code}") + self.userLanguage = languageCode + logger.info(f"User language set to: {languageCode}") - async def call_ai(self, messages: List[Dict[str, str]], produce_user_answer: bool = False, temperature: float = None) -> str: + async def callAi(self, messages: List[Dict[str, str]], produceUserAnswer: bool = False, temperature: float = None) -> str: """ Enhanced AI service call with language support Args: messages: List of message dictionaries - produce_user_answer: Whether this response is for the end-user + produceUserAnswer: Whether this response is for the end-user temperature: Optional temperature setting Returns: AI response text """ - if not self.ai_service: + if not self.aiService: logger.error("AI service not set in LucyDOMInterface") return "Error: AI service not available" # Add language instruction for user-facing responses - if produce_user_answer and self.user_language: - ltext= f"Please respond in '{self.user_language}' language." + if produceUserAnswer and self.userLanguage: + ltext= f"Please respond in '{self.userLanguage}' language." if messages and messages[0]["role"] == "system": if "language" not in messages[0]["content"].lower(): messages[0]["content"] = f"{ltext} {messages[0]['content']}" @@ -171,13 +172,13 @@ class LucyDOMInterface: # Call the AI service if temperature is not None: - return await self.ai_service.call_api(messages, temperature=temperature) + return await self.aiService.callApi(messages, temperature=temperature) else: - return await self.ai_service.call_api(messages) + return await self.aiService.callApi(messages) # Utilities - def get_initial_id(self, table: str) -> Optional[int]: + def getInitialId(self, table: str) -> Optional[int]: """ Returns the initial ID for a table. @@ -187,96 +188,96 @@ class LucyDOMInterface: Returns: The initial ID or None if not present """ - return self.db.get_initial_id(table) + return self.db.getInitialId(table) - def _get_current_timestamp(self) -> str: + def _getCurrentTimestamp(self) -> str: """Returns the current timestamp in ISO format""" return datetime.now().isoformat() # Prompt methods - def get_all_prompts(self) -> List[Dict[str, Any]]: + def getAllPrompts(self) -> List[Dict[str, Any]]: """Returns all prompts for the current mandate""" - return self.db.get_recordset("prompts") + return self.db.getRecordset("prompts") - def get_prompt(self, prompt_id: int) -> Optional[Dict[str, Any]]: + def getPrompt(self, promptId: int) -> Optional[Dict[str, Any]]: """Returns a prompt by its ID""" - prompts = self.db.get_recordset("prompts", record_filter={"id": prompt_id}) + prompts = self.db.getRecordset("prompts", recordFilter={"id": promptId}) if prompts: return prompts[0] return None - def create_prompt(self, content: str, name: str) -> Dict[str, Any]: + def createPrompt(self, content: str, name: str) -> Dict[str, Any]: """Creates a new prompt""" - prompt_data = { - "mandate_id": self.mandate_id, - "user_id": self.user_id, + promptData = { + "mandateId": self.mandateId, + "userId": self.userId, "content": content, "name": name, - "created_at": self._get_current_timestamp() + "createdAt": self._getCurrentTimestamp() } - return self.db.record_create("prompts", prompt_data) + return self.db.recordCreate("prompts", promptData) - def update_prompt(self, prompt_id: int, content: str = None, name: str = None) -> Dict[str, Any]: + def updatePrompt(self, promptId: int, content: str = None, name: str = None) -> Dict[str, Any]: """ Updates an existing prompt Args: - prompt_id: ID of the prompt to update + promptId: ID of the prompt to update content: New content for the prompt Returns: The updated prompt object """ # Check if the prompt exists - prompt = self.get_prompt(prompt_id) + prompt = self.getPrompt(promptId) if not prompt: return None # Prepare data for update - prompt_data = {} + promptData = {} if content is not None: - prompt_data["content"] = content + promptData["content"] = content if name is not None: - prompt_data["name"] = name + promptData["name"] = name # Update prompt - return self.db.record_modify("prompts", prompt_id, prompt_data) + return self.db.recordModify("prompts", promptId, promptData) - def delete_prompt(self, prompt_id: int) -> bool: + def deletePrompt(self, promptId: int) -> bool: """ Deletes a prompt from the database Args: - prompt_id: ID of the prompt to delete + promptId: ID of the prompt to delete Returns: True if the prompt was successfully deleted, otherwise False """ - return self.db.record_delete("prompts", prompt_id) + return self.db.recordDelete("prompts", promptId) # File Utilities - def calculate_file_hash(self, file_content: bytes) -> str: + def calculateFileHash(self, fileContent: bytes) -> str: """Calculates a SHA-256 hash for the file content""" - return hashlib.sha256(file_content).hexdigest() + return hashlib.sha256(fileContent).hexdigest() - def check_for_duplicate_file(self, file_hash: str) -> Optional[Dict[str, Any]]: + def checkForDuplicateFile(self, fileHash: str) -> Optional[Dict[str, Any]]: """Checks if a file with the same hash already exists""" - files = self.db.get_recordset("files", record_filter={"file_hash": file_hash}) + files = self.db.getRecordset("files", recordFilter={"fileHash": fileHash}) if files: return files[0] return None - def get_mime_type(self, filename: str) -> str: + def getMimeType(self, filename: str) -> str: """Determines the MIME type based on the file extension""" import os ext = os.path.splitext(filename)[1].lower()[1:] - extension_to_mime = { + extensionToMime = { "pdf": "application/pdf", "docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "doc": "application/msword", @@ -300,122 +301,122 @@ class LucyDOMInterface: "js": "application/javascript", "css": "text/css" } - return extension_to_mime.get(ext.lower(), "application/octet-stream") + return extensionToMime.get(ext.lower(), "application/octet-stream") # File methods - metadata-based operations - def get_all_files(self) -> List[Dict[str, Any]]: + def getAllFiles(self) -> List[Dict[str, Any]]: """ Returns all files for the current mandate without binary data. Returns: List of FileItem objects without binary data """ - files = self.db.get_recordset("files") + files = self.db.getRecordset("files") return files - def get_file(self, file_id: int) -> Optional[Dict[str, Any]]: + def getFile(self, fileId: int) -> Optional[Dict[str, Any]]: """ Returns a file by its ID, without binary data. Args: - file_id: ID of the file + fileId: ID of the file Returns: FileItem without binary data or None if not found """ - files = self.db.get_recordset("files", record_filter={"id": file_id}) + files = self.db.getRecordset("files", recordFilter={"id": fileId}) if files: return files[0] return None - def create_file(self, name: str, mime_type: str, size: int = None, file_hash: str = None) -> Dict[str, Any]: + def createFile(self, name: str, mimeType: str, size: int = None, fileHash: str = None) -> Dict[str, Any]: """ Creates a new file entry in the database without content. The actual file content is stored separately in the FileData table. Args: name: Name of the file - mime_type: MIME type of the file + mimeType: MIME type of the file size: Size of the file in bytes - file_hash: Hash value of the file for deduplication + fileHash: Hash value of the file for deduplication Returns: The created FileItem object """ - file_data = { - "mandate_id": self.mandate_id, - "user_id": self.user_id, + fileData = { + "mandateId": self.mandateId, + "userId": self.userId, "name": name, - "mime_type": mime_type, + "mimeType": mimeType, "size": size, - "file_hash": file_hash, - "creation_date": self._get_current_timestamp() + "fileHash": fileHash, + "creationDate": self._getCurrentTimestamp() } - return self.db.record_create("files", file_data) + return self.db.recordCreate("files", fileData) - def update_file(self, file_id: int, update_data: Dict[str, Any]) -> Dict[str, Any]: + def updateFile(self, fileId: int, updateData: Dict[str, Any]) -> Dict[str, Any]: """ Updates the metadata of an existing file without affecting the binary data. Args: - file_id: ID of the file to update - update_data: Dictionary with fields to update + fileId: ID of the file to update + updateData: Dictionary with fields to update Returns: The updated FileItem object """ # Check if the file exists - file = self.get_file(file_id) + file = self.getFile(fileId) if not file: - raise FileNotFoundError(f"File with ID {file_id} not found") + raise FileNotFoundError(f"File with ID {fileId} not found") # Update file - return self.db.record_modify("files", file_id, update_data) + return self.db.recordModify("files", fileId, updateData) - def delete_file(self, file_id: int) -> bool: + def deleteFile(self, fileId: int) -> bool: """ Deletes a file from the database (metadata and content). Args: - file_id: ID of the file + fileId: ID of the file Returns: True on success, False on error """ try: # Find the file in the database - file = self.get_file(file_id) + file = self.getFile(fileId) if not file: - raise FileNotFoundError(f"File with ID {file_id} not found") + raise FileNotFoundError(f"File with ID {fileId} not found") # Check if the file belongs to the current mandate - if file.get("mandate_id") != self.mandate_id: - raise FilePermissionError(f"No permission to delete file {file_id}") + if file.get("mandateId") != self.mandateId: + raise FilePermissionError(f"No permission to delete file {fileId}") # Check for other references to this file (by hash) - file_hash = file.get("file_hash") - if file_hash: - other_references = [f for f in self.db.get_recordset("files", record_filter={"file_hash": file_hash}) - if f.get("id") != file_id] + fileHash = file.get("fileHash") + if fileHash: + otherReferences = [f for f in self.db.getRecordset("files", recordFilter={"fileHash": fileHash}) + if f.get("id") != fileId] # If other files reference this content, only delete the database entry for FileItem - if other_references: - logger.info(f"Other references to the file content found, only FileItem will be deleted: {file_id}") + if otherReferences: + logger.info(f"Other references to the file content found, only FileItem will be deleted: {fileId}") else: # Also delete the file content in the FileData table try: - file_data_entries = self.db.get_recordset("file_data", record_filter={"id": file_id}) - if file_data_entries: - self.db.record_delete("file_data", file_id) - logger.info(f"FileData for file {file_id} deleted") + fileDataEntries = self.db.getRecordset("fileData", recordFilter={"id": fileId}) + if fileDataEntries: + self.db.recordDelete("fileData", fileId) + logger.info(f"FileData for file {fileId} deleted") except Exception as e: - logger.warning(f"Error deleting FileData for file {file_id}: {str(e)}") + logger.warning(f"Error deleting FileData for file {fileId}: {str(e)}") # Delete the FileItem entry - return self.db.record_delete("files", file_id) + return self.db.recordDelete("files", fileId) except FileNotFoundError as e: # Pass through FileNotFoundError @@ -424,18 +425,18 @@ class LucyDOMInterface: # Pass through FilePermissionError raise except Exception as e: - logger.error(f"Error deleting file {file_id}: {str(e)}") + logger.error(f"Error deleting file {fileId}: {str(e)}") raise FileDeletionError(f"Error deleting file: {str(e)}") # FileData methods - binary data operations - def create_file_data(self, file_id: int, data: bytes) -> bool: + def createFileData(self, fileId: int, data: bytes) -> bool: """ Stores the binary data of a file in the database as a Base64 string. Args: - file_id: ID of the associated file + fileId: ID of the associated file data: Binary data Returns: @@ -446,8 +447,8 @@ class LucyDOMInterface: # Convert binary data to base64 string if isinstance(data, bytes): - encoded_data = base64.b64encode(data).decode('utf-8') - logger.debug(f"Converted {len(data)} bytes to base64 string of length {len(encoded_data)}") + encodedData = base64.b64encode(data).decode('utf-8') + logger.debug(f"Converted {len(data)} bytes to base64 string of length {len(encodedData)}") else: logger.warning(f"Data is not bytes, but {type(data)}. Attempting to handle...") # Try to convert to bytes if it's not already @@ -457,80 +458,80 @@ class LucyDOMInterface: # See if it's valid base64 base64.b64decode(data) # If no error, assume it's already encoded - encoded_data = data + encodedData = data logger.info(f"Data appears to be already base64 encoded, using as is") except: # Not base64, so encode the string as bytes then to base64 - encoded_data = base64.b64encode(data.encode('utf-8')).decode('utf-8') + encodedData = base64.b64encode(data.encode('utf-8')).decode('utf-8') logger.info(f"Converted string to base64") else: # For other types, convert to string first - encoded_data = base64.b64encode(str(data).encode('utf-8')).decode('utf-8') + encodedData = base64.b64encode(str(data).encode('utf-8')).decode('utf-8') logger.warning(f"Converted non-standard type to base64") - # Create the file_data record with encoded data - file_data = { - "id": file_id, - "data": encoded_data + # Create the fileData record with encoded data + fileData = { + "id": fileId, + "data": encodedData } - self.db.record_create("file_data", file_data) - logger.info(f"Successfully stored encoded data for file {file_id}") + self.db.recordCreate("fileData", fileData) + logger.info(f"Successfully stored encoded data for file {fileId}") return True except Exception as e: - logger.error(f"Error storing binary data for file {file_id}: {str(e)}") + logger.error(f"Error storing binary data for file {fileId}: {str(e)}") return False - def get_file_data(self, file_id: int) -> Optional[bytes]: + def getFileData(self, fileId: int) -> Optional[bytes]: """ Returns the binary data of a file. Converts Base64 string from the database back to bytes. Args: - file_id: ID of the file + fileId: ID of the file Returns: Binary data or None if not found """ import base64 - file_data_entries = self.db.get_recordset("file_data", record_filter={"id": file_id}) - if file_data_entries and "data" in file_data_entries[0]: - encoded_data = file_data_entries[0]["data"] + fileDataEntries = self.db.getRecordset("fileData", recordFilter={"id": fileId}) + if fileDataEntries and "data" in fileDataEntries[0]: + encodedData = fileDataEntries[0]["data"] try: # Check if it's a string (most likely base64) - if isinstance(encoded_data, str): + if isinstance(encodedData, str): try: # Try to decode base64 - binary_data = base64.b64decode(encoded_data) - logger.debug(f"Successfully decoded base64 string to {len(binary_data)} bytes") - return binary_data + binaryData = base64.b64decode(encodedData) + logger.debug(f"Successfully decoded base64 string to {len(binaryData)} bytes") + return binaryData except Exception as e: logger.error(f"Failed to decode base64 data: {str(e)}") # If it's not valid base64, return as bytes - return encoded_data.encode('utf-8') + return encodedData.encode('utf-8') # If it's already bytes (shouldn't happen with model change) - elif isinstance(encoded_data, bytes): + elif isinstance(encodedData, bytes): logger.warning(f"Data was already bytes, no conversion needed") - return encoded_data + return encodedData else: - logger.error(f"Unexpected data type in database: {type(encoded_data)}") + logger.error(f"Unexpected data type in database: {type(encodedData)}") return None except Exception as e: logger.error(f"Error processing file data: {str(e)}") return None else: - logger.warning(f"No data found for file ID {file_id}") + logger.warning(f"No data found for file ID {fileId}") return None - def update_file_data(self, file_id: int, data: Union[bytes, str]) -> bool: + def updateFileData(self, fileId: int, data: Union[bytes, str]) -> bool: """ Updates the binary data of a file in the database. Converts bytes to Base64 string for storage. Args: - file_id: ID of the file + fileId: ID of the file data: New binary data or encoded data Returns: @@ -541,7 +542,7 @@ class LucyDOMInterface: # Convert data to base64 string if it's bytes if isinstance(data, bytes): - encoded_data = base64.b64encode(data).decode('utf-8') + encodedData = base64.b64encode(data).decode('utf-8') logger.debug(f"Converted {len(data)} bytes to base64 string") elif isinstance(data, str): # Check if it might already be base64 encoded @@ -549,439 +550,439 @@ class LucyDOMInterface: # See if it's valid base64 base64.b64decode(data) # If no error, assume it's already encoded - encoded_data = data + encodedData = data logger.debug(f"Data appears to be already base64 encoded, using as is") except: # Not base64, so encode the string as bytes then to base64 - encoded_data = base64.b64encode(data.encode('utf-8')).decode('utf-8') + encodedData = base64.b64encode(data.encode('utf-8')).decode('utf-8') logger.debug(f"Converted string to base64") else: # For other types, convert to string first - encoded_data = base64.b64encode(str(data).encode('utf-8')).decode('utf-8') + encodedData = base64.b64encode(str(data).encode('utf-8')).decode('utf-8') logger.warning(f"Converted non-standard type to base64") # Check if a record already exists - file_data_entries = self.db.get_recordset("file_data", record_filter={"id": file_id}) + fileDataEntries = self.db.getRecordset("fileData", recordFilter={"id": fileId}) - if file_data_entries: + if fileDataEntries: # Update the existing record - self.db.record_modify("file_data", file_id, {"data": encoded_data}) - logger.info(f"Updated existing file data for file ID {file_id}") + self.db.recordModify("fileData", fileId, {"data": encodedData}) + logger.info(f"Updated existing file data for file ID {fileId}") else: # Create a new record - file_data = { - "id": file_id, - "data": encoded_data + fileData = { + "id": fileId, + "data": encodedData } - self.db.record_create("file_data", file_data) - logger.info(f"Created new file data for file ID {file_id}") + self.db.recordCreate("fileData", fileData) + logger.info(f"Created new file data for file ID {fileId}") return True except Exception as e: - logger.error(f"Error updating binary data for file {file_id}: {str(e)}") + logger.error(f"Error updating binary data for file {fileId}: {str(e)}") return False - def save_uploaded_file(self, file_content: bytes, file_name: str) -> Dict[str, Any]: + def saveUploadedFile(self, fileContent: bytes, fileName: str) -> Dict[str, Any]: """ Saves an uploaded file in the database. Metadata is stored in the 'files' table, - Binary data in the 'file_data' table as a Base64 string. + Binary data in the 'fileData' table as a Base64 string. Args: - file_content: Binary data of the file - file_name: Name of the file + fileContent: Binary data of the file + fileName: Name of the file Returns: Dictionary with metadata of the saved file """ try: # Debug: Log the start of the file upload process - logger.info(f"Starting upload process for file: {file_name}") + logger.info(f"Starting upload process for file: {fileName}") - # Debug: Check if file_content is valid bytes - if not isinstance(file_content, bytes): - logger.error(f"Invalid file_content type: {type(file_content)}") - raise ValueError(f"file_content must be bytes, got {type(file_content)}") + # Debug: Check if fileContent is valid bytes + if not isinstance(fileContent, bytes): + logger.error(f"Invalid fileContent type: {type(fileContent)}") + raise ValueError(f"fileContent must be bytes, got {type(fileContent)}") # Calculate file hash for deduplication - file_hash = self.calculate_file_hash(file_content) - logger.debug(f"Calculated file hash: {file_hash}") + fileHash = self.calculateFileHash(fileContent) + logger.debug(f"Calculated file hash: {fileHash}") # Check for duplicate - existing_file = self.check_for_duplicate_file(file_hash) - if existing_file: + existingFile = self.checkForDuplicateFile(fileHash) + if existingFile: # Simply return the existing file metadata - logger.info(f"Duplicate found for {file_name}: {existing_file['id']}") - return existing_file + logger.info(f"Duplicate found for {fileName}: {existingFile['id']}") + return existingFile # Determine MIME type - mime_type = self.get_mime_type(file_name) + mimeType = self.getMimeType(fileName) # Determine file size - file_size = len(file_content) + fileSize = len(fileContent) # 1. Save metadata in the 'files' table - logger.info(f"Saving file metadata to database for file: {file_name}") - db_file = self.create_file( - name=file_name, - mime_type=mime_type, - size=file_size, - file_hash=file_hash + logger.info(f"Saving file metadata to database for file: {fileName}") + dbFile = self.createFile( + name=fileName, + mimeType=mimeType, + size=fileSize, + fileHash=fileHash ) - # 2. Save binary data as Base64 string in the 'file_data' table - logger.info(f"Saving file content to database for file: {file_name}") - self.create_file_data(db_file["id"], file_content) + # 2. Save binary data as Base64 string in the 'fileData' table + logger.info(f"Saving file content to database for file: {fileName}") + self.createFileData(dbFile["id"], fileContent) # Debug: Export file to static folder - self._export_file_to_static(file_content, db_file["id"], file_name) # DEBUG TODO + self._exportFileToStatic(fileContent, dbFile["id"], fileName) # DEBUG TODO # Debug: Verify database record was created - if not db_file: - logger.warning(f"Database record for file {file_name} was not created properly") + if not dbFile: + logger.warning(f"Database record for file {fileName} was not created properly") else: - logger.debug(f"Database record created for file {file_name}") + logger.debug(f"Database record created for file {fileName}") - logger.info(f"File upload process completed for: {file_name}") - return db_file + logger.info(f"File upload process completed for: {fileName}") + return dbFile except Exception as e: - logger.error(f"Error in save_uploaded_file for {file_name}: {str(e)}", exc_info=True) + logger.error(f"Error in saveUploadedFile for {fileName}: {str(e)}", exc_info=True) raise FileStorageError(f"Error saving file: {str(e)}") - def download_file(self, file_id: int) -> Optional[Dict[str, Any]]: + def downloadFile(self, fileId: int) -> Optional[Dict[str, Any]]: """ Returns a file for download, including binary data. Args: - file_id: ID of the file + fileId: ID of the file Returns: Dictionary with file data and metadata or None if not found """ try: # 1. Get metadata from the 'files' table - file = self.get_file(file_id) + file = self.getFile(fileId) if not file: - raise FileNotFoundError(f"File with ID {file_id} not found") + raise FileNotFoundError(f"File with ID {fileId} not found") - # 2. Get binary data from the 'file_data' table - file_content = self.get_file_data(file_id) + # 2. Get binary data from the 'fileData' table + fileContent = self.getFileData(fileId) - if file_content is None: - raise FileNotFoundError(f"Binary data for file with ID {file_id} not found") + if fileContent is None: + raise FileNotFoundError(f"Binary data for file with ID {fileId} not found") return { - "id": file_id, - "name": file.get("name", f"file_{file_id}"), - "content_type": file.get("mime_type", "application/octet-stream"), - "size": file.get("size", len(file_content)), - "content": file_content + "id": fileId, + "name": file.get("name", f"file_{fileId}"), + "contentType": file.get("mimeType", "application/octet-stream"), + "size": file.get("size", len(fileContent)), + "content": fileContent } except FileNotFoundError as e: # Re-raise FileNotFoundError as is raise except Exception as e: - logger.error(f"Error downloading file {file_id}: {str(e)}") + logger.error(f"Error downloading file {fileId}: {str(e)}") raise FileError(f"Error downloading file: {str(e)}") - def _export_file_to_static(self, file_content: bytes, file_id: int, file_name: str): - debug_filename = f"{file_id}_{file_name}" - with open(f"./static/{debug_filename}", 'wb') as f: - f.write(file_content) + def _exportFileToStatic(self, fileContent: bytes, fileId: int, fileName: str): + debugFilename = f"{fileId}_{fileName}" + with open(f"./static/{debugFilename}", 'wb') as f: + f.write(fileContent) # Workflow methods - def get_all_workflows(self) -> List[Dict[str, Any]]: + def getAllWorkflows(self) -> List[Dict[str, Any]]: """Returns all workflows for the current mandate""" - return self.db.get_recordset("workflows") + return self.db.getRecordset("workflows") - def get_workflows_by_user(self, user_id: int) -> List[Dict[str, Any]]: + def getWorkflowsByUser(self, userId: int) -> List[Dict[str, Any]]: """Returns all workflows for a user""" - return self.db.get_recordset("workflows", record_filter={"user_id": user_id}) + return self.db.getRecordset("workflows", recordFilter={"userId": userId}) - def get_workflow(self, workflow_id: str) -> Optional[Dict[str, Any]]: + def getWorkflow(self, workflowId: str) -> Optional[Dict[str, Any]]: """Returns a workflow by its ID""" - workflows = self.db.get_recordset("workflows", record_filter={"id": workflow_id}) + workflows = self.db.getRecordset("workflows", recordFilter={"id": workflowId}) if workflows: return workflows[0] return None - def create_workflow(self, workflow_data: Dict[str, Any]) -> Dict[str, Any]: + def createWorkflow(self, workflowData: Dict[str, Any]) -> Dict[str, Any]: """Creates a new workflow in the database""" - # Make sure mandate_id and user_id are set - if "mandate_id" not in workflow_data: - workflow_data["mandate_id"] = self.mandate_id + # Make sure mandateId and userId are set + if "mandateId" not in workflowData: + workflowData["mandateId"] = self.mandateId - if "user_id" not in workflow_data: - workflow_data["user_id"] = self.user_id + if "userId" not in workflowData: + workflowData["userId"] = self.userId # Set timestamp if not present - current_time = self._get_current_timestamp() - if "started_at" not in workflow_data: - workflow_data["started_at"] = current_time + currentTime = self._getCurrentTimestamp() + if "startedAt" not in workflowData: + workflowData["startedAt"] = currentTime - if "last_activity" not in workflow_data: - workflow_data["last_activity"] = current_time + if "lastActivity" not in workflowData: + workflowData["lastActivity"] = currentTime - return self.db.record_create("workflows", workflow_data) + return self.db.recordCreate("workflows", workflowData) - def update_workflow(self, workflow_id: str, workflow_data: Dict[str, Any]) -> Dict[str, Any]: + def updateWorkflow(self, workflowId: str, workflowData: Dict[str, Any]) -> Dict[str, Any]: """ Updates an existing workflow. Args: - workflow_id: ID of the workflow to update - workflow_data: New data for the workflow + workflowId: ID of the workflow to update + workflowData: New data for the workflow Returns: The updated workflow object """ # Check if the workflow exists - workflow = self.get_workflow(workflow_id) + workflow = self.getWorkflow(workflowId) if not workflow: return None # Set update time - workflow_data["last_activity"] = self._get_current_timestamp() + workflowData["lastActivity"] = self._getCurrentTimestamp() # Update workflow - return self.db.record_modify("workflows", workflow_id, workflow_data) + return self.db.recordModify("workflows", workflowId, workflowData) - def delete_workflow(self, workflow_id: str) -> bool: + def deleteWorkflow(self, workflowId: str) -> bool: """ Deletes a workflow from the database. Args: - workflow_id: ID of the workflow to delete + workflowId: ID of the workflow to delete Returns: True on success, False if the workflow doesn't exist """ # Check if the workflow exists - workflow = self.get_workflow(workflow_id) + workflow = self.getWorkflow(workflowId) if not workflow: return False # Check if the user is the owner or has admin rights - if workflow.get("user_id") != self.user_id: + if workflow.get("userId") != self.userId: # Here could be a check for admin rights return False # Delete workflow - return self.db.record_delete("workflows", workflow_id) + return self.db.recordDelete("workflows", workflowId) # Workflow Messages - def get_workflow_messages(self, workflow_id: str) -> List[Dict[str, Any]]: + def getWorkflowMessages(self, workflowId: str) -> List[Dict[str, Any]]: """Returns all messages of a workflow""" - return self.db.get_recordset("workflow_messages", record_filter={"workflow_id": workflow_id}) + return self.db.getRecordset("workflowMessages", recordFilter={"workflowId": workflowId}) - def create_workflow_message(self, message_data: Dict[str, Any]) -> Dict[str, Any]: + def createWorkflowMessage(self, messageData: Dict[str, Any]) -> Dict[str, Any]: """ Creates a new message for a workflow. Args: - message_data: The message data + messageData: The message data Returns: The created message or None on error """ try: # Check if required fields are present - required_fields = ["id", "workflow_id"] - for field in required_fields: - if field not in message_data: - logger.error(f"Required field '{field}' missing in message_data") + requiredFields = ["id", "workflowId"] + for field in requiredFields: + if field not in messageData: + logger.error(f"Required field '{field}' missing in messageData") raise ValueError(f"Required field '{field}' missing in message data") # Validate that ID is not None - if message_data["id"] is None: - message_data["id"] = f"msg_{uuid.uuid4()}" - logger.warning(f"Automatically generated ID for workflow message: {message_data['id']}") + if messageData["id"] is None: + messageData["id"] = f"msg_{uuid.uuid4()}" + logger.warning(f"Automatically generated ID for workflow message: {messageData['id']}") # Ensure required fields are present - if "started_at" not in message_data and "created_at" not in message_data: - message_data["started_at"] = self._get_current_timestamp() + if "startedAt" not in messageData and "createdAt" not in messageData: + messageData["startedAt"] = self._getCurrentTimestamp() - if "created_at" in message_data and "started_at" not in message_data: - message_data["started_at"] = message_data["created_at"] - del message_data["created_at"] + if "createdAt" in messageData and "startedAt" not in messageData: + messageData["startedAt"] = messageData["createdAt"] + del messageData["createdAt"] # Set status if not present - if "status" not in message_data: - message_data["status"] = "completed" + if "status" not in messageData: + messageData["status"] = "completed" # Set sequence number if not present - if "sequence_no" not in message_data: + if "sequenceNo" not in messageData: # Get current messages to determine next sequence number - existing_messages = self.get_workflow_messages(message_data["workflow_id"]) - message_data["sequence_no"] = len(existing_messages) + 1 + existingMessages = self.getWorkflowMessages(messageData["workflowId"]) + messageData["sequenceNo"] = len(existingMessages) + 1 - # Ensure role and agent_name are present - if "role" not in message_data: - message_data["role"] = "assistant" if message_data.get("agent_name") else "user" + # Ensure role and agentName are present + if "role" not in messageData: + messageData["role"] = "assistant" if messageData.get("agentName") else "user" - if "agent_name" not in message_data: - message_data["agent_name"] = "" + if "agentName" not in messageData: + messageData["agentName"] = "" # Debug log for data to create - logger.debug(f"Creating workflow message with data: {message_data}") + logger.debug(f"Creating workflow message with data: {messageData}") # Create message in database - created_message = self.db.record_create("workflow_messages", message_data) + createdMessage = self.db.recordCreate("workflowMessages", messageData) - # Update workflow's message_ids if this is a new message - if created_message: - workflow_id = message_data["workflow_id"] - workflow = self.get_workflow(workflow_id) + # Update workflow's messageIds if this is a new message + if createdMessage: + workflowId = messageData["workflowId"] + workflow = self.getWorkflow(workflowId) if workflow: - # Get current message_ids or initialize empty list - message_ids = workflow.get("message_ids", []) + # Get current messageIds or initialize empty list + messageIds = workflow.get("messageIds", []) # Add the new message ID if not already in the list - if created_message["id"] not in message_ids: - message_ids.append(created_message["id"]) - self.update_workflow(workflow_id, {"message_ids": message_ids}) + if createdMessage["id"] not in messageIds: + messageIds.append(createdMessage["id"]) + self.updateWorkflow(workflowId, {"messageIds": messageIds}) - return created_message + return createdMessage except Exception as e: logger.error(f"Error creating workflow message: {str(e)}") # Return None instead of raising to avoid cascading failures return None - def update_workflow_message(self, message_id: str, message_data: Dict[str, Any]) -> Dict[str, Any]: + def updateWorkflowMessage(self, messageId: str, messageData: Dict[str, Any]) -> Dict[str, Any]: """ Updates an existing workflow message in the database. Args: - message_id: ID of the message - message_data: Data to update + messageId: ID of the message + messageData: Data to update Returns: The updated message object or None on error """ try: # Debug info - logger.debug(f"Updating message {message_id} in database") + logger.debug(f"Updating message {messageId} in database") - # Ensure message_id is provided - if not message_id: - logger.error("No message_id provided for update_workflow_message") - raise ValueError("message_id cannot be empty") + # Ensure messageId is provided + if not messageId: + logger.error("No messageId provided for updateWorkflowMessage") + raise ValueError("messageId cannot be empty") # Check if message exists in database - messages = self.db.get_recordset("workflow_messages", record_filter={"id": message_id}) + messages = self.db.getRecordset("workflowMessages", recordFilter={"id": messageId}) if not messages: - logger.warning(f"Message with ID {message_id} does not exist in database") + logger.warning(f"Message with ID {messageId} does not exist in database") - # If message doesn't exist but we have workflow_id, create it - if "workflow_id" in message_data: - logger.info(f"Creating new message with ID {message_id} for workflow {message_data.get('workflow_id')}") - return self.db.record_create("workflow_messages", message_data) + # If message doesn't exist but we have workflowId, create it + if "workflowId" in messageData: + logger.info(f"Creating new message with ID {messageId} for workflow {messageData.get('workflowId')}") + return self.db.recordCreate("workflowMessages", messageData) else: - logger.error(f"Workflow ID missing for new message {message_id}") + logger.error(f"Workflow ID missing for new message {messageId}") return None # Update existing message - existing_message = messages[0] + existingMessage = messages[0] # Ensure required fields present - for key in ["role", "agent_name"]: - if key not in message_data and key not in existing_message: - message_data[key] = "assistant" if key == "role" else "" + for key in ["role", "agentName"]: + if key not in messageData and key not in existingMessage: + messageData[key] = "assistant" if key == "role" else "" # Ensure ID is in the dataset - if 'id' not in message_data: - message_data['id'] = message_id + if 'id' not in messageData: + messageData['id'] = messageId - # Convert created_at to started_at if needed - if "created_at" in message_data and "started_at" not in message_data: - message_data["started_at"] = message_data["created_at"] - del message_data["created_at"] + # Convert createdAt to startedAt if needed + if "createdAt" in messageData and "startedAt" not in messageData: + messageData["startedAt"] = messageData["createdAt"] + del messageData["createdAt"] # Update the message - updated_message = self.db.record_modify("workflow_messages", message_id, message_data) - if updated_message: - logger.info(f"Message {message_id} updated successfully") + updatedMessage = self.db.recordModify("workflowMessages", messageId, messageData) + if updatedMessage: + logger.info(f"Message {messageId} updated successfully") else: - logger.warning(f"Failed to update message {message_id}") + logger.warning(f"Failed to update message {messageId}") - return updated_message + return updatedMessage except Exception as e: - logger.error(f"Error updating message {message_id}: {str(e)}", exc_info=True) + logger.error(f"Error updating message {messageId}: {str(e)}", exc_info=True) # Re-raise with full information - raise ValueError(f"Error updating message {message_id}: {str(e)}") + raise ValueError(f"Error updating message {messageId}: {str(e)}") - def delete_workflow_message(self, workflow_id: str, message_id: str) -> bool: + def deleteWorkflowMessage(self, workflowId: str, messageId: str) -> bool: """ Deletes a message from a workflow in the database. Args: - workflow_id: ID of the associated workflow - message_id: ID of the message to delete + workflowId: ID of the associated workflow + messageId: ID of the message to delete Returns: True on success, False on error """ try: # Check if the message exists - messages = self.get_workflow_messages(workflow_id) - message = next((m for m in messages if m.get("id") == message_id), None) + messages = self.getWorkflowMessages(workflowId) + message = next((m for m in messages if m.get("id") == messageId), None) if not message: - logger.warning(f"Message {message_id} for workflow {workflow_id} not found") + logger.warning(f"Message {messageId} for workflow {workflowId} not found") return False # Delete the message from the database - return self.db.record_delete("workflow_messages", message_id) + return self.db.recordDelete("workflowMessages", messageId) except Exception as e: - logger.error(f"Error deleting message {message_id}: {str(e)}") + logger.error(f"Error deleting message {messageId}: {str(e)}") return False - def delete_file_from_message(self, workflow_id: str, message_id: str, file_id: int) -> bool: + def deleteFileFromMessage(self, workflowId: str, messageId: str, fileId: int) -> bool: """ Removes a file reference from a message. The file itself is not deleted, only the reference in the message. Enhanced version with improved file matching. Args: - workflow_id: ID of the associated workflow - message_id: ID of the message - file_id: ID of the file to remove + workflowId: ID of the associated workflow + messageId: ID of the message + fileId: ID of the file to remove Returns: True on success, False on error """ try: # Log operation - logger.info(f"Removing file {file_id} from message {message_id} in workflow {workflow_id}") + logger.info(f"Removing file {fileId} from message {messageId} in workflow {workflowId}") # Get all workflow messages - all_messages = self.get_workflow_messages(workflow_id) - logger.debug(f"Workflow {workflow_id} has {len(all_messages)} messages") + allMessages = self.getWorkflowMessages(workflowId) + logger.debug(f"Workflow {workflowId} has {len(allMessages)} messages") # Try different approaches to find the message message = None # Exact match - message = next((m for m in all_messages if m.get("id") == message_id), None) + message = next((m for m in allMessages if m.get("id") == messageId), None) # Case-insensitive match - if not message and isinstance(message_id, str): - message = next((m for m in all_messages - if isinstance(m.get("id"), str) and m.get("id").lower() == message_id.lower()), None) + if not message and isinstance(messageId, str): + message = next((m for m in allMessages + if isinstance(m.get("id"), str) and m.get("id").lower() == messageId.lower()), None) # Partial match (starts with) - if not message and isinstance(message_id, str): - message = next((m for m in all_messages - if isinstance(m.get("id"), str) and m.get("id").startswith(message_id)), None) + if not message and isinstance(messageId, str): + message = next((m for m in allMessages + if isinstance(m.get("id"), str) and m.get("id").startswith(messageId)), None) if not message: - logger.warning(f"Message {message_id} not found in workflow {workflow_id}") + logger.warning(f"Message {messageId} not found in workflow {workflowId}") return False # Log the found message @@ -989,283 +990,290 @@ class LucyDOMInterface: # Check if message has documents if "documents" not in message or not message["documents"]: - logger.warning(f"No documents in message {message_id}") + logger.warning(f"No documents in message {messageId}") return False # Log existing documents documents = message.get("documents", []) logger.debug(f"Message has {len(documents)} documents") for i, doc in enumerate(documents): - doc_id = doc.get("id", "unknown") - file_id_value = doc.get("file_id", "unknown") - logger.debug(f"Document {i}: doc_id={doc_id}, file_id={file_id_value}") + docId = doc.get("id", "unknown") + fileIdValue = doc.get("fileId", "unknown") + logger.debug(f"Document {i}: docId={docId}, fileId={fileIdValue}") # Create a new list of documents without the one to delete - updated_documents = [] + updatedDocuments = [] removed = False for doc in documents: - doc_id = doc.get("id") - file_id_value = doc.get("file_id") + docId = doc.get("id") + fileIdValue = doc.get("fileId") # Flexible matching approach - should_remove = ( - (doc_id == file_id) or - (file_id_value == file_id) or - (isinstance(doc_id, str) and str(file_id) in doc_id) or - (isinstance(file_id_value, str) and str(file_id) in file_id_value) + shouldRemove = ( + (docId == fileId) or + (fileIdValue == fileId) or + (isinstance(docId, str) and str(fileId) in docId) or + (isinstance(fileIdValue, str) and str(fileId) in fileIdValue) ) - if should_remove: + if shouldRemove: removed = True - logger.info(f"Found file to remove: doc_id={doc_id}, file_id={file_id_value}") + logger.info(f"Found file to remove: docId={docId}, fileId={fileIdValue}") else: - updated_documents.append(doc) + updatedDocuments.append(doc) if not removed: - logger.warning(f"No matching file {file_id} found in message {message_id}") + logger.warning(f"No matching file {fileId} found in message {messageId}") return False # Update message with modified documents array - message_update = { - "documents": updated_documents + messageUpdate = { + "documents": updatedDocuments } # Apply the update directly to the database - updated = self.db.record_modify("workflow_messages", message["id"], message_update) + updated = self.db.recordModify("workflowMessages", message["id"], messageUpdate) if updated: - logger.info(f"Successfully removed file {file_id} from message {message_id}") + logger.info(f"Successfully removed file {fileId} from message {messageId}") return True else: - logger.warning(f"Failed to update message {message_id} in database") + logger.warning(f"Failed to update message {messageId} in database") return False except Exception as e: - logger.error(f"Error removing file {file_id} from message {message_id}: {str(e)}") + logger.error(f"Error removing file {fileId} from message {messageId}: {str(e)}") return False # Workflow Logs - def get_workflow_logs(self, workflow_id: str) -> List[Dict[str, Any]]: - """Returns all log entries for a workflow""" - return self.db.get_recordset("workflow_logs", record_filter={"workflow_id": workflow_id}) + def getWorkflowLogs(self, workflowId: str) -> List[Dict[str, Any]]: + """Returns all log entries for a workflow""" + return self.db.getRecordset("workflowLogs", recordFilter={"workflowDd": workflowId}) - def create_workflow_log(self, log_data: Dict[str, Any]) -> Dict[str, Any]: + def createWorkflowLog(self, logData: Dict[str, Any]) -> Dict[str, Any]: """Creates a new log entry for a workflow""" # Make sure required fields are present - if "timestamp" not in log_data: - log_data["timestamp"] = self._get_current_timestamp() + if "timestamp" not in logData: + logData["timestamp"] = self._getCurrentTimestamp() # Add status information if not present - if "status" not in log_data and "type" in log_data: - if log_data["type"] == "error": - log_data["status"] = "error" + if "status" not in logData and "type" in logData: + if logData["type"] == "error": + logData["status"] = "error" else: - log_data["status"] = "running" + logData["status"] = "running" # Add progress information if not present - if "progress" not in log_data: + if "progress" not in logData: # Default progress values based on log type - if log_data.get("type") == "info": - log_data["progress"] = 50 # Default middle progress - elif log_data.get("type") == "error": - log_data["progress"] = -1 # Error state - elif log_data.get("type") == "warning": - log_data["progress"] = 50 # Default middle progress + if logData.get("type") == "info": + logData["progress"] = 50 # Default middle progress + elif logData.get("type") == "error": + logData["progress"] = -1 # Error state + elif logData.get("type") == "warning": + logData["progress"] = 50 # Default middle progress - return self.db.record_create("workflow_logs", log_data) + return self.db.recordCreate("workflowLogs", logData) # Workflow Management - def save_workflow_state(self, workflow: Dict[str, Any], save_messages: bool = True, save_logs: bool = True) -> bool: + def saveWorkflowState(self, workflow: Dict[str, Any], saveMessages: bool = True, saveLogs: bool = True) -> bool: """ Saves the state of a workflow to the database. Workflow data is updated, but messages are stored separately. Args: workflow: The workflow object - save_messages: Flag to determine if messages should be saved - save_logs: Flag to determine if logs should be saved + saveMessages: Flag to determine if messages should be saved + saveLogs: Flag to determine if logs should be saved Returns: True on success, False on failure """ try: - workflow_id = workflow.get("id") - if not workflow_id: + workflowId = workflow.get("id") + if not workflowId: return False # Extract only the database-relevant workflow fields # IMPORTANT: Don't store messages in the workflow table! - workflow_db_data = { - "id": workflow_id, - "mandate_id": workflow.get("mandate_id", self.mandate_id), - "user_id": workflow.get("user_id", self.user_id), - "name": workflow.get("name", f"Workflow {workflow_id}"), + workflowDbData = { + "id": workflowId, + "mandateId": workflow.get("mandateId", self.mandateId), + "userId": workflow.get("userId", self.userId), + "name": workflow.get("name", f"Workflow {workflowId}"), "status": workflow.get("status", "completed"), - "started_at": workflow.get("started_at", self._get_current_timestamp()), - "last_activity": workflow.get("last_activity", self._get_current_timestamp()), - "data_stats": workflow.get("data_stats", {}) + "startedAt": workflow.get("startedAt", self._getCurrentTimestamp()), + "lastActivity": workflow.get("lastActivity", self._getCurrentTimestamp()), + "dataStats": workflow.get("dataStats", {}) } # Check if workflow already exists - existing_workflow = self.get_workflow(workflow_id) - if existing_workflow: - self.update_workflow(workflow_id, workflow_db_data) + existingWorkflow = self.getWorkflow(workflowId) + if existingWorkflow: + self.updateWorkflow(workflowId, workflowDbData) else: - self.create_workflow(workflow_db_data) + self.createWorkflow(workflowDbData) # Save messages - if save_messages and "messages" in workflow: + if saveMessages and "messages" in workflow: for message in workflow["messages"]: - message_id = message.get("id") - if not message_id: + messageId = message.get("id") + if not messageId: continue - # Since each message is already saved with create_workflow_message, + # Since each message is already saved with createWorkflowMessage, # we only need to check if updates are necessary # First, get existing message from database - existing_messages = self.get_workflow_messages(workflow_id) - existing_message = next((m for m in existing_messages if m.get("id") == message_id), None) + existingMessages = self.getWorkflowMessages(workflowId) + existingMessage = next((m for m in existingMessages if m.get("id") == messageId), None) - if existing_message: + if existingMessage: # Check if updates are needed - has_changes = False - for key in ["role", "agent_name", "content", "status", "documents"]: - if key in message and message.get(key) != existing_message.get(key): - has_changes = True + hasChanges = False + for key in ["role", "agentName", "content", "status", "documents"]: + if key in message and message.get(key) != existingMessage.get(key): + hasChanges = True break - if has_changes: + if hasChanges: # Extract only relevant data for the database - message_data = { - "role": message.get("role", existing_message.get("role", "unknown")), - "content": message.get("content", existing_message.get("content", "")), - "agent_name": message.get("agent_name", existing_message.get("agent_name", "")), - "status": message.get("status", existing_message.get("status", "completed")), - "documents": message.get("documents", existing_message.get("documents", [])) + messageData = { + "role": message.get("role", existingMessage.get("role", "unknown")), + "content": message.get("content", existingMessage.get("content", "")), + "agentName": message.get("agentName", existingMessage.get("agentName", "")), + "status": message.get("status", existingMessage.get("status", "completed")), + "documents": message.get("documents", existingMessage.get("documents", [])) } - self.update_workflow_message(message_id, message_data) + self.updateWorkflowMessage(messageId, messageData) else: # Message doesn't exist in database yet - # It should have been saved via create_workflow_message + # It should have been saved via createWorkflowMessage # If not, log a warning - logger.warning(f"Message {message_id} in workflow {workflow_id} not found in database") + logger.warning(f"Message {messageId} in workflow {workflowId} not found in database") # Save logs - if save_logs and "logs" in workflow: + if saveLogs and "logs" in workflow: # Get existing logs - existing_logs = {log["id"]: log for log in self.get_workflow_logs(workflow_id)} + existingLogs = {log["id"]: log for log in self.getWorkflowLogs(workflowId)} for log in workflow["logs"]: - log_id = log.get("id") - if not log_id: + logId = log.get("id") + if not logId: continue # Extract only relevant data for the database - log_data = { - "id": log_id, - "workflow_id": workflow_id, + logData = { + "id": logId, + "workflowId": workflowId, "message": log.get("message", ""), "type": log.get("type", "info"), - "timestamp": log.get("timestamp", self._get_current_timestamp()), - "agent_name": log.get("agent_name", "(undefined)"), + "timestamp": log.get("timestamp", self._getCurrentTimestamp()), + "agentName": log.get("agentName", "(undefined)"), "status": log.get("status", "running"), "progress": log.get("progress", 50) } # Create or update log - if log_id in existing_logs: - self.db.record_modify("workflow_logs", log_id, log_data) + if logId in existingLogs: + self.db.recordModify("workflowLogs", logId, logData) else: - self.db.record_create("workflow_logs", log_id, log_data) + self.db.recordCreate("workflowLogs", logData) return True except Exception as e: logger.error(f"Error saving workflow state: {str(e)}") return False - def load_workflow_state(self, workflow_id: str) -> Optional[Dict[str, Any]]: + def loadWorkflowState(self, workflowId: str) -> Optional[Dict[str, Any]]: """ Loads the complete state of a workflow from the database. This includes the workflow itself, messages, and logs. Args: - workflow_id: ID of the workflow to load + workflowId: ID of the workflow to load Returns: The complete workflow object or None on error """ try: # Load base workflow - workflow = self.get_workflow(workflow_id) + workflow = self.getWorkflow(workflowId) if not workflow: return None # Log the workflow base retrieval - logger.debug(f"Loaded base workflow {workflow_id} from database") + logger.debug(f"Loaded base workflow {workflowId} from database") # Load messages - messages = self.get_workflow_messages(workflow_id) + messages = self.getWorkflowMessages(workflowId) # Sort by sequence number - messages.sort(key=lambda x: x.get("sequence_no", 0)) + messages.sort(key=lambda x: x.get("sequenceNo", 0)) # Debug log for messages and document counts - message_count = len(messages) - logger.debug(f"Loaded {message_count} messages for workflow {workflow_id}") + messageCount = len(messages) + logger.debug(f"Loaded {messageCount} messages for workflow {workflowId}") - # Check if message_ids exists and is valid - message_ids = workflow.get("message_ids", []) - if not message_ids or len(message_ids) != len(messages): - # Rebuild message_ids from messages - message_ids = [msg.get("id") for msg in messages] + # Check if messageIds exists and is valid + messageIds = workflow.get("messageIds", []) + if not messageIds or len(messageIds) != len(messages): + # Rebuild messageIds from messages + messageIds = [msg.get("id") for msg in messages] # Update in database - self.update_workflow(workflow_id, {"message_ids": message_ids}) - logger.info(f"Rebuilt message_ids for workflow {workflow_id}") + self.updateWorkflow(workflowId, {"messageIds": messageIds}) + logger.info(f"Rebuilt messageIds for workflow {workflowId}") # Log document counts for each message for msg in messages: - doc_count = len(msg.get("documents", [])) - if doc_count > 0: - logger.info(f"Message {msg.get('id')} has {doc_count} documents loaded from database") + docCount = len(msg.get("documents", [])) + if docCount > 0: + logger.info(f"Message {msg.get('id')} has {docCount} documents loaded from database") # Load logs - logs = self.get_workflow_logs(workflow_id) + logs = self.getWorkflowLogs(workflowId) # Sort by timestamp logs.sort(key=lambda x: x.get("timestamp", "")) # Assemble complete workflow object - complete_workflow = workflow.copy() - complete_workflow["messages"] = messages - complete_workflow["message_ids"] = message_ids # Ensure message_ids is included - complete_workflow["logs"] = logs + completeWorkflow = workflow.copy() + completeWorkflow["messages"] = messages + completeWorkflow["messageIds"] = messageIds # Ensure messageIds is included + completeWorkflow["logs"] = logs - return complete_workflow + return completeWorkflow except Exception as e: logger.error(f"Error loading workflow state: {str(e)}") return None # Singleton factory for LucyDOMInterface instances per context -_lucydom_interfaces = {} +_lucydomInterfaces = {} -def get_lucydom_interface(mandate_id: int = 0, user_id: int = 0) -> LucyDOMInterface: +def getLucydomInterface(mandateId: int = 0, userId: int = 0) -> LucyDOMInterface: """ Returns a LucyDOMInterface instance for the specified context. Reuses existing instances. + + Args: + mandateId: ID of the mandate + userId: ID of the user + + Returns: + LucyDOMInterface instance """ - context_key = f"{mandate_id}_{user_id}" - if context_key not in _lucydom_interfaces: + contextKey = f"{mandateId}_{userId}" + if contextKey not in _lucydomInterfaces: # Create new interface instance - interface = LucyDOMInterface(mandate_id, user_id) + interface = LucyDOMInterface(mandateId, userId) # Initialize AI service - ai_service = ChatService() - interface.ai_service = ai_service # Directly set the attribute - _lucydom_interfaces[context_key] = interface - return _lucydom_interfaces[context_key] + aiService = ChatService() + interface.aiService = aiService # Directly set the attribute + _lucydomInterfaces[contextKey] = interface + return _lucydomInterfaces[contextKey] # Init -get_lucydom_interface() \ No newline at end of file +getLucydomInterface() \ No newline at end of file diff --git a/modules/lucydom_model.py b/modules/lucydomModel.py similarity index 54% rename from modules/lucydom_model.py rename to modules/lucydomModel.py index 746ffc56..28a82df8 100644 --- a/modules/lucydom_model.py +++ b/modules/lucydomModel.py @@ -1,3 +1,7 @@ +""" +LucyDOM model classes for the workflow and document system. +""" + from pydantic import BaseModel, Field from typing import List, Dict, Any, Optional @@ -7,7 +11,7 @@ class Label(BaseModel): default: str translations: Dict[str, str] = {} - def get_label(self, language: str = None): + def getLabel(self, language: str = None): """Returns the label in the specified language, or the default value if not available""" if language and language in self.translations: return self.translations[language] @@ -17,8 +21,8 @@ class Label(BaseModel): class Prompt(BaseModel): """Data model for a prompt""" id: int = Field(description="Unique ID of the prompt") - mandate_id: int = Field(description="ID of the associated mandate") - user_id: int = Field(description="ID of the creator") + mandateId: int = Field(description="ID of the associated mandate") + userId: int = Field(description="ID of the creator") content: str = Field(description="Content of the prompt") name: str = Field(description="Display name of the prompt") @@ -28,10 +32,10 @@ class Prompt(BaseModel): ) # Labels for attributes - field_labels: Dict[str, Label] = { + fieldLabels: Dict[str, Label] = { "id": Label(default="ID", translations={}), - "mandate_id": Label(default="Mandate ID", translations={"en": "Mandate ID", "fr": "ID de mandat"}), - "user_id": Label(default="User ID", translations={"en": "User ID", "fr": "ID d'utilisateur"}), + "mandateId": Label(default="Mandate ID", translations={"en": "Mandate ID", "fr": "ID de mandat"}), + "userId": Label(default="User ID", translations={"en": "User ID", "fr": "ID d'utilisateur"}), "content": Label(default="Content", translations={"en": "Content", "fr": "Contenu"}), "name": Label(default="Name", translations={"en": "Label", "fr": "Nom"}), } @@ -40,14 +44,14 @@ class Prompt(BaseModel): class FileItem(BaseModel): """Data model for a file""" id: int = Field(description="Unique ID of the data object") - mandate_id: int = Field(description="ID of the associated mandate") - user_id: int = Field(description="ID of the creator") + mandateId: int = Field(description="ID of the associated mandate") + userId: int = Field(description="ID of the creator") name: str = Field(description="Name of the data object") - mime_type: str = Field(description="Type of the data object MIME type") + mimeType: str = Field(description="Type of the data object MIME type") size: Optional[int] = Field(None, description="Size of the data object in bytes") - file_hash: str = Field(description="Hash code for deduplication") - creation_date: Optional[str] = Field(None, description="Upload date") - workflow_id: Optional[str] = Field(None, description="ID of the associated workflow, if any") + fileHash: str = Field(description="Hash code for deduplication") + creationDate: Optional[str] = Field(None, description="Upload date") + workflowId: Optional[str] = Field(None, description="ID of the associated workflow, if any") label: Label = Field( default=Label(default="Data Object", translations={"en": "Data Object", "fr": "Objet de données"}), @@ -55,16 +59,16 @@ class FileItem(BaseModel): ) # Labels for attributes - field_labels: Dict[str, Label] = { + fieldLabels: Dict[str, Label] = { "id": Label(default="ID", translations={}), - "mandate_id": Label(default="Mandate ID", translations={"en": "Mandate ID", "fr": "ID de mandat"}), - "user_id": Label(default="User ID", translations={"en": "User ID", "fr": "ID d'utilisateur"}), + "mandateId": Label(default="Mandate ID", translations={"en": "Mandate ID", "fr": "ID de mandat"}), + "userId": Label(default="User ID", translations={"en": "User ID", "fr": "ID d'utilisateur"}), "name": Label(default="Name", translations={"en": "Name", "fr": "Nom"}), - "mime_type": Label(default="Type", translations={"en": "Type", "fr": "Type"}), + "mimeType": Label(default="Type", translations={"en": "Type", "fr": "Type"}), "size": Label(default="Size", translations={"en": "Size", "fr": "Taille"}), - "file_hash": Label(default="File Hash", translations={"en": "Hash", "fr": "Hash"}), - "creation_date": Label(default="Upload date", translations={"en": "Upload date", "fr": "Date de téléchargement"}), - "workflow_id": Label(default="Workflow ID", translations={"en": "Workflow ID", "fr": "ID du workflow"}) + "fileHash": Label(default="File Hash", translations={"en": "Hash", "fr": "Hash"}), + "creationDate": Label(default="Upload date", translations={"en": "Upload date", "fr": "Date de téléchargement"}), + "workflowId": Label(default="Workflow ID", translations={"en": "Workflow ID", "fr": "ID du workflow"}) } class FileData(BaseModel): @@ -77,71 +81,71 @@ class FileData(BaseModel): class DocumentContent(BaseModel): """Content of a document in the workflow""" - sequence_nr: int = Field(1, description="Sequence number of the content in the source document") + sequenceNr: int = Field(1, description="Sequence number of the content in the source document") name: str = Field(description="Designation") ext: str = Field(description="Content extension for export: txt, csv, json, jpg, png") - content_type: str = Field(description="MIME type") + contentType: str = Field(description="MIME type") summary: str = Field(description="Summary of the file content") - metadata: Dict[str, Any] = Field(default_factory=dict, description="Metadata about the content, such as is_text flag, format information, encoding, etc.") + metadata: Dict[str, Any] = Field(default_factory=dict, description="Metadata about the content, such as isText flag, format information, encoding, etc.") class Document(BaseModel): """Document in the workflow - References a file directly in the database""" id: str = Field(description="Unique ID of the document") name: str = Field(description="Name of the data object") ext: str = Field(description="Extension of the data object") - file_id: int = Field(description="ID of the referenced file in the database") + fileId: int = Field(description="ID of the referenced file in the database") data: str = Field(description="Content of the data as base64 string") contents: List[DocumentContent] = Field(description="Document contents") class DataStats(BaseModel): """Statistics for performance and data usage""" - processing_time: Optional[float] = Field(None, description="Processing time in seconds") - token_count: Optional[int] = Field(None, description="Token count (for AI models)") - bytes_sent: Optional[int] = Field(None, description="Bytes sent") - bytes_received: Optional[int] = Field(None, description="Bytes received") + processingTime: Optional[float] = Field(None, description="Processing time in seconds") + tokenCount: Optional[int] = Field(None, description="Token count (for AI models)") + bytesSent: Optional[int] = Field(None, description="Bytes sent") + bytesReceived: Optional[int] = Field(None, description="Bytes received") class WorkflowMessage(BaseModel): """Message object in the workflow""" id: str = Field(description="Unique ID of the message") - workflow_id: str = Field(description="Reference to the parent workflow") - parent_message_id: Optional[str] = Field(None, description="Reference to the replied message") - started_at: str = Field(description="Timestamp for message creation") - finished_at: Optional[str] = Field(None, description="Timestamp for message completion") - sequence_no: int = Field(description="Sequence number for sorting") + workflowId: str = Field(description="Reference to the parent workflow") + parentMessageId: Optional[str] = Field(None, description="Reference to the replied message") + startedAt: str = Field(description="Timestamp for message creation") + finishedAt: Optional[str] = Field(None, description="Timestamp for message completion") + sequenceNo: int = Field(description="Sequence number for sorting") - status: str = Field(description="Status of the message ('processing', 'completed')") + status: str = Field(description="Status of the message ('first', 'step', 'last')") role: str = Field(description="Role of the sender ('system', 'user', 'assistant')") - data_stats: Optional[DataStats] = Field(None, description="Statistics") + dataStats: Optional[DataStats] = Field(None, description="Statistics") documents: Optional[List[Document]] = Field(None, description="Documents in this message (references to files in the database)") content: Optional[str] = Field(None, description="Text content of the message") - agent_name: Optional[str] = Field(None, description="Name of the agent used") + agentName: Optional[str] = Field(None, description="Name of the agent used") class WorkflowLog(BaseModel): """Log entry for a workflow""" id: str = Field(description="Unique ID of the log entry") - workflow_id: str = Field(description="ID of the associated workflow") + workflowId: str = Field(description="ID of the associated workflow") message: str = Field(description="Log message content") type: str = Field(description="Type of log ('info', 'warning', 'error')") timestamp: str = Field(description="Timestamp of the log entry") - agent_name: str = Field(description="Name of the agent that created the log") + agentName: str = Field(description="Name of the agent that created the log") status: str = Field(description="Status of the workflow at log time") progress: Optional[int] = Field(None, description="Progress value (0-100)") - mandate_id: Optional[int] = Field(None, description="ID of the mandate") - user_id: Optional[int] = Field(None, description="ID of the user") + mandateId: Optional[int] = Field(None, description="ID of the mandate") + userId: Optional[int] = Field(None, description="ID of the user") class Workflow(BaseModel): """Workflow object for multi-agent system""" id: str = Field(description="Unique ID of the workflow") name: Optional[str] = Field(None, description="Name of the workflow") - mandate_id: int = Field(description="ID of the mandate") - user_id: int = Field(description="ID of the user") - status: str = Field(description="Status of the workflow ('running', 'completed')") - started_at: str = Field(description="Start timestamp") - last_activity: str = Field(description="Timestamp of the last activity") - data_stats: Optional[Dict[str, Any]] = Field(None, description="Total statistics") - current_round: int = Field(default=1, description="Current round/iteration of the workflow") - message_ids: List[str] = Field(default=[], description="List of message IDs in this workflow") + mandateId: int = Field(description="ID of the mandate") + userId: int = Field(description="ID of the user") + status: str = Field(description="Status of the workflow ('running', 'completed', 'failed', 'stopped')") + startedAt: str = Field(description="Start timestamp") + lastActivity: str = Field(description="Timestamp of the last activity") + dataStats: Optional[Dict[str, Any]] = Field(None, description="Total statistics") + currentRound: int = Field(default=1, description="Current round/iteration of the workflow") + messageIds: List[str] = Field(default=[], description="List of message IDs in this workflow") messages: List[WorkflowMessage] = Field(default=[], description="Message history (in-memory representation)") logs: List[WorkflowLog] = Field(default=[], description="Log entries (in-memory representation)") @@ -152,4 +156,4 @@ class Workflow(BaseModel): class UserInputRequest(BaseModel): """Request for user input to a running workflow""" prompt: str = Field(description="Message from the user") - list_file_id: List[int] = Field(default=[], description="List of FileItem IDs") \ No newline at end of file + listFileId: List[int] = Field(default=[], description="List of FileItem IDs") \ No newline at end of file diff --git a/modules/chat_registry.py b/modules/workflowAgentsRegistry.py similarity index 58% rename from modules/chat_registry.py rename to modules/workflowAgentsRegistry.py index ed301fe1..3669db64 100644 --- a/modules/chat_registry.py +++ b/modules/workflowAgentsRegistry.py @@ -1,5 +1,5 @@ """ -Chat Agent Registry Module. +Agent Registry Module. Provides a central registry system for all available agents. Optimized for the standardized task processing pattern. """ @@ -26,11 +26,11 @@ class AgentBase: self.capabilities = [] self.mydom = None - def set_dependencies(self, mydom=None): + def setDependencies(self, mydom=None): """Set external dependencies for the agent.""" self.mydom = mydom - def get_agent_info(self) -> Dict[str, Any]: + def getAgentInfo(self) -> Dict[str, Any]: """ Return standardized information about the agent's capabilities. @@ -43,18 +43,18 @@ class AgentBase: "capabilities": self.capabilities } - async def process_task(self, task: Dict[str, Any]) -> Dict[str, Any]: + async def processTask(self, task: Dict[str, Any]) -> Dict[str, Any]: """ Process a standardized task structure and return results. This method must be implemented by all concrete agent classes. Args: task: A dictionary containing: - - task_id: Unique ID for this task - - workflow_id: ID of the parent workflow (optional) + - taskId: Unique ID for this task + - workflowId: ID of the parent workflow (optional) - prompt: The main instruction for the agent - - input_documents: List of document objects to process - - output_specifications: List of required output documents + - inputDocuments: List of document objects to process + - outputSpecifications: List of required output documents - context: Additional contextual information Returns: @@ -63,9 +63,9 @@ class AgentBase: - documents: List of document objects created by the agent """ # Base implementation - should be overridden by specialized agents - logger.warning(f"Agent {self.name} is using the default implementation of process_task") + logger.warning(f"Agent {self.name} is using the default implementation of processTask") return { - "feedback": f"The process_task method was not implemented by agent '{self.name}'.", + "feedback": f"The processTask method was not implemented by agent '{self.name}'.", "documents": [] } @@ -76,7 +76,7 @@ class AgentRegistry: _instance = None @classmethod - def get_instance(cls): + def getInstance(cls): """Return a singleton instance of the agent registry.""" if cls._instance is None: cls._instance = cls() @@ -85,124 +85,124 @@ class AgentRegistry: def __init__(self): """Initialize the agent registry.""" if AgentRegistry._instance is not None: - raise RuntimeError("Singleton instance already exists - use get_instance()") + raise RuntimeError("Singleton instance already exists - use getInstance()") self.agents = {} self.mydom = None - self._load_agents() + self._loadAgents() - def _load_agents(self): + def _loadAgents(self): """Load all available agents from modules.""" logger.info("Loading agent modules...") # List of agent modules to load - agent_modules = [] - agent_dir = os.path.dirname(__file__) + agentModules = [] + agentDir = os.path.dirname(__file__) # Search the directory for agent modules - for filename in os.listdir(agent_dir): - if filename.startswith("chat_agent_") and filename.endswith(".py"): - agent_modules.append(filename[:-3]) # Remove .py extension + for filename in os.listdir(agentDir): + if filename.startswith("agent") and filename.endswith(".py"): + agentModules.append(filename[0:-3]) # Remove .py extension - if not agent_modules: + if not agentModules: logger.warning("No agent modules found") return - logger.info(f"{len(agent_modules)} agent modules found") + logger.info(f"{len(agentModules)} agent modules found") # Load each agent module - for module_name in agent_modules: + for moduleName in agentModules: try: # Import the module - module = importlib.import_module(f"modules.{module_name}") + module = importlib.import_module(f"modules.{moduleName}") # Look for agent class or get_*_agent function - agent_name = module_name.split('_')[-1] - class_name = f"Agent{agent_name.capitalize()}" - getter_name = f"get_{agent_name}_agent" + agentName = moduleName.split("agent")[-1] + className = f"Agent{agentName}" + getterName = f"getAgent{agentName}" agent = None - # Try to get the agent via the get_*_agent function - if hasattr(module, getter_name): - getter_func = getattr(module, getter_name) - agent = getter_func() - logger.info(f"Agent '{agent.name}' loaded via {getter_name}()") + # Try to get the agent via the get*Agent function + if hasattr(module, getterName): + getterFunc = getattr(module, getterName) + agent = getterFunc() + logger.info(f"Agent '{agent.name}' loaded via {getterName}()") # Alternatively, try to instantiate the agent directly - elif hasattr(module, class_name): - agent_class = getattr(module, class_name) - agent = agent_class() + elif hasattr(module, className): + agentClass = getattr(module, className) + agent = agentClass() logger.info(f"Agent '{agent.name}' directly instantiated") if agent: # Register the agent - self.register_agent(agent) + self.registerAgent(agent) else: - logger.warning(f"No agent class or getter function found in module {module_name}") + logger.warning(f"No agent class or getter function found in module {moduleName}") except ImportError as e: - logger.error(f"Module {module_name} could not be imported: {e}") + logger.error(f"Module {moduleName} could not be imported: {e}") except Exception as e: - logger.error(f"Error loading agent from module {module_name}: {e}") + logger.error(f"Error loading agent from module {moduleName}: {e}") - def set_mydom(self, mydom): + def setMydom(self, mydom): """Set the AI service for all agents.""" self.mydom = mydom - self.update_agent_dependencies() + self.updateAgentDependencies() - def update_agent_dependencies(self): + def updateAgentDependencies(self): """Update dependencies for all registered agents.""" - for agent_id, agent in self.agents.items(): - if hasattr(agent, 'set_dependencies'): - agent.set_dependencies(mydom=self.mydom) + for agentId, agent in self.agents.items(): + if hasattr(agent, 'setDependencies'): + agent.setDependencies(mydom=self.mydom) - def register_agent(self, agent): + def registerAgent(self, agent): """ Register an agent in the registry. Args: agent: The agent to register """ - agent_id = getattr(agent, 'name', "unknown_agent") + agentId = getattr(agent, 'name', "unknown_agent") # Initialize agent with dependencies - if hasattr(agent, 'set_dependencies'): - agent.set_dependencies(mydom=self.mydom) - self.agents[agent_id] = agent + if hasattr(agent, 'setDependencies'): + agent.setDependencies(mydom=self.mydom) + self.agents[agentId] = agent logger.debug(f"Agent '{agent.name}' registered") - def get_agent(self, agent_identifier: str): + def getAgent(self, agentIdentifier: str): """ Return an agent instance Args: - agent_identifier: ID or type of the desired agent + agentIdentifier: ID or type of the desired agent Returns: Agent instance or None if not found """ - if agent_identifier in self.agents: - agent = self.agents[agent_identifier] + if agentIdentifier in self.agents: + agent = self.agents[agentIdentifier] # Ensure the agent has the AI service - if hasattr(agent, 'set_dependencies') and self.mydom: - agent.set_dependencies(mydom=self.mydom) + if hasattr(agent, 'setDependencies') and self.mydom: + agent.setDependencies(mydom=self.mydom) return agent - logger.error(f"Agent with identifier '{agent_identifier}' not found") + logger.error(f"Agent with identifier '{agentIdentifier}' not found") return None - def get_all_agents(self) -> Dict[str, Any]: + def getAllAgents(self) -> Dict[str, Any]: """Return all registered agents.""" return self.agents - def get_agent_infos(self) -> List[Dict[str, Any]]: + def getAgentInfos(self) -> List[Dict[str, Any]]: """Return information about all registered agents.""" - agent_infos = [] - seen_agents = set() + agentInfos = [] + seenAgents = set() for agent in self.agents.values(): - if agent not in seen_agents: - agent_infos.append(agent.get_agent_info()) - seen_agents.add(agent) - return agent_infos + if agent not in seenAgents: + agentInfos.append(agent.getAgentInfo()) + seenAgents.add(agent) + return agentInfos # Singleton factory for the agent registry -def get_agent_registry(): - return AgentRegistry.get_instance() \ No newline at end of file +def getAgentRegistry(): + return AgentRegistry.getInstance() \ No newline at end of file diff --git a/modules/workflowManager.py b/modules/workflowManager.py new file mode 100644 index 00000000..e9d1d0e0 --- /dev/null +++ b/modules/workflowManager.py @@ -0,0 +1,1236 @@ +""" +Workflow Manager Module for state machine-based backend chat workflow. +Implements the state machine as defined in the documentation. +""" + +import asyncio +import os +import logging +import json +import re +import uuid +import base64 +from datetime import datetime +from typing import Dict, Any, List, Optional, Union, Tuple + +# Required imports +from modules.workflowAgentsRegistry import getAgentRegistry +from modules.lucydomInterface import getLucydomInterface as domInterface +from modules.documentProcessor import getDocumentContents + +# Configure logger +logger = logging.getLogger(__name__) + +# Global settings for the workflow management +GLOBAL_WORKFLOW_LABELS = { + "systemName": "AI Assistant", # Default system name for logs + "workflowStatusMessages": { + "init": "Workflow initialized", + "running": "Running workflow", + "waiting": "Waiting for input", + "completed": "Workflow completed successfully", + "stopped": "Workflow stopped by user", + "failed": "Error in workflow" + } +} + +class WorkflowManager: + """ + Manages the processing of chat requests, agent execution, and + the integration of results into the workflow, following a state machine approach. + """ + + def __init__(self, mandateId: int, userId: int): + """ + Initializes the WorkflowManager with mandate and user context. + + Args: + mandateId: ID of the current mandate + userId: ID of the current user + """ + self.mandateId = mandateId + self.userId = userId + self.mydom = domInterface(mandateId, userId) + self.agentRegistry = getAgentRegistry() + self.agentRegistry.setMydom(self.mydom) + + ### Workflow State Machine Implementation + + async def workflowStart(self, userInput: Dict[str, Any], workflowId: Optional[str] = None) -> Dict[str, Any]: + """ + Main entry point for starting or continuing a workflow (State 1: Workflow Initialization). + Initializes a new workflow or loads an existing one based on workflowId. + + Args: + userInput: User input with prompt and optional file list + workflowId: Optional workflow ID to continue an existing workflow + + Returns: + Initialized workflow object with status "running" + """ + # 1. Initialize workflow or load existing one + workflow = self.workflowInit(workflowId) + self.logAdd(workflow, "Starting workflow processing", level="info", progress=0) + + # Start asynchronous processing + asyncio.create_task(self.workflowProcess(userInput, workflow)) + + return workflow + + async def workflowStop(self, workflowId: str) -> Dict[str, Any]: + """ + Stops a running workflow (State 8: Workflow Stopped). + Sets status to "stopped" and adds a log entry. + + Args: + workflowId: ID of the workflow to stop + + Returns: + Updated workflow with status="stopped" + """ + workflow = self.mydom.loadWorkflowState(workflowId) + if not workflow: + return {"error": "Workflow not found", "status": "failed"} + + # Update status to stopped + workflow["status"] = "stopped" + workflow["lastActivity"] = datetime.now().isoformat() + + # Update in database + self.mydom.updateWorkflow(workflowId, { + "status": workflow["status"], + "lastActivity": workflow["lastActivity"] + }) + + self.logAdd(workflow, GLOBAL_WORKFLOW_LABELS["workflowStatusMessages"]["stopped"], level="info", progress=100) + return workflow + + async def workflowProcess(self, userInput: Dict[str, Any], workflow: Dict[str, Any]) -> Dict[str, Any]: + """ + Main processing function that implements the workflow state machine. + Handles the complete workflow process from user input to final response. + + Args: + userInput: User input with prompt and optional file list + workflow: Current workflow object + + Returns: + Updated workflow with processing results + """ + try: + # State 3: User Message Processing + messageUser = await self.chatMessageToWorkflow("user", "", userInput, workflow) + messageUser["status"] = "first" # For first message + + # State 4: Project Manager Analysis + self.logAdd(workflow, "Analyzing request and planning work", level="info", progress=10) + projectManagerResponse = await self.projectManagerAnalysis(messageUser, workflow) + objFinalDocuments = projectManagerResponse.get("objFinalDocuments", []) + objWorkplan = projectManagerResponse.get("objWorkplan", []) + objUserResponse = projectManagerResponse.get("objUserResponse", "") + + # Get detected language and set it in the mydom interface + userLanguage = projectManagerResponse.get("userLanguage", "en") + self.mydom.setUserLanguage(userLanguage) + + # Save the response as a message in the workflow and add log entries + responseMessage = { + "role": "assistant", + "agentName": "project_manager", + "content": objUserResponse, + "status": "step" # As per state machine specification + } + self.messageAdd(workflow, responseMessage) + + self.logAdd(workflow, f"Planned outputs: {len(objFinalDocuments)} documents", level="info", progress=20) + self.logAdd(workflow, f"Work plan created with {len(objWorkplan)} steps", level="info", progress=25) + + # State 5: Agent Execution + objResults = [] + if objWorkplan: + totalTasks = len(objWorkplan) + for taskIndex, task in enumerate(objWorkplan): + agentName = task.get("agent", "unknown") + progressValue = 30 + int((taskIndex / totalTasks) * 60) # Progress from 30% to 90% + + progressMsg = f"Running task {taskIndex+1}/{totalTasks}: {agentName}" + self.logAdd(workflow, progressMsg, level="info", progress=progressValue) + + taskResults = await self.agentProcessing(task, workflow) + objResults.extend(taskResults) + + # Log completion of this task + self.logAdd( + workflow, + f"Completed task {taskIndex+1}/{totalTasks}: {agentName}", + level="info", + progress=progressValue + (60/totalTasks)/2 + ) + + # State 6: Final Response Generation + self.logAdd(workflow, "Creating final response", level="info", progress=90) + finalMessage = await self.generateFinalMessage(objUserResponse, objFinalDocuments, objResults) + finalMessage["status"] = "last" # As per state machine specification + self.messageAdd(workflow, finalMessage) + + # State 7: Workflow Completion + self.workflowFinish(workflow) + self.logAdd(workflow, GLOBAL_WORKFLOW_LABELS["workflowStatusMessages"]["completed"], level="info", progress=100) + + return workflow + + except Exception as e: + # State 2: Workflow Exception + logger.error(f"Workflow processing error: {str(e)}", exc_info=True) + workflow["status"] = "failed" + workflow["lastActivity"] = datetime.now().isoformat() + + # Update in database + self.mydom.updateWorkflow(workflow["id"], { + "status": "failed", + "lastActivity": workflow["lastActivity"] + }) + + self.logAdd(workflow, f"Workflow failed: {str(e)}", level="error", progress=100) + return workflow + + def workflowInit(self, workflowId: Optional[str] = None) -> Dict[str, Any]: + """ + Initializes a workflow or loads an existing one with round counting (State 1: Workflow Initialization). + + Args: + workflowId: Optional - ID of the workflow to load + + Returns: + Initialized workflow object + """ + currentTime = datetime.now().isoformat() + + if workflowId is None or not self.mydom.getWorkflow(workflowId): + # Create new workflow + newWorkflowId = str(uuid.uuid4()) if workflowId is None else workflowId + workflow = { + "id": newWorkflowId, + "mandateId": self.mandateId, + "userId": self.userId, + "name": f"Workflow {newWorkflowId[:8]}", + "startedAt": currentTime, + "messages": [], # Empty list - will be filled with references + "messageIds": [], # Initialize empty messageIds list + "logs": [], + "dataStats": {}, + "currentRound": 1, + "status": "running", + "lastActivity": currentTime, + } + + # Save to database - only the workflow metadata + workflowDb = { + "id": workflow["id"], + "mandateId": workflow["mandateId"], + "userId": workflow["userId"], + "name": workflow["name"], + "startedAt": workflow["startedAt"], + "status": workflow["status"], + "dataStats": workflow["dataStats"], + "currentRound": workflow["currentRound"], + "lastActivity": workflow["lastActivity"], + "messageIds": workflow["messageIds"] # Include messageIds + } + self.mydom.createWorkflow(workflowDb) + + self.logAdd(workflow, GLOBAL_WORKFLOW_LABELS["workflowStatusMessages"]["init"], level="info", progress=0) + return workflow + else: + # State 10: Workflow Resumption - Load existing workflow + workflow = self.mydom.loadWorkflowState(workflowId) + + # Ensure messageIds exists + if "messageIds" not in workflow: + # Initialize from existing messages + workflow["messageIds"] = [msg["id"] for msg in workflow.get("messages", [])] + + # Update in database + self.mydom.updateWorkflow(workflowId, {"messageIds": workflow["messageIds"]}) + + # Update status and increment round counter + workflow["status"] = "running" + workflow["lastActivity"] = currentTime + + # Increment currentRound if it exists, otherwise set it to 1 + if "currentRound" in workflow: + workflow["currentRound"] += 1 + else: + workflow["currentRound"] = 1 + + # Update in database - only the relevant workflow fields + workflowUpdate = { + "status": workflow["status"], + "lastActivity": workflow["lastActivity"], + "currentRound": workflow["currentRound"] + } + self.mydom.updateWorkflow(workflowId, workflowUpdate) + + self.logAdd(workflow, GLOBAL_WORKFLOW_LABELS["workflowStatusMessages"]["running"], level="info", progress=0) + return workflow + + def workflowFinish(self, workflow: Dict[str, Any]) -> Dict[str, Any]: + """ + Finalizes a workflow and sets the status to 'completed' (State 7: Workflow Completion). + + Args: + workflow: Workflow object + + Returns: + Updated workflow object + """ + # Prepare workflow update data + workflowUpdate = { + "status": "completed", + "lastActivity": datetime.now().isoformat(), + } + + # Update the workflow object in memory + workflow["status"] = workflowUpdate["status"] + workflow["lastActivity"] = workflowUpdate["lastActivity"] + + # Save workflow state to database - only relevant fields + self.mydom.updateWorkflow(workflow["id"], workflowUpdate) + + self.logAdd(workflow, GLOBAL_WORKFLOW_LABELS["workflowStatusMessages"]["completed"], level="info", progress=100) + return workflow + + async def projectManagerAnalysis(self, messageUser: Dict[str, Any], workflow: Dict[str, Any]) -> Dict[str, Any]: + """ + Creates the prompt for the project manager and processes the response (State 4: Project Manager Analysis). + + Args: + messageUser: Message object with user request + workflow: Current workflow object + + Returns: + Project manager's response with objFinalDocuments, objWorkplan and objUserResponse + """ + # Get available agents with their capabilities + availableAgents = self.agentProfiles() + + # Create a workflow summary + workflowSummary = await self.workflowSummarize(workflow, messageUser) + + # Create a list of currently available documents from user input or previously generated documents + availableDocuments = self.getAvailableDocuments(workflow, messageUser) + availableDocsStr = json.dumps(availableDocuments, indent=2) + + # Create the prompt for the project manager with language detection requirement + prompt = f""" +Based on the user request and the provided documents, please analyze the requirements and create a processing plan. +Also, identify the language of the user's request and include it in your response. + + +{messageUser.get('content')} + + +# Previous conversation history: + +{workflowSummary} + + +# Available documents (currently in workflow): + +{availableDocsStr} + + +# Available agents and their capabilities: + +{self.parseJson2text(availableAgents)} + + +Please analyze the request and create: + +1. A list of required result documents (objFinalDocuments) +2. A plan for executing agents (objWorkplan) +3. A clear response to the user explaining what you're doing (objUserResponse) +4. Identified language of the user's request (userLanguage) + +## IMPORTANT RULES FOR THE WORKPLAN: +1. Each input document must either already exist (provided by the user or previously created by an agent) or be created by an agent before it's used. +2. If necessary, convert input documents to a suitable format using agents when the type doesn't match. +3. Do not define document inputs that don't exist or haven't been generated beforehand. +4. Create a logical sequence - earlier agents can create documents that are later used as inputs. +5. If the user has provided documents but hasn't clearly stated what they want, try to act according to the context. + +Your answer must be strictly in the JSON_OUTPUT format, with no additions before or after the JSON object. + +JSON_OUTPUT = {{ + "objFinalDocuments": ["label",...], # document label in the format 'filename.ext' + "objWorkplan": [ + {{ + "agent": "agent_name", # Name of an available agent + "prompt": "Specific instructions to the agent, that he knows what to do with which documents and which output to provide." + "outputDocuments": [ + {{ + "label":"document label in the format 'filename.ext'", + "prompt":"AI prompt to describe the content of the file" + }} + ], + "inputDocuments": [ + {{ + "label":"document label in the format 'filename.ext'", + "fileId":id, # if refering to an existing document, provide fileId to select the correct file + "contentPart":"", # provide empty string, if all document contents to consider, otherwise the contentPart of the document to focus on + "prompt":"AI prompt to describe what data to extract from the file." + }} + ], # If no input documents are needed, include "inputDocuments" as an empty list + }} + # Multiple agent tasks can be added here and should build logically on each other + ], + "objUserResponse": "Information to the user about how his request will be solved, in the language of the user's request.", + "userLanguage": "en" # Language code (e.g., en, de, fr, es) based on the user's request +}} + +## RULES for inputDocuments: +1. The user request refers to documents where "fileSource" in available documents is "user". Those documents are in the focus for input +2. In case of redundant label in available documents, use document with highest sequenceNr if not specified differently + +## STRICT RULES FOR document "label": +1. Every document label MUST include a proper file extension that matches the content type. +2. Use standard extensions like: + - ".txt" for text files + - ".md" for markdown files + - ".csv" for comma-separated values + - ".json" for JSON data + - ".html" for HTML content + - ".jpg" or ".png" for images + - ".docx" for Word documents + - ".xlsx" for Excel files + - ".pdf" for PDF documents +3. Use descriptive filenames that indicate the document's purpose (e.g., "analysis_report.txt" rather than just "report.txt") +4. If you use label for an existing file +""" + + # Call the AI service through mydom for language support + logger.debug(f"PROJECT MANAGER Planning prompt: {prompt}") + projectManagerOutput = await self.mydom.callAi([ + { + "role": "system", + "content": "You are an experienced project manager who analyzes user requests and creates work plans. You pay very careful attention to ensure that all document dependencies are correct and that no non-existent documents are defined as inputs. The output follows strictly the specified format." + }, + { + "role": "user", + "content": prompt + } + ]) + + # Parse the JSON response + logger.debug(f"PROJECT MANAGER Planning answer: {projectManagerOutput}") + return self.parseJsonResponse(projectManagerOutput) + + async def agentProcessing(self, task: Dict[str, Any], workflow: Dict[str, Any]) -> List[Dict[str, Any]]: + """ + Process a single agent task from the workflow (State 5: Agent Execution). + Optimized for the task-based approach where all agents implement processTask. + + Args: + task: The task definition containing agent name, prompt, and document specifications + workflow: The current workflow object + + Returns: + List of document objects created by the agent + """ + # 1. Extract task information + agentName = task.get("agent") + agentPrompt = task.get("prompt", "") + + # Log the current step + outputLabels = [] + for doc in task.get("outputDocuments", []): + outputLabels.append(doc.get("label", "unknown")) + + stepInfo = f"Agent '{agentName}' to create {', '.join(outputLabels)}." + self.logAdd(workflow, stepInfo, level="info") + + # Check if prompt is empty + if agentPrompt == "": + logger.warning("Empty prompt, no task to do") + return [] + + # Get agent from registry + agent = self.agentRegistry.getAgent(agentName) + if not agent: + logger.error(f"Agent '{agentName}' not found") + return [] + + # Prepare output document specifications + outputSpecs = [] + for doc in task.get("outputDocuments", []): + outputSpec = { + "label": doc.get("label"), + "description": doc.get("prompt", "") + } + outputSpecs.append(outputSpec) + + # Prepare input documents for the agent + inputDocuments = await self.prepareAgentInputDocuments(task.get('inputDocuments', []), workflow) + + # Create a standardized task object for the agent as per state machine spec + agentTask = { + "taskId": str(uuid.uuid4()), + "workflowId": workflow.get("id"), + "prompt": agentPrompt, + "inputDocuments": inputDocuments, + "outputSpecifications": outputSpecs, + "context": { + "workflowRound": workflow.get("currentRound", 1), + "agentType": agentName, + "timestamp": datetime.now().isoformat(), + "language": self.mydom.userLanguage # Pass language to agent + } + } + + # Execute the agent with the standardized task + try: + # Process the task using the agent's standardized interface + logger.debug("TASK: "+self.parseJson2text(agentTask)) + logger.debug(f"Agent '{agentName}' AI service available: {agent.mydom is not None}") + + agentResults = await agent.processTask(agentTask) + + logger.debug(f"Agent '{agentName}' completed task. RESULT: {self.parseJson2text(agentResults)}") + + # Log the agent response + self.logAdd( + workflow, + f"Agent '{agentName}' completed task. Feedback: {agentResults.get('feedback', 'No feedback provided')}", + level="info" + ) + + # Store produced files and prepare input object for message + agentInputs = { + "prompt": agentResults.get("feedback", ""), + "listFileId": self.saveAgentDocuments(agentResults) + } + + # Create a message in the workflow with the agent's response + agentMessage = await self.chatMessageToWorkflow("assistant", agentName, agentInputs, workflow) + agentMessage["status"] = "step" # As per state machine specification + logger.debug(f"Agent result = {self.parseJson2text(agentMessage)}.") + + return agentMessage.get("documents", []) + + except Exception as e: + errorMsg = f"Error executing agent '{agentName}': {str(e)}" + logger.error(errorMsg, exc_info=True) # Add exc_info=True to get full traceback + self.logAdd(workflow, errorMsg, level="error") + return [] + + async def generateFinalMessage(self, objUserResponse: str, objFinalDocuments: List[str], objResults: List[Dict[str, Any]]) -> Dict[str, Any]: + """ + Creates the final response message with review of promised and delivered documents (State 6: Final Response Generation). + + Args: + objUserResponse: Initial text response to the user + objFinalDocuments: List of expected response documents + objResults: List of generated result documents + + Returns: + Complete message object with content and relevant documents + """ + # Find documents that match the objFinalDocuments requirements + matchingDocuments = [] + + if len(objFinalDocuments) > 0: + for answerLabel in objFinalDocuments: + # Find matching document in results + for doc in objResults: + docName = self.getFilename(doc) + # Check if this document matches the answer specification + if docName == answerLabel: + contentRef = [] + for c in doc.get("contents", []): + contentRef.append(c.get("summary", "")) + docRef = { + "label": docName, + "contentSummary": contentRef + } + matchingDocuments.append(docRef) + break + + # Use the mydom for language-aware AI calls + finalPrompt = await self.mydom.callAi([ + {"role": "system", "content": "You are a project manager, who delivers results to a user."}, + {"role": "user", "content": f""" +Give the final short feedback to the user with reference to the initial statement (objUserResponse). Inform him about the list of filesDelivered. You do not need to send the files, this is handled separately. If in the list of filesDelivered there might miss some files_promised, just give a comment on this, otherwise task is now completed successful. + +Here the data: +objUserResponse = {self.parseJson2text(objUserResponse)} +filesPromised = {self.parseJson2text(objFinalDocuments)} +filesDelivered = {self.parseJson2text(matchingDocuments)} +""" + } + ], produceUserAnswer=True) + + # Create basic message structure with proper fields + logger.debug(f"FINAL PROMPT = {self.parseJson2text(finalPrompt)}.") + finalMessage = { + "role": "assistant", + "agentName": "project_manager", + "content": finalPrompt, + "documents": [] # DO NOT include the results documents, already with agents + } + + logger.debug(f"FINAL MESSAGE = {self.parseJson2text(finalMessage)}.") + return finalMessage + + async def workflowSummarize(self, workflow: Dict[str, Any], messageUser: Dict[str, Any]) -> str: + """ + Creates a summary of the workflow without the current user message. + + Args: + workflow: Workflow object + messageUser: Current user message + + Returns: + Summary of the workflow + """ + if not workflow or "messages" not in workflow or not workflow["messages"]: + return "" # First message + + # Go through messages in chronological order + messages = sorted(workflow["messages"], key=lambda m: m.get("sequenceNo", 0), reverse=False) + + summaryParts = [] + for message in messages: + if message["id"] != messageUser["id"]: + messageSummary = await self.messageSummarize(message) + summaryParts.append(messageSummary) + + return "\n\n".join(summaryParts) + + async def messageSummarize(self, message: Dict[str, Any]) -> str: + """ + Creates a summary of a message including its documents. + + Args: + message: Message to summarize + + Returns: + Summary of the message + """ + role = message.get("role", "undefined") + agentName = message.get("agentName", "") + content = message.get("content", "") + + try: + # Use the mydom for language-aware AI calls + contentSummary = await self.mydom.callAi([ + {"role": "system", "content": f"You are a chat message summarizer. Create a very concise summary (2-3 sentences, maximum 300 characters)"}, + {"role": "user", "content": content} + ]) + except Exception as e: + logger.error(f"Error creating summary: {str(e)}") + contentSummary = content[:200] + "..." + + # Summarize documents + docsSummary = "" + if "documents" in message and message["documents"]: + docsList = [] + for i, doc in enumerate(message["documents"]): + docName = self.getFilename(doc) + docsList.append(docName) + if docsList: + docsSummary = "\nDocuments:" + "\n- ".join(docsList) + + return f"[{role} {agentName}]: {contentSummary}{docsSummary}" + + async def chatMessageToWorkflow(self, role: str, agentName: str, chatMessage: Dict[str, Any], workflow: Dict[str, Any]) -> Dict[str, Any]: + """ + Integrates user inputs into a Message object including files with complete contents (State 3: User Message Processing). + + Args: + role: Role of the message sender ('user' or 'assistant') + agentName: Name of the agent, if message is from an agent + chatMessage: Input data with "prompt"=str, "listFileId"=[] + workflow: Current workflow object + + Returns: + Message object with content and documents including contents + """ + logger.info(f"Message from {role} {agentName} sent with {len(chatMessage.get('listFileId', []))} documents") + logger.debug(f"message = {self.parseJson2text(chatMessage)}.") + + # Check message content + messageContent = chatMessage.get("prompt", "") + if isinstance(messageContent, dict) and "content" in messageContent: + messageContent = messageContent["content"] + + # If message content is empty, no chat + if role == "user" and (messageContent is None or messageContent.strip() == ""): + logger.warning(f"Empty message, no chat") + messageContent = "(No user input received)" + + # Process additional files with complete contents + additionalFileIds = chatMessage.get("listFileId", []) + additionalFiles = await self.processFileIds(additionalFileIds) + + # Create message object + messageObject = { + "role": role, + "agentName": agentName, + "content": messageContent, + "documents": additionalFiles + } + + messageObject = self.messageAdd(workflow, messageObject) + logger.debug(f"message_user = {self.parseJson2text(messageObject)}.") + return messageObject + + async def processFileIds(self, fileIds: List[int]) -> List[Dict[str, Any]]: + """ + Processes a list of File-IDs and returns the corresponding file objects as a list of Document objects. + Loads all contents directly and adds summaries to each content item. + + Args: + fileIds: List of file IDs + + Returns: + List of Document objects with contents and summaries + """ + documents = [] + logger.info(f"Processing {len(fileIds)} files") + + for fileId in fileIds: + try: + # Check if the file exists + file = self.mydom.getFile(fileId) + if not file: + logger.warning(f"File with ID {fileId} not found") + continue + + # Check if file belongs to the current mandate + if file.get("mandateId") != self.mandateId: + logger.warning(f"File {fileId} does not belong to mandate {self.mandateId}") + continue + + # Load file content + fileContent = self.mydom.getFileData(fileId) + if fileContent is None: + logger.warning(f"No content found for file with ID {fileId}") + continue + + # Create document + fileNameExt = file.get("name") + document = { + "id": f"doc_{str(uuid.uuid4())}", + "fileId": fileId, + "name": os.path.splitext(fileNameExt)[0] if os.path.splitext(fileNameExt)[0] else "noname", + "ext": os.path.splitext(fileNameExt)[1][1:] if os.path.splitext(fileNameExt)[1] else "bin", + "data": base64.b64encode(fileContent).decode('utf-8'), # Add file data as base64 + "contents": [] + } + + # Extract contents + contents = getDocumentContents(file, fileContent) + + # Add summaries to each content item + for content in contents: + content["summary"] = await self.messageSummarizeContent(content) + + document["contents"] = contents + + logger.info(f"File {file.get('name', 'unnamed')} (ID: {fileId}) loaded with {len(contents)} contents and summaries") + documents.append(document) + + except Exception as e: + logger.error(f"Error processing file {fileId}: {str(e)}") + # Continue with remaining files instead of failing + continue + + return documents + + async def prepareAgentInputDocuments(self, docInputList: List[Dict[str, Any]], workflow: Dict[str, Any]) -> List[Dict[str, Any]]: + """ + Prepares input documents for an agent, sorted with newest first. + + Args: + docInputList: List of required input documents as specified by the project manager + workflow: Workflow object + + Returns: + Prepared input documents for the agent, sorted with newest first + """ + preparedInputs = [] + + # Sort workflow messages by sequence number (descending) + sortedMessages = sorted( + workflow.get("messages", []), + key=lambda m: m.get("sequenceNo", 0), + reverse=True + ) + + for docSpec in docInputList: + docFilename = docSpec.get("label", "") + docFileId = docSpec.get("fileId", "") + + foundDoc = None + # Search for the document in sorted workflow messages (newest first) + for message in sortedMessages: + for doc in message.get("documents", []): + if (docFileId != "" and docFileId == doc.get("fileId")) or (docFilename != "" and self.getFilename(doc) == docFilename): + foundDoc = doc + break + if foundDoc: + break + if foundDoc: + # Process document for agent based on the specification + processedDoc = await self.processDocumentForAgent(foundDoc, docSpec) + + preparedInputs.append(processedDoc) + else: + logger.warning(f"Document with label '{docFilename}', fileId '{docFileId}' not found in workflow") + + return preparedInputs + + async def processDocumentForAgent(self, document: Dict[str, Any], docSpec: Dict[str, Any]) -> Dict[str, Any]: + """ + Processes a document for an agent based on the document specification. + Uses AI to extract relevant content from the document based on the specification. + + Args: + document: The document to process + docSpec: The document specification from the project manager + + Returns: + Processed document with AI-extracted content + """ + processedDoc = document.copy() + partSpec = docSpec.get("contentPart", "") + + # Process each content item in the document + if "contents" in processedDoc: + processedContents = [] + + for content in processedDoc["contents"]: + + # Check if part required + if partSpec != "" and partSpec != content.get("name"): + continue + + # Get the data from the content + data = content.get("data", "") + processedContent = content.copy() + + # Check if content data is base64 encoded + isBase64 = content.get("metadata", {}).get("base64Encoded", False) + + try: + # Use the AI service to process the document content according to the prompt from the project manager for the document specification + summary = docSpec.get("prompt", "Extract the relevant information from this document") + aiPrompt = f""" +# Please process the following document content according to this instruction: + +{summary} + + +# Document content: + +{data} + + +# Extract and provide only the relevant information as requested. +""" + + # Call the AI service through mydom for language support + processedData = await self.mydom.callAi([ + {"role": "system", "content": "You are a document processing assistant. Extract only the relevant information as requested."}, + {"role": "user", "content": aiPrompt} + ]) + + # DO NOT change the original data field + # processedContent["data"] unchanged + processedContent["dataExtracted"] = processedData + processedContent["metadata"]["aiProcessed"] = True + + except Exception as e: + logger.error(f"Error processing document content with AI: {str(e)}") + # Fall back to original content if AI processing fails + processedContent["dataExtracted"] = "(no information)" + + processedContents.append(processedContent) + + processedDoc["contents"] = processedContents + + return processedDoc + + async def messageSummarizeContent(self, content: Dict[str, Any]) -> str: + """ + Generates a summary for a content item using AI. + + Args: + content: Content item to summarize (already processed by getDocumentContents) + + Returns: + Brief summary of the content + """ + # Extract relevant information + data = content.get("data", "") + contentType = content.get("contentType", "text/plain") + isText = content.get("metadata", {}).get("isText", False) + + try: + # Use the mydom for language-aware AI calls + summary = await self.mydom.callAi([ + {"role": "system", "content": "You are a content summarizer. Create very concise summary (1-2 sentences, maximum 200 characters) about this file."}, + {"role": "user", "content": f"Summarize this {contentType} content briefly:\n\n{data}"} + ]) + return summary + + except Exception as e: + logger.error(f"Error generating content summary: {str(e)}") + return f"Text content ({contentType})" + + def messageAdd(self, workflow: Dict[str, Any], message: Dict[str, Any]) -> Dict[str, Any]: + """ + Adds a message to the workflow and updates lastActivity. + Saves the message in the database and updates the workflow with references. + + Args: + workflow: Workflow object + message: Message to be saved + + Returns: + Added message + """ + currentTime = datetime.now().isoformat() + + # Ensure messages list exists + if "messages" not in workflow: + workflow["messages"] = [] + + # Generate new message ID if not present + if "id" not in message: + message["id"] = f"msg_{str(uuid.uuid4())}" + + # Add workflow ID and timestamps + message["workflowId"] = workflow["id"] + message["startedAt"] = currentTime + message["finishedAt"] = currentTime + + # Set sequence number + message["sequenceNo"] = len(workflow["messages"]) + 1 + + # Ensure required fields are present + if "role" not in message: + # Set a default role based on agentName + message["role"] = "assistant" if message.get("agentName") else "user" + + if "agentName" not in message: + message["agentName"] = "" + + # Set status if not present + if "status" not in message: + message["status"] = "completed" + + # Add message to workflow + workflow["messages"].append(message) + + # Ensure messageIds list exists + if "messageIds" not in workflow: + workflow["messageIds"] = [] + + # Add message ID to the messageIds list + workflow["messageIds"].append(message["id"]) + + # Update workflow status + workflow["lastActivity"] = currentTime + + # Save to database - first the message itself + self.mydom.createWorkflowMessage(message) + + # Then save the workflow with updated references + workflowUpdate = { + "lastActivity": currentTime, + "messageIds": workflow["messageIds"] # Update the messageIds field + } + self.mydom.updateWorkflow(workflow["id"], workflowUpdate) + + return message + + def logAdd(self, workflow: Dict[str, Any], message: str, level: str = "info", + progress: Optional[int] = None) -> str: + """ + Adds a log entry to the workflow and also logs it in the logger. + Enhanced with standardized formatting and workflow status tracking. + + Args: + workflow: Workflow object + message: Log message + level: Log level (info, warning, error) + progress: Optional - Progress value (0-100) + + Returns: + ID of the created log entry + """ + # Ensure logs list exists + if "logs" not in workflow: + workflow["logs"] = [] + + # Generate log ID + logId = f"log_{str(uuid.uuid4())}" + + # Get workflow status + workflowStatus = workflow.get("status", "running") + + # Set agentName from global settings + agentName = GLOBAL_WORKFLOW_LABELS.get("systemName", "AI Assistant") + + # Create log entry + logEntry = { + "id": logId, + "workflowId": workflow["id"], + "message": message, + "type": level, + "timestamp": datetime.now().isoformat(), + "agentName": agentName, + "status": workflowStatus + } + + # Add progress if provided + if progress is not None: + logEntry["progress"] = progress + + # Add log to workflow + workflow["logs"].append(logEntry) + + # Save in database + self.mydom.createWorkflowLog(logEntry) + + # Also log in logger + if level == "info": + logger.info(f"Workflow {workflow['id']}: {message}") + elif level == "warning": + logger.warning(f"Workflow {workflow['id']}: {message}") + elif level == "error": + logger.error(f"Workflow {workflow['id']}: {message}") + + return logId + + def saveAgentDocuments(self, agentResults: Dict[str, Any]) -> List[int]: + """ + Saves all documents from agent results as files and returns a list of file IDs. + Enhanced to handle the standardized document format from agents. + + Args: + agentResults: Dictionary containing agent feedback and documents + + Returns: + List of file IDs for the saved documents + """ + fileIds = [] + + # Extract documents from agent results + documents = agentResults.get("documents", []) + + for doc in documents: + try: + # Extract label (filename) and content + label = doc.get("label", "unnamed_file.txt") + content = doc.get("content", "") + + # Split label into name and extension + name, ext = os.path.splitext(label) + if ext.startswith('.'): + ext = ext[1:] # Remove leading dot + elif not ext: + # If no extension is provided, default to .txt for text content + ext = "txt" + label = f"{label}.{ext}" + + # Determine if content is base64 encoded + isBase64 = False + if isinstance(content, dict) and content.get("metadata", {}).get("base64Encoded", False): + isBase64 = True + content = content.get("data", "") + + # Convert content to bytes + if isinstance(content, str): + if isBase64: + # Decode base64 to bytes + try: + fileContent = base64.b64decode(content) + except Exception as e: + logger.warning(f"Failed to decode base64 content: {str(e)}") + fileContent = content.encode('utf-8') + else: + # Convert text to bytes + fileContent = content.encode('utf-8') + else: + # Already bytes + fileContent = content + + # Save file to database + fileMeta = self.mydom.saveUploadedFile(fileContent, label) + + if fileMeta and "id" in fileMeta: + fileId = fileMeta["id"] + fileIds.append(fileId) + logger.info(f"Saved document '{label}' with file ID: {fileId}") + else: + logger.warning(f"Failed to save document '{label}'") + + except Exception as e: + logger.error(f"Error saving document from agent results: {str(e)}") + # Continue with other documents instead of failing + continue + + return fileIds + + def getAvailableDocuments(self, workflow: Dict[str, Any], messageUser: Dict[str, Any]) -> List[Dict[str, Any]]: + """ + Determines all currently available documents from user input and already generated documents. + + Args: + messageUser: Current message from the user + workflow: Current workflow object + + Returns: + List with information about all available documents, sorted by message sequenceNr in descending order + """ + availableDocs = [] + + if "messages" in workflow and workflow["messages"]: + for message in workflow["messages"]: + messageId = message.get("id", "unknown") + sequenceNr = message.get("sequenceNo", 0) + + # Determine source + source = "user" if messageId == messageUser.get("id") else "workflow" + + # Process documents in this message + if "documents" in message and message["documents"]: + for doc in message["documents"]: + # Get filename using our helper method + filename = self.getFilename(doc) + fileId = doc.get("fileId") + + # Extract summaries from all contents + contentSummaries = [] + for content in doc.get("contents", []): + contentSummaries.append({ + "contentPart": content.get("name", "noname"), + "metadata": content.get("metadata", ""), + "summary": content.get("summary", "No summary"), + }) + + # Create document info + docInfo = { + "sequenceNr": sequenceNr, + "fileSource": source, + "fileId": fileId, + "messageId": messageId, + "label": filename, + "contentSummaryList": contentSummaries, + } + availableDocs.append(docInfo) + + # Sort by message sequenceNr in descending order (newest first) + availableDocs.sort(key=lambda x: x["sequenceNr"], reverse=True) + + logger.info(f"Available documents: {len(availableDocs)}") + return availableDocs + + def agentProfiles(self) -> List[Dict[str, Any]]: + """ + Gets information about all available agents. + + Returns: + List with information about all available agents + """ + return self.agentRegistry.getAgentInfos() + + def getFilename(self, document: Dict[str, Any]) -> str: + """ + Gets the filename from a document by combining name and extension. + + Args: + document: Document object + + Returns: + Filename with extension + """ + name = document.get("name", "unnamed") + ext = document.get("ext", "") + if ext: + return f"{name}.{ext}" + return name + + def parseJson2text(self, jsonObj: Any) -> str: + """ + Converts a JSON object to a readable text representation. + + Args: + jsonObj: JSON object to convert + + Returns: + Formatted text representation + """ + if not jsonObj: + return "No data available" + + try: + # Format with indentation for better readability + return json.dumps(jsonObj, indent=2, ensure_ascii=False) + except Exception as e: + logger.error(f"Error in JSON conversion: {str(e)}") + return str(jsonObj) + + def parseJsonResponse(self, responseText: str) -> Dict[str, Any]: + """ + Parses the JSON response from a text. + + Args: + responseText: Text with JSON content + + Returns: + Parsed JSON data + """ + try: + # Extract JSON from the text (if mixed with other content) + jsonStart = responseText.find('{') + jsonEnd = responseText.rfind('}') + 1 + + if jsonStart >= 0 and jsonEnd > jsonStart: + jsonStr = responseText[jsonStart:jsonEnd] + return json.loads(jsonStr) + else: + # Try to parse the entire text + return json.loads(responseText) + except json.JSONDecodeError as e: + logger.error(f"JSON parsing error: {str(e)}") + # Fallback: Return empty structure + return { + "objFinalDocuments": [], + "objWorkplan": [], + "objUserResponse": "Sorry, I could not parse your data.", + "userLanguage": "en" + } + + +# Singleton factory for the WorkflowManager +_workflowManagers = {} + +def getWorkflowManager(mandateId: int = 0, userId: int = 0) -> WorkflowManager: + """ + Returns a WorkflowManager for the specified context. + Reuses existing instances. + + Args: + mandateId: ID of the mandate + userId: ID of the user + + Returns: + WorkflowManager instance + """ + contextKey = f"{mandateId}_{userId}" + if contextKey not in _workflowManagers: + _workflowManagers[contextKey] = WorkflowManager(mandateId, userId) + return _workflowManagers[contextKey] \ No newline at end of file diff --git a/notes/changelog.txt b/notes/changelog.txt index 278d4552..aab318c4 100644 --- a/notes/changelog.txt +++ b/notes/changelog.txt @@ -1,13 +1,20 @@ ....................... TASKS -AI Chat: + +CHECKS: + + + + + + ----------------------- OPEN PRIO1: -CHECK: If pictures not displayed to check utf-8 encoding in the base64 string!! +CHECK: If pictures not displayed to check utf-8 encoding in the base64 string!! general file writing and reading (example with svg) STOP File export to static folder ("TODO) @@ -36,6 +43,186 @@ frontend: no labels definition ----------------------- DONE + +FRONTEND: +- login page and register page withoug fallback. they have mandatory to load their login.html or register.html pages to work (not html in the code). + + + +I want formCeneric module to use api calls over apiCalls.js module, not directly. So please adapt formCeneric parameter "apiEndpoint" with the respective api-functions as objects, handed over by the modules: +- apiEndpoint.get --> the api to get data +- apiEndpoint.update --> the api to update data +- apiEndpoint.delete --> the api to delete data +then to use those api-functions in the module formGeneric instead of direct api calls +the modules mandates, users, files, prompts, to adapt accordingly + + + + + +- all api calls from workflowUI.js and workflowData.js also to transfer to apiCall.js. There to integrate ALL route endpoints from all routes and to call over window.utils.api..... +- handleFileUplad and uploadfile is on nmany places. To have the api functionality only in apiCall.js. + + + + +please refactor those topics. + +- all api calls from workflowUI.js and workflowData.js also to transfer to apiCall.js. There to integrate ALL route endpoints from all routes and to call over window.utils.api..... + +- Functions to handleFileUplad and uploadfile are on many places. To have the api functionality only in apiCall.js. + +no api relevant code in other modules than apiCall.js. + +In apiCalls.js to remove the generic functions get, post, put, delete from the public set. those not to expose. only the specific endpoints from the routes to expose. + +If more than 3 changes in a module, give me the full module. otherwise tell me the parts to change. + + + + +Please enhance this: +- config & env variables integration to have config variables in the globalState set in category "config" integrated. + +cleanup utils.js: + - remove all elements in the context of workflow and messages. those elements have to be integrated within workflow... modules. Some functions within utils.js anyway are not used anymore, so to remove anyway. + - extract all api-call functions to a separate submodule "apiCalls.js" module. There to implement one interface function for each api-call. all calls to put into one object "api" to be accessed. + - at the end utils.js shall only include config & environment data management, show general toast and error, uiUtils, dataUtils + - in workflow... modules there are some redundant functions like in utils.js (e.g. showToast, showError, etc.). Those to remove in workflow and to get from utils.js + - utils data shall be accesssible within those categories: + - window.utils.api --> the functions from apiCalls.js + - window.utils.ui --> what is in uiUtils currently, plus showError, showToast and similair + - window.utils.data --> what is in dataUtils currently plus handleFileUpload + +adapt other modules accordingly. for workflowUi.js only give me the parts to adapt. If only 1-3 adaptions for module, just give me the changes. Otherwise the revised module. + + + + + +please adapt module workflowUi.js with this input (the other modules have already been adapted): +- Error handling for file parsing failures to add +- Clear indication of workflow completion status +- The message object structure to fully match the documented model +- Status field handling to be exaclty and only the implementation according documentation (adjustment to recognize "first", "step", "last") +- File preview to better handle the documented document structure +- File actions to use the correct API paths +- log progress indicator implementation to improve, e.g. the feature to collapse/expand details +- Agent-specific log formatting to fully match the documented model +Updates Required: +- Update message rendering to handle status field correctly +- Improve file preview to handle documented document structure +- Update API paths for file operations +- Add better indication of workflow completion status +- Improve log progress indicator implementation + +also remove unused functionality and objects. + + + +Can you adapt following two modules. the modules workflowCoordination.ja and workflowData.js have already been updated. +please remove unused functionality and objects. + +please adapt module workflow.js with this input: +Updates Required: +- Implement explicit state machine transitions +- Update API interaction to match documented endpoints +- Improve error handling to match documented failure states +- Align status handling with the documented state transitions +- Ensure proper handling of the "last" message status + +please adapt module workflow.js with this input: +- adapt: Explicit handling of the workflow status transitions per state machine, clean separation of workflow states according to the documentation +- The workflow state management to align with the documented state machine +- Status transition handling to be more explicit +- Verify API paths and request structures +- Response handling to match the documented workflow object +Updates Required: +- Implement explicit state machine transitions +- Update API interaction to match documented endpoints +- Improve error handling to match documented failure states +- Align status handling with the documented state transitions +- Ensure proper handling of the "last" message status + + + +please adapt module workflowCoordination.js with this input: +- the workflow state object structure to be updated to match documentation +- Status transitions to follow the documented state machine +- message Status Handling to properly handle message status ("first", "step", "last") +Updates Required: +- Update workflowState object to match documented model +- Implement proper status transitions (null → running → completed/failed/stopped) +- Ensure message status field handling ("first", "step", "last") +- Ensure correct polling mechanism with log/message IDs +- Add missing getWorkflowStatus() function +- Fix the updateWorkflowStatus() function to handle all status transitions + + + + +please adapt module workflowData.js with this input: +- estimateJsonSize not to be in frontend. data stats is delivered in workflow object with attribute "tokensUsed" +- pollWorkflowStatus to implement +- adapt object Model Discrepancies: workflow object structure to match the state machine docs, File object structure to follow the documented model +- API Endpoint paths to correct to be: /api/workflows/${workflowId}/logs?id=${workflowState.lastPolledLogId}; Same issue to adapt for messages endpoint +- Data Handling: lastPolledLogId and lastPolledMessageId tracking variable paths to ensure corretly +- uploadAndAddFile: no change, this happens in the backend +- submitUserInput() and createWorkflow() to align response handling with the documented workflow object +Updates Required: +- Implement pollWorkflowStatus() function +- Define estimateJsonSize() function +- Fix API endpoint paths to match documentation (?logId= → ?id=) +- Update object models to match documentation +- Improve error handling according to the state machine +- Fix file handling to match documented file object model + + + +Can you please refactor the workflow_utils.js. The other documents we have. + +Attached: Frontend State machine Documentation as ruleset for the refactory, the current frontend + +To organize workflow... modules like this: +1. Centralized State Management: Use a single state object that all modules reference. +2. Event-Based Updates: Use a simple event system to trigger UI updates when state changes. +3. Clear Separation of Concerns: + * Model: Manages workflow state and API communication + * View: Purely responsible for rendering the UI based on state + * Controller: Connects user actions to model updates + +Comments: +- all variables and objects and functions and classes to name in camelCase, not in snake_case +- Adapted routes to implement +- I do not need backwards compatibility +- please remove all unnecessary elements and provide smart, well structured code, which is maintainable + +New File names: +- workflow.js - The main module as manager and coordinator +- workflow_state.js - Centralized state management +- workflow_api.js - API communication layer +- workflow_ui.js - UI rendering layer + + + + + +Can you please refactor the backend with those inputs: + +Attached: Backend State machine Documentation as ruleset for the refactory + +Comments: +- all variables and objects and functions and classes to name in camelCase, not in snake_case +- Adapted routes to implement +- I do not need backwards compatibility +- please remove all unnecessary elements and provide smart, well structured code, which is maintainable + +If you need further documents, please tell me. + + + + + I like your proposition. So do the refactory according to your proposition to clean and structure with these documents: - workflow_presentation.js - workflow_presentation_core.js diff --git a/notes/frontend.md b/notes/doc_frontend.md similarity index 100% rename from notes/frontend.md rename to notes/doc_frontend.md diff --git a/notes/doc_statemachine_backend.md b/notes/doc_statemachine_backend.md new file mode 100644 index 00000000..4556b8f3 --- /dev/null +++ b/notes/doc_statemachine_backend.md @@ -0,0 +1,366 @@ +# State Machine Documentation for Backend Chat Workflow + +## Overview + +The Chat Workflow system implements a state machine that processes user inputs through a sequence of well-defined steps. The system orchestrates interactions between users, project managers, and specialized agents to produce final outputs. + +## Core Objects + +### Workflow Object +```json +{ + "id": "uuid-string", + "mandateId": int, + "userId": int, + "name": "Workflow name", + "startedAt": "ISO-datetime", + "messages": [], // References to messages + "messageIds": [], // List of message IDs + "logs": [], // Log entries + "dataStats": {}, // Performance metrics + "currentRound": int, // Increments with each interaction + "status": "string", // running, completed, failed, stopped + "lastActivity": "ISO-datetime" +} +``` + +### Message Object +```json +{ + "id": "msg_uuid-string", + "workflowId": "workflow-uuid", + "role": "string", // user, assistant + "agentName": "string", // Empty for user, agent name for assistant + "content": "string", // The message text + "documents": [], // List of document objects + "timestamp": "ISO-datetime", + "sequenceNo": int, // Position in conversation + "status": "string" // first, step, last +} +``` + +### Log Entry Object +```json +{ + "id": "log_uuid-string", + "workflowId": "workflow-uuid", + "message": "string", + "progress": int, // Optional, 0-100 + "type": "string", // info, warning, error + "timestamp": "ISO-datetime", + "agentName": "string", // Name of the agent that generated the log + "status": "string" // current workflow status (running, completed, failed, stopped) +} +``` + +### Document Object +```json +{ + "id": "doc_uuid-string", + "fileId": int, + "name": "string", // Filename without extension + "ext": "string", // File extension + "data": "base64-encoded-string", // File contents + "contents": [] // Extracted content items in text format +} +``` + +### Content Item Object +```json +{ + "sequenceNr": int, // Sequence in the document + "name": "string", + "ext": "string", + "contentType": "string", // mime type + "data": "string|base64", // Original content + "dataExtracted": "string", // Optional AI-processed content based on extraction requirement + "metadata": { + "isText": boolean, + "base64Encoded": boolean, + "aiProcessed": boolean, + // Optional metadata specific to content type + }, + "summary": "string" // AI-generated static summary of the content +} +``` + +## State Machine Workflow + +### 1. Workflow Initialization +- **Trigger**: User message received via `/api/workflows/start` OR `/api/workflows/start?id=string` +- **Input**: `UserInputRequest` with `prompt` and optional `listFileId` +- **Process**: + - If `id` existing and workflow exists for `id`==`workflowId`: Load workflow, increment `currentRound`, set status "running" + - Else: Create new workflow with "currentRound"=1, status "running" +- **Logs**: "Workflow initialized" or "Running workflow", progress 0% +- **API Responses**: + - Success: 200 OK with workflow ID + - Error: 400 Bad Request if input invalid, 404 Not Found if workflow ID not found + +### 2. Workflow Exception +- **Trigger**: + - User stopped workflow via API + - An exception happened +- **Process**: + - If status=="stopped": Set workflow status to "stopped", add message with status "last", update lastActivity, stop execution immediately + - If status=="failed": Set workflow status to "failed", add message with status "last", update lastActivity, stop execution immediately + - Else: Continue normally +- **Logs**: "Workflow failure reported", progress 100% +- **API Responses**: + - For stop request: 200 OK when workflow successfully stopped + - For exceptions: 500 Internal Server Error with error details + +### 3. User Message Processing +- **Process**: + - Transform user input into message object with documents, message status "first" + - Extract contents from files using `getDocumentContents()` + - Generate static summaries for each content item +- **State Changes**: + - Add user message to `workflow.messages` array + - Add message ID to `workflow.messageIds` array + - Update `workflow.lastActivity` +- **Logs**: "Workflow processing started", progress 0% + +### 4. Project Manager Analysis +- **Process**: + - Generate prompt for project manager AI + - Project manager analyzes request and documents + - Project manager generates work plan and response +- **Outputs**: + - `objFinalDocuments`: List of str "filename.ext" for expected final output documents + - `objWorkplan`: List of agent tasks + - `objUserResponse`: Text response to user + - `userLanguage`: Detected language code (e.g. en) +- **State Changes**: + - Add assistant message with project manager response, status "step" + - Set user language in mydom interface +- **Logs**: "Analyzing request and planning work" (10%), "Planned outputs" (20%), "Work plan created" (25%) + +### 5. Agent Execution +- **Process** (For each task in workplan): + - Prepare input documents for agent + - Execute agent with standardized task object + - Save produced documents + - Create assistant message with agent response, status "step" +- **Agent Task Object**: +```json +{ + "taskId": "uuid-string", + "workflowId": "workflow-uuid", + "prompt": "string", + "inputDocuments": [], // list of documents including original document data and all content items data with original (attribute "data") and based on prompt (attribute "dataExtracted") + "outputSpecifications": [ + { + "label": "filename.ext", + "description": "string" + } + ], + "context": { + "workflowRound": int, + "agentType": "string", + "timestamp": "ISO-datetime", + "language": "language-code" + } +} +``` +- **Agent Result Object**: +```json +{ + "feedback": "string", // Text describing what the agent did + "documents": [ + { + "label": "filename.ext", + "content": "string|binary" // Document contents + } + ] +} +``` +- **State Changes**: Add assistant message for each agent with agentName set, status "step" +- **Logs**: "Running task X/Y: agentName" with progress updates from 30% to 90% + +### 6. Final Response Generation +- **Process**: + - Create final message reviewing promised and delivered documents + - Add documents to workflow +- **State Changes**: Add final assistant message from projectManager, status "last" +- **Logs**: "Creating final response" (90%) + +### 7. Workflow Completion +- **Process**: + - Finalize workflow and update status +- **State Changes**: + - Set workflow status to "completed" + - Update `workflow.lastActivity` +- **Logs**: "Workflow completed successfully" with progress 100% +- **API Responses**: + - A message with status "last" is included in the response + - Status endpoint will return "completed" + +### 8. Workflow Stopped +- **Trigger**: `/api/workflows/{workflowId}/stop` endpoint called +- **Process**: + - Immediately interrupt workflow execution + - Save current state and mark as stopped +- **State Changes**: + - Set workflow status to "stopped" + - Update lastActivity timestamp +- **Logs**: "Workflow stopped by user" with progress 100% +- **API Responses**: + - 200 OK with confirmation message + +### 9. Workflow Failed +- **Trigger**: Exception during workflow execution +- **Process**: + - Log error details + - Set workflow status to "failed" +- **State Changes**: + - Set workflow status to "failed" + - Update lastActivity timestamp +- **Logs**: Detailed error message with progress 100% +- **API Responses**: + - Status endpoint will return "failed" with error context + +### 10. Workflow Resumption +- **Trigger**: `/api/workflows/start?id={workflowId}` endpoint called with existing workflow ID +- **Process**: + - Load existing workflow + - Increment currentRound counter + - Start processing from user message +- **State Changes**: + - Set status to "running" + - Increment currentRound + - Add new user message +- **Logs**: "Resuming workflow, round {currentRound}" with progress 0% +- **API Responses**: + - Same as workflow initialization + +### 11. Workflow Reset/Deletion +- **Trigger**: `/api/workflows/{workflowId}` DELETE endpoint called +- **Process**: + - Remove all workflow data from storage +- **State Changes**: + - Workflow no longer exists in the system +- **Logs**: Log in system log that workflow was deleted +- **API Responses**: + - 200 OK if successful + - 404 Not Found if workflow didn't exist + +## API Endpoints and Polling Support + +### Main Workflow Endpoints +- `POST /api/workflows/start?id=string`: Submit user input to start a new workflow, optional with workflow id to continue existing workflow +- `POST /api/workflows/{workflowId}/stop`: Stop a running workflow: Immediately to set workflow status to "stopped" +- `DELETE /api/workflows/{workflowId}`: Delete a workflow +- `GET /api/workflows/{workflowId}/status`: Get workflow status (running, completed, failed, stopped) +- `GET /api/workflows/{workflowId}/logs?id=string`: Get workflow logs, optional with log id to get only logs produced after and including log with log id +- `GET /api/workflows/{workflowId}/messages?id=string`: Get workflow messages, optional with message id to get only messages produced after and including message with log id + +### Document Management +- `DELETE /api/workflows/{workflowId}/messages/{messageId}`: Delete a message +- `DELETE /api/workflows/{workflowId}/messages/{messageId}/files/{fileId}`: Remove file from message + +### Backend Support for Frontend Polling + +The backend implements efficient support for frontend polling mechanisms: + +1. **Selective Data Transfer**: + - Both `/logs` and `/messages` endpoints accept an optional `id` parameter + - When provided, only records with IDs equal to or newer than the specified ID are returned + - This minimizes data transfer and improves performance + +2. **Log Storage**: + - Each log entry includes timestamp, progress indicators, and status + - Frontend can accurately track workflow progress and update UI accordingly + - Logs are stored in chronological order with monotonically increasing IDs + +3. **Message Handling**: + - Messages include a status field ("first", "step", "last") + - The "last" status indicates completion of the current workflow round + - Frontend uses this to determine when to enable user input + +4. **Status Endpoint**: + - Lightweight endpoint that returns only the current workflow status + - Used by frontend to detect state changes without transferring all data + - Also includes lastActivity timestamp to detect stalled workflows + +5. **Caching Layer**: + - Backend implements caching for frequent polling requests + - Reduces database load and improves response times + - Cache invalidation occurs when workflow status changes + +6. **Batch Processing**: + - Large log or message sets are paginated automatically + - Frontend receives data in manageable chunks + - Prevents memory issues with long-running workflows + +## Document Object Structure Clarification +The Document Object contains both raw data and processed contents: +- `data`: Contains the base64-encoded binary representation of the entire original file +- `contents`: Contains an array of structured Content Item objects extracted from the original file + +The relationship works as follows: +1. When a file is uploaded, its binary data is stored in the `data` field +2. The original file's complete data is always preserved in the document's `data` field +3. The file is then processed by content extractors based on file type (PDF, image, text, etc.) +4. Each logically separate piece of content is added to the `contents` array +5. For text files, there might be just one content item +6. For PDFs, there might be multiple content items (one per page or per embedded image) +7. For complex documents, content items might represent different sections or formats +8. Each content item contains its own `data` field with the specific extracted content; for agents convenience it contains the additional field `dataExtracted` with extracted data based on agents task prompt + +This dual structure allows agents to: +- Access the complete original file when needed +- Work with pre-processed, extracted content for efficiency +- Process specific sections of a document without loading the entire file + +## State Transitions + +``` +[null] → [running] // New workflow created +[running] → [completed] // Workflow completes successfully +[running] → [stopped] // User manually stops workflow +[running] → [failed] // Error occurs during workflow +[completed] → [running] // User continues workflow with new input (new round) +[stopped] → [running] // User continues after manual stop (new round) +[failed] → [running] // User retries workflow despite error (new round) +[any] → [null] // Workflow deleted +``` + +## Exception Handling + +### Rules +- Workflow status changes to "failed" on exceptions, all message and workflow generation exceptions to handle to ensure data consistency in the database +- Errors are logged in workflow logs with type "error" +- Produced project manager analysis output, inputs to agents, output from agents, workflow items, message items are all logged for debugging in the logger with type "debug" +- HTTP exceptions are returned to the client with appropriate status codes +- Failed agent tasks are recorded but don't stop the workflow + +### Workflow Stop Conditions +- User explicitly cancels the workflow via the stop endpoint + +Action to take: +- workflow to set to "stopped" status + +### Workflow Failure Conditions +- Unhandled exceptions in the main workflow execution path +- Project manager analysis fails to generate a valid workplan +- More than 50% of the agent tasks in the workplan fail to complete +- Timeout exceeded (workflow runs longer than the configured maximum duration) +- System resource limits exceeded (memory, CPU, etc.) + +Action to take, when a workflow fails: +- The last log entry will contain details about the failure reason +- workflow to set to "failed" status + +### Workflow Exception Checkpoints +At the following points in the code the Workflow Execution routine is called: +- Before adding or updating a message to the workflow +- Before doing an API call + +## Special Notes + +1. **Document Processing**: Files uploaded by users are processed with content extraction to make them accessible to agents. +2. **AI Language Support**: The system detects and adapts to the user's language. +3. **Round Counting**: Each interaction increments the `currentRound` counter. +4. **Agent Registry**: Agents are loaded dynamically and registered in the AgentRegistry. +5. **Standardized Task Processing**: All agents implement the same task processing interface. diff --git a/notes/doc_statemachine_frontend.md b/notes/doc_statemachine_frontend.md new file mode 100644 index 00000000..0fa1f374 --- /dev/null +++ b/notes/doc_statemachine_frontend.md @@ -0,0 +1,453 @@ +# State Machine Documentation for Frontend Chat Workflow + +## Overview + +The Chat Workflow frontend implements a state machine that manages user interactions through a well-defined sequence of states. This system coordinates the user interface components, handles file attachments, and manages communication with the backend to provide a seamless multi-agent chat experience. + +## Core Objects + +### Frontend Workflow State Object +```json +{ + "status": "string", // null or "running", "completed", "failed", "stopped" + "workflowId": "string", // null or Unique workflow identifier + "logs": [], // Log entries + "chatMessages": [], // Chat messages + "lastPolledLogId": "string", // ID of last polled log + "lastPolledMessageId": "string", // ID of last polled message + "dataStats": { + "bytesSent": int, // Data sent to backend + "bytesReceived": int, // Data received from backend + "tokensUsed": float // Used tokens required for billing + } +} +``` + +### User Input State Object +```json +{ + "promptText": "string", // Current user input text + "additionalFiles": [], // List of file IDs to attach + "domElements": {} // References to UI DOM elements +} +``` + +### Log Entry Object +```json +{ + "id": "log_timestamp", + "message": "string", + "progress": int, // Optional, 0-100 + "type": "string", // info, warning, error + "timestamp": "ISO-datetime", + "agentName": "string", // Name of the agent that generated the log + "waiting": boolean, // Whether this log shows a waiting indicator + "highlighted": boolean // Whether this log should be visually highlighted +} +``` + +### Chat Message Object +```json +{ + "id": "msg_type_timestamp", + "role": "string", // user, assistant + "agentName": "string", + "content": "string", + "documents": [], // List of document objects + "timestamp": "ISO-datetime", + "status": "string" // first, step, last ("workflowComplete" can be asked as `status`=="last") +} +``` + +### File Object +```json +{ + "id": "file_uuid-string", + "name": "filename.ext", + "size": int, + "fileId": int, + "contentType": "string", // mime type +} +``` + +## State Machine Workflow + +### 1. Initial State +- **State**: `null` (No workflow active) +- **UI Elements**: + - Empty chat container with placeholder + - Prompt input field enabled + - "Start" button enabled + - "Stop" button hidden + - File upload area enabled + - Empty log panel +- **User Actions**: + - Enter prompt text + - Add files via upload or drag & drop + - Select pre-defined prompts from dropdown + - Click Start button +- **API Interactions**: None in this state + +### 2. Prompt Preparation +- **State**: `null` (transitioning to `running`) +- **Triggers**: + - User typing in prompt field (updates `userInputState.promptText`) + - File uploads/drag & drop (adds to `userInputState.additionalFiles`) + - Prompt selection from dropdown (sets `userInputState.promptText`) +- **Process**: + - Files are uploaded to backend via `uploadAndAddFile()` + - Files appear in attachment list with name, size, remove option + - Prompt visualization is updated with file count and names +- **State Changes**: + - `userInputState.additionalFiles` array updated + - `userInputState.promptText` updated +- **UI Updates**: + - File attachment list rendered + - Prompt preview area shows attached files +- **API Interactions**: + - `POST /api/files/upload`: For each file being attached, an API call is made to upload the file and get a file ID + - Response contains file metadata which is stored in the frontend state + +### 3. Workflow Initialization +- **State**: `running` +- **Trigger**: User clicks "Start" button or presses Enter +- **Process**: + - Validate user input (ensures non-empty prompt) + - Set loading state (disable start button, show spinner) + - Submit prompt and files + - Receive workflow ID from backend +- **State Changes**: + - `status` → `running` + - `workflowId` set to returned ID + - `userInputState.additionalFiles` reset to empty array + - `userInputState.promptText` reset to empty string +- **UI Updates**: + - Chat messages container shown + - User message appears in chat + - Log entry added: "Workflow started" + - System chat message added: "Multi-Agent Chat has been started" + - Start button becomes Send button, deactivated and with animation + - Stop button becomes visible + - Input field disabled temporarily +- **API Interactions**: + - `POST /api/workflows/start`: Submit user prompt and list of file IDs + - Request payload: `{ prompt: string, fileIds: array }` + - Response contains `workflowId` which is stored for future API calls + - For continuing an existing workflow: `POST /api/workflows/start?id={workflowId}` + +### 4. Polling for Updates +- **State**: `running` +- **Process**: + - `pollWorkflowStatus()` initiated with workflow ID + - `pollWorkflowLogs()` and `pollWorkflowMessages()` called periodically + - Last log and message IDs tracked to request only new items + - New logs and messages added to state +- **State Changes**: + - `logs` array updated with new log entries + - `chatMessages` array updated with new messages + - `lastPolledLogId` and `lastPolledMessageId` updated + - `dataStats` updated with sent/received bytes and tokens +- **UI Updates**: + - Updated and new logs rendered in log panel + - Updated and new chat messages rendered in chat area + - Waiting animation shown on latest log entry + - Data statistics counters updated +- **API Interactions**: + - `GET /api/workflows/{workflowId}/status`: Polls workflow status (every 2000ms) + - `GET /api/workflows/{workflowId}/logs?id={lastPolledLogId}`: Gets only logs newer than the last polled log + - `GET /api/workflows/{workflowId}/messages?id={lastPolledMessageId}`: Gets only messages newer than the last polled message + - Polling continues until workflow status changes from "running" or a message with status "last" is received + +### 5. Workflow Running +- **State**: `running` +- **Process**: + - Backend processes user input through agent workflow + - Frontend continuously polls for updates + - Log entries show progress of agents + - Chat messages display agent responses +- **UI Elements**: + - Stop button visible and enabled + - Input field disabled + - Log panel shows processing steps with progress indicators + - Chat displays multi-agent conversation +- **User Actions**: + - Click Stop button to interrupt workflow + - View file attachments in messages + - Preview or download files +- **API Interactions**: + - Continued polling via endpoints described in State 4 + - `POST /api/workflows/{workflowId}/stop`: If user clicks Stop button + +### 6. Workflow Completion +- **State**: `completed` +- **Trigger**: Backend returns workflow status "completed" or message with status "last" +- **Process**: + - Final message displayed, input enabled for new prompt + - Polling stops +- **State Changes**: + - `status` → `completed` +- **UI Updates**: + - Stop button hidden + - Start button enabled + - Input field enabled and focused + - Final log shows "Workflow completed" +- **API Interactions**: + - No further API calls until user inputs new prompt + +### 7. Workflow Failure +- **State**: `failed` +- **Trigger**: Backend returns workflow status "failed" +- **Process**: + - Error message displayed, option to retry + - Polling stops +- **State Changes**: + - `status` → `failed` +- **UI Updates**: + - Error indicators in UI + - Retry option enabled + - Input field enabled +- **API Interactions**: + - No further API calls until user initiates retry + +### 8. Workflow Stopped +- **State**: `stopped` +- **Trigger**: User clicks Stop button or backend returns "stopped" +- **Process**: + - Workflow processing interrupted + - Polling stops +- **State Changes**: + - `status` → `stopped` +- **UI Updates**: + - Resume option enabled + - Start button enabled + - Input field enabled +- **API Interactions**: + - No further API calls until user continues or resets + +### 9. User Input Requested +- **State**: Varies based on workflow state +- **Trigger**: Received message with status "last" or workflow status not "running" +- **Process**: + - Special log entry added: "Waiting for user input to continue" + - Input field enabled for user response +- **State Changes**: + - `status` → The status from the workflow +- **UI Updates**: + - Stop Polling + - Waiting animation stopped + - Input field enabled and focused + - Send button enabled + - Send button shows "Start" for new workflow or "Send" for continuation + - Input field may show specific placeholder + - Stop button hidden +- **API Interactions**: + - No API calls until user provides input + +### 10. Continuation Preparation +- **State**: `completed`, `failed`, or `stopped` (transitioning to `running`) +- **Trigger**: User enters new input after previous workflow cycle +- **Process**: + - Prepare continuation with existing workflow ID + - Similar to Prompt Preparation but preserves context +- **State Changes**: + - `userInputState.promptText` updated + - `userInputState.additionalFiles` updated if new files added +- **UI Updates**: + - File attachment list updated if changed + - Send button ready for continuation +- **API Interactions**: + - Same as Prompt Preparation if new files are added + +### 11. Workflow Resumption +- **State**: `running` +- **Trigger**: User continues workflow after stop/failure/completion +- **Process**: + - Submit new input with existing workflow ID +- **State Changes**: + - `status` → `running` + - New user message added +- **UI Updates**: + - Similar to Workflow Initialization but preserves history + - Polling resumes +- **API Interactions**: + - `POST /api/workflows/start?id={workflowId}`: Sends continuation prompt with existing workflow ID + - Polling endpoints resume as in State 4 + +### 12. Workflow Reset +- **State**: `null` +- **Trigger**: User clicks Reset button +- **Process**: + - All state data cleared + - UI reset to initial state +- **State Changes**: + - `status` → `null` + - `workflowId` → `null` + - `logs` → `[]` + - `chatMessages` → `[]` +- **UI Updates**: + - Empty chat state shown + - Log panel cleared + - Input field reset + - Chat area cleared + - File attachments removed +- **API Interactions**: + - Optional `DELETE /api/workflows/{workflowId}` to clean up server resources + +## API Interaction Details + +### Polling Implementation +The frontend implements a sophisticated polling mechanism that efficiently retrieves only the new data: + +1. **Initialization**: + - When a workflow starts, the frontend stores the workflow ID + - Initial polling begins immediately after receiving workflow ID + +2. **Selective Data Retrieval**: + - Frontend tracks `lastPolledLogId` and `lastPolledMessageId` + - Each polling request includes the last ID to receive only newer items + - This significantly reduces bandwidth and processing requirements + +3. **Polling Schedule**: + - Status polling: Every 2000ms while in `running` state + - Logs polling: Every 1000ms while in `running` state + - Messages polling: Every 1000ms while in `running` state + - All polling stops when workflow status changes from `running` + +4. **Retry Mechanism**: + - Network failures trigger exponential backoff + - Starting at 1000ms, doubling up to 16000ms max + - After 5 consecutive failures, displays connection error + +5. **Polling Suspension**: + - Polling automatically pauses when browser tab is inactive + - Resumes when tab becomes active again + - Can be manually suspended with `suspendPolling()` during UI transitions + +### API Endpoints Used + +| Frontend Function | Backend Endpoint | Parameters | Description | +|-------------------|------------------|------------|-------------| +| `startWorkflow()` | `POST /api/workflows/start` | `{ prompt: string, fileIds: [] }` | Starts new workflow | +| `continueWorkflow()` | `POST /api/workflows/start?id={workflowId}` | `{ prompt: string, fileIds: [] }` | Continues existing workflow | +| `pollWorkflowStatus()` | `GET /api/workflows/{workflowId}/status` | None | Gets current workflow status | +| `pollWorkflowLogs()` | `GET /api/workflows/{workflowId}/logs?id={lastLogId}` | Optional log ID | Gets logs newer than specified ID | +| `pollWorkflowMessages()` | `GET /api/workflows/{workflowId}/messages?id={lastMessageId}` | Optional message ID | Gets messages newer than specified ID | +| `stopWorkflow()` | `POST /api/workflows/{workflowId}/stop` | None | Interrupts running workflow | +| `resetWorkflow()` | `DELETE /api/workflows/{workflowId}` | None | Cleans up workflow resources | +| `uploadFile()` | `POST /api/files/upload` | FormData with file | Uploads file and returns file ID | +| `deleteMessage()` | `DELETE /api/workflows/{workflowId}/messages/{messageId}` | None | Removes message from workflow | +| `removeFileFromMessage()` | `DELETE /api/workflows/{workflowId}/messages/{messageId}/files/{fileId}` | None | Removes file from message | + +## Special Features + +### File Handling +1. **File Upload**: + - Direct upload via button or drag & drop + - FileId added to `userInputState.additionalFiles` + - UI renders file in attachment list + - Each file can be removed individually + +2. **File Preview**: + - Files in messages can be previewed + - Preview shows content based on file type (text, image, PDF) + - Files can be downloaded or copied to clipboard + - Various file formats supported with appropriate visualizations + +### Chat Message Rendering +1. **Message Types**: + - User messages (grey background) + - Agent messages (white background) + - Moderator questions (specially formatted) + +2. **Message Features**: + - Collapsible for long content + - Symbol to delete message + - File attachments with preview options + - Markdown-like formatting support + - Agent name and timestamp display + +### Log Panel Features +1. **Log Types**: + - Info (blue) + - Warning (orange) + - Error (red) + +2. **Log Features**: + - Log items are read selectively from API: Only the last log entry and newer ones + - Progress indicators for agent tasks; before a next log message is rendered, the last log message progress is set to 100% + - Waiting animation for ongoing processes + - Agent-specific highlighting + - Collapsible detailed information, meaning the first n (e.g., 40) characters are by default displayed with "..." at the end. By clicking on "..." the additional part can be expanded/collapsed + - Timestamp display + +### Waiting States +1. **Animation**: + - Dots animation in log entries + - Spinner in Send button during loading + - Progress indicators in agent logs + +2. **State Management**: + - `waiting` flag in log objects + - `waitingDotsInterval` controls animation + - `setLoadingState()` manages UI element states + +## State Transitions + +``` +[null] → [running] // Initial prompt submission +[running] → [running] // Ongoing polling updates +[running] → [completed] // Workflow completes successfully +[running] → [stopped] // User manually stops workflow +[running] → [failed] // Error occurs during workflow +[completed] → [running] // User continues workflow with new input +[stopped] → [running] // User continues after manual stop +[failed] → [running] // User retries workflow despite error +[any] → [null] // User resets workflow +``` + +## Error Handling + +### Client-side Errors +1. **Network Errors**: + - Retry mechanism in polling functions + - Exponential backoff for repeated failures + - Informative error logs for debugging + +2. **UI Errors**: + - Validation before state changes + - Fallback DOM element selection + - Error boundaries for component isolation + +### Backend Communication Errors +1. **API Failures**: + - Error logging in console + - User-friendly error messages in UI + - Error state with option to retry + - Toast notifications for transient errors + +2. **Data Inconsistencies**: + - ID matching with fallback to partial matching + - Multiple file reference methods + - Content extraction fallbacks + +## Implementation Notes + +1. **Module Structure**: + - `workflow.js`: Main initialization and coordination + - `workflowState.js`: State management + - `workflowApi.js`: Backend communication + - `workflowUi.js`: UI rendering + - `workflowUtils.js`: Helper functions + +2. **Key Functions**: + - `workflowInit()`: Entry point for initialization + - `workflowStatusUpdate()`: Core state transition function + - `workflowStatusPoll()`: Main update loop + - `workflowUserInput()`: Handles user input submission + - `renderLogs()` and `renderMessages()`: UI update functions + +3. **Performance Optimizations**: + - Selective DOM updates + - Scroll position preservation + - Data size estimation for statistics + - Conditional re-rendering diff --git a/routes/attributes.py b/routes/attributes.py deleted file mode 100644 index 46fc07b1..00000000 --- a/routes/attributes.py +++ /dev/null @@ -1,74 +0,0 @@ -from fastapi import APIRouter, HTTPException, Depends, Path, Response -from typing import List, Dict, Any -from fastapi import status - -from modules.auth import get_current_active_user, get_user_context - -# Import the attribute definition and helper functions -from modules.def_attributes import AttributeDefinition, get_model_attributes - -# Import the model modules (without specific classes) -import modules.gateway_model as gateway_model -import modules.lucydom_model as lucydom_model - -model_classes = { - # Gateway model classes - "mandate": gateway_model.Mandate, - "user": gateway_model.User, - - # LucyDOM model classes - admin - "file": lucydom_model.FileItem, - "prompt": lucydom_model.Prompt, - - # LucyDOM model classes - chat - "document_content": lucydom_model.DocumentContent, - "document": lucydom_model.Document, - "data_stats": lucydom_model.DataStats, - "user_input_request": lucydom_model.UserInputRequest, - "workflow": lucydom_model.Workflow, - "workflow_message": lucydom_model.WorkflowMessage, - "workflow_log": lucydom_model.WorkflowLog, -} - - -# Create a router for the attribute endpoints -router = APIRouter( - prefix="/api/attributes", - tags=["Attributes"], - responses={404: {"description": "Not found"}} -) - -@router.get("/{entity_type}", response_model=List[AttributeDefinition]) -async def get_entity_attributes( - entity_type: str = Path(..., description="Type of entity (e.g. prompt)"), - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """ - Retrieves the attribute definitions for a specific entity. - This can be used for dynamic form generation. - """ - # Authentication and user context - mandate_id, user_id = await get_user_context(current_user) - - # Determine preferred language of the user - user_language = current_user.get("language", "de") - - # Check if entity type is known - if entity_type not in model_classes: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail=f"Entity type '{entity_type}' not found." - ) - - # Get model class and derive attributes from it - model_class = model_classes[entity_type] - attributes = get_model_attributes(model_class, user_language) - - # Return only editable and visible attributes - visible_attributes = [attr for attr in attributes if attr.visible] - -@router.options("/{entity_type}") -async def options_entity_attributes( - entity_type: str = Path(..., description="Type of entity (e.g. prompt)") -): - return Response(status_code=200) \ No newline at end of file diff --git a/routes/mandates.py b/routes/mandates.py deleted file mode 100644 index e89b486a..00000000 --- a/routes/mandates.py +++ /dev/null @@ -1,216 +0,0 @@ -from fastapi import APIRouter, HTTPException, Depends, Body, Path -from typing import List, Dict, Any -from fastapi import status -from datetime import datetime -from dataclasses import dataclass - -# Import interfaces -from modules.auth import get_current_active_user, get_user_context -from modules.gateway_interface import get_gateway_interface -from modules.gateway_model import Mandate - -# Determine all attributes of the model (except internal/special attributes) -def get_model_attributes(model_class): - return [attr for attr in dir(model_class) - if not callable(getattr(model_class, attr)) - and not attr.startswith('_') - and attr != 'metadata' - and attr != 'query' - and attr != 'query_class' - and attr != 'label' - and attr != 'field_labels'] - -# Model attributes for Mandate -mandate_attributes = get_model_attributes(Mandate) - -@dataclass -class AppContext: - """Context object for all required connections and user information""" - mandate_id: int - user_id: int - interface_data: Any # Gateway Interface - -async def get_context(current_user: Dict[str, Any]) -> AppContext: - """ - Creates a central context object with all required interfaces - - Args: - current_user: Current user from authentication - - Returns: - AppContext object with all required connections - """ - mandate_id, user_id = await get_user_context(current_user) - interface_data = get_gateway_interface(mandate_id, user_id) - - return AppContext( - mandate_id=mandate_id, - user_id=user_id, - interface_data=interface_data - ) - -# Create router for mandate endpoints -router = APIRouter( - prefix="/api/mandates", - tags=["Mandates"], - responses={404: {"description": "Not found"}} -) - -@router.get("", response_model=List[Dict[str, Any]]) -async def get_mandates(current_user: Dict[str, Any] = Depends(get_current_active_user)): - """Get all available mandates (only for SysAdmin users)""" - context = await get_context(current_user) - - # Permission check - if current_user.get("privilege") != "sysadmin": - raise HTTPException( - status_code=status.HTTP_403_FORBIDDEN, - detail="Only system administrators can access all mandates" - ) - - # Get mandates generically - return context.interface_data.get_all_mandates() - - -@router.post("", response_model=Dict[str, Any]) -async def create_mandate( - mandate: Dict[str, Any] = Body(...), - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """Create a new mandate (only for SysAdmin users)""" - context = await get_context(current_user) - - # Permission check - if current_user.get("privilege") != "sysadmin": - raise HTTPException( - status_code=status.HTTP_403_FORBIDDEN, - detail="Only system administrators can create mandates" - ) - - # Set attributes from the request dynamically - mandate_data = {} - for attr in mandate_attributes: - if attr in mandate: - mandate_data[attr] = mandate[attr] - - # Default values for missing fields - if "name" not in mandate_data: - mandate_data["name"] = "New Mandate" - if "language" not in mandate_data: - mandate_data["language"] = "de" - - # Create mandate - new_mandate = context.interface_data.create_mandate(**mandate_data) - - return new_mandate - - -@router.get("/{mandate_id}", response_model=Dict[str, Any]) -async def get_mandate( - mandate_id: int, - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """Get a specific mandate""" - context = await get_context(current_user) - - # Permission check - # Admin can only see their own mandate, SysAdmin can see all - is_admin = current_user.get("privilege") == "admin" - is_sysadmin = current_user.get("privilege") == "sysadmin" - is_own_mandate = context.mandate_id == mandate_id - - if (is_admin and not is_own_mandate) and not is_sysadmin: - raise HTTPException( - status_code=status.HTTP_403_FORBIDDEN, - detail="No permission to access this mandate" - ) - - # Get mandate generically - mandate = context.interface_data.get_mandate(mandate_id) - if not mandate: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail=f"Mandate with ID {mandate_id} not found" - ) - - return mandate - -@router.put("/{mandate_id}", response_model=Dict[str, Any]) -async def update_mandate( - mandate_id: int = Path(..., description="ID of the mandate to update"), - mandate_data: Dict[str, Any] = Body(..., description="Updated mandate data"), - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """Update an existing mandate""" - context = await get_context(current_user) - - # Mandate exists? - mandate = context.interface_data.get_mandate(mandate_id) - if not mandate: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail=f"Mandate with ID {mandate_id} not found" - ) - - # Permission check - is_admin = current_user.get("privilege") == "admin" - is_sysadmin = current_user.get("privilege") == "sysadmin" - is_own_mandate = context.mandate_id == mandate_id - - if (is_admin and not is_own_mandate) and not is_sysadmin: - raise HTTPException( - status_code=status.HTTP_403_FORBIDDEN, - detail="No permission to update this mandate" - ) - - # Dynamically filter attributes from the request into update_data - update_data = {} - for attr in mandate_attributes: - if attr in mandate_data: - update_data[attr] = mandate_data[attr] - - # Update mandate - updated_mandate = context.interface_data.update_mandate( - mandate_id=mandate_id, - mandate_data=update_data - ) - - return updated_mandate - -@router.delete("/{mandate_id}", status_code=status.HTTP_204_NO_CONTENT) -async def delete_mandate( - mandate_id: int = Path(..., description="ID of the mandate to delete"), - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """Delete a mandate, including all associated users and referenced objects""" - context = await get_context(current_user) - - # Mandate exists? - mandate = context.interface_data.get_mandate(mandate_id) - if not mandate: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail=f"Mandate with ID {mandate_id} not found" - ) - - # Permission check - is_admin = current_user.get("privilege") == "admin" - is_sysadmin = current_user.get("privilege") == "sysadmin" - is_own_mandate = context.mandate_id == mandate_id - - if (is_admin and not is_own_mandate) and not is_sysadmin: - raise HTTPException( - status_code=status.HTTP_403_FORBIDDEN, - detail="No permission to delete this mandate" - ) - - # Delete mandate - success = context.interface_data.delete_mandate(mandate_id) - if not success: - raise HTTPException( - status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, - detail=f"Error deleting mandate with ID {mandate_id}" - ) - - # Return no content on successful deletion - return None \ No newline at end of file diff --git a/routes/prompts.py b/routes/prompts.py deleted file mode 100644 index 2509b994..00000000 --- a/routes/prompts.py +++ /dev/null @@ -1,188 +0,0 @@ -from fastapi import APIRouter, HTTPException, Depends, Body, Query, Path -from typing import List, Dict, Any, Optional -from fastapi import status -from datetime import datetime -from dataclasses import dataclass - -# Import auth module -from modules.auth import get_current_active_user, get_user_context - -# Import interfaces -from modules.lucydom_interface import get_lucydom_interface -from modules.lucydom_model import Prompt - -# Get all attributes of the model (except internal/special attributes) -def get_model_attributes(model_class): - return [attr for attr in dir(model_class) - if not callable(getattr(model_class, attr)) - and not attr.startswith('_') - and attr != 'metadata' - and attr != 'query' - and attr != 'query_class' - and attr != 'label' - and attr != 'field_labels'] - -# Model attributes for Prompt -prompt_attributes = get_model_attributes(Prompt) - -@dataclass -class AppContext: - """Context object for all required connections and user information""" - mandate_id: int - user_id: int - interface_data: Any # LucyDOM Interface - -async def get_context(current_user: Dict[str, Any]) -> AppContext: - """ - Creates a central context object with all required interfaces - - Args: - current_user: Current user from authentication - - Returns: - AppContext object with all required connections - """ - mandate_id, user_id = await get_user_context(current_user) - interface_data = get_lucydom_interface(mandate_id, user_id) - - return AppContext( - mandate_id=mandate_id, - user_id=user_id, - interface_data=interface_data - ) - -# Create router for prompt endpoints -router = APIRouter( - prefix="/api/prompts", - tags=["Prompts"], - responses={404: {"description": "Not found"}} -) - -@router.get("", response_model=List[Dict[str, Any]]) -async def get_prompts( - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """Get all prompts""" - context = await get_context(current_user) - - # Retrieve prompts generically - return context.interface_data.get_all_prompts() - - -@router.post("", response_model=Dict[str, Any]) -async def create_prompt( - prompt: Dict[str, Any] = Body(...), - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """Create a new prompt""" - context = await get_context(current_user) - - # Set attributes from the request dynamically - prompt_data = {} - for attr in prompt_attributes: - if attr in prompt: - prompt_data[attr] = prompt[attr] - - # Required fields with default values - content = prompt.get("content", "") - name = prompt.get("name", "New Prompt") - - # Create prompt - new_prompt = context.interface_data.create_prompt( - content=content, - name=name - ) - - # Set current time for created_at if it exists in the model - if "created_at" in prompt_attributes and hasattr(new_prompt, "created_at"): - new_prompt["created_at"] = datetime.now().isoformat() - - return new_prompt - - -@router.get("/{prompt_id}", response_model=Dict[str, Any]) -async def get_prompt( - prompt_id: int, - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """Get a specific prompt""" - context = await get_context(current_user) - - # Get prompt generically - prompt = context.interface_data.get_prompt(prompt_id) - if not prompt: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail=f"Prompt with ID {prompt_id} not found" - ) - - return prompt - - -@router.put("/{prompt_id}", response_model=Dict[str, Any]) -async def update_prompt( - prompt_id: int, - prompt_data: Dict[str, Any] = Body(...), - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """Update an existing prompt""" - context = await get_context(current_user) - - # Check if the prompt exists - existing_prompt = context.interface_data.get_prompt(prompt_id) - if not existing_prompt: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail=f"Prompt with ID {prompt_id} not found" - ) - - # Filter attributes from the request dynamically - update_data = {} - for attr in prompt_attributes: - if attr in prompt_data: - update_data[attr] = prompt_data[attr] - - # Standard fields for update - content = prompt_data.get("content") - name = prompt_data.get("name") - - # Update prompt - updated_prompt = context.interface_data.update_prompt( - prompt_id=prompt_id, - content=content, - name=name - ) - - if not updated_prompt: - raise HTTPException( - status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, - detail="Error updating the prompt" - ) - - return updated_prompt - - -@router.delete("/{prompt_id}", response_model=Dict[str, Any]) -async def delete_prompt( - prompt_id: int, - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """Delete a prompt""" - context = await get_context(current_user) - - # Check if the prompt exists - existing_prompt = context.interface_data.get_prompt(prompt_id) - if not existing_prompt: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail=f"Prompt with ID {prompt_id} not found" - ) - - success = context.interface_data.delete_prompt(prompt_id) - if not success: - raise HTTPException( - status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, - detail="Error deleting the prompt" - ) - - return {"message": f"Prompt with ID {prompt_id} successfully deleted"} \ No newline at end of file diff --git a/routes/routeAttributes.py b/routes/routeAttributes.py new file mode 100644 index 00000000..7a085da3 --- /dev/null +++ b/routes/routeAttributes.py @@ -0,0 +1,74 @@ +from fastapi import APIRouter, HTTPException, Depends, Path, Response +from typing import List, Dict, Any +from fastapi import status + +from modules.auth import getCurrentActiveUser, getUserContext + +# Import the attribute definition and helper functions +from modules.defAttributes import AttributeDefinition, getModelAttributes + +# Import the model modules (without specific classes) +import modules.gatewayModel as gatewayModel +import modules.lucydomModel as lucydomModel + +modelClasses = { + # Gateway model classes + "mandate": gatewayModel.Mandate, + "user": gatewayModel.User, + + # LucyDOM model classes - admin + "file": lucydomModel.FileItem, + "prompt": lucydomModel.Prompt, + + # LucyDOM model classes - chat + "documentContent": lucydomModel.DocumentContent, + "document": lucydomModel.Document, + "dataStats": lucydomModel.DataStats, + "userInputRequest": lucydomModel.UserInputRequest, + "workflow": lucydomModel.Workflow, + "workflowMessage": lucydomModel.WorkflowMessage, + "workflowLog": lucydomModel.WorkflowLog, +} + +# Create a router for the attribute endpoints +router = APIRouter( + prefix="/api/attributes", + tags=["Attributes"], + responses={404: {"description": "Not found"}} +) + +@router.get("/{entityType}", response_model=List[AttributeDefinition]) +async def getEntityAttributes( + entityType: str = Path(..., description="Type of entity (e.g. prompt)"), + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """ + Retrieves the attribute definitions for a specific entity. + This can be used for dynamic form generation. + """ + # Authentication and user context + mandateId, userId = await getUserContext(currentUser) + + # Determine preferred language of the user + userLanguage = currentUser.get("language", "de") + + # Check if entity type is known + if entityType not in modelClasses: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"Entity type '{entityType}' not found." + ) + + # Get model class and derive attributes from it + modelClass = modelClasses[entityType] + attributes = getModelAttributes(modelClass, userLanguage) + + # Return only visible attributes + return [attr for attr in attributes if attr.visible] + +@router.options("/{entityType}") +async def optionsEntityAttributes( + entityType: str = Path(..., description="Type of entity (e.g. prompt)") +): + """Handle OPTIONS request for CORS preflight""" + return Response(status_code=200) \ No newline at end of file diff --git a/routes/files.py b/routes/routeFiles.py similarity index 56% rename from routes/files.py rename to routes/routeFiles.py index d15d2538..f1026d03 100644 --- a/routes/files.py +++ b/routes/routeFiles.py @@ -6,54 +6,42 @@ from datetime import datetime from dataclasses import dataclass import io -from modules.auth import get_current_active_user, get_user_context +from modules.auth import getCurrentActiveUser, getUserContext from modules.configuration import APP_CONFIG # Import interfaces -from modules.lucydom_interface import get_lucydom_interface, FileError, FileNotFoundError, FileStorageError, FilePermissionError, FileDeletionError -from modules.lucydom_model import FileItem +from modules.lucydomInterface import getLucydomInterface, FileError, FileNotFoundError, FileStorageError, FilePermissionError, FileDeletionError +from modules.lucydomModel import FileItem # Configure logger logger = logging.getLogger(__name__) -# Get all attributes of the model (except internal/special attributes) -def get_model_attributes(model_class): - return [attr for attr in dir(model_class) - if not callable(getattr(model_class, attr)) +# Get all attributes of the model +def getModelAttributes(modelClass): + return [attr for attr in dir(modelClass) + if not callable(getattr(modelClass, attr)) and not attr.startswith('_') - and attr != 'metadata' - and attr != 'query' - and attr != 'query_class' - and attr != 'label' - and attr != 'field_labels'] + and attr not in ('metadata', 'query', 'query_class', 'label', 'field_labels')] # Model attributes for FileItem -file_attributes = get_model_attributes(FileItem) +fileAttributes = getModelAttributes(FileItem) @dataclass class AppContext: """Context object for all required connections and user information""" - mandate_id: int - user_id: int - interface_data: Any # LucyDOM Interface + mandateId: int + userId: int + interfaceData: Any # LucyDOM Interface -async def get_context(current_user: Dict[str, Any]) -> AppContext: - """ - Creates a central context object with all required interfaces - - Args: - current_user: Current user from authentication - - Returns: - AppContext object with all required connections - """ - mandate_id, user_id = await get_user_context(current_user) - interface_data = get_lucydom_interface(mandate_id, user_id) +async def getContext(currentUser: Dict[str, Any]) -> AppContext: + """Creates a central context object with all required connections""" + mandateId, userId = await getUserContext(currentUser) + interfaceData = getLucydomInterface(mandateId, userId) return AppContext( - mandate_id=mandate_id, - user_id=user_id, - interface_data=interface_data + mandateId=mandateId, + userId=userId, + interfaceData=interfaceData ) # Create router for file endpoints @@ -70,13 +58,13 @@ router = APIRouter( ) @router.get("", response_model=List[Dict[str, Any]]) -async def get_files(current_user: Dict[str, Any] = Depends(get_current_active_user)): +async def getFiles(currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)): """Get all available files""" try: - context = await get_context(current_user) + context = await getContext(currentUser) # Get all files generically - only metadata, no binary data - files = context.interface_data.get_all_files() + files = context.interfaceData.getAllFiles() return files except Exception as e: logger.error(f"Error retrieving files: {str(e)}") @@ -85,41 +73,38 @@ async def get_files(current_user: Dict[str, Any] = Depends(get_current_active_us detail=f"Error retrieving files: {str(e)}" ) - @router.post("/upload", status_code=status.HTTP_201_CREATED) -async def upload_file( +async def uploadFile( file: UploadFile = File(...), - workflow_id: Optional[str] = Form(None), - current_user: Dict[str, Any] = Depends(get_current_active_user) + workflowId: Optional[str] = Form(None), + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) ): - """ - Upload a file - """ + """Upload a file""" try: - context = await get_context(current_user) + context = await getContext(currentUser) # Read file - file_content = await file.read() + fileContent = await file.read() # Check size limits - max_size = int(APP_CONFIG.get("File_Management_MAX_UPLOAD_SIZE_MB")) * 1024 * 1024 # in bytes - if len(file_content) > max_size: + maxSize = int(APP_CONFIG.get("File_Management_MAX_UPLOAD_SIZE_MB")) * 1024 * 1024 # in bytes + if len(fileContent) > maxSize: raise HTTPException( status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE, detail=f"File too large. Maximum size: {APP_CONFIG.get('File_Management_MAX_UPLOAD_SIZE_MB')}MB" ) # Save file via LucyDOM interface in the database - file_meta = context.interface_data.save_uploaded_file(file_content, file.filename) + fileMeta = context.interfaceData.saveUploadedFile(fileContent, file.filename) - # If workflow_id is provided, update the file information - if workflow_id: - update_data = {"workflow_id": workflow_id} - context.interface_data.update_file(file_meta["id"], update_data) - file_meta["workflow_id"] = workflow_id + # If workflowId is provided, update the file information + if workflowId: + updateData = {"workflowId": workflowId} + context.interfaceData.updateFile(fileMeta["id"], updateData) + fileMeta["workflowId"] = workflowId # Successful response - return file_meta + return fileMeta except FileStorageError as e: logger.error(f"Error during file upload (storage): {str(e)}") @@ -134,30 +119,25 @@ async def upload_file( detail=f"Error during file upload: {str(e)}" ) - -@router.get("/{file_id}") -async def get_file( - file_id: str, - current_user: Dict[str, Any] = Depends(get_current_active_user) +@router.get("/{fileId}") +async def getFile( + fileId: str, + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) ): - """ - Returns a file by its ID for download. - Retrieves both metadata and binary data. - """ + """Returns a file by its ID for download""" try: - context = await get_context(current_user) + context = await getContext(currentUser) # Get file via LucyDOM interface from the database - # Uses the download_file method, which now combines metadata and binary data - file_data = context.interface_data.download_file(file_id) + fileData = context.interfaceData.downloadFile(fileId) # Return file headers = { - "Content-Disposition": f'attachment; filename="{file_data["name"]}"' + "Content-Disposition": f'attachment; filename="{fileData["name"]}"' } return Response( - content=file_data["content"], - media_type=file_data["content_type"], + content=fileData["content"], + media_type=fileData["contentType"], headers=headers ) @@ -186,22 +166,17 @@ async def get_file( detail=f"Error retrieving file: {str(e)}" ) - -@router.delete("/{file_id}", status_code=status.HTTP_204_NO_CONTENT) -async def delete_file( - file_id: str, - current_user: Dict[str, Any] = Depends(get_current_active_user) +@router.delete("/{fileId}", status_code=status.HTTP_204_NO_CONTENT) +async def deleteFile( + fileId: str, + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) ): - """ - Deletes a file by its ID from the database. - Removes both metadata and binary data. - """ + """Deletes a file by its ID from the database""" try: - context = await get_context(current_user) + context = await getContext(currentUser) # Delete file via LucyDOM interface - # The method now handles deleting from both tables (files and file_data) - context.interface_data.delete_file(file_id) + context.interfaceData.deleteFile(fileId) # Return successful deletion without content (204 No Content) return Response(status_code=status.HTTP_204_NO_CONTENT) @@ -232,34 +207,32 @@ async def delete_file( ) @router.get("/stats", response_model=Dict[str, Any]) -async def get_file_stats( - current_user: Dict[str, Any] = Depends(get_current_active_user) +async def getFileStats( + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) ): - """ - Returns statistics about the stored files. - """ + """Returns statistics about the stored files""" try: - context = await get_context(current_user) + context = await getContext(currentUser) # Get all files - metadata only - all_files = context.interface_data.get_all_files() + allFiles = context.interfaceData.getAllFiles() # Calculate statistics - total_files = len(all_files) - total_size = sum(file.get("size", 0) for file in all_files) + totalFiles = len(allFiles) + totalSize = sum(file.get("size", 0) for file in allFiles) # Group by file type - file_types = {} - for file in all_files: - file_type = file.get("mime_type", "unknown").split("/")[0] - if file_type not in file_types: - file_types[file_type] = 0 - file_types[file_type] += 1 + fileTypes = {} + for file in allFiles: + fileType = file.get("mimeType", "unknown").split("/")[0] + if fileType not in fileTypes: + fileTypes[fileType] = 0 + fileTypes[fileType] += 1 return { - "total_files": total_files, - "total_size_bytes": total_size, - "file_types": file_types + "totalFiles": totalFiles, + "totalSizeBytes": totalSize, + "fileTypes": fileTypes } except Exception as e: diff --git a/routes/routeMandates.py b/routes/routeMandates.py new file mode 100644 index 00000000..ab71cc7e --- /dev/null +++ b/routes/routeMandates.py @@ -0,0 +1,199 @@ +from fastapi import APIRouter, HTTPException, Depends, Body, Path +from typing import List, Dict, Any +from fastapi import status +from datetime import datetime +from dataclasses import dataclass + +# Import interfaces +from modules.auth import getCurrentActiveUser, getUserContext +from modules.gatewayInterface import getGatewayInterface +from modules.gatewayModel import Mandate + +# Determine all attributes of the model +def getModelAttributes(modelClass): + return [attr for attr in dir(modelClass) + if not callable(getattr(modelClass, attr)) + and not attr.startswith('_') + and attr not in ('metadata', 'query', 'query_class', 'label', 'field_labels')] + +# Model attributes for Mandate +mandateAttributes = getModelAttributes(Mandate) + +@dataclass +class AppContext: + """Context object for all required connections and user information""" + mandateId: int + userId: int + interfaceData: Any # Gateway Interface + +async def getContext(currentUser: Dict[str, Any]) -> AppContext: + """Creates a central context object with all required connections""" + mandateId, userId = await getUserContext(currentUser) + interfaceData = getGatewayInterface(mandateId, userId) + + return AppContext( + mandateId=mandateId, + userId=userId, + interfaceData=interfaceData + ) + +# Create router for mandate endpoints +router = APIRouter( + prefix="/api/mandates", + tags=["Mandates"], + responses={404: {"description": "Not found"}} +) + +@router.get("", response_model=List[Dict[str, Any]]) +async def getMandates(currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)): + """Get all available mandates (only for SysAdmin users)""" + context = await getContext(currentUser) + + # Permission check + if currentUser.get("privilege") != "sysadmin": + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="Only system administrators can access all mandates" + ) + + # Get mandates + return context.interfaceData.getAllMandates() + +@router.post("", response_model=Dict[str, Any]) +async def createMandate( + mandate: Dict[str, Any] = Body(...), + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """Create a new mandate (only for SysAdmin users)""" + context = await getContext(currentUser) + + # Permission check + if currentUser.get("privilege") != "sysadmin": + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="Only system administrators can create mandates" + ) + + # Set attributes from the request dynamically + mandateData = {} + for attr in mandateAttributes: + if attr in mandate: + mandateData[attr] = mandate[attr] + + # Default values for missing fields + mandateData.setdefault("name", "New Mandate") + mandateData.setdefault("language", "de") + + # Create mandate + newMandate = context.interfaceData.createMandate(**mandateData) + + return newMandate + +@router.get("/{mandateId}", response_model=Dict[str, Any]) +async def getMandate( + mandateId: int, + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """Get a specific mandate""" + context = await getContext(currentUser) + + # Permission check + # Admin can only see their own mandate, SysAdmin can see all + isAdmin = currentUser.get("privilege") == "admin" + isSysadmin = currentUser.get("privilege") == "sysadmin" + isOwnMandate = context.mandateId == mandateId + + if (isAdmin and not isOwnMandate) and not isSysadmin: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="No permission to access this mandate" + ) + + # Get mandate + mandate = context.interfaceData.getMandate(mandateId) + if not mandate: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"Mandate with ID {mandateId} not found" + ) + + return mandate + +@router.put("/{mandateId}", response_model=Dict[str, Any]) +async def updateMandate( + mandateId: int = Path(..., description="ID of the mandate to update"), + mandateData: Dict[str, Any] = Body(..., description="Updated mandate data"), + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """Update an existing mandate""" + context = await getContext(currentUser) + + # Mandate exists? + mandate = context.interfaceData.getMandate(mandateId) + if not mandate: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"Mandate with ID {mandateId} not found" + ) + + # Permission check + isAdmin = currentUser.get("privilege") == "admin" + isSysadmin = currentUser.get("privilege") == "sysadmin" + isOwnMandate = context.mandateId == mandateId + + if (isAdmin and not isOwnMandate) and not isSysadmin: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="No permission to update this mandate" + ) + + # Dynamically filter attributes from the request into updateData + updateData = {} + for attr in mandateAttributes: + if attr in mandateData: + updateData[attr] = mandateData[attr] + + # Update mandate + updatedMandate = context.interfaceData.updateMandate( + mandateId=mandateId, + mandateData=updateData + ) + + return updatedMandate + +@router.delete("/{mandateId}", status_code=status.HTTP_204_NO_CONTENT) +async def deleteMandate( + mandateId: int = Path(..., description="ID of the mandate to delete"), + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """Delete a mandate, including all associated users and referenced objects""" + context = await getContext(currentUser) + + # Mandate exists? + mandate = context.interfaceData.getMandate(mandateId) + if not mandate: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"Mandate with ID {mandateId} not found" + ) + + # Permission check + isAdmin = currentUser.get("privilege") == "admin" + isSysadmin = currentUser.get("privilege") == "sysadmin" + isOwnMandate = context.mandateId == mandateId + + if (isAdmin and not isOwnMandate) and not isSysadmin: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="No permission to delete this mandate" + ) + + # Delete mandate + success = context.interfaceData.deleteMandate(mandateId) + if not success: + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error deleting mandate with ID {mandateId}" + ) + + return None \ No newline at end of file diff --git a/routes/routePrompts.py b/routes/routePrompts.py new file mode 100644 index 00000000..0e9216e7 --- /dev/null +++ b/routes/routePrompts.py @@ -0,0 +1,160 @@ +from fastapi import APIRouter, HTTPException, Depends, Body, Query, Path +from typing import List, Dict, Any, Optional +from fastapi import status +from datetime import datetime +from dataclasses import dataclass + +# Import auth module +from modules.auth import getCurrentActiveUser, getUserContext + +# Import interfaces +from modules.lucydomInterface import getLucydomInterface +from modules.lucydomModel import Prompt + +# Get all attributes of the model +def getModelAttributes(modelClass): + return [attr for attr in dir(modelClass) + if not callable(getattr(modelClass, attr)) + and not attr.startswith('_') + and attr not in ('metadata', 'query', 'query_class', 'label', 'field_labels')] + +# Model attributes for Prompt +promptAttributes = getModelAttributes(Prompt) + +@dataclass +class AppContext: + """Context object for all required connections and user information""" + mandateId: int + userId: int + interfaceData: Any # LucyDOM Interface + +async def getContext(currentUser: Dict[str, Any]) -> AppContext: + """Creates a central context object with all required connections""" + mandateId, userId = await getUserContext(currentUser) + interfaceData = getLucydomInterface(mandateId, userId) + + return AppContext( + mandateId=mandateId, + userId=userId, + interfaceData=interfaceData + ) + +# Create router for prompt endpoints +router = APIRouter( + prefix="/api/prompts", + tags=["Prompts"], + responses={404: {"description": "Not found"}} +) + +@router.get("", response_model=List[Dict[str, Any]]) +async def getPrompts( + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """Get all prompts""" + context = await getContext(currentUser) + + # Retrieve prompts + return context.interfaceData.getAllPrompts() + +@router.post("", response_model=Dict[str, Any]) +async def createPrompt( + prompt: Dict[str, Any] = Body(...), + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """Create a new prompt""" + context = await getContext(currentUser) + + # Required fields with default values + content = prompt.get("content", "") + name = prompt.get("name", "New Prompt") + + # Create prompt + newPrompt = context.interfaceData.createPrompt( + content=content, + name=name + ) + + # Set current time for createdAt if it exists in the model + if "createdAt" in promptAttributes and hasattr(newPrompt, "createdAt"): + newPrompt["createdAt"] = datetime.now().isoformat() + + return newPrompt + +@router.get("/{promptId}", response_model=Dict[str, Any]) +async def getPrompt( + promptId: int, + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """Get a specific prompt""" + context = await getContext(currentUser) + + # Get prompt + prompt = context.interfaceData.getPrompt(promptId) + if not prompt: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"Prompt with ID {promptId} not found" + ) + + return prompt + +@router.put("/{promptId}", response_model=Dict[str, Any]) +async def updatePrompt( + promptId: int, + promptData: Dict[str, Any] = Body(...), + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """Update an existing prompt""" + context = await getContext(currentUser) + + # Check if the prompt exists + existingPrompt = context.interfaceData.getPrompt(promptId) + if not existingPrompt: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"Prompt with ID {promptId} not found" + ) + + # Standard fields for update + content = promptData.get("content") + name = promptData.get("name") + + # Update prompt + updatedPrompt = context.interfaceData.updatePrompt( + promptId=promptId, + content=content, + name=name + ) + + if not updatedPrompt: + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail="Error updating the prompt" + ) + + return updatedPrompt + +@router.delete("/{promptId}", response_model=Dict[str, Any]) +async def deletePrompt( + promptId: int, + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """Delete a prompt""" + context = await getContext(currentUser) + + # Check if the prompt exists + existingPrompt = context.interfaceData.getPrompt(promptId) + if not existingPrompt: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"Prompt with ID {promptId} not found" + ) + + success = context.interfaceData.deletePrompt(promptId) + if not success: + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail="Error deleting the prompt" + ) + + return {"message": f"Prompt with ID {promptId} successfully deleted"} \ No newline at end of file diff --git a/routes/routeUsers.py b/routes/routeUsers.py new file mode 100644 index 00000000..ed574274 --- /dev/null +++ b/routes/routeUsers.py @@ -0,0 +1,249 @@ +from fastapi import APIRouter, HTTPException, Depends, Body, Path +from typing import List, Dict, Any, Optional +from fastapi import status +from datetime import datetime +from dataclasses import dataclass + +# Import auth module +from modules.auth import getCurrentActiveUser, getUserContext + +# Import interfaces +from modules.gatewayInterface import getGatewayInterface +from modules.gatewayModel import User + +# Determine all attributes of the model +def getModelAttributes(modelClass): + return [attr for attr in dir(modelClass) + if not callable(getattr(modelClass, attr)) + and not attr.startswith('_') + and attr not in ('metadata', 'query', 'query_class', 'label', 'field_labels')] + +# Model attributes for User +userAttributes = getModelAttributes(User) + +@dataclass +class AppContext: + """Context object for all required connections and user information""" + mandateId: int + userId: int + interfaceData: Any # Gateway Interface + +async def getContext(currentUser: Dict[str, Any]) -> AppContext: + """Creates a central context object with all required connections""" + mandateId, userId = await getUserContext(currentUser) + interfaceData = getGatewayInterface(mandateId, userId) + + return AppContext( + mandateId=mandateId, + userId=userId, + interfaceData=interfaceData + ) + +# Create router for user endpoints +router = APIRouter( + prefix="/api/users", + tags=["Users"], + responses={404: {"description": "Not found"}} +) + +@router.get("", response_model=List[Dict[str, Any]]) +async def getUsers(currentUser: Dict[str, Any] = Depends(getCurrentActiveUser)): + """Get all available users (only for Admin/SysAdmin users)""" + context = await getContext(currentUser) + + # Permission check + if currentUser.get("privilege") not in ["admin", "sysadmin"]: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="No permission to access the user list" + ) + + # Admin sees only users of own mandate, SysAdmin sees all + if currentUser.get("privilege") == "admin": + return context.interfaceData.getUsersByMandate(context.mandateId) + else: # sysadmin + return context.interfaceData.getAllUsers() + +@router.post("/register", response_model=Dict[str, Any]) +async def registerUser(userData: dict = Body(...)): + """Register a new user""" + # Don't use user context for registration + gateway = getGatewayInterface() + + if "username" not in userData or "password" not in userData: + raise HTTPException(status_code=400, detail="Username and password required") + + try: + # Prepare mandate data + mandateData = { + "name": f"Mandate of {userData['username']}", + "language": userData.get("language", "de") + } + + newMandate = gateway.createMandate(**mandateData) + + # Filter user attributes from the request + userCreateData = {} + for attr in userAttributes: + if attr in userData and attr != "id": # ID is auto-assigned + userCreateData[attr] = userData[attr] + + # Required fields + userCreateData["username"] = userData["username"] + userCreateData["password"] = userData["password"] + userCreateData["mandateId"] = newMandate["id"] + + # Default values for optional fields + userCreateData.setdefault("disabled", False) + userCreateData.setdefault("privilege", "user") + userCreateData.setdefault("language", "de") + + newUser = gateway.createUser(**userCreateData) + return newUser + except ValueError as e: + raise HTTPException(status_code=400, detail=str(e)) + +@router.get("/{userId}", response_model=Dict[str, Any]) +async def getUser( + userId: int, + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """Get a specific user""" + context = await getContext(currentUser) + + # Initialize gateway interface with user context + userToGet = context.interfaceData.getUser(userId) + if not userToGet: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"User with ID {userId} not found" + ) + + # Permission check + # User can only view themselves, Admin only users of their own mandate, SysAdmin all + if userId == context.userId: + # User can view themselves + pass + elif currentUser.get("privilege") == "admin" and userToGet.get("mandateId") == context.mandateId: + # Admin can view users of their own mandate + pass + elif currentUser.get("privilege") == "sysadmin": + # SysAdmin can view all users + pass + else: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="No permission to view this user" + ) + + return userToGet + +@router.put("/{userId}", response_model=Dict[str, Any]) +async def updateUser( + userId: int = Path(..., description="ID of the user to update"), + userData: Dict[str, Any] = Body(..., description="Updated user data"), + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """Update an existing user""" + context = await getContext(currentUser) + + # User exists? + userToUpdate = context.interfaceData.getUser(userId) + if not userToUpdate: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"User with ID {userId} not found" + ) + + # Permission check + isSelfUpdate = userId == context.userId + isAdmin = currentUser.get("privilege") == "admin" + isSysadmin = currentUser.get("privilege") == "sysadmin" + sameMandate = userToUpdate.get("mandateId") == context.mandateId + + # Filter allowed fields based on permission level + allowedFields = {"username", "email", "fullName", "language"} + sensitiveFields = {"mandateId", "disabled", "privilege"} + + # Check if sensitive fields should be changed + sensitiveUpdate = any(field in userData for field in sensitiveFields) + + if isSelfUpdate and sensitiveUpdate: + # Normal users cannot change their sensitive data + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="No permission to change sensitive user data" + ) + elif isAdmin and sensitiveUpdate and not sameMandate: + # Admins can only change sensitive data for users of their own mandate + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="No permission to change sensitive data for users of other mandates" + ) + elif not (isSelfUpdate or (isAdmin and sameMandate) or isSysadmin): + # No permission for other cases + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="No permission to update this user" + ) + + # Dynamically filter attributes from the request + updateData = {} + for attr in userAttributes: + if attr in userData and attr != "id": # ID cannot be changed + updateData[attr] = userData[attr] + + # Remove disallowed fields for normal users + if not (isAdmin or isSysadmin): + updateData = {k: v for k, v in updateData.items() if k in allowedFields} + + # Update user data + updatedUser = context.interfaceData.updateUser(userId, updateData) + return updatedUser + +@router.delete("/{userId}", status_code=status.HTTP_204_NO_CONTENT) +async def deleteUser( + userId: int = Path(..., description="ID of the user to delete"), + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """Delete a user""" + context = await getContext(currentUser) + + # User exists? + userToDelete = context.interfaceData.getUser(userId) + if not userToDelete: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"User with ID {userId} not found" + ) + + # Permission check + isSelfDelete = userId == context.userId + isAdmin = currentUser.get("privilege") == "admin" + isSysadmin = currentUser.get("privilege") == "sysadmin" + sameMandate = userToDelete.get("mandateId") == context.mandateId + + if isSelfDelete: + # User can delete themselves + pass + elif isAdmin and sameMandate: + # Admin can delete users of their own mandate + pass + elif isSysadmin: + # SysAdmin can delete all users + pass + else: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="No permission to delete this user" + ) + + # Delete user and all referenced objects + success = context.interfaceData.deleteUser(userId) + if not success: + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error deleting user with ID {userId}" + ) + + return None \ No newline at end of file diff --git a/routes/routeWorkflows.py b/routes/routeWorkflows.py new file mode 100644 index 00000000..1cd4326d --- /dev/null +++ b/routes/routeWorkflows.py @@ -0,0 +1,667 @@ +""" +Workflow routes for the backend API. +Implements the endpoints for workflow management according to the state machine. +""" + +import os +import json +import logging +from typing import List, Dict, Any, Optional +from fastapi import APIRouter, HTTPException, Depends, Body, Path, Query, Response, status +from dataclasses import dataclass +from datetime import datetime + +# Import interfaces +from modules.lucydomInterface import getLucydomInterface +from modules.auth import getCurrentActiveUser, getUserContext +from modules.workflowManager import getWorkflowManager + +# Import models +from modules.lucydomModel import UserInputRequest + +# Configure logger +logger = logging.getLogger(__name__) + +# Create router for workflow endpoints +router = APIRouter( + prefix="/api/workflows", + tags=["Workflow"], + responses={404: {"description": "Not found"}} +) + +@dataclass +class AppContext: + """Context object for all required connections and user information""" + mandateId: int + userId: int + interfaceData: Any # LucyDOM Interface + interfaceChat: Any # Workflow Manager + +async def getContext(currentUser: Dict[str, Any]) -> AppContext: + """ + Creates a central context object with all required interfaces + + Args: + currentUser: Current user from authentication + + Returns: + AppContext object with all required connections + """ + mandateId, userId = await getUserContext(currentUser) + interfaceData = getLucydomInterface(mandateId, userId) + interfaceChat = getWorkflowManager(mandateId, userId) + + return AppContext( + mandateId=mandateId, + userId=userId, + interfaceData=interfaceData, + interfaceChat=interfaceChat + ) + +# State 1: Workflow Initialization endpoint +@router.post("/start", response_model=Dict[str, Any]) +async def startWorkflow( + workflowId: Optional[str] = Query(None, description="Optional ID of the workflow to continue"), + userInput: UserInputRequest = Body(...), + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """ + Starts a new workflow or continues an existing one. + Corresponds to State 1 in the state machine documentation. + + Args: + workflowId: Optional ID of an existing workflow to continue + userInput: User input with prompt and optional file list + currentUser: Authenticated user + + Returns: + Dictionary with workflow ID and status + """ + context = await getContext(currentUser) + + try: + # Convert the user input to a dictionary + userInputDict = { + "prompt": userInput.prompt, + "listFileId": userInput.listFileId + } + + # Start or continue workflow using the workflow manager + workflow = await context.interfaceChat.workflowStart(userInputDict, workflowId) + logger.info("User Input received. Answer:",workflow) + + return { + "id": workflow.get("id"), + "status": workflow.get("status", "running"), + "message": "Workflow initialized and processing started" + } + except Exception as e: + logger.error(f"Error starting workflow: {str(e)}", exc_info=True) + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error starting workflow: {str(e)}" + ) + +# State 8: Workflow Stopped endpoint +@router.post("/{workflowId}/stop", response_model=Dict[str, Any]) +async def stopWorkflow( + workflowId: str = Path(..., description="ID of the workflow to stop"), + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """ + Stops a running workflow. + Corresponds to State 8 in the state machine documentation. + + Args: + workflowId: ID of the workflow to stop + currentUser: Authenticated user + + Returns: + Dictionary with status information + """ + context = await getContext(currentUser) + + try: + # Verify workflow exists and belongs to user + workflow = context.interfaceData.getWorkflow(workflowId) + if not workflow: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"Workflow with ID {workflowId} not found" + ) + + if workflow.get("userId") != context.userId: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="You don't have permission to stop this workflow" + ) + + # Stop the workflow + stoppedWorkflow = await context.interfaceChat.workflowStop(workflowId) + + return { + "id": workflowId, + "status": stoppedWorkflow.get("status", "stopped"), + "message": "Workflow has been stopped" + } + except HTTPException: + # Re-raise HTTP exceptions + raise + except Exception as e: + logger.error(f"Error stopping workflow: {str(e)}", exc_info=True) + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error stopping workflow: {str(e)}" + ) + +# State 11: Workflow Reset/Deletion endpoint +@router.delete("/{workflowId}", response_model=Dict[str, Any]) +async def deleteWorkflow( + workflowId: str = Path(..., description="ID of the workflow to delete"), + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """ + Deletes a workflow and its associated data. + Corresponds to State 11 in the state machine documentation. + + Args: + workflowId: ID of the workflow to delete + currentUser: Authenticated user + + Returns: + Dictionary with status information + """ + context = await getContext(currentUser) + + try: + # Verify workflow exists + workflow = context.interfaceData.getWorkflow(workflowId) + if not workflow: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"Workflow with ID {workflowId} not found" + ) + + # Check if user has permission to delete + if workflow.get("userId") != context.userId: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="You don't have permission to delete this workflow" + ) + + # Delete workflow + success = context.interfaceData.deleteWorkflow(workflowId) + + if not success: + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail="Failed to delete workflow" + ) + + return { + "id": workflowId, + "message": "Workflow and associated data deleted successfully" + } + except HTTPException: + # Re-raise HTTP exceptions + raise + except Exception as e: + logger.error(f"Error deleting workflow: {str(e)}", exc_info=True) + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error deleting workflow: {str(e)}" + ) + +# API Endpoint for getting all workflows +@router.get("", response_model=List[Dict[str, Any]]) +async def listWorkflows( + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """ + List all workflows for the current user. + + Args: + currentUser: Authenticated user + + Returns: + List of workflow objects + """ + context = await getContext(currentUser) + + try: + # Retrieve workflows for the user + workflows = context.interfaceData.getWorkflowsByUser(context.userId) + return workflows + except Exception as e: + logger.error(f"Error listing workflows: {str(e)}", exc_info=True) + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error listing workflows: {str(e)}" + ) + +# API Endpoint for workflow status +@router.get("/{workflowId}/status", response_model=Dict[str, Any]) +async def getWorkflowStatus( + workflowId: str = Path(..., description="ID of the workflow"), + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """ + Get the current status of a workflow. + + Args: + workflowId: ID of the workflow + currentUser: Authenticated user + + Returns: + Dictionary with workflow status information + """ + context = await getContext(currentUser) + + try: + # Retrieve workflow + workflow = context.interfaceData.getWorkflow(workflowId) + if not workflow: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"Workflow with ID {workflowId} not found" + ) + + # Create status response + statusInfo = { + "id": workflow.get("id"), + "name": workflow.get("name"), + "status": workflow.get("status"), + "startedAt": workflow.get("startedAt"), + "lastActivity": workflow.get("lastActivity"), + "currentRound": workflow.get("currentRound", 1), + "dataStats": workflow.get("dataStats", {}) + } + + return statusInfo + except HTTPException: + # Re-raise HTTP exceptions + raise + except Exception as e: + logger.error(f"Error getting workflow status: {str(e)}", exc_info=True) + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error getting workflow status: {str(e)}" + ) + +# API Endpoint for workflow logs with selective data transfer +@router.get("/{workflowId}/logs", response_model=List[Dict[str, Any]]) +async def getWorkflowLogs( + workflowId: str = Path(..., description="ID of the workflow"), + logId: Optional[str] = Query(None, description="Optional log ID to get only newer logs"), + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """ + Get logs for a workflow with support for selective data transfer. + If logId is provided, returns only logs with IDs equal to or newer than the specified ID. + + Args: + workflowId: ID of the workflow + logId: Optional ID to get only newer logs + currentUser: Authenticated user + + Returns: + List of log entries + """ + context = await getContext(currentUser) + + try: + # Verify workflow exists + workflow = context.interfaceData.getWorkflow(workflowId) + if not workflow: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"Workflow with ID {workflowId} not found" + ) + + # Get all logs + allLogs = context.interfaceData.getWorkflowLogs(workflowId) + + # Apply selective data transfer if logId is provided + if logId: + # Find the index of the specified log + logIndex = next((i for i, log in enumerate(allLogs) if log.get("id") == logId), None) + + if logIndex is not None: + # Return logs from this index onwards + return allLogs[logIndex:] + + return allLogs + except HTTPException: + # Re-raise HTTP exceptions + raise + except Exception as e: + logger.error(f"Error getting workflow logs: {str(e)}", exc_info=True) + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error getting workflow logs: {str(e)}" + ) + +# API Endpoint for workflow messages with selective data transfer +@router.get("/{workflowId}/messages", response_model=List[Dict[str, Any]]) +async def getWorkflowMessages( + workflowId: str = Path(..., description="ID of the workflow"), + messageId: Optional[str] = Query(None, description="Optional message ID to get only newer messages"), + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """ + Get messages for a workflow with support for selective data transfer. + If messageId is provided, returns only messages with IDs equal to or newer than the specified ID. + + Args: + workflowId: ID of the workflow + messageId: Optional ID to get only newer messages + currentUser: Authenticated user + + Returns: + List of message objects + """ + context = await getContext(currentUser) + + try: + # Verify workflow exists + workflow = context.interfaceData.getWorkflow(workflowId) + if not workflow: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"Workflow with ID {workflowId} not found" + ) + + # Get all messages + allMessages = context.interfaceData.getWorkflowMessages(workflowId) + + # Apply selective data transfer if messageId is provided + if messageId: + # Find the index of the specified message based on messageIds array + messageIds = workflow.get("messageIds", []) + if messageId in messageIds: + messageIndex = messageIds.index(messageId) + # Return messages from this index onwards based on the messageIds order + filteredMessages = [] + for msgId in messageIds[messageIndex:]: + message = next((msg for msg in allMessages if msg.get("id") == msgId), None) + if message: + filteredMessages.append(message) + return filteredMessages + + # Sort messages by sequenceNo + allMessages.sort(key=lambda x: x.get("sequenceNo", 0)) + return allMessages + except HTTPException: + # Re-raise HTTP exceptions + raise + except Exception as e: + logger.error(f"Error getting workflow messages: {str(e)}", exc_info=True) + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error getting workflow messages: {str(e)}" + ) + +# Document Management Endpoints + +@router.delete("/{workflowId}/messages/{messageId}", response_model=Dict[str, Any]) +async def deleteWorkflowMessage( + workflowId: str = Path(..., description="ID of the workflow"), + messageId: str = Path(..., description="ID of the message to delete"), + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """ + Delete a message from a workflow. + + Args: + workflowId: ID of the workflow + messageId: ID of the message to delete + currentUser: Authenticated user + + Returns: + Dictionary with status information + """ + context = await getContext(currentUser) + + try: + # Verify workflow exists and belongs to user + workflow = context.interfaceData.getWorkflow(workflowId) + if not workflow: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"Workflow with ID {workflowId} not found" + ) + + if workflow.get("userId") != context.userId: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="You don't have permission to modify this workflow" + ) + + # Delete the message + success = context.interfaceData.deleteWorkflowMessage(workflowId, messageId) + + if not success: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"Message with ID {messageId} not found in workflow {workflowId}" + ) + + # Update workflow's messageIds + messageIds = workflow.get("messageIds", []) + if messageId in messageIds: + messageIds.remove(messageId) + context.interfaceData.updateWorkflow(workflowId, {"messageIds": messageIds}) + + return { + "workflowId": workflowId, + "messageId": messageId, + "message": "Message deleted successfully" + } + except HTTPException: + # Re-raise HTTP exceptions + raise + except Exception as e: + logger.error(f"Error deleting message: {str(e)}", exc_info=True) + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error deleting message: {str(e)}" + ) + +@router.delete("/{workflowId}/messages/{messageId}/files/{fileId}", response_model=Dict[str, Any]) +async def deleteFileFromMessage( + workflowId: str = Path(..., description="ID of the workflow"), + messageId: str = Path(..., description="ID of the message"), + fileId: int = Path(..., description="ID of the file to delete"), + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """ + Delete a file reference from a message in a workflow. + The file itself is not deleted from the database, only the reference in the message. + + Args: + workflowId: ID of the workflow + messageId: ID of the message + fileId: ID of the file to delete + currentUser: Authenticated user + + Returns: + Dictionary with status information + """ + context = await getContext(currentUser) + + try: + # Verify workflow exists and belongs to user + workflow = context.interfaceData.getWorkflow(workflowId) + if not workflow: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"Workflow with ID {workflowId} not found" + ) + + if workflow.get("userId") != context.userId: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="You don't have permission to modify this workflow" + ) + + # Delete file reference from message + success = context.interfaceData.deleteFileFromMessage(workflowId, messageId, fileId) + + if not success: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"File with ID {fileId} not found in message {messageId}" + ) + + return { + "workflowId": workflowId, + "messageId": messageId, + "fileId": fileId, + "message": "File reference deleted successfully" + } + except HTTPException: + # Re-raise HTTP exceptions + raise + except Exception as e: + logger.error(f"Error deleting file reference: {str(e)}", exc_info=True) + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error deleting file reference: {str(e)}" + ) + +# File preview and download routes + +@router.get("/files/{fileId}/preview", response_model=Dict[str, Any]) +async def previewFile( + fileId: int = Path(..., description="ID of the file to preview"), + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """ + Get file metadata and a preview of the file content. + + Args: + fileId: ID of the file + currentUser: Authenticated user + + Returns: + Dictionary with file metadata and preview content + """ + context = await getContext(currentUser) + + try: + # Get file metadata + file = context.interfaceData.getFile(fileId) + if not file: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"File with ID {fileId} not found" + ) + + # Check if file belongs to user or their mandate + if file.get("mandateId") != context.mandateId and file.get("userId") != context.userId: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="You don't have permission to access this file" + ) + + # Get file data (limited for preview) + fileData = context.interfaceData.getFileData(fileId) + if fileData is None: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"File data not found for file ID {fileId}" + ) + + # For text-based files, return a preview of the content + mimeType = file.get("mimeType", "application/octet-stream") + isText = mimeType.startswith("text/") or mimeType in [ + "application/json", + "application/xml", + "application/javascript" + ] + + previewData = None + if isText: + # Convert to string and limit to 1000 chars for preview + if isinstance(fileData, bytes): + try: + filePreview = fileData.decode('utf-8')[:1000] + previewData = filePreview + except UnicodeDecodeError: + # Try other encodings + for encoding in ['latin-1', 'cp1252', 'iso-8859-1']: + try: + filePreview = fileData.decode(encoding)[:1000] + previewData = filePreview + break + except UnicodeDecodeError: + continue + + # For images, return base64 encoded data + if mimeType.startswith("image/"): + import base64 + previewData = base64.b64encode(fileData).decode('utf-8') + + # Return file metadata with limited preview + return { + "id": fileId, + "name": file.get("name"), + "mimeType": mimeType, + "size": file.get("size"), + "creationDate": file.get("creationDate"), + "isPreviewable": isText or mimeType.startswith("image/"), + "preview": previewData + } + except HTTPException: + # Re-raise HTTP exceptions + raise + except Exception as e: + logger.error(f"Error previewing file: {str(e)}", exc_info=True) + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error previewing file: {str(e)}" + ) + +@router.get("/files/{fileId}/download") +async def downloadFile( + fileId: int = Path(..., description="ID of the file to download"), + currentUser: Dict[str, Any] = Depends(getCurrentActiveUser) +): + """ + Download a file. + + Args: + fileId: ID of the file + currentUser: Authenticated user + + Returns: + File data with appropriate headers + """ + context = await getContext(currentUser) + + try: + # Get file data + fileInfo = context.interfaceData.downloadFile(fileId) + if not fileInfo: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"File with ID {fileId} not found" + ) + + # Return file as response + return Response( + content=fileInfo["content"], + media_type=fileInfo["contentType"], + headers={ + "Content-Disposition": f"attachment; filename={fileInfo['name']}" + } + ) + except HTTPException: + # Re-raise HTTP exceptions + raise + except Exception as e: + logger.error(f"Error downloading file: {str(e)}", exc_info=True) + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error downloading file: {str(e)}" + ) \ No newline at end of file diff --git a/routes/users.py b/routes/users.py deleted file mode 100644 index 3f88fb31..00000000 --- a/routes/users.py +++ /dev/null @@ -1,265 +0,0 @@ -from fastapi import APIRouter, HTTPException, Depends, Body, Path -from typing import List, Dict, Any, Optional -from fastapi import status -from datetime import datetime -from dataclasses import dataclass - -# Import auth module -from modules.auth import get_current_active_user, get_user_context - -# Import interfaces -from modules.gateway_interface import get_gateway_interface -from modules.gateway_model import User - -# Determine all attributes of the model (except internal/special attributes) -def get_model_attributes(model_class): - return [attr for attr in dir(model_class) - if not callable(getattr(model_class, attr)) - and not attr.startswith('_') - and attr != 'metadata' - and attr != 'query' - and attr != 'query_class' - and attr != 'label' - and attr != 'field_labels'] - -# Model attributes for User -user_attributes = get_model_attributes(User) - -@dataclass -class AppContext: - """Context object for all required connections and user information""" - mandate_id: int - user_id: int - interface_data: Any # Gateway Interface - -async def get_context(current_user: Dict[str, Any]) -> AppContext: - """ - Creates a central context object with all required interfaces - - Args: - current_user: Current user from authentication - - Returns: - AppContext object with all required connections - """ - mandate_id, user_id = await get_user_context(current_user) - interface_data = get_gateway_interface(mandate_id, user_id) - - return AppContext( - mandate_id=mandate_id, - user_id=user_id, - interface_data=interface_data - ) - -# Create router for user endpoints -router = APIRouter( - prefix="/api/users", - tags=["Users"], - responses={404: {"description": "Not found"}} -) - -@router.get("", response_model=List[Dict[str, Any]]) -async def get_users(current_user: Dict[str, Any] = Depends(get_current_active_user)): - """Get all available users (only for Admin/SysAdmin users)""" - context = await get_context(current_user) - - # Permission check - if current_user.get("privilege") not in ["admin", "sysadmin"]: - raise HTTPException( - status_code=status.HTTP_403_FORBIDDEN, - detail="No permission to access the user list" - ) - - # Admin sees only users of own mandate, SysAdmin sees all - if current_user.get("privilege") == "admin": - return context.interface_data.get_users_by_mandate(context.mandate_id) - else: # sysadmin - return context.interface_data.get_all_users() - -@router.post("/register", response_model=Dict[str, Any]) -async def register_user(user_data: dict = Body(...)): - """Register a new user""" - # Don't use user context for registration - gateway = get_gateway_interface() - - if "username" not in user_data or "password" not in user_data: - raise HTTPException(status_code=400, detail="Username and password required") - - try: - # Dynamically filter attributes - mandate_data = { - "name": f"Mandate of {user_data['username']}", - "language": user_data.get("language", "de") - } - - new_mandate = gateway.create_mandate(**mandate_data) - - # Filter user attributes from the request - user_create_data = {} - for attr in user_attributes: - if attr in user_data and attr not in ["id"]: # ID is auto-assigned - user_create_data[attr] = user_data[attr] - - # Required fields - user_create_data["username"] = user_data["username"] - user_create_data["password"] = user_data["password"] - user_create_data["mandate_id"] = new_mandate["id"] - - # Default values for optional fields - if "disabled" not in user_create_data: - user_create_data["disabled"] = False - if "privilege" not in user_create_data: - user_create_data["privilege"] = "user" - if "language" not in user_create_data: - user_create_data["language"] = "de" - - new_user = gateway.create_user(**user_create_data) - return new_user - except ValueError as e: - raise HTTPException(status_code=400, detail=str(e)) - -@router.get("/{user_id}", response_model=Dict[str, Any]) -async def get_user( - user_id: int, - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """Get a specific user""" - context = await get_context(current_user) - - # Initialize gateway interface with user context - user_to_get = context.interface_data.get_user(user_id) - if not user_to_get: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail=f"User with ID {user_id} not found" - ) - - # Permission check - # User can only view themselves, Admin only users of their own mandate, SysAdmin all - if user_id == context.user_id: - # User can view themselves - pass - elif current_user.get("privilege") == "admin" and user_to_get.get("mandate_id") == context.mandate_id: - # Admin can view users of their own mandate - pass - elif current_user.get("privilege") == "sysadmin": - # SysAdmin can view all users - pass - else: - raise HTTPException( - status_code=status.HTTP_403_FORBIDDEN, - detail="No permission to view this user" - ) - - return user_to_get - -@router.put("/{user_id}", response_model=Dict[str, Any]) -async def update_user( - user_id: int = Path(..., description="ID of the user to update"), - user_data: Dict[str, Any] = Body(..., description="Updated user data"), - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """Update an existing user""" - context = await get_context(current_user) - - # User exists? - user_to_update = context.interface_data.get_user(user_id) - if not user_to_update: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail=f"User with ID {user_id} not found" - ) - - # Permission check - is_self_update = user_id == context.user_id - is_admin = current_user.get("privilege") == "admin" - is_sysadmin = current_user.get("privilege") == "sysadmin" - same_mandate = user_to_update.get("mandate_id") == context.mandate_id - - # Filter allowed fields based on permission level - allowed_fields = {"username", "email", "full_name", "language"} - sensitive_fields = {"mandate_id", "disabled", "privilege"} - - # Check if sensitive fields should be changed - sensitive_update = any(field in user_data for field in sensitive_fields) - - if is_self_update and sensitive_update: - # Normal users cannot change their sensitive data - raise HTTPException( - status_code=status.HTTP_403_FORBIDDEN, - detail="No permission to change sensitive user data" - ) - elif is_admin and sensitive_update and not same_mandate: - # Admins can only change sensitive data for users of their own mandate - raise HTTPException( - status_code=status.HTTP_403_FORBIDDEN, - detail="No permission to change sensitive data for users of other mandates" - ) - elif not (is_self_update or (is_admin and same_mandate) or is_sysadmin): - # No permission for other cases - raise HTTPException( - status_code=status.HTTP_403_FORBIDDEN, - detail="No permission to update this user" - ) - - # Dynamically filter attributes from the request - update_data = {} - for attr in user_attributes: - if attr in user_data and attr not in ["id"]: # ID cannot be changed - update_data[attr] = user_data[attr] - - # Remove disallowed fields for normal users - if not (is_admin or is_sysadmin): - update_data = {k: v for k, v in update_data.items() if k in allowed_fields} - - # Update user data - updated_user = context.interface_data.update_user(user_id, update_data) - return updated_user - -@router.delete("/{user_id}", status_code=status.HTTP_204_NO_CONTENT) -async def delete_user( - user_id: int = Path(..., description="ID of the user to delete"), - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """Delete a user""" - context = await get_context(current_user) - - # User exists? - user_to_delete = context.interface_data.get_user(user_id) - if not user_to_delete: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail=f"User with ID {user_id} not found" - ) - - # Permission check - is_self_delete = user_id == context.user_id - is_admin = current_user.get("privilege") == "admin" - is_sysadmin = current_user.get("privilege") == "sysadmin" - same_mandate = user_to_delete.get("mandate_id") == context.mandate_id - - if is_self_delete: - # User can delete themselves - pass - elif is_admin and same_mandate: - # Admin can delete users of their own mandate - pass - elif is_sysadmin: - # SysAdmin can delete all users - pass - else: - raise HTTPException( - status_code=status.HTTP_403_FORBIDDEN, - detail="No permission to delete this user" - ) - - # Delete user and all referenced objects - success = context.interface_data.delete_user(user_id) - if not success: - raise HTTPException( - status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, - detail=f"Error deleting user with ID {user_id}" - ) - - # Return no content on successful deletion - return None \ No newline at end of file diff --git a/routes/workflows.py b/routes/workflows.py deleted file mode 100644 index ef66e039..00000000 --- a/routes/workflows.py +++ /dev/null @@ -1,371 +0,0 @@ -import os -import json -from fastapi import APIRouter, HTTPException, Depends, Body, Path, Query -from typing import List, Dict, Any, Optional -from fastapi import status -import asyncio -import uuid -from datetime import datetime -import logging -from dataclasses import dataclass - -# Import interfaces -from modules.lucydom_interface import get_lucydom_interface -from modules.auth import get_current_active_user, get_user_context -from modules.chat import get_chat_manager - -# Import models -import modules.lucydom_model as lucydom_model - -# Configure logger -logger = logging.getLogger(__name__) - -# Create router for workflow endpoints -router = APIRouter( - prefix="/api/workflows", - tags=["Workflow"], - responses={404: {"description": "Not found"}} -) - -@dataclass -class AppContext: - """Context object for all required connections and user information""" - mandate_id: int - user_id: int - interface_data: Any # LucyDOM Interface - interface_chat: Any # Chat Manager - -async def get_context(current_user: Dict[str, Any]) -> AppContext: - """ - Creates a central context object with all required interfaces - - Args: - current_user: Current user from authentication - - Returns: - AppContext object with all required connections - """ - mandate_id, user_id = await get_user_context(current_user) - interface_data = get_lucydom_interface(mandate_id, user_id) - interface_chat = get_chat_manager(mandate_id, user_id) - - return AppContext( - mandate_id=mandate_id, - user_id=user_id, - interface_data=interface_data, - interface_chat=interface_chat - ) - - -@router.get("", response_model=List[Dict[str, Any]]) -async def list_workflows(current_user: Dict[str, Any] = Depends(get_current_active_user)): - """Lists all workflows of the user""" - context = await get_context(current_user) - - # Retrieve workflows for the user - workflows = context.interface_data.get_workflows_by_user(context.user_id) - - return workflows - -@router.post("/{workflow_id}/user-input", response_model=Dict[str, Any]) -async def submit_user_input( - workflow_id: str = Path(..., description="ID of the workflow (optional)"), - user_input: lucydom_model.UserInputRequest = Body(...), - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """ - Allows the user to send inputs for a running workflow - or start a new workflow. - """ - logger.debug("CHECK 01...") - context = await get_context(current_user) - logger.debug("CHECK 02...") - - # Improved logging - logger.info(f"User input for workflow '{workflow_id}' received") - - if workflow_id == "new": workflow_id = None #agreed placeholder with frontend - logger.debug("CHECK trying...") - try: - # Continue or start workflow with the chat manager - user_input_dict = { - "prompt": user_input.prompt, - "list_file_id": user_input.list_file_id - } - logger.debug("CHECK start Workflow ...") - workflow = await context.interface_chat.chat_run(user_input_dict, workflow_id) - logger.debug("CHECK end Workflow ...") - - if not workflow: - raise HTTPException( - status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, - detail="Error processing user input" - ) - - return { - "workflow_id": workflow.get("id"), - "status": "running", - "message": "User input received and being processed" - } - except HTTPException: - # Forward HTTP exceptions - raise - except Exception as e: - logger.error(f"Error processing user input: {str(e)}", exc_info=True) - raise HTTPException( - status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, - detail=f"Error processing user input: {str(e)}" - ) - -@router.post("/{workflow_id}/stop", response_model=Dict[str, Any]) -async def stop_workflow( - workflow_id: str = Path(..., description="ID of the workflow to stop"), - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """Stops a running workflow""" - context = await get_context(current_user) - - # Load workflow - workflow = context.interface_data.get_workflow(workflow_id) - if not workflow: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail=f"Workflow with ID {workflow_id} not found" - ) - - # Set status to "stopped" - workflow["status"] = "completed" - workflow["last_activity"] = datetime.now().isoformat() - - # Update workflow - context.interface_data.update_workflow(workflow_id, workflow) - - return { - "workflow_id": workflow_id, - "status": "completed", - "message": "Workflow has been stopped" - } - -@router.delete("/{workflow_id}", response_model=Dict[str, Any]) -async def delete_workflow( - workflow_id: str, - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """Deletes a workflow""" - context = await get_context(current_user) - - # Delete workflow - success = context.interface_data.delete_workflow(workflow_id) - if not success: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail=f"Workflow with ID {workflow_id} not found" - ) - - return { - "workflow_id": workflow_id, - "message": "Workflow has been deleted" - } - -@router.get("/{workflow_id}/data-statistics", response_model=Dict[str, Any]) -async def get_workflow_data_statistics( - workflow_id: str, - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """ - Returns statistics about the transferred data volumes for a workflow. - """ - context = await get_context(current_user) - - # Load workflow - workflow = context.interface_data.get_workflow(workflow_id) - if not workflow: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail=f"Workflow with ID {workflow_id} not found" - ) - - # Return data statistics - data_stats = workflow.get("data_stats", {}) - if not data_stats: - data_stats = { - "total_processing_time": 0.0, - "total_token_count": 0, - "total_bytes_sent": 0, - "total_bytes_received": 0 - } - - return { - "workflow_id": workflow_id, - "data_stats": data_stats - } - -@router.get("/{workflow_id}/status", response_model=Dict[str, Any]) -async def get_workflow_status( - workflow_id: str, - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """Get the status of a workflow""" - context = await get_context(current_user) - - # Load workflow - workflow = context.interface_data.get_workflow(workflow_id) - if not workflow: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail=f"Workflow with ID {workflow_id} not found" - ) - - # Create status from the loaded workflow - status_info = { - "id": workflow.get("id"), - "name": workflow.get("name"), - "status": workflow.get("status"), - "started_at": workflow.get("started_at"), - "last_activity": workflow.get("last_activity"), - "data_stats": workflow.get("data_stats", {}) - } - - return status_info - -@router.get("/{workflow_id}/logs", response_model=List[Dict[str, Any]]) -async def get_workflow_logs( - workflow_id: str, - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """Get logs of a workflow""" - context = await get_context(current_user) - - # Get logs - logs = context.interface_data.get_workflow_logs(workflow_id) - if not logs: - # Check if the workflow exists - workflow = context.interface_data.get_workflow(workflow_id) - if not workflow: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail=f"Workflow with ID {workflow_id} not found" - ) - # Return empty log list - logs = [] - - return logs - -@router.get("/{workflow_id}/messages", response_model=List[Dict[str, Any]]) -async def get_workflow_messages( - workflow_id: str, - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """Get messages of a workflow""" - context = await get_context(current_user) - - # Get messages - messages = context.interface_data.get_workflow_messages(workflow_id) - if messages is None: - # Check if the workflow exists - workflow = context.interface_data.get_workflow(workflow_id) - if not workflow: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail=f"Workflow with ID {workflow_id} not found" - ) - # Return empty message list - messages = [] - - return messages - -@router.delete("/{workflow_id}/messages/{message_id}", response_model=Dict[str, Any]) -async def delete_workflow_message( - workflow_id: str = Path(..., description="ID of the workflow"), - message_id: str = Path(..., description="ID of the message to delete"), - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """ - Deletes a single message from a workflow. - - This function removes the message from the workflow and also from the database. - """ - context = await get_context(current_user) - - try: - # Check if the workflow exists - workflow = context.interface_data.get_workflow(workflow_id) - if not workflow: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail=f"Workflow with ID {workflow_id} not found" - ) - - # Delete message - success = context.interface_data.delete_workflow_message(workflow_id, message_id) - - if not success: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail=f"Message with ID {message_id} in workflow {workflow_id} not found" - ) - - return { - "workflow_id": workflow_id, - "message_id": message_id, - "success": True, - "message": "Message successfully deleted" - } - - except HTTPException: - # Forward known HTTP exceptions - raise - except Exception as e: - # Catch other errors - raise HTTPException( - status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, - detail=f"Error deleting the message: {str(e)}" - ) - -@router.delete("/{workflow_id}/messages/{message_id}/files/{file_id}", response_model=Dict[str, Any]) -async def delete_file_from_message( - workflow_id: str = Path(..., description="ID of the workflow"), - message_id: str = Path(..., description="ID of the message"), - file_id: str = Path(..., description="ID of the file to delete"), - current_user: Dict[str, Any] = Depends(get_current_active_user) -): - """ - Deletes a single file reference from a message in the workflow. - The file itself is not deleted from the database, only the reference in the message. - """ - context = await get_context(current_user) - - # Add detailed logging - logger.debug(f"DELETE request: Remove file {file_id} from message {message_id} in workflow {workflow_id}") - - try: - # Remove file from the message - success = context.interface_data.delete_file_from_message(workflow_id, message_id, file_id) - - if not success: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail=f"File with ID {file_id} in message {message_id} not found" - ) - - return { - "workflow_id": workflow_id, - "message_id": message_id, - "file_id": file_id, - "success": True, - "message": "File successfully deleted from message" - } - - except HTTPException: - # Forward HTTP exceptions - raise - except Exception as e: - logger.error(f"Error deleting file: {str(e)}") - import traceback - traceback_str = traceback.format_exc() - logger.error(f"Traceback: {traceback_str}") - - raise HTTPException( - status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, - detail=f"Error deleting file from message: {str(e)}" - ) \ No newline at end of file diff --git a/static/1_test_document.txt b/static/1_test_document.txt new file mode 100644 index 00000000..d5591e3c --- /dev/null +++ b/static/1_test_document.txt @@ -0,0 +1,10 @@ + + This is a test text file for the WorkflowManager workflow. + It contains some information for testing document processing. + + The WorkflowManager should be able to process this file + and extract relevant information from it. + + This file serves as an example for text-based documents that can be + used in a chat workflow. + \ No newline at end of file diff --git a/static/2_test_image.png b/static/2_test_image.png new file mode 100644 index 0000000000000000000000000000000000000000..1618d553946d766b484c2aa1f5b59763d61e6e66 GIT binary patch literal 287 zcmeAS@N?(olHy`uVBq!ia0vp^DIm + Sales Q1 Bar Chart + + + + + + + + Sales ($) + + + Month + + + + Jan + $150K + + + + Feb + $165K + + + + Mar + $180K + + diff --git a/static/44_LF-Details.png b/static/44_LF-Details.png deleted file mode 100644 index 3a2be57d619cb66e70f76081929e723e874ffcad..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 253009 zcmeFZcT`hb_bwb11rbC=R8T=sEFeXS^di{kk=_yMAVqo&C;|#9sB|eoDIpLLAs}7h zC`t)P??pb8H+bH2e1G@5|9#&WcZ|CSB7~i_*P3gVXFhYTJVL8nr=ww}L7`A| z@;9!ip-?ndC={g+^=^3OMaiQQ_>aO_?Yb-~n{<2(exbCytb7@T$_?AQX0i)@-{W{g z*BOP{SB3nesCK}a!5f0DHFR8bl$FFx9qf2a%p7i;^LW@f!rds8gtUjFiK(r*%gNj3 zme%%?XJ<+(&YrY3lRT>}q|B%6C}(bEeZ$MiT-{4W!_>>xRMhOOv=kkUgohZ6U}x@P za?-=@j=i&(ha~&fz+&(-@-i>Gl!TL+g_zovYrpS+-z3?sTwEN*czNC3-Fe&vcpRK8 zc`u5Jit_UD^YZg^!yVktp7t ^CfMr+yD`#oXD{$=cDy+QI%LGN8$A2UizKc2`$x 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 <%-6Eo*l=x^BB6uQj~m6$8uaci81tOBjq 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%0Adu}Gp`oLAvH7xLQ0eB~u=#w6_W9Rt zQ}?8qk6!e!dm~S@+p)vyp!aB7x;=?aJNT%+CnPEo*`=7>C3hGgHK3#$Ka6hoPf1%n z&$yiCxS7^WLXf{p_xC_y>q`ks!5iqo@T`9!<^AN*qw_Iz%BOjeM7}R8GebzXi?7S_ z$38Pdlmafw9{I1~JfMkKz^_ZSa9hMw!4($EO{5#1l+_Ur1HcB6y>?z(dIf{1Ictuu zRzr@4gs6ETJy)jpa{2*1^d4{kclKS}MiXvuG+qsV0+R-P1pBMqT3%@3>@dYhDLbQ4 zaUmM78(U~vZm{{jGC=`Aaz_9ch0pv=mf4DbHzLW^h#9|RzI@#;%j8;WlP_M#h zc^r8Glu25@H%{NzwTg|CTFIH~mvI@Q_5RP0x?LQ7AkK~?wf2Yffn4r>Hy>g*eEoU} znK3Li9AbNy_sPYEZ)aAiN(@t`t)<(B4rD{@|mRg~DV$<=~2v0*} zWqhM9Lra~0A+A=XVv#U`?${u~=YNw8R(W2d3N&J0XXeT#GN@J!)h(kU8kivtC;g*q zldX-8z4N#tBMAqoHjQpv8j}ly$q6cVryRw|F$6TcrthlKg$-5aY)~Q@Ua^c?wJUth zE)_as`}HsAj0@&YKh3nzj9V8Yg^sPs(!Dq6u-3vA7*#>nsClN;ms21Gamb^ zw&T6N_lP!?3M}(m)Ov(ysx)|X!#|*3Ag!&ADt?}%BYt5e{~F`vV<(RD@zWVEr(=Q? zt(47*z{1dtoLOeRpm0}xFDzaDQx~ZVx5C`${w$FLc>0aFZO0#b?DxPcZl~bYZLh54 zZ(Y4S@c5t^w3p&KU6FOCTAEs0W@*{H-V%5HU4P4bmixq)jXzG07D#=!&&^d4zK~Jq zNUf-_v^_{i(pZs*nHhgh?uz}n?Fz!1JPz&IbMtNv`3Lk2MQh?Xjn^~tpF#bZv;Fw$ z?rYg9Iy&v~^?X=8_IfAM&=Rk2Y0p}XP6VozKBW|CTW*!AbqrWzzUbUx3`QV9T_@4zFP1ztPZmh0{1wdP626{&&~GqqSU84baSC%R ztF?)jFg){2ybIO)od5Jw;KvdH&;emRE-$Zb)Jz;01+MM^1(&7L6rRqX!gT{$o!h`# zkzjPU@tqK4Z5V`ri8`qEkC&FH_zr?KChu%@)} z1;=%6W!RAY^)$a_>0T&hMc5_GUR72pd8F;rsI1fioQ~$p<+SEl+o2i zVhk08Cl4Q1NABuEi(~NC4pf^NP{9FK35IRD=DsF$O?}b!>2=!{_85fO7~~|TsF+bK z=5*f|MMtXqx|s@%FIK~t8@jE1NVQH-8T|2UERt?*IotpDiTkQ3BP@b6#{2!s_V|_6 z4kS@GibYVYQMH78dcT;t{g*E~)bY{LrK8VMsX6&CcoOD%0s;c&d?2v*^VVY@YqN_V zbD3OFL?2@{E|{^-D_hRe$WgV}QMNvvtE#{^f7K|Dd-sjf?g06UlBl^OXy%D$XZ!}(K%+*mO-JP*x$BqOn?X-A9DVzM8PNh3X*8Tc~#My_7Mf;=9Dy)b;C_Bl|a3AK+uZwtYyZ2 z5?4NLMnAFcxz&{+tMasD3x?&+R(zqH2JWK`LyO7!u!8Op&}x07l~OV<<|Eius&TYz zrlD#aECW>l;n=m$W|}oRb7_A)Idow_ET)th-PKxBdmAxC$mgU6j63s}g00hIv(A9U zy$mAb@s;C`VQH>Lx03Qm`9{rLhApmbOSVl+<&rl+S>)yG!8V~bI)T*$ti`Ipt+)Jn z1RALICMgyw-=VA`)cWYUA6(4^;{vbPV9%{w$Fv_!Ux1KEE7idc&@`!u4ecLyO#g#2 z;h_WIm`TjMeEs^oeQvvUN#_E%rUcxUa>IT;QTHsK}Lvb71K ziOrrQWqg{X)gd8CAVOpF9y)xuybY6Yk@zbNwA$9qH4WQaG{1gtP`FM8qGOMrn%8$xgnPt}e&|tp3 z6gq;@DF5>+Qdc-3HkF%kb8_Y4^u}Ifj)X(RW$?OHls z)b$M-tW<+U?d+O7Mu5|Hp=M_LM8h+Ft}VcAFhN5@qAMTq{{6dmb!%)Ws%mPc_3^6Y z%A#llPb&kw?<7iwtU}BMw2*6|YEypH0QfQCov?~KYdkgO!J6VYazx!0%vCe>VKy7A z1_CytK0+q(lyF**g~nkA_Z)*PvoZcjqSbk_55y-IDlECydrKkp@&Ek21{luJrbH+j zQ~_Q{M)8FFIjHwxK!D*$udPUib+-(;#yzQ+5m2#W`iSt!w}GPf49unTBqyxwW!-b8 zwW^@#bqA4~6NeM6;q^(>bw6*ZmHBKZz5S5M_}!*rr_rDUQei%Q?EjY4@Y!|;PSG`c zuC53-faVC_ifhJ&=*-}&QgF1FDq?sv{)%8^dU|?CBble4waRU0y&761Z0Y)<^f-Iv z#a7jMQ9Xk&+6WIS#?^fot=`X0C^)0t&RHT5x=RQuf>j(4pxYiU0it}zpS@1Y;;qNtejk;gYWIb z0K>+|$4O__iOpwF5tu1@2Vh;Bs&%exk#$XaZ$u5evZ~LM!6;tvVjs&~0gA;bb_$$BT}!7$cHtI(9bOm{>^A6MEP5D9;Z@*qT^u^5?!09RmAAxV;k#vVC*cHlIl zX%MzIXpOkehtBwobKUysyy_O)YTw9=+K-ivZ#}FLj$}!2+YpaN%ARcvu8C|yPdDyP z8I^#n2?08Q@^q)W%>D>Z*-Dpj{KVM^Dw4l!G&DWwudVt=P9r4>!Q_Ksnt&q%u9Gtu zJs{+)xV`gcSIXRFn-TqksN;exz6V{C_f^)TsTWZLy&TL&fR5T|9JIj18ynDdL=RbX zXXBy&U687Wv+k!EXj(kVx?f~C9q46wG-2sCY^9xH5tq~&SR89>oM>RNmP{TZJkQ-4 zq?|+=5b3R%r)$>ghR$7QFp2qn z&;9P7cOIWaDKqbT-gEZZd+oK>X>NqFaE{5W8o89A5j6_4MR1B41I`754W5z>G<-^p z7)hZFwHYV>w^|jLP8$mo==XkuFg9wSCajAr5P?M?+ z(FwwKi$dMZVZVy=akY@w$RVgmGXTX7&o479MJIx6lqd}VcpH!uiMIDbc&&xkOq9xo zdABr`L6hH`kBl028Ak}kn`BV}AJ9`Kgy9NB_Hlv`v}eZo9{|cusPLpd#)l};Yx9GS znRQk^Rc21!x_J}(sdb9)w@(LSPSDs-pe9PjI=+8UwCc+jTU7fbShgFvdk3x0nebmC*9vrIdmq(G(;!0x844G76fwiyoo(;$vnjdqJvTgyi6As zJ!_0x(EPXG(s8Z}N`eGD7>B2IJk$y>$FOnY4{|n}5Z5Mb;se?GYDvR0#Bgy@(IU%< z+`a-yHeqbzy~>}UAY_hCFjvA)trokj6iB0}o9M<_n%Lj2(WSuR=x;j4|T7GfcLu+5g{SbsZ?Zj3j(cBu!Fl$;~lG5|Hv^j8Woc5-qe z%vj_wk=iEWl48EU9?Y8DjV}9b54J~?ve*bMsWm_U^tV0Z!Fs7ib=D!14dS`bP&*|5 z>dv0#ejENVIs*K~tQJD&bV=aD_v%eO%Qs8SOP3`%&h(P=srf~#WNbr!ZBMP8W4`UE zfn={?(WF)QT_ugLU(K`GKSGj;##zAby@3C?IyhOW7I_SH)s)JAX{%7^(*dDMGg2-V z9C`2q2W-^6&C%1eI3X!7-_XH&x>Eooco5zOT9~OrLv*yp+$(LUzLWxz*=&wEyZ>0P zyL$e3^l!rUjDHc$0$)!`7Nej-JX?$5* z;%gpBR_-|lYARvSyF5MSiH1}L``OWrrf#{oTnD`We*jI2^U1p=u3~8^h??6*Wbbh08m7jIh{8wUOC`{6QNirnz7~vAL)Gow;c`L zkw|nUsgcNCV-AgT<~;56*WML=GM~W!bT92VPp095G9*bCf1x-p z!0JV5uCrP-S9*p#+7Q7-f0m$TXkcIvU!EOuRKp3yEOvSwNY>J*C&gfods$u_?;*K>gJyjG-qal-~~2myF4yN5RLO3x4slS zDS}VPgVDs@`o6VF?ET2&f{Aa3!CKpv2zu&@5-pt;pLpW{GWr*JfGgTP=d?ozO##`- zpM3WNKW{T;!Ys|7;MYB_&n@kK-nsKe2Td4dQ&@%2$+qlS6dM1IhRC}iA#-dUOm%f1 z!nd{7RtxTBzitk-;#u~1(9|3ygP6GZfMM}lxG5b%QUUyx2->hodWoI!$l4vBznelS zcY5_g$0Q{3;plGV8sMT@8#QPP#kXu>*kv`vb;~N(?(PVRJ--Rp$~X@UlIqgjT1KMa zj)u3ow>r8LKm82)@_xj5=1Gc)I+6$MY(rgzK~~IE8N`{K)`j@Zouf(qR{bgVqhOuu zl4=-|9ePdo>GY#o8X7}ZXY6+*+UV))N9?VVwqe42>mbzO7Jg2^*+|BY#0Ih-QU@o2 zm#S1cn?fndJ@s2+g`98X8h7di|DdO&iS@DQ!hscD6GYo^-K24PvTaSeHI^A=cj9#?fT792lO{uZcR3>nNI2WH+p~0dakGc8#?T) zK-~p>&BgMyTiEaS{Mwf{sTXy{l9F@%-_FrZ3-9aOo+@h$RL5^s@=4B-HW!vE2PO~_ znQ^4}{&u@Tk$ri8BcHU^XCFzmgX<(94LV#ze+c?fGUg@yc=oRj1*37`M@u0bA#{_t zft$-2ZI2-BLd0z3KP*sMh<>aN)|?ulJNCj-QAQav_E$ZcQ`nIiMc<6D@%)aUB~wYhy;nXPl}jCLKc z+RA@g>xg#Hn)31J<*@@e0&}RA8RYWmkLeTn8%%tM-i>uVIM>~jbjD08+!~J3IsMNU zO2df_Pqz}Mgdhnc?P$Qw z+Y_)az~)bfnp`7S+{|+E8VljMelkyb^<~9JOWsJI`S?O_dbj8@xRfNS2JmeKy9@gU zvz5;rnb(z|pn6z-))x8>_}Wt#kN+F%d8nC-pg!Y3k>)rr1M<69Xo0(ya1)Pc~NY;TE59x=y2j;<|PF z5L7+TdKJWxA6UuRCFlaXe0(tnm%&Ogw z*2Own*Hu4@P6SWJac(KrKkbMm3~nQlS><|*o}hOW^ux3rY$Od&&flgwB(@FZ)I6mL8Tw1I#@xc>~m zWh9}7q<^mn;VdDu9vYuM>|KAX#lTaA^knFMac*zE_4oJ7iwHTX1+D2B$S(B+pVmd& zW+dW%!-t1#K{fTk%trfT0M`tqk*6MkzsXM3P^Prt*n1vl7j7wq&9lP`c&JDP89qxG z$yd=nNx9}{F|MM*PxUsDq3!;j5Yh!1ppO#;rPSn|B)Y1~OQMPGZgNY&)OAT{>iVPg z$Woj{8Z1g16`>0=2rz?`SQ^c8JiJF}G83YAnuW%NSQ*vFCyPqp!NM3DVr9Vb94qQD zzAM~qL(kH_IFf90O-NP~cdLu@CGuI<@sI6=6MuRPe}S?$cqlZH*Gm)HKy(FX1sP)$ zLC3NIfbL_aN&p8Ezn_>#2n-{naay#b4m#0}Gx{FDmz79(h|m!|T9;QF?{>Nsjz@ud z-mS>oc=z}{5Jw;Br{>Tb5l@_vs55uB_@|^PuEhbJ>3S+@iaBs*a{<@D22z{urrfMg zx?N7-ZcKbzNnM8?75^*^GfwAQbv-l`m?>uow z|0`}TFNSsM(zX(LB*dYnTIPV`UIS%#-$sbf$iF27?qCcEBe&A#nY-pS?Ne(>oq(PL zSAmZn-Kg%wiCs(9N1nxvCIYQRI!`u+?BhQ5UXVP1E5)*%$Jhy%X;sY8x`%g76JbDt z9j^-pK=l}A=7SH|NM~L>OZ!e;`UBD!yNi-lukCX`i?QNdi$DMV$|9}n&o|qSK}-|C zXNoN`3S!wT(^ z7Pi}w4+uSzx(+Lqc(j(BqN}dt#!g~QNu!+v*JTszR8q~in^@u*l9LS0pY6w(G zC~eyrQx7zz?$Pb=nWhxM7{_4dI zMgNy5_O$9=tHd7dGhZbFloeoun4+QyVIO+NB#%qKXmOE?(iB$osFh!?vL3w)(u>C< zKss5AUrzTPcZI$!t7t*h-vjNu%%$aX_Xa?XK*IE@j~a(_Q5bb2NzI-45}<1m7){)< zq_nht^!`<3yZFFvY<}cIP_)|2T^uB$oPvG_W)luNJ4}>HsAnNKg#Z=IZ$VU#NLg)q z-)FZ^T)VairAg(YBZ7O&Q22+lu#lynRub9+3SC0Y1*JqOL?n>W1Xfkqne~x!h;%WN zdHDpum34orK8IZ&qz?(`u5rF*G_!u z$!b|sE4{Mb)})cgQ?UNTwN<(X7w9Tsn52a8iZ=#BeDAy+Ld8bjH69X)yq4gv|EYPY z;>6ihXz`CIPV^U}VgC0WYomKl*%t@ntHdx0C0$kRYCmYdF$-?T{>EDjR$&58KEOeT zI~(^R6A!CfM*n8h_`tZsvl6D6L%S{4>lm~sF$ezq#^>cBDds20$~m4wGyYAe=xATt zTzSpM-Hk2Odb^7|^U2&kSikmQk{-PpyjC>$4C8g(RoNMIKwOe1`m3L61wLX}eeTPl zhaC9l>L?C9eI^-8;Guv{uaUv8zut6#rv=pAGFqn!x|jX1<#A;ro{|m-3Yn z40fWVLKc?6G9DrhYQeQR5~%7en*jTh#xFj`BZ(RAN#y01=@0~u zk_ha8(saVdm+$SJJ-30}Wni1xG;fX2g2OU#5Utq!dtpVLu$Ul&7+9md^6^8d&rj7p zm&f(%^B&DOSqjibX6$(0s6uLJXy_(g30~)D{}~jR3MhjVDUd1R69tz$C-<#X({_Rx zM7#7VyZ2l@H9A-@sArR%`pzG1k$%ZiGAxce*9&7p0{wY0e?|ymFRT?<(}~cUC^+Fu zDxWn$@kM821T-tB*^c2u%U^_S8 zd`^@U_@mGzu%D)^wy+QLW28*B;m`3~ckU48F}PQA@`K1YEf)|FTfbfvt)5$rJu=3A z@edz%U03LZmq8d>g$UTf{S)7Tt`J1)arxDJF_V(Jc1gix*Dpj7CsdM#QK7_#!0yng zike0UG6x}~i7+SI6mov6-ZpPuwJlXoW!iGkRxk6doYB4C#Xf^*kL3|6uy~!I=xY#G z#T6Cvn^_sV63s0vESR}1L|Zc6GTq#vWXL{zlMvQ6X} z;iO4M0^+u9DHY~uXd(GJhRT4rZm?368rEGjK&6S>?gAP73E!O0@KR-GH-m!v2pi(3 z`p2+ZI=d&DCN?N@3RSVF;k@sI%}`4JqF`(Hl2rC&l9(I<9*n5K;$_lJ^NmPw)YT0k z;vP&gvbEH$fsZ^ANCQOLQM)?3i{kWancY)~M@u*u`KZqALD`lBd9ti=7Lt7Z$%~>~ zJ?4>FY_C2iiEZ1MNVv*_P4FS$qgtfo!plkWgJo0w2gQ0G10y!n2YQ%aQ3JBWX6T(l zr7QvYMR<6)e5nWe)f3U^>`Io~?aYuU4-{xG+3h}$C%@hVFpF0104D0#YDq+NWa#bE zD7&g7ahj3H4#)62ciNpanH}%mw!?IEcn<-@0BAT}cguK<5eh3ED)2ezfqcTd_tw#- zYL6JbR8u5 zQX{bJtG@(Y- za6dSV#xVeFWGb67HrR>(h=FoN$@*2Wekh1#8FeA(Bu{#nhdj@n-n_DY+4q9@j@HXX z)D$4dUEt&seK}n<4qG7Itk4v=EqlJZs|C0(1g|so89fbt{u}xC7NE$+-5wQpDGEKj zOki!l;I;GPHB#HXu~~VG``>ec8<*)T!#7fU#(qWj>1pbXzCQ8#UKo{aF-Ro`^8`%h zpt&pk+Y25bIbmk1*91O-Uff>a1&S*Y5F#eZ>B(%wsZ*&CK6N2!K<{4{u&d$G0aOr@ z06u%*6zw{A^4q*Z@hZHB6B6r@ezU>PLD}Ki`_E%>Q{%paVwp_u3fpZ>q1kBAXL<~@IAgq zWb+8CSjsizpU`y!!#e+gn*M)ssM4)ot$z6M$Zf@)v2VQSeLO!xw$495woR4rDgL)~ z&lBJs9dC1%cY&0NxE+A$n8D{}4Ztm7c#T}*3zofps*=Vu*IWuu$p0UOdiYR4CFOh; z6va&*EP4(W30?J9%M{wyL@JOZiV6cIz{93ow|c9E_NVEY^J#5x&H&@S-yBHbaBq`w z{I}BxPXt=Qq(N4ggmEXHF~DAIdvP{NDws=R*hzuBfe5uAUu}mZmMH>+%k}lCYwufM zxZYfPIVi|MZ+{u)7-VG!TD%4Vp@Xl3SUM)NyJV-p&ju&fpw<35`S&mYp%}qOq{Qid z$lfh9?q0d`d?-oV2D@s8AlA~r-`Uyv+>+n-TbdKuZ4ZJ?09b*nY6GcSpW}Ngx~^Sw z?NYI{ytvpG6mBt?RiFdzB4#YuT1I@SKvcB|DI>>SEHZ}pu?xkPG*>tQ-bNTa&S*vF zXgW%U_OlU=p#C{JCtax|gIHfFm4*SJMy71|)d>@ebc?dElD48kAAZK< zD@9sKNvTui^Z(dkq0l4-1TkVXq>leElxVj)Yx{P9V@mFUu^Kx))K@N1%r`2QpPRxP zV-))GYHV+vigH8Hd)?)XKi!QEg}f^xr4nr|PM;?33Vo5<@6ZW_9TA;OZ>(LHh7jXa zH|$185q0ugUqa`VfFi5C6qWx^%a_+BjFL~o%kO&9v3XKoMc^97KAS!d|En(!%A+8J8Jziq&oDBL=c6|C48v5{YvjfXav@g)6?L+jeh;~`=Yy2U(fa|`mP1oAyjE&~ zN@nEC_evIJ@Ns6SpG+|3G*NPcYIdWv4Syc-Z;~>)-7y15Ld4EQ(u?i`3U_e$%&)%^ zAF)dA=-Uat%UrG~I*#W(M5dN^3UN9mTIfm#%rK=kh|Ht13zt5V8YX}>!eF_d#f%x- zBeVyNQEjvj3AG`hyJY^Io64tX3NxhKb55u`b)-yM$T_{bps7*#*?NEADr+U!7}eTk z9e)^A7w90lMhwyg>oEy^W7+!`(i(e^W8>xL`YgfGig%yj@*TQD1v$>eL+6(R*R=(H}`;n1gsH}{q@w$ZW8R&vCDNfpTv0}Z!P|-UmQ|G_!?w-zczOcBK z-!lkSVdrrwqH;JYw|lXj683$UhMS%ao_O9vP;bZ>M5Pt9xu-rk5t~%;b>eGu3qz?W z#UZMruYvRaojk;W39Sq}9pC=+r0y#r)_;#MnIe?6!5C(p6@1qNSJgPG)KGW! z3h%Q`{O+hm81UAZbP{J7j}q2a6h*k%xc0f2PSjj*nH@Se&8U;BrBXUb(SsW0jU`lf zb6$a2rDrdjHDQ^Ou|Kb}?c6ingSk0q46#U0=HFN6O?ht>$<3SNakPY+UZMEGD}vqy zE(!a4h%KKrSB%E#ixQJ`r$z~VL)oypeRub0%Pz9!)}e>&qz^1RVK;{-dyL}%_3t}U z9HNwHR-M+OION)1u6>`$g6BLqKCY6%AhIp724X_f3gu%>9jOFKMXwf{`c$GCS!xfOKe21Wt1ocE%_CgE=~XB7k%jq;0T zu879#eA&$j-bsjl^aurs`_-pt3vM>cD1N(F`-isWVg2B1f{L{c(ue1q`I4}+B}*+! zX%X3)D!L~vsA&aPBJ~iY#&l}Eo(>ljL4GxZ0L;>VFJ(MEawuHhE}YPA&xfn5_!IcD z@JPqfrl|ohm%geR`D@$S53IL^xdk1E8XZ#S@BBzg7FgWu4~$7(c&}t@p66oLvhM?D zw>CNMYF>l_m9Z9$0A!FXZFRZTd=EF2N{bEF-z1MN?bioxa}GKvxOunaC|D1&TUA-E zzTWaNp?CtEI}YW|(M zi#Mo1rzuCe$L7=c`0Jr>$7}{QT`qt8XlpWMBf(g{%C3BS#O=7Gn`z6c(t=zLF=Qmd z?x)|r{O9IP2?v50UX@qcJ%=w{@UUi;!hGnW%S-3UI!jjkt+|PAsmxLN$BwQ0Ox#;9 z5%UXF@Rq{%N5OZoj6NGj(n6dE!g7oshRoi&@7(=EdA+Vf-8C(kGxU^^>=sr{{&tpr zp}_;V1sMc1zQA!$Nnj$7ywWoAjK9m%zesEE>Wb}5c<3jqie^|=u0heJUeo)!{@sND z!+=>djpXsV@!?~3NqO#k&?mwQy$J;Zz9K&)cT<$R)OF~#mh zi)kM=>%6S2YhsweJ3ifevS8tvKW_S2G%nb$QqwX-F2LmQ&OdSf4Z)gLy@KLTIavQSd6x+^X=g^ zj&qa0tfGn>Bmp~odRVqE(>UeV+RlLtM5oQPZ2Z?Ux~S!A;~~%aR1Z$y%p0kIu-MDD zO8^=!5#*MdzWuPwme{%>t2-Z@gaWx3lyP9&IKc~mnbU`!H2WF>sXyM{m7bTZ}h%`gEx*{m4Lw-cj!M7v# z)2w(cxf;)Cc4SvZh5Rd^1u!m(o)*?kldZ!5ed*voQyxYmtKK;~--?yTFQ=>`H#F z9L%ETY$2m{`;?XNY(KrB7m2x2)Ms7D($I#x>#~ym0j{`upUt9cGbP05Tg|2(`<&`E zo!$B813BK6JD$m3)4Ky`2$TbeeT3y4pUE#;dokK~>TEtv)D~3s$peC8AuMyL&besn z3Sm;BPW$XEPgm7wca*z*b9H>ePE|BkubxHbS(n?#2rjrI^ai;sJRN#(>q`BLJn^j( z12+ViD>L|NiFM~oZlZU7dN=wwJv~ekzOxBs?ZAci0h=1@s6Po&x>vx2AgJn|4lR5= zEyi(;$ByBr(6Nst!0B$AF#iK)iS|v;>BV>g{|V@8m?zV3SenTt#Ao`zyK46Ijrt+| z7s~W@4L{*@SZ?sH+Vw)db{+8P`#9-%YhLAIY3Ebt*LhSA zuU27=jpXMy6lNVUblN4w;Vq1=z5Rdi7EWWv8x{KG5BIgCV#KXS`dc|jp`f1ycA*u6 zQ{#OsOXcw}``n&Pk3#mBo3qMc0V;+P1DZbh+Ed(8RRRt2G>BI|Im#i-iMYIWJa}L+ zHF0?Nt~C^fQC`yN>V`d!(P$fRa$YfUXSIqD8m~vQ?3+lTe?F{-f_^{`?>~~rmZX#v z8Q(ZUVsKf>(|P}b<)Z_YCl|1ossT!#hRX8Wk1SOjY2rOE39C84euuGWZL>lobB$DL z9%DNrG_mO^b|Geoa7*OGWzFsYX1UUs^Z13FE)izAUl52Z31)>pa9{W}J|Xg57`Rm6 zN1$(O0Ljc4W^ZyaC7cR_ZTYrql7lVNlPyDf6;jTx{Ngt7LdXakuv0}cP>L?>5v65= zp9<;7!{WIsSv9K=(eY{^jiCl1=t^gL-RI&w-KOh}GKYmH#~C}F8m09kA4Y8A)oCf1 zn6*MaAVrYDE!eh#-Baf&;$`0SrLDm1_yf_7ulWKwcPdtba-ih=PWkd195o4Ih&sw8 z*W9T7b>xG{tLMGbc9Gh8vvL3Y7~fGz;i*lIl-1-Lj6EPGgx$Ke9xY*H!b{OtI|aQT zGUS<;io&<|hhwZPhwjRIe0kuaUg@BakXoo@-^9s2dCqNvL9X3$4fNcb-fuw14S9Wr z{ahn3Xvfjjv}}4W23j;=dGNmQhARB`51vN0gioCyw=I&_{EqFLog3gfPAsA*%D)M21Y3hvoE1VTD5~ zoJwOK9UlOO|APjap%YrSh=nLC);+i^z((b2jXDq07I3VEu)Q>PS33_c@>!iP?F%Pe z30LaRQ`egl$C5OolczPDDAcW~cIEX5ZPFV@Hx2bRk!-#5S##5L#&G_q?uELYEaKAKU`|;PP0G zN&W77h${|KJb4!t2xNbOpbi)&De+!@kyHXKZ}7zwhsA|S z;ezK2sF91C6Kl)2*4z#bRv9XD?S8j{ulo^Qg!S^qvuR(me~DHu1=oK*{#1K~se3F) z-0?8lVp;8l^>z-brloszI$vF96jlZQq zfbshugA#YTP~lUD)aLOILM#gr_T( zZ!Hc`6?9#w`+>i|)FRDLHbV@(G%!-g5<50;1@z7s04k^ZduE;E$lS*stf*p-sqNlq zwzHMf)cE8QrVFNi-v5hpSKMyugPrCjOJ3V{a75qpx%;y3D%Bj*@=Z=HoL?Z;{_iqu zLZ}EJT%MJ)G@dDA@fty&Es$_;zOyUfJM8mWBoRtDMlw(G`IUE4JPs(h`Nr~Zo*H1~ z3#F{0VLfknFyDC{x0E*sKIaE|r&2R)dlbglvF6O!x#eNfI%l55Z@o9KMT^#kw~@N$ zx9I~BvP)cwNya%npTPPx-gftmJohug_iX#RW#`T+?9}9C^orS`RM+cmHg-{RV;9|R zG3&*vZPVcRq%hPnmDpDK=dM~tr}`rDINO&$inel}`dsNe z646fQgqyXruJxQeE+Tl-62Gd3$OW80Nl6dPYTljf?ck#upOIb1RQ5fz96(wQt;2Ne zh(c1~qE{j|dkTBj>T;Uyv@jm3(J4zy;vgc+m0;%(ee0GgG~49Wpsrdc$y>Q+`cbsk znE5`uyYtS@4r8a-^X!OTh^^RFBa~13B(m~&U~WyF|&rUwK6>W?(*tY zO63jpo{W-P_5L{S?JM21&xuDlU#*QHczTXYb zMxmk3ZzA~j8yFi4y=!>i9oC^tCZEji519N7SsiBb*e0yr^>6q-s#aie5nm}xVC3oY z+|H|XDmfFE)?@44d#tCqal-L)goB9vupq8=(lFnrkWX0NqUrrQEHLuY0#OFcOE+A?~v##{Vk`r?^Y)0AUZYURS&SOQg5 zB-NoXy(m@n5Rn;P!P<(P_w&cx z4i~xE*t6-uWz9+~-yYXvfB*WQ(!bEl>EupTIv!h3`j8BOWl>lm(xAUoaUc86_qn~+ zJ$BqG`RdvSms6fm?V{236Xpy8MdAzHjgPY|UtAUhuA;r4A5DQCtW}o55?{wN^Hmax0Yd8xND3tFjIlrHIx2J?_Dn!@{+rs^d(dr&8y`YT~1W zblz6)uvIr}a&Mw!-#x&>t}SL=`$&|Y$9bM6OOaF#SaMEup@mVDa(ZezVwTy@D^IRr#U12Q_2J}Aoyj~@nG0^}HLZ?_ z!#K%80auUw2PGf^-wjMKq)`f|UM`CT=Mb*udu=$=fYR`i*>(G2uJWTa>_70bVmLq?`WsZ@x3)ZoN+ z-xIaV{q0Yy`3}S<%5@_*M+-$q=a;{)RvlAVYR|w#yvMh$Ae3pG#{%$lEp634(8s~w z(ncwXGo5pJ_6X`qjt{Zo;Y?RM-%=2ntk`t|wV9qeY zXv?MIJlc8d`4|aTwT`;GPYUnwU(6zQUJj1Y8}f>WQyMXFiicT|GNof`Dn(9G5OPRs3nctP@D9;k&Q*UPvKzZLQ94^)y)p#2SquT2-6vfCE^!afTsUUls4Zb@^c z15a4cT-(oqhCu9cI-i|9j3ydd62VROvN0{!SCiEe=n=^IOh0A^f7vzaMCvzkLowyK ze*e68`ni&6y%mAK@me?7W(EgHn{2zQ^;g-KFJEYh7GtW*%bx)P(Gu#vE?7P2z6bY5 z=E5!0^_;g|n{J&XbMPT?BodR_z%_z=Id?3!h7xOgX-YUPZ69#>D2NqgYGdYvnZ@8<3HJ4f( zZqSt5zfUo*Lg3F6aUn}zdbvkw1bzCetNGH3pDMoV-TVZ88f*D>&$M}OIb_L!U{0WG zZ6V~mKE12&B2xl3skF&T-LysvYFBz#@xq>K##{LK8z?v=s2B&ff&)vK7ok6sVc@ zbMfT{?pYe#w>i6Y(?(S+JD_60Jw&n&kXc$8wbCmAER>Lt3KctYqn>*3UNVsv;uOaez~q#mB~ z<=hs9;@$`k0|XIi*m%qcJFGz%=q;QE0?}Z@IaO;Vg)yh+UD^TSWCoR7l4OM(DekaA zg*^rpOOU1ZtP%2Amy!OHq+-&JM++U>J{|LvrF|6|p&QnHY3x!x=Cds)%b3JW1ceu* zT65=q0QF|P$upZP&vSE4v1&b**>(k&9h}+2zvAux)cRXJ?d@U zOji{J?AEv^w5z=BD=Yv)fwFToPj^b?4>d1#PLB3#4=xIDE(-Qdgh0hvo48~}AY20r zS_;X?#Cq6SJ;XB6{$BMK(z6u!QOf~KI~Mg5XC|Z@vnL$FUcXjO$~xcfU3g7@-+MzH z2Dkh<314@8ArbGxEnc4QM`TBenn8WGyAd-=Yw>^6+TXk$Soclg$)c`hOk* z=baKBd@-|-euL?+=Iim5*8cO`M-v(%3BPy5TIlB>^&E{*ViYc(+&nUhEA9lOF=mV1 z1iGAcr#LBL2Eqt#(B)7Bas?8BaOC%YZuM^eH=7unSBY-UEjML#zbyZ_NRM_RE{i=q z<#NA%4uvKzO1m7qYhO6V@h$>saqDAED``xbf3rV=11$JwaFG}@gPq0`^ee~ii}ZQ- z2kLe7Oc!h%E$T}ycF7yO>npXg44Y}uqv<3m#xIzN@^I6|=7K0;lo1{$9eS|t$0uRw z{CPyuWz0%3IbzbI?}EemMAy;RX3C4@Lw64_2b?SXOi8brCNN7Q9Xic*p!5@hJfbbM z5E24RGOTi|F|wHMdYYPixd;*?k2pqvSiV(HhdobrglRGR8A=xG>us2RyK zA=&**`OmQ=7Adk@ay}fG)?xSGLYspzE)o@& z)jWRgy71yGzA*nqN)HzLPaIRskv*=yZ)ue5sMx{XopaC<_ zn)9i=8SSr08!RgAfbH0`>B_}Q z1wl=44-^&RjShd2s#TVeC!?6aPwz?O58kchC?PwqelWTvtKUHH*t)fK(NOpD5!OP+ z4FpuiulPBQRiXrWAM;9Xpv7ef=N#R5?5Efx=?m6JhDArid5>H0ZhmJU_p?#Wu`PeFx7^n=h~QeAHwQRwGTLu%zwO_p=;vzt>E#XLaXN*QVY*>~jlNOmu9Vfjn3nVa z7pIpdXRKJO=TZDB{QNdG2(M4K@}|(~073!KUkMES&K)DSOA`)*$(W`>j}(|(U7-AB z@Nt=x%*=JW?EX*WZ=ne_RMb-{!GNk&xQM)$Gg9Q&DGgz;p|{2{=D4wk8K;()i*^iE zy_lBI{fjvdMH`Vb{`+DaOxIbiVHCkdVYvSw1i=r;UluQoc@)zux8s2*=PmZHAFF9V zd8_t6?{N8IPTg*TOi%@ZGyd?3D*Jr*Qd}JzWH}d{5DmnD9}oVAAL%@ml9xQHyFDPX z{s8|p>x)Gy7ez%M3c8t}p>A&W=y7NY?JiXX$u z{`(E=`TGX^WHN^;W4edmEgy@SHyt;AC+|^IZXxwX|0e=F0$xdO?C|nU?pn1*cxvpa z3qTxdM|7jB_H_lZp`?~CH9cwKgZTfkv!4r%H>ixFr|{~GWysm&0NH61vw=x2it|c+ zQ`b2AaH+=!|2sAo(EQC@dU`Cu0jI}nHe1j>0`OpEEzYOo6YYGytru2on4tYduBFFG zZ1C+ZkuCt)q+aamV zGXMqWxwxr3Zr6`u5_RAx3~huYRA74Pn-|)Z!I3%nr9qJN(5>=0fr!Sn-++X zPFS^tVddU2nJUdrF=-fl+d?7)*IdjUVSV!?s_E{jfWUAR8WTy=@qa5a|a)|L456?$qhVw&7CNgpB+JW+P z-&;Dlyh=rV8HF*$ZMv43iz5^-_$_o80kU2Zvn7u8ep zyKT`lXv)dfEen&reZ`u>*lTj;U09A)^)nCEaOAW1fdRx57)Z2wtZ?Xi5%!@C*WDQ} z%V#?jyooH2&Zh;b_ul1*mfNJr9iBX&@P0mpTIe5HubTr3G580#FH zmTz=eUjAmg;<26Pn)f~MkVI=e3cr58D(zIJwTlwU)=Bq|yXk^F_;RdUQEIv_sDIB1}bZoECJDr?`0MT&cej!3@)UGc*T-W zv*mdZBG2!f?x-94GSHVCp=wc)9DC)eB3)O^o2$I4Zg#lZ4x<0+_AEKEfAEW4)NG1G zcN?4CmG|--u{MzQnHb>{u7yi4DMiS&3NobjxddiFQ$!1@iT?EYGfKCJ`u9gu@8`dI z`BEF?L>=S3PLPL2^%fYJDU??kswR`?lVh}tY+V96hL$)>JDv&zZV zUUhH(SXHRFGw5Su(bZ%13n@2sre5D7tcp8(`ln$6XD8gdgIHy3od^@6tUX2jOITj# z0*UfDnL?>Tv_Jk}On3MC+svib?vGyrD28?`d-!!4>Kv}REG??)?T*DgNkXX#*i;#O z#Ita+;*Z+Xw=9-ca5LgQZYw+p(}}K(kH33EF9Oqz&TspsjZGdpO^=L5OKl7 zxps#sk(<(uH^WPKYto*~kQ7HV;;uI7`vRtM^-Uc5Ib76>Gr0COs5z4-@|CwEUA-Tx z-&wQX^i1a1@I(3Sj5Wl6rK-*MkQ~2C?h?0A4eTjvDLz6ADOC7ut9f<_Jo6??iQF2m z-SToF)zu@o)tSVF?}L_u2g^yW5bOO((Z3pk_RaayM+OWW4g%!$K@2p z!>{}tpAPJ3nwJuPn|R&-X?wsC*- z_L3ejs-4A@G^pqOE8L$D8HQTFx)WbtEv3<4a6E(NeY0EVmG@?;T+8~? zAEJUvUQbb?0K01j_x~Zd6-1*=4i@0_X-`6ue$F?Ei(+Dcasj?(pydlVGcaCTAacYv zQI6msM-#^Q*eyf>DEVVDa3&7G=jEL>ZaATYVfRGHNIV$!#Gx!tGbiwEDh;8tBZoXg zcaEqrP^gD`3y%!Kwlu!c(--HdW<(1a?IRjXry zan>`3E6_C(2jTYjP-qPdu^jAJ;cD*EjET2z4d^DhdabP!v(W;jNfI=EtVh*>)wmu& z(BACU@L6PI3(h<|kKyr;BC2*^_lNJ6{2SEgJWKbO^a;^lU0t>5B4-a8kPPS=tnol0 z^FP6wI{D$_kNxvyzj_XTK}5MK)sx~CrRW~&vXav9BFC&L`IFH0dR#9@=;xT5^?!!u zuf~RyP8F!U0gTO_TfXdzyo&t66&LUF&nktO`sH=nt`jj7KJAd^`o!-`PlQoytXXSggDP&!5T$Lg8^qbm?_J z2inN2!D-g*9!36A`5kaCc+;^OUO{lOs0?o|D)VoL!y$L_V`RgA*E>pVA_V>{3sbmu z#RK7XZ@uZ+JIG*YW5Zqc!in|YQ?!VQ08tX}C}tDRb11?%Z*^zm3FG23C9ZuRPS7aP zRSS-1j2qVPGHA35xN^p}&5OQ#cc9HzK7NmRJ;~7ZmhWUK2G>g)sfM3prumOeG>Nc= z$C#2UB_83>B60|xspk&e!xtdIB0D)*1bhMaHPv_FoXL&?kANNYWcD+U$&%rc<_k=S zm#j=<&ZJEB9>gHLn~S@@*DwkuH8C!45on)k2%d*iZebp2Gc;@&7nwLIeK|# z=mDBaXowrNItCAXphay-wOD9>RFQ&TedvI#I)crG*cbj48X5JS-V#G}D`EDEEsJFG z5;t)#3v{`Vof5}6ym84r+4avXuZ=HU0u$+m@Oeg+ILJ4fYNNI?GcI#BRh8`p#rIG% zzv_;jM!L-$C#`Ev>2sBMn{C8ij-D&Q6)~PPx%W^4b4G5{xbDiz>|)?C%E#EG>`~|x z<1}RNsYN|!b2q%jd;&kuN_)#?A@yB&^&P7FiWC#g_jh>_eQdHt-@E5 zx2sdBR88~eNg5}4FZ&y*)~~o$!Yz>>bARl7pxxHcjw*#OE3e%7P{h4EUs^_cRT-qs zJThC52>V?>iS2p;j`3ti%w)m~l*-5j#h;kjbM5nbR}b|F9S`MX@=GGeTAJoj(uIn+ z%jM6oy$(a^N;QwoM|;uS54dzpcws8Zczg(P8h8;e^`(6 zv~xVKS{*UA?)y3{up})yw<_P|=Ejda7QdNxnG@7f~&EfMQU+FXP{A@_BY?f*` z$(cy!v461&nL?DnQY|A2;}TXoHU(m z4|XG}nMmDJrUNzg3mP+u`pye5(rjw^IGZA$fq5I_`T?N`h z#6wq$(w7~maSxCf`1Y-vn=kM~+!I9^napBt?FehE8{##ED2u(-1#X~DWlwz~%H!~k zF07I)eOv?etgNZRGl!5Ql}0?Pi46HdBniu;yO$MkS~2MF>8W1cOzBVhhher*-rYjS zH2KjZw5`Z-P3N2IMf&U`ML15Q@YoyXT_!zU#hx?7L8>2RNGby138 zjQ{m|9mq&w%yH^|{i61<^I_(?2q3s6;)LJqecrBK7>r{muQSxQJlR^m`5-I`iJ`*= zE11JBSnSYjHtpFWd5{>f;4>|z>LE<6S(G|g-p9O>I4~gIAIP`y7>F)}3ky!?lu7VJ zt?PL-il98z#ea#t^4{aej{CpU!3sm9&y7LZsHW&K_}E@e;p;zjmHLO& zrS)dsq(r27uoI^{aQFneoSY_7 zbxHc$S?#W^{~r}sa07wRB#a(dxqW7RDJllLl(C69*=@10#XWly@EQ*5t}*|AR2C~K z;UI}oxEb%b!mZanu+lkdo8aQIqxH>+b^~eW?LvYM$=a!woe8rvq?c4nC8{yAe4V5} zkJVo6H&@N$x(lC`o5ijDLS<4M5GhdCz+ely^XF6#BpGLo6;^PmBzX7hJybLGx?zD6 z|KLV&KD=kiEDeM2-f;3>BabWc*BUi>{$fDL$YcFcCS$LHHX~>1Os~;|59d~xHEDG% zjBpvb>T4hyF?X@>!`Suw%c_!sToQ`kO?@;U>t=Mw_xIZOwB(v7ua?tMJy62>Q>eOj zdQg&HBh>S3s;L1U$}Pg9Mi>0A*D|j1*QU9dvC{osXDX&_pPmfcuyraCr_T?jB_C_3 zJvZq&IP!YV*q3Ly;c4zy*9Gi1jHg{f2}*%U+H4g{lp@XQV#{}DX)H*z#nrNQE#Bm{ zs%&-AiQb1xeQrO1O4~!#sR+q<_p@0VzBc-LdWmtF53>us_m#Ko=5{*X=Xc6{c%als zQ8LtV1A&DYE8X6o2~e73?<{|+ptV#H$7;=@>E>lhn>A)8*G^84E9ZQ=d6>s4Q<7V% zwVcONEhr`#vY*-{Enmo^sAoh9(vAgvs;Kb=pqabS>LbLdh{UseIn{!Z$aZRvekfE4ZsVC;KQF6gy+RaM3r(^P;P1 zvG5(1eOlnxAyeV)+XlsKFLRXC0RmV+!GH&kzt#ZV6ANKVe5au{rE}{va1qWQ( zis_v*+`by^s)i$<9&c&7nZIv)-h{q4+z^;2Y5Nzgkv}Bcl6~a5r)*fz&S4fgt#JQf z_xGB%BOLWcAjZBzO3a*chx<5bLq$Bxg}*Q!zMl^uM>@3566tF_ho{Vzjb>hw=< zS4v5p>QT;nXMj1RQ)%j*(Ui2#LNzbRGE=`re@>KoZhgtmM zmgcTBVT#`!bm=HLYx^jM2l!5V%oD=_vdP8e)gfHr%|>Eh-rfYBQQjR7eE@n=%q89R z$hSJ*lLI)<@LN{jS*DWfh?P)U*vEvQJ6Bw0nWBuN4ijC89&ivmhUBo#?=25nT7oJ%r@fKUQTDq=DF zqIS=lwPx1LkEzvfJ;mbts=j;g3HzM0cf=X}4++Vv_W2&s7ptq4bI0yJ9dK`E43;ks z(Qhd%aOAe=n0Qhsu`$r&6FCoU50lk02W?#0{`fqyaGJ8tN^kqRV{O5aLS40r^l6*v zd6SQ0dG-VB=qXI^?%6Z;rifKb1n~7oa%MJv(p_3J=s@}@W9(M6FG5YzKz*sjsc^cy zq9S8u0ytupW#}1qb9Po>kfNl!-&*Z=!h~NaoUiRI;_ui{jz$1y+WGHURTC>ok$wjZ zFNW6KJS~ceMW5H7%GVr01v{t)`RZk}pD!`9S&rtV0)Zm%Q!cxS+F$d2&zLc;9nIHg z?gxqMuvPd>3^zJxA0#F^E6MM!oJlNpa!9|)P z!ru@iYSX19%Wk>WZ=N+fjWt6UkNk0T##$@{eU<5<2wbPui>Q z*htXv^p-Ck!v6@W2bNqh(tq z>>h7-9#64slpR*5*Yr3JCR&iT@#@`cE?u@>-XS|!EYmZkcN+0ZN zAKnskQsu6B&EqbujL$Jr-SYMq<}EoTN4%;secD?RhrO>`WbRt$_xARIbzeF*96ZW# zs!7hr+~)1BUP&!M!)$fF*}tgFX}gyhtY113OVmHrSBfU22833>T`piZ{9uc;dHq@~ zt`9}BKFRMM&d{<3(pZKATO9MpZo56QiEC<}^`Q^@;pc%qrA5rJj&XU6(liSj|VdUiADvSD5BdklHP)Pl4P7=F9r}tlw0@W zJzyEL)cx5?MM=NmW7c9j+>xf+;o7&=ZET_@uYnB8bZ9R2O-=Zg=cGYj=foI@KM`jB zwOX0O*(P6V=2{UrUh9T?brXF$I*i*2j=?CY%-0oJnHRdYEOlUuyRU?Dwlb%yxU{@25AMEGxJg^?Kvp(Z5&UJ1{Dcc7-QyciA18kB?VfdX^)s zaKHC_&dYbFZr$kgkLx*meNea4Kt zOTNwkmyE~AS7u1_EaQ$sVg+ZFs5otEYL?DzeCsK1$8{}f?m6`et*L-ueGSi|Qd+7= zXnlu@er=U(k-gR)&jQ6wT(k+VvW$yP&qlJW>fig$m^M-i1}5v%_*f`9y~G>|je-=r zA26UuvHz=AucD;3kx+!|#Ffn|*48fwsJ9QnZ~4)#Cx;AxOP>ibzAb2AV4$nV65rX` zd6<#+_{iNYUeqUmmh7f-4{~`|wXE2w5taN9lZBWM7GEmV*8d?TQm#Q>7EOh@a}zCX z-f=r$KlSsALfx>SJemE+5v3^Q6z+?YYWfmQX_&a0_*|1+eYfJHEJaC4QHDXm>=2jy zH7CC-RR{bnoC7)ZI*#+8`)SF3-tA*UT~tST1B;n!al-o*>+kmbb!JK~!F!hBaeSDI zuc$NBPwSY9?{PV*iGO2n{`SF&b;DJ4y+!;I;`2$%1;;B6+;cI^z;zqLROS2ZRdd#T9S`jYoXc z(@UfW68kA_kfZ13=rffa$ynj!MDu%))}bFB=HnLM;v(}o?zuefC;#4dQs)GBNW}Eo zWLnXge*%V%2lB)f=HQmib}Q;sP6w5zJs78W4D{UVh(C94F@^d!&J`M@L5x^tu$O+W zdrP>$@jneEMIyIHeH(lxv8d#JMXZ_WY~70T5OeFw=Jwg^jCkq;>*$)Kg8VS^lH_<~ zfdhnS%=bW{^!%)COk;0Wn?q1i_QzF_21qIIGqKL{6pBSItE30w9gRO)_h+nJRp+O1 z?#|YiZvupE^JQdNmHNbwLjvaj{UDz&gXSKiW$O{X83m={zb9B9+uKduo@K^Xfjo?n;Tc#VGWiwyQ%4EGc*>ORfpfOpS-zx z-8v1hFo8MUkdvxPn3A9pB{=(j%B(g&!+tU~b$kCl*N0OPVh&ql^LBhx&2rm8-#BOM znoHJPXl=5_r%z30A3nXE_j1)a-1ySIyrxtn#!U9@^4tSozKD(|O?8OcG6j|955zqX z{l-5WXDTP{>1WLTs?&gu`(9KXfoq>y!| zt#4zJj{oHCLh0G4w|n*nSkYN~Ibu@S%X(bO=HG5hbea*Ja~bWhGw*ZD72jTI@uU`) zwS1eG`_2EiECYG%Df*42gs9d2(Q8jQe1daR``tx8ud%VAJ!Zmdobg`~&H z$;p5WPB6e$$GEhPhYdsZ3`{F?ZSsj4GDKETPnC4HqSmo6KA(NHTGZ`AIk$%4o{ zM|v0{A&2^0K{VUg#Z#Q}Ypn8tv}avs99>i|12+2pIwI2XrL2J&(vt4pCv2f5uD{iP z&%m2Qy6L@x{bJ0~^>-$`RV76hRhHJyMpK*`Z1h6}(rMN)O2#KSnTHkM>&cr(dLYHRTj^T>NMYv|CArp z?3oL-pkRhAAM0?3=Eyehfb{K-?#w~S9jZmInmT*kCx!)E;N0m7I7ubpCAt$W~(JNa^lNeqGA!Q%;?CdMtIyCs&<^zSz$RYjQcx;r_oxCZOMjgpN?9(l^r1hGv~jMFao{YjIA~;&yxvkfOn()t`_q^T z^FI0qMd`g*kT+*f`w!;48Q>N=Ii6(k<^^q|9RTq za2cOrt51;GlfHjeSTk#wqiTis6jW<%O&av<&#WY$Z}Y(!F~6L*~Ue z_R4(h{ef zw{PFxyK^TQK~(5Ei>lt_&|zW1SAF~Tldx{2Jp=IA0To8JQye*PsnD(Yva#|L{YRTO zU?=6F&zx~T3?*lKSj@*~a=hXFu~QW{EO{>if8Lk;A>DvJV^*L3d^|fyh|N&7MzA@U zo4nI^RR~+#{8x=0D|@$0Kc@zB7Prax>mmDxZB2Txi`9nFML^v|R@7_B^5t|m71dLx z{&cD^xi~aweR+w%$_}-4aP@p)^eXB3)*kcMDXF~(9#D<{vJpK1KVI3@unH9`@9_<@-*lO9&Qwjcu8SxQTd_rB zqqm)S>U~kZd;PX;S9EWhMPv6G{Z_YPoa2W4j`Y(9fAo@M=N|}}$^KI1RbOdAx2H~m zU<7`sEh7DC_js3h^1$nFVJJOXw^ypyT-nKfQO=Vm&~faZYQeN|iTZB&2JggSgmzi3 z*E2_q=9bao9XPp1r@43ipMtS-dfs@KyGG6Xw63?s`n{&3%}WEjQLCTG)JkMf*Lor_UadGU-R6md3Fe{+evx5|e; z5xSn*@zt5W38vuR{-@wuRqbimdVdVgT#9!Sw{0d}h)U7PjNT{1`&uO(=3O3547WzB zygAtj$KBsrGFJZXXrk`qvsDLvFHL3)RWoPzhltr*GOSHHn#N=JzuHoi3hqqY6O1>p zJP(eX^#bXR&jRtbU%$M(n_9bDD5uS3%1$^c(QxcB=-F#zyPDqYVYQ2y0WX+TYrpJCWOKR?{milpEn^R-a%P zvi&rP0xiutPJ0Driiv0S&-V%!i7JUqIo7`ar#qM0o{^hrBcR)o{dDp0=Xh-~J2klM z_;w*LJ6z4I30HDB&wE1kaJk!%G>ykuGqejG4QR=J;<758mz zqH3D|=q!mt42ARdh1XB?R#>h&sK1&H`a_qH#Y3MXg*kJnlb@1D;#?}4`qn#7G=Kdo zxxd##T&FQ)e5PrJcWPU9*p7z02{Bz4T>&AJRvnritvuLqJcAZzl-O+MpyJY2FQsa~ zzw15jViE5)@M)#z%s}E+%PaIT9byre-kwkoV%4>$#wtnK(}QeVkQlMp2sDVjxZg69 zcf7WNrW3QZWl5Y(T~KRfPO!!N<*4Q?izsMn#ySkj4d)DFl4Xx#sOp6a;RCc}D|ENm zI=mS!nje~)AD|o+@`qyYchLocX5-xV6Q!U(vo*~&Y>ehj-nqg)PV@z@_G*3S*H>tb zuHo{IvajRREfx!8+eKAuORjmyQa|Ob)Ija&_pF?ZEGS}%Cu*U$TEgkA*yVwa_`mM9 z(p1~+C*7`!YNuZQYh>MKy0_c9IB!KsBu~ov!xhTSdbCEr+4GnzVG579| zjTdr?sp&iypONiHh~}iPmJ@L!k(;kJ)ZOY_Ox}=2P)n}poxS>AdD^l?;?KJ_=&Q^q z6!2_&(K_9=otRSZi!AmUe*|A2P#-Gj{`h{Vyum{$Cm2Sqx0p32I z(Uk!to)rIh8edFbTl)O-f4Ym#2ZUyc&z$U!h_i}!H5p#D{NMs+7y5lwurNHIUnW(J zw>+)8$8>)`GE#Vk*pmK_j~Y$!kA5F3naU$cE}6N#5x&$w{Dk5`#TW|t1J-oWatA|t zR)<1RgFx|eZ{@^hz3H)ntkN}d*C*Pwn_oyMS3SsA`)QJcs@4R|IB9<+j<)m&VeIoldiwS7mFO>l#$f&k787uyO0KI8)62iG!tf zvdZjYGJob_=KbGCmvI>#VzHpAwUqTco2m(Vz5E1dLrm@ZxdSZ@_43RRJClyh&0%3t zclf<(hTN^Lu2PIH9Eoi_5EA8@!#+J&K7Tx7xr2KWtm5=#HQ$!bTX|{Q(DY;HUzU3- zFLhkUPS$m@GQK$|C_=zkA^v2GH&r<@n$9M<@kvY+4-2b*QYan_e zA~#h=-k#e;rJ~t>=X(RT3YNUo44Vdt5FV+xA(oQQci!lKuG#EgI?;M**YiGlOg#DZ2JNmZpg{na9s8Hsoe5v9+@&2^=%9$@#R{g3q z^Ofw{Bf$@ZEUf6!p|?t?{sCDz%P17p*2Z<4;=WGuk65%F6UkU-KfUYWeN%)E83N`7 z3T&JEE8Ua>3p@2W!d@Kb-_JbWZM>g`I#Ntky9+&-dX+qgmp$md|NcOf6ac&PBAwZ@ z+|fO$qcT{Tal^pQ@sD7+*i^&33**}kH}>T2wC6tZw#T{5;T7?0?7s>Hue}+XNM)ak zd7gITjAuq@Wx#WmJZaiffta>X+CN?S9NvBG=0mncy%90(>Mh=FA&s~jgLSZ?1}S?m z7mk-m{3Vgxh$tD!DGgoMLHow2&2MNfjwbGI{`d-}*ILhxyMA5iL`$^to@uW=*0$W+ zCKunGLTOn0GersyX8kg)QxqaPSliwj`%F_kXw>%N?caEx8Mb)yb;+N&?6vd+{I5+IMbf+iOPW%3 zUzj~!vac+!H;r+o`Ek~2haBl!DakuIKg<IUK1ARNH7^6==I(Ak$mRT?qCg(>X|NFa0N=^{|;o7UQn&N(v%tL%*swz zZ7cm&gJ6LD`Pjy@U!<%ba5?RMvqng-zxr+dJ9&s~4c;8DuFoRpTQ*Elqb1zZDBHHJ zR#V|s<)&R0ja~;omkkf?8}H)28qhS<+8X&OpS^#IL;GsG$gaM`tYBl^?qBP#J3VNO zsj7|JPQx?qY`rpf;o&Nu`AY>lND@AMP7fOHCfm+qwdcPl_AX0arF!%isp{TeOYN=) zTQGD_EcmO#T5cS#z3TUF)%eT0PIfRE78#XzL{)dUceups z7zb#;w5XQRzszxd@Ec4Ki;awx-u1pLCUpETg>pm|0ZUE4%ATH<+*@Xi6RE5L{nds1 zcGO>Q`RY!~zR$CCr5i3h2^PQt3$LU5q+F_!RATPcKhr%G*LC*9*f z)k@XMC>R@;s`BH>a?3t-r-*r_Kxbbj{0SZ`2;Vc2(Gg5>U>3Z zcacC@Lbzt6%v$=!%?Fy7(Mx@K{AEskOk=dywtTk_wx+U7a^CbUjoz~x^Iiy~6@8%2 ziDx;Te-wd(p?=@NxJqEl?-elCasU8x(~n9cLfopc%apnLkeKGR*8IZH{61!|G>X&$Dr4KPjwomy_hs_OIgz$(Ff8)>lVHM7# zqY1wEaBJ__u&(z4N1%*l4Go$I?l63eLm8fzOBO*L7 zvvVz5HUH~r)1fb$qcV@Rsm5mp_*c5>h-W1_uDWD7XZ>(f{@9-bA|~e|&UBGyV=ao_ z`tMKanzglKCS>id4_2%_(6W@idtQM!;IxVD5#@{F#*S_$kj8AQ!bf3L{WzkUku7wTaO2VQmGS}=9x zc_V*F)FruH@x(R#<2xGaJ*H7BP&{t;UTidfhDjUH@nszn&3pUA3eiH&Zuc4K`uy?4 z0nuv-W=>AxA&571{?}6=n8SWZAdz!dOh;n_P0tuo>oX_Ie%O;I z%ACc^sDl=5s%gHrd>tq5p9>1NoSvxWiz*O4hLEtKBB!k?ZWrWDaU0fuNZg=ltkJ-b)5E`aE(CBm7797?d60a?>_}j_}wMu z)Bh!((T7nO#E{1P7n7^UUA~?U@Q6-vKrq?3DhLm%|Do|Y)snm{rw_(*?dqHAa0}4vN;{c%K~k{ifNh1yuB!Jo6+7zA)n^(oR%OVbF+ca4g=;+U z=1&tf-*c9J;^jNmD~hRA+SwV;@0FAoKaf#W5P|8Jclf9M`}q@!A87&lpV!e{|61;!KmY&vQmMRd^K*=j#LbH+=ZuV^F=+4@ z$`-S$O6Mep99K~ciTF6NGuax`{bow1WoRS4s0ym51IdN4}>kGtV$){G3@ zUptQ~Q=!!uvFdb?s9xlb<*}oj5mYt$?8Nb&|CX7QRNsoTaBs9?7@xkrKH(z)>*EVneQU^HoH=z$2|8Q} zC;ZGH8xe@n)4S55`tpHUnXD`?Pk!r7+p*EcY8`k^kCG-wRt+a}T2h0e^xSiBFr&JJ1G8yYKXU;)J#6)%py%yk}e+TiO3g7CcSkx{&E$yZxe zvtO$d0#}&)1A2p_YA24?u_3~301E`gnq-;R@MEmu%R6?3iz*apJLv(pS{?_cDnVj{ zJh8L58X^0Z6z=1uY8OS=XX~smQOCT_MTCao)ZfGV?}0I4fb5WL$Efiin~7SesIiA$ zb3Q0PKOe-i)Cj=+r6nb@L5+opAD?Z&g}=WxFT(KOOBSAmO_=?6Wz5Z9tX65u-wAhC zw@0IITLrhz9G=nCUG_lTBKh8Y){RwxY8%)DFNWXT?Lob}Dlmz!VO3zqmzm>lPTpxO zqwv|HfT%Gra|W06a6y0g%OCEXZzr}j4|z7~%()G1(x%?|$+^v9I=dI+dW+<@;IYPH zqB=LXesSPadV7sDsgChWYk5*sH^^&G$I(4JKe^B7_RVoUB43r%VkEu?$DPM9sT-cU zzB*rGef8}dcpB8Z9?|h~yTYd`3i-z>6Rx$<=J_Om~phM`?HI&p>oM@r^#Rr8e^je!xHKhWtrxj%P7I%i~ey7@_(u< z`tDD8-HS3uzI{t!T@?Ga@~&Wz7C#GxXVK4WXyM(|zc3`f5Xny7`Zu8cd7aqH8nYmL zEz;&+OnLrqsb5Y*$L0>|w0Kp@L2rU>y@;H}&428A{DcyUqr{Y6=sIon&9HveqAI!Q z0tOyyON-o}&Frao$WYVJ_AGn+|GH|g@TM@Vvo`hrVq&{iHI2C4oA`vW6_t~Xzf&6i z2q@gqFp+89FhVup*egwyiwPEZoIMU{-x=${*m$V2IwU>gdby}e_gs6 zDud{9g@G>>Q;l;NYK_~c5^Xa1Xtd$ElR4cw?l7$&(nzZ4bIqZ3aS&l9r=}hpGa3CI z%X?^su}P+Ow{U9yrTFp84iq@$CJ)JbHUD z1H8s>eRV6o35llOtzY+fAU;_gy)EQ;)u9UpN`s1rV4yPOr zJg&VU&WgbJ+9Qts3_wGG~RvO?bml%t~2Yw58 za>6bzo?0fjZt#5#GB?v}uYV(ZI(K^D-n`@Dmpz205p^f!GHsVo+f$D`qIt zv#pcTp-xI(-`_aeR~67^iT^~31MdQXMxlyG$Ck5Kb#cSjnzrDp&bG8YTe)F3c7Awx z_;1jv#Qfk)iRTua508PLf$>qHp7XkOoF%J*LX%tqyN@JGbcgo(WlB>hdy7uE*p4Zk z-3a!8XiqNZQ+cWFwB!=ER914pVt4+WVyE7C@&tpKsjt^u=6F@294RB3A*pd%yYTP7 ze<9i@sFkUin8dbU>t1VX0hwR4@`J=S29-A3O8*1e<-ZvMe#~iayM})g?VWu0?p-y6 zLmvD3KI7BPJu(RD{|9<)qPl;T2B(nawM$U9xm(oQxMoZ;8yy!$*#M=+8a#k00tl z=Mb=!+c$bdpP5+0%1Ritb&m&oyPRhqO<-I`r=w?`=CNbPsG4cf*eZ6@W2P}VqVj2O4(XZxfT3?K^cJP;Q{IKrWB__>7J-Hrnv;-%)l&wOQMg%czIOD1~3Z35pV zpnZSOu3b(ETK)Sjn6~Xe@BXe<)AAr`_d@WdpdGUz;>7ZpgC?MTg-DsKi!Hfn_6i8k z`C+@F<_sZ%cl&PVKq-ezZ8kMEK~2q03-|Px|Ct@Iwl>7fGrVsK&#gQZfVelM;N^ah~`54uqsnI@{gz)~qlr`%<><|}k+4oD}qetBv%fHmeJ*q2! zJXAb(2ejja;$6kmn-^-)vo;8a(rvnB=0G_e_UV_(F$TkN>P{i3x#&>96F%_>vlR*l zs=Y2m*|bfLVm+=b+ZP7rbldV=SvR-BWotQ}2k5(L;w#v!a^h%^LhJZ*NRhqQ*@`8E z0Q}p2DI6N+-hbC`{SFD!+d_#CY$6M;VLr4Z$Izy=IEB+$N$KyKw{H3Q`x|8*6ye&V z5Uh0e?1SScPWa)Ap|w7(As4cSB}ey>_3QlS@Xe>tCRj0 z%D>?v^thPNTCnuRKuI%ZRS<6Iz7ZB_;T4dAGmrNuhCnp*)>Cip>ImG=YpABjw<0kXQ|MQ2#!tr9bxZ@eu`1`c?KP zJBf!hQTW111V>mjY$m!ph~5;D&c(W~G+0crUf(r1Y**U&N9DV$*(!WiH_xFVRyk4-YanFR z-fG%va>G($w|wAp)GEaYv(zLQycP}v9}Ok`r+BK%vq%8I%} z`KDPd_Op{VG4>RXvH(1mf%>@ab2YUO@yGmvf(o7|WEcr^EcRMC*P3@gY93qJI@gDd zSN%z1xhIq&aod4AoAs)p)?7YJ4$il09oSk6K6_z{&2~MQ=s~9p)o3wAY5Y@fZ?0NPm*xym(;w;|A>Up%C*#5+8}N4dU=FU3#YJDgY&Ih`?j> ztNL(BmOFXdmZo`jYjuBnyVdG59xq?FZmt~>ibbpY<@P<4@JmR1lE}%!0KWfD?3S~{ zY(htd*UHLjEf$eZOQxYElAPA5nHf4H&uiiFh$<<`XCV@plnTk;KrOXKA@L>UYa=>i9rkU+r&Z>ict-HS3~u8+wde1SsQ!vL!Acf zhe=9G&>IR*{kcEz7(5;kCVx!W!v7hTB3U9l0t#$AEG#U zhU407t0d7>NYzLVRhg`-G@3Zu+F2-_wMOZG=wn$` zwvORUX~iIcR9*S=aqtOKj-vVOk_~|KSI^>o;t+fZP=qw z51sUc6MQ@zvvzhVH*eqHbl@BL~!W@eKh3uFLVp3GnHj@nF% z7Q2D^ee_=_Iu0@qwp>)FmRD5R&**Iz5ush-FT_y60r1=-gXjCbvi7m@x)N(+9GJVT zoMxG4ME;PG8F-{9RYODqWy7RgCGH+yL5_wLn_@Y17vc51XOGYuRl zv3t?%g~p8%u`$nsm3^MCDAfB10uvE|K)Tb>^uQ3&?nCTD)RwSmTMim)o@psIQL{`x zJq))*bUq+WKU#=W%t%nfJkPo>4dY^4po`C=`k+R@pOG4Ky z7}bOlt z0cT&g(ckl1D~Q@MAkPXMrrnUg+lhl=DiMI~EUvaxXhI9BQ&af~E^(g<3f}a1P9%I8c^Pwo2s9-ugHdwyj&urGDM80X^!61fH8dAZG>Qgkla~ zp44eBJoVX!KT$YU7Ie{*ka*1+RfOWfN$fY|3@Wm1x)BA$;+aExQuIy<)}#DIWOo?E zzsF*v=g_Eln(vj80jzZjf=EH2|}QKi(P8^3oW(wkj8DW9>{6o(h`!l8ubFKJDAmH`JO_ zw`P;f$&>p81yx~l>^{sT07!@>35b|MWw(!X5*~CA+s-hzY14qC22LcgY(~Qp;(}x} zB%KGnZxZ{mHW(qe{L7(gF$$bn5ofy%x(mhZK8KTc04YmXS#4MH4HjoX|G4~x_xS#j znZHlGsNKStm=LZK(F&IS_Id-^AqeX>vavXZ@D!nI8!#GJ&B(sPYKAsb_F-P}QQ&hTHG9G@wF@N;n7dPcU?YDbD`u z|0MYWVsR2hyt%&_N6O11JjKVx646>+F2b|DIF$TFv#Cg^upz`uu}IFK=2g?tNx&S; z-rs&Zx=wobMOiL(o!2(e+I%T&EBKt8U_%{|<9_&L&f^UlA(bt8j>#>Uy1FK~_~y{@ zhd9&D{ZRo6BI|eW4s>~PgC8WIE|?fTj42BbzgclWMpib+9C33L61NPi4n49X#Ol6@ z64Rc1YupWM+L_vTq-=%5GW6!+5{*M`d6LTny}m{&caKDV`S$V6!eIC* z9`-N@;1x2b&FR&Kkq~2^H9QFv-sY#nTL2@{evLX~YGt`rpSp9e=@L;+#-ZM2ICJnv z`9|q)`4B(ng}pM-0QGx_mbWbQf)Ue26*wW&0vsfWcrd{KGuFo_$h`Yvur#EOaH35< zzW$3Z@f|EiJ!Ak0u%Tce^MXI)d1@47<1gHn;$%sZ`6cZcA@C^l4n6K76IBk$9D&=H zZlB~FPC@vM!AIMfz^&%oE?*A$9H^H(4f%3d)7qx>cvj?G7Iq5-|B7ARy6r>bwF|u6su!K+Xk(AOcfxK5qvYIv9IT^ zj5B*Es*c`+6?u03&yY(HR_ENlP?!1~TjKzR0L7y;1sVREk`i+mv)-8=a%{y0eJ|Zs zDBF5is5fAfQhxB_2aSE_l$63v>!SNRU)@p|MU%kPfBE(U{~nnwwTG_tzjJOobh-Zn zPn+($x>#pZ2?@2DFEx>#-rUkdf*mQl7?2JY1jBOLo7`_K&ydcU;^>iYnTwBx7&nMv zqZuh+#~d z?uGJVxwY|0&Eeu}UfYVFd3TdI4k1pNYmp&|7}8Da%KHvOP1C1p7hs5ef1vPomLO;C z?d^?m6s1JOD`q(8M&`CaIS61#0wR?lTguU%t-@EHkRyVoauWP%B8jYe3jc21l{<8hR_WgKy9>AuK$K_(he(q6vb}Y+ zwZT+9j_yVeqZcQ>))KuD4-X2Fv%hk{G9=Phas#YccejE1Q@eaA#2DDEpP@-^X7!g{Z!!%%n^!$_}l<5k}vFU1zTHDO+FfEZgmn%w3 zYdusMCh3yNoT_p+t9^dj(mg!H-#;4LHBC1c8L9X>3Y9m~o*XvNA-_6H$$p32w?hBm zKwDnc@#DwGpz$ZJ_CY7*(jC!F@G;P_45DRSY5J)8W&|R8G+-|YxL7~|CqroB!M%Hj z`|{GR_M92-uPc$5K^w9%EJw6L2o>vc9>_xj@=H5l9i#b>FNRb|Y5tI95im+q1ao}d z-aLmL8>niK>qy3}iQ9sStz09Uq?K_dNW`k~ z?`6lcY(%^)k)&DRoFQ!0p5WN-B#RiJQI^~FIV^L)D)P7q7kjx&rZ>CG7@ejFPOo~P zVq?YYq@MtTi?#gMRqZ&oYw#V?r?zGEgsw6qKLAPdmI!)DZaZ-wlIzoTVN6mJz}$>E z!b64M6=Y$dNd6*L{I{>~N4r90`ReoClh$i2_>kM7@``U~%q1h-GG5MPO@?rz)couyK^>e1 zlilayaTvR69oo)IyECtkenE6m+R>qpIDzCeM4$Tfqur$3;JXvqMxth#j7s#`nmu9H z7p&7U+3t4#{hH6>RAL5DlF@){c1tJJ!xw-vfZcx}10_Wc@{>>R*3(r5JaBf&$6U)L zah}_C?4f8@c=%BgRS{Zb1Q6ypVFYc1I5zo>(c$N0ufR%{>PTPvdSPmE@?BMxB6R5w z(zZ!lQz~Lk$1hvQm4Hcj$;r-JgqLM{VvrZOQcPx_%pDBeTvs9J04y58bPyK@JAv|l zK~OeYz78=w5fPvY{fpR%nrGKGJG9zJAU}aiu1hs66C}oB(V1%(KL=wXMn%*J%v z2UQrU_ou6O32tFK$XRues>Y#q1Xie=ya!81Mcj!T>Cg!mH#axu$u3XO@(xYPgRtFb>o~l@d(<+03F11~QKXMzhNF`dw&kj| zYa4LpDpGJUpTsw}0O*332ZxLYOaL*8VGdL&c23R%_;`1Zdr=}%8dqp>98=u!$ASZZ zIWl@uV-s@75w6;(LB4ycdC&p)p*jh}T0DB_$wf(s*UkYNtHtA~NGqHjkrU`Nxy>!9 z7PSAs<^C;PLR)BrEd~oCR-uV}W@q6#X0bmIs^ssGxxPGr-<74~G?g9>XDeF#; zDG9GM4&f^%OxF?kXUmr7_!MVox{e`rqs*_x>m=`r=GoH;n0ngx?i%)I_=72IoYA{l zY%ka!xLU7ZW`b{80^NPGYdH)`5JUL#yI+tS+j^(Od}HXrGx=1#2|=jGi$o3H&wnS` z)UrNY3ybqhG&~sB^{>Z}&w_wFgN%q{k6&gMY(!nD_a2%+<{arKDIOpv`_WzBe~&lm z1uIFFUpn=-7vydKXcQ-}^du?2HpAD@ly&13jrO~j59oZ&oI1hQdDR9{G#$*4HLx}P z8_img;_5l|u)+M&a-WwvfBb8YAUt%NO$nz$!`bfcZqyZd7Q~Nt_3gr5g!NQ}k%a@CqT8*z8I09EGSS&iN>W+UeiW@SXm*LE)aO^s6Yt|7lQQ zvl^Zo$+k{(anFDtG$as|ypX%d-}=~#fdh1s9R7doJsB3xc8q}RHSh1gA4}9yn;lR1 z6KJ_v>EnGI%um;aOxsaBrnB&kDxBaK#CTYm2>cNXtFwdM(nAzge zGUz}mvb}+*W8o2<0pSy0M+XT#02Uw(Gy$ZAD2t%vnq6eq^^S@piK-6~_z#hm)ZCZ~ zsRa>C1??|UzLd|%#m7r|lRuX~6$nHWuIDyoh%%5B`7?MR>0^%LH*YQ`1D<9rnTd5m z1|i+!#9LD1lWM`)gnGagX49d^qbquu8)&*tj}huCxYmXkMedlH zLlf3(4B>IqVA7N@6^?YD0FF-^1Y+caqBrYbSN0XOXcjDhT*?T8Awt`|bLTr4m32~+ z;qA`!1EW)FP`5O!5bH?Hkm3#Z(W-1@JXQyK_I*4~WQ(u33vN7pMPPf2>c> zwY9zYZ$w&f-gUW0>CvS>SgI*%_msP8zjXtw%2TB#43OLz4;N*>()@`xoAvh|K3r?j za}I9(s;w;wYlA5R!j&CxUw+`@1Uy4m%7LZahniG3K_5|rYJfqy#5r9|uwG2$r;Q)> zxc{liIIIB}n|+5XqrX8z-@e5=e>O3kg|wzC6ck>3m5wI#}2u(8&jhHHh#Z0m!#W5|8rIWFIW$tU9dq zH182^fxxdHHFbg{LuWjMYVQBGs;bK1Whzn_t`fv7LqB5{O6*}hmqDSlg4`OJZ-A^P zK6n@KY(?FI0A)ZL$q6MT6!`sUgj^wY>#i^AJWeKI{wXd7sQ7W@+UE$*)@9n2vYM}o z28bArI?8!bcQ|>wh4>UHwg6V5yyumvrLGifu>Ty4F?)K|MALFEZ4Z;l1kGx4X|Qq6 z@NhCN?x%GiJwdc_rmU(;1K_=6VT?X8%|*sZIytphjQKn#zJvlhj<7dZ=S-N>0a$RTZ{uhs$1^N z(Xc?2Sb+faeOsPGu}&d^)krnsFj<_0D20laDp0b9Or^whuHsQdBN+}>QsJ~20ZTWc z%1c%e1zP-<39LKm?@#yGcsGL9jzq5n<4!fa4;Qlw@V~&7rzi>zX{#H`@AzYiR>V|8 z>auU#4d*!y&pJ`Rs9how5slH_8YJ043+O4BtO- zcTEi%+o<@xm?`hy&lcm*Wti6Owk1(676t@v2S@cZ61Aeo~q@RiC-Udh(6cos{4P%ex4&~AT7*?Dc zF8+$vJ$ljnTrxa=EKXuSqM1hb`5Apzluig1i|8^E!DMa%h(s&Ee@-AiIA=N3AT>}_ z2CxzQmND3}2hM#oqq3~54k%CT($$-ewB>cXA~i2=ZOQh*WSkx_ffUQ!{@o~YHgvmc z4JYPz)ew=KR+^DlQtki`f%;HvN+uI_L-%V5bT@c>`Ddy# zP0O&Cub4E zK#K0x;-PJ^xf&ubSOW%v_-*a&6Sv=4(xGk?j%Si&J0)%mP^ux_RAn?5CC57R!6QTG z$46i}k;(k+G=~aXJ?Z@eT5V1sKL8UbOEzTN7$6iX>)F=5zr^0RzQDyXVA$eqK9Qh) z@j?lTE-L5GKVfHGi_VSYA|{ncS?BinYj4C5wUj3a#He`kX3gnwmf2m)5G!k=bXCXc z*a|UP1>zi?d!HKDqf2E}%B$~FclQqD6{zO!1=brZZTDFz%i{Ii>}+r^iJR6*eDx4@ zgdHEKj<_{cz|eyeIRhAx#EInUwm$H6aWL%DNP6v2UV*WQ14iFVH*)3lvN2#H?%#PD z*=nPjhHj6bTZItqGdO%2@HfNEgN}|>=*2BU5n=ynOtn6&GdFHMfjwOxtGr{BgBqHj zFTpuGVJtK;u0h&pyRJ4d-=E2_YB>V|@0^{|G=k^h=(BCv^3G)?#czPbbZw*a4U0U? z_6rE8K*y=HwDfxcJG>S+fbM#mwEEq9&uZvtruz!(WRh9U6xOHz_d%JRg0!H!lTLPHL6H_f zq%77P(inkkSsoR_xZ@vC^d!cB!0Xo`m#qyhYf>fv_?!WdfYcL_Wsm|SDdE5=qjrTF z?)f~&;YQfNaYoU+E^6v3Fx0Huj)d^`7J8)OJZn5t0$8j*|%(*K zV0C^BY``4wjz$0|$-vKXM2HJ*B-RulD7F`=-jg^6p)w4bVY?#w7ueRXk3i$d5lI@} zF!0x&P^DzO0)o^L<3rvIh=i3(;h*!7yrFYI+0q?{^$M3Bq3McyxA3lfD zzcO~iv&cp97i}n%`LWY~98-<7|Jr$Mv>mP_5}CGbYgt*@nw4Uqrb{-|!7n{Kxf;tF zj|i4rmCzxQg}8dn;=$ZDmZvznhmzS})sBE><1RSe%O%mR)PQeZQEh;=Z@qhjbC_RD zOpE*a*Beg5zJk{$tpi-Lk_3i2av31|H%x2NnSftVK@p0HqS(`_Zp5Aq2yMnktEBT1 zgeu#!tiq-wz=uo1Zri!`0+$Svn(dNPpB|C!iX0pWF$Km#2gznaLGknTIH<wy$28MR!MSPJX7Mb76ox$ zLw`^3(RGgs9sg6NWf0Me)?a`9rC_{Hz706-vP`3L*(_~`uZQ}? z<(ND1l4V`?ZJ9-#=SYr>QecfJDNAqrS(Yw44^c)GV6B)hTA;+t%PVJGdCk(#} zcEAZ6;efqD$YL?bK%$KXzI9v@v4yTP1JGy`Xo+?odB2C)fH7jh z9P$cUf3F!St*AIKo*}&WZyDZiXzWl!A}?Ixg?Xp45%g!o3pfYq2F1PUtM9Aq3ey%3cILvi|F5M}sxH?dB`x@89optgcbHFmjx7p!8oB+x`TNL1eq3U-8^&lY_w80HLd)nE=fnBqRJ4#mxu% z(^4q{}0~Y1FFii>lOtI_LgWA1dK661p(-oa$Am4^z@#WJVA|Nfg!e*nY3Agln6 z9~cks0K`#RNvU{x|B4d}bhx*<>i}vYslwaWdY#r*yN?P17l^+`oH3Wa%%TZNs29*W zx<{NGbc#!RLwCiAF6C0Ks_zq6ffg5Z_b=|6ePthn~g&)zMUR%oklR(}CUDCecud2I1tqXY$tUzfzkK1uOl4apI z^$Qm-GJ(3N;#dY@HWDvOI4xMoiIstX1e}6Z2<-1Kkrqcww*{yq!yPWi&P2|IFga&7?U z#_yV--#~ujMYf*XcH)Mpf0xNfue}s==|3qi1gxf-7j6E|`R*6eo%cu5uS5N{yA=A& zc>ASSjk}*wEV;&`c*7&(sKcPkJFMTSe*%$Nzcz!I>x_DuN+4#X)C&}JKOU03Lj_&0 zNy-t4oe>3{i5OkWu~OoYcTn2HrGA?`!k>+adxVFEi2q)%?~!Z&`EG!`TNa=_3~O=} zGp;OMQts!jlXg(id>C0B#-WW~65&8%7EQmCfH82l#L=i5O+ght zho9!ki5@FpsZDU{R(qrKe=rRJYwEjvYH$ymXzxu^KV(v12~xvLHSvCD<{VM3dJJ1P zCQ_8pALrN$A-W)%De*MK!^lDuasf!AiZ)-p6%@pLsDW63rt2UUd=RUWL4r-5n4^jH z>OQ;l;eLo~G)|eKXdGQq3fY$Bb`>5Mw7B(4JR}bJaB=gZjH~mF^+NGMbjR~# z6YHn44&`&o^xEYPDQR@)xl5=zA5PAiCyF{W7Jb%ca}zyw9H}>;#X$bLZz+FvOz2-w zju>@j-Ix`4!Rm|3l~;f_1(GMWoz9D8`j15t6Yk&Yu2@S}C8oTgP@l}kjYToKSx3BU z=9_CtrExk)SkBqR#b|P7YjGPMc+;UPb=$v( zyK;{8@#U5AI{tq^>czVVNtkugC--kNCH=u2;tY|p6+imsb62&hoe~PDFA4`;hR)Y^ zsXA^4JKK_l3zcyIljsMqY*c3FtET7_&BKS=h1-PgnSh#man`I^MAgE#jyE&AYs&p< z;cW5b;@Z3#zT}ZjGF=-(q=$mOsInmb`p@C_rE_lrG6K3fKKmj@Q$7 ziZzxVGk)U0A@Z@UaX4w+^as;G-FZ)qKgyI0Hku`ML!R+q>Fj7DdgjQ4c{jNRB*ua$ zPQtqFJa^7eAo_yyuU1xz4O`IuY5Ux=5(p*Z@-C}aiKgUr^S0FYvwe*Qr{%l{62dk^ z=>68XDz4)tgRxc&g&?oVtlCPTbXL?=ef{|Sr$t<0U({sHvjSBs?S98Q)UuOeQ|@0< zGN{5<|LRq@T4pN2d8nK}jJ5rf2-sr1<70c|K0lSkeprG3UifRee-YQ@g9hhJ9j!Jy zKkl_{T0=^Nl%{LRJ=KcFq3NQz48|H!VoFpJ%`B^K+?rG#OkMk>_v-g`bgs zg`ch;5oB)o7e+fAz53fB9}OUe&^gE6LhS=j{{17~`wnOOypBDRJQ(ILGewO_Hc&l@|0&3Q=wgKXim$NZ1?yJENnG!BhH67q z$JKIGHj557l0azoVwSdC?7q3wAyh^3$AZ!B`nbP}ju|?+rM#BO6?XA`XzN}bqmuu1 zXnXR-jX^#F>-?(H?!VaKxF$9uh&zAvt`%6D4&fhA)i#n?8; z(sZ5HW;Kxokok5lFn;r?vtc;c^NXsLG<~r%B1LXQuMb~bemob&2+xLte zsED|{s=wfnJ)R&E45&)-T^x_r!J^2?^i=sm9rCBCk|J$;<9%g@+(fco{uh#(ER^u$& zlK3a9b^dS6(+&eLPI#i$3cl|Uj06b>%FD|`A}l$xZT_jWj>VATg3()_r}HYS)?G>P z=PTuynJ06&b~)k*gy{BUc+?#J>`l0J|SsK{a&cZ z*gD|f!(#6|%ZyWe@N86KJdeCD;d-V-%5m}r*z0@zQ~qS)fV=NLyy(Bh@w>ig=YN!x zu)UuDvP)`P_si~2(-{%JJUW2T!J-D&C=GwD?IOVP#)>}eTEgW@tqx-@w!=#>6q1Sx z3x%O`6Cr34<-D00()H=t98MBRLYWzvka72J)xJP+`v3qj=qFfO^y^4cwIxxxf zoslW9s48I5D1XTHje&C)y1^7o{vDA0R#i^?kFE;?i`0I=^+e|2dL#l&qT@XoH%C;+ zshs4#C5*&+2{AKNX_M+2tJD;;<~yRm>P0>%S%N;S%vuv zJWbGLZ5-@B`-v$$7#wSi7ys`|S}}7;B%BU^Kw>=TUTvG^6-4lZY=Jbi`oq5D+C+oT zQuD+B8m$_5UDRgM**G12zj9J=?_hTJUzQdgsS}NLDhXN|S{M1^VUM9`^ej&CFrQMO z$UAa`nv>FhYBEN1C!d3@(ASQGep8ZojQUY2&PmXl_z7c+0DlwKSb z_)8d`RKfWj*Z|)x1f<(M894riN*-D4SJK=oBh5luc;fsNF(wr3nYWvky`sxg(b}He zhO_J553xql^h>yVgB||bV*TDyrp*}-=vq>&U+*;Ro6vjYux-SC4b`eORvk88*I zrn9DNnvVpL`1<_BElXO{x3JMzapCrBMB4_F%eba7T}{Uh&Km8r-r-zB$W(1zy1vxi zL840A)~e?DJXb!kU`=*9vlWD@RLkeI|Jo5QI_dm=;};Jlzi;B^0v^WpN2kx9n-d2> zEk$hJF=tHpiHTk`@n~$w^zP>CmQ^Vm8+my)XY6MaS#oih@oq5Y7raDmgTgX7yCbm& zDEQYd_#Oo^4sbRPWtImMVAVd0N}SQugeWbsr29+Nq<}@-8xx=TR31NnDS01!zLK-38UCa%r{rBcZCx_sYmmHRB=dJhe@?&J6J_Ip=C&a0}g8U`NQ!gK+5r3P=wreS{4zK zOfS@3vj_i#TUiYVu!T(kl1L&FPmLD*IlI$Rt*@&q>hBGEAhbOIM2iTzRD1RW3g!-8 z(>yXj*h{))O9}?Ug-F^w?(TSWb{-%6%7MC6WA=+3o*-%&W6ZvWcgxilOAWNWiCq9I zh^Sb9e0t%c_>Mwu;?aI3+746@>z1k+P;t>ZjmAo7hQ3e7@!KL0F!)M)bpo-sP&!oy zQl6I)imSm?>I@#i5>eBDxQzXjjcYt=AEvz6SbOt0PB&THQJD7fL5@mXPn5Xt zSGp3@7_ABC;rAxEld#A!Bw0Wh*f=v(QljDEVt|iq=TncjUU(GB8efK!I&rUv?F|&D z7%FBwB%`?{M6@7AIdTG8Ce)q*2YIL=%@y>jF)R=wu8}aar!7C9^r*u+ese@}b92$P z4g=NH6cWwOrS@96pWj@eDJk?&&(2%M3&xO15|qThW2BJTE@6_B4 zUqospV(AY-g&??Pb*DKIIN+W8MFz7)P*9L*eI8Q+{w2U9%a$da+^z-@V5oTF;k zD51_ho8hohv{)UWy9)Lv5jhqhH@^}&;;;~(0#*}v=@WW_n>JNqwGBc`$tN$b2kaSi z51}L(iU-*9FF`~j>CWO4=)*!1Q)Yq|g7xcf32`(VISxR@ga)WLmyG(10|;lFIft5% z+}vNG6ro}4iMsGg^5!^bz^mDH6pjQyQ(K9vQQWUlN6oiT)p}vo0u(FXTWL* zG`e$&+SG7*K5@y6 zqN}5?-nxA|iHQ4tnN@e2Gc32xy4AOawG{QyEj6JQ8}mb!e)xeMXW2IY`s>q}+Kk#o zf;nNp+4*E;bwHFr`_L@{-T~N}&ldlgwdk+0(NUA3o?3FYc!}pnu>ras?uwX8I1)sT znW&cAsRDyhHc{c(QI30-xdc5Z&)D+-l;~@_*z%PtPpB6F3_!6bb^|g9B1e-Fr&cWa z;lq`16``w*7~SA2dl!Ggp~5FB`qJFS(scqbcff#`Z-SqU_qxhV83~NSow!qt20gI= zK-Qo40N~49CNLtlIuWZ8r}mp9lgcDeb}n;SgOjfw3>;nU?3EEDj{ zAq@6MM-bI=2dfn+K2tx3&QkJY2mYvACrPq)LmhPEQYtBl%P(O4%eEOnxp15Be;Lcp}zd(rZ=SLQ$zg|!oX*9bk<0W&EKb{+m4 zV|c!+{6Xa)l?ILwJc==(wS4=~23Ccb{G=`JcR2)$M)?bsE2MSpH{tQ)^NR?%0Riw(W@aWYFRyR~ z1Y!ges-#-86l7|Gum&Dv>hULR$&c@a1AY^^Z=zZ-fo=&IX8ZHrP~ZJ?jgV-!rME$6 zsUM$44~~_Wpz)=k^){r32q zkHq068Hq)2GiN^g+Xmu`C8WODyM&BqB0Q zI8s&f(NzImAk86OY3W8;7jR$>4tTkw=m84!+kmFn#Iq$GE}5y%GFLRqYJ4Tts6^wA zS8sMD!Ma_nmr1F}th;>-xKvf33K26bUWv2C6wSD?k45XK?PHddTenyYRJ(Cnsb8f& zW*}<{96!icboo~3<69TNu?k!zfr7r*?t;+p<3)m-wrnXix1EB*RV%#;<{uO|u#S~s zFF~A4A8t8bEdS(|%l2t}1*_nQ0Jsn{eCoPWd7a+Cy0jh%nN=cV3`n zXAF|6^r^R(6f=kyPl64|E8?&W;&4D2dDaAERrVfG7gs(OAqRaIxBcL5cDB`~O&MFly<;=?e-fn~=*{086)*{J*BD{gLCW)}46 zp}RFCS;3G;7>(QUdf;R^E~%b!;NU@ZZ0xc+Kn&}M(p|bRkO&G}3>06F*YGNXY}7ZgK4J zR(|0Y4{{Tjt&Gp4l0w25#9IC(#VqCFlt#J|WxH0w^1bL%q-$Hg2d03JXXCM`_{dQ} z!F@e(nBdbuPa6CGCC=Sb7iD<5L6x8J5h#MuQ17SNn;^d!MVKi2=?#&-NWPJ=BFxTQ zqR%H)m@x`Zh?gMAme%$7)WV#ntKy3|=+wgBwVVPCbR=d4sfQLOuqqX0)`@sM0ISQk zIqUWYrp|_4Qn)w1W)Rcbq=`9pOSWQJDnGgAW1H~0bbxD}@QF)JOkM*_Rb$L8u!45(MXE>q%(Q>Kx|M4c~Wio zo@KUqHo3nXSB%B9D|`{OME{S<(9>W$B0ijjjv}o#G8+I>54tlxG+WI*Ea&`!z*qLM z_}CnNZ}m=eIPDi)l)fNz9UXjC)q7v0K+>rv4(;DBtPqJ%Gy(e##1AdJ@o5t|d1wX8 zLS!`1DZ`0fhut5EJPG>mNAZzxaOf7@h<9161+o}9b202U9H72CeuR3E_*VR3BdkVc83$19m)z!BM4Yc2qdR zM%*7c6yGnFHyh`i?=I%k<yP(gKQ4cP|lFLC+ zg-Y6*7mIIvtop+(DE~;s!JxaqE?U8srR*9BEXOwYoF?_=)mq>2#%KB!mmB_jSc74) z&WKOo=)~PUMY2ylBv=E$yo*(umfw^wpkS{QzBc}eq4R(A4#%cGl}DTa=>Oj?df&P) zI)zAaL4SS!Y3ojJpN_sWK7|?fc~QPCy2p}Rf~g-$Bf=@ z`P8xg+>ubS3Dx(QRHOHn>CXvAyx=!i4JGEzk6) zKCO29@Ms<-LiY2))A|p%50rg9cy(0ymaNuAlamruf7URq4`0P*j=&O7n7sa>`fKH@ z$)CI>bf=F`y<$^MK-bYbHPY^=+{qlwv^6KQCg3=(Nnm_6#1r61<9*DDS)s7-)Q5p$=jpA8s$6o;FP%rv%&25fXSP9cXWj=GV5ey6!lmjL9?WcZ3vSXD$S+{vF zEZ#KYkKVyq$tCaF@UX|+_!F6`fvH1lj(pXwc7cv!m1w(IkHdw-qS(9L2t*^fG{q5A z%Rs3p-CgXYOSIGw5lgUA0SmBMHNA`u zQqmag@~(0{@rg0W4uth=&eNx@Aip5p)rkdv!dZbtH+49M%QAOYega4G>i#o+C_}`% z*6cXMqywE$oB?jGkpp}8T5D|sk%mjsdi$y98>6Kn74HBOF^UT1IR4ztXLi1f9Pm(G z3oBd)xuVLzS1uCnTg97YGtKG+XlyC?f5BZDg&!-3Ufjig{E)$+vmNfVb%;fbe+=r_ z9Z+LzGX;&=CKPDF9hR=sQ@F7HPqALAe#lO8+liyfHiwMi*a!O{$ic}?uu8OdRafP@6KfE3)#t?b8Mi}Nn5E^~Mjgt&l zpuf_KxVRZYS>6c+^*!)L0=y?^>kG7y#zxhinY*Z1Y#mGNWt4$YBa3N3Dk^*V@%PEL zQ}WuY);!8XX?d$2i~-Q7Iz^KnMnpx)glOu4)rS*QK59Js>iS0mnMoxyIzH6((>^+0 zNi|l}05PvlV#t-^#(5db5m8b-rrj}xsCu#RQuram%LA#BIv!2%&Y;kvT`*oGaD@a^ zH^7@B79527fe`J(1uFsqx&jk->glbBxQO=v-8$^l#_yR#=1U3aI%lr2D zaN0;ei3Pa|OH@p|vdLT=c-wR7GML6~Bjqz=(uih7K87gzzEmqX&_G|cNQg9gsOTdY zu!NZ%Twj6cTayDcGV4~-z}aQ;Bo*w2@bFYdc(UJSZx>;1Qpl?Q5U2xaN6&3YjT%2V zEwX+)6dKP=%sz-EdjvG;QZf2Rphbpk@-VhB)VnR~^boP3w32~)QEJnX1GANPWT}FM zQ)Z7a8!?sdhtos4#Q|&&5)ut?L!u%;fC6EJU`0outP5Ht$u(kJeeW+2b>hf74K)ra z)iYa-lDom-t-;HY*P%$t0+wiaP0u81V3wddAP7xMOUrMW`kFgCitfLKe*ht#s6?Ka zSQ<*#_XHum1!Jmfl`>Gqvn94o88+c0Km)P`&k<&Df4}d2tSsfTpv0^bDdu{jy<0*|8lcx5=p;<~|v7mJp-_+UnrcW8I)rOxX?tCfQY) z1sk@sg)}$oKnH!x*1JCrOH`n(sAQpJ)>;P#%5sp8F(%g<6zVWt`HEab8soENimoH> z$(-Ls46GMrdVRyToCBgo0UDv>ycW$hZfjg*re1L@Pc47Y_u4TxrRyQ=1(bp%kDwf| zV;}exd{jK5%^H_Zf$m4X2hRG*FtG6-k@6vfsYpm+vf^jQUPkE^hkI_cT?GCe@eSJQ zTcMGJ-yj4D0qd1E1b2UyZ!%tGIa0}(&>0;cFM*6!Fz3S=6ioUi;~YuPNPa$k8i*e< z=-Y0?w}^%fRVztHAg`dB@0EJXQ8NpTz88?-z_!R-Ju`k2)@qdJJ(Te?Lg;H@_!FS= z;6iU-sKf|HBnXz%Um?y)Dup%u!q$=}#vzs|vn66JK?3!*91+=h6QS=ukaQyAnJ6JB z4x((9Nfow2^s5Obj^t;5o&*<3y>vDqzBj;-YsBhxI#Tw~Pl5%i(1xiEH99QYYrl2y z!#JLUyNoj=1&+@C?PsbA?Z8Sx32L`+cO;z2@E3H*l#wwv2|1W~O~y0#%amLNl@UBj zawgMZCT2w#G#zB-N|oD8ux39nqF;ahd~3aAD4p42ol;NcZ-gh*7sv$(_m=F;gqe{1(K$-77B~P*Spw&B>&7SRoc#0dwe7d!~9+SBJof?!Ley za@7q_91~%OBQk9w=YW7twQQPYOOG()1#HUffXkO)r?fb<*)QZ-b4RH|514&PW`s9; zv)r~0F}r3DglrPPX8PKPd_4P(f*PO&#t<$fV={PFK?GT`Nn5vjKIGbYl|WIrWJUtl zLn>;92!aZ|4yhJt2&8kntmA(HTi0?*qS5i_+1nQouW2O`URt8F!FUuMfS?Yrv@Ny& zUb|yohs&L+-7OiGuKh6OqykJ7o-wZ!8?&{aI2TT)8&~br)6>I7R6%~33O76w0K%bw zKn0aeTX}e%bsy;9=IqjzO4FAZb_S6jAmb)53(;BV!C2Z;nfVXjW}0}&gT+e(W{W2X zQ?caBLCXElFE(NxX7qDTk-m~F4RR#Jn}ZweA~q}>8_V7i+SdVa{0R1RX4J<(xI~Mr zq?6ki@I0dt0YX|WRR_I# z))~VxE^E9mdkBAihlqtwRfDIa(>DaxcpaI~f~wKlJw+80&+hiBj~z4~-XrG4e3RIF zfq)_9$PqmKxDqoI3f_Z{9$hBMoTy3luWqP7U;~?!5*9g>3h!2txKpvezB~%+R`puZ zSlz5eJEao`PN0>9utnNsI#U3IrnhPEsv!9++G>oAP@L2CFdnA^N!Fp?Y8P+UtP+tu z|655oidTV?x6LX~0f~ciMHONwW%5N_4jBnQ_Z-B!s~FW`DR@T1Vd<+~*dM1nWIS`{ z&7-sH;PE1?6*z1Y@{7Kq`0QXG{wgwq0*IFUINaVG#sQE-GO_??qMU9p)WtD}+5#Z= zJ)lu&IkoY82*7K?xd)M30i-sDmf8G=py-alVHncn6Y_#_suHhDajBaT?C>Uau=)(% z83=;i)~0weZXv@EJhM^}WUwt4CgLp~dyAV8{T*%r)OqpcuOwn1E@?o=q2dWw(J>=@ z2b!c5gQBHa!Bsg%=eWFVz1xoy>G|&6L3E@b)wf^_IB-fFJ$s47IIoKNLHq)P>Tk|7 zmkP~{m+)|`+6d*Fu1G_7U#gv|R;|*84^FUt9WXC)v3&_!=>fBs9H!Qb4LHy-A-iYd z`-A(2`5pK09xFLGOyvbT?4|5`Zq%54b&Y#>dwL=YvWWyVc3vO?6HnXNc#|Jm>z_!g zcd~*TCkuHJk=hboGlaXt{+M8H@&RLKh~`DDQ4@e)PO8g@CEk$qz!efq$e= zFOirPfQDTq@LlSrkgxWBdt;SQBH;rVLy-wH7IhTUP^fhO@ENKM;*p2+r6XHAXzO*K z0Ur}o34io;!5)47ugIecbf(cKGW+!Q1(m17sf8HlA6h*Wtnr{C2c87ETy?sCdU6}G z19FAK8wqIeHB!^2zpYK@NAxKGO=i0Ju9w(xV1ufOSIemqelmm89Tu*`kLV*|10+I@ zk7D5IC(nu+;$-Ui3{WY*4aS6wfnMlY$xsRn#%GH|4+e>sO*l8;)K_T`g0=txF*Shq z&V%n>EBC%cmrQVzl$0iM*MYgcUAf#1F{W%F2~a5Ygdq@4x4eU8IoT=bfrL~i^K2lw zNzD8#hkXi;Vd@jpHKDVKgf(xJu@+CK`_FmYhY>l;_TM6(P0aC<1b4+V~F+#w?-@_8=M_R9aELCQ$&A?%B!<__zc1Vvdhv@_;BZFy zgU5HHOs|kn4UA8RAYTjEc0;1COfnovH#try3g+H}c!*b2R27R%tcevaTbW)Jm<(9D zZkLqstn0fQgwZu~?NwZK63wG`VQ`?QWWkV4%mH?`$glYDdC5~pajw$Y6~V6X{~@t? z)ZwThd56B{?o$+wfUbw*l)Y6?7P!!~;co0nZ*`92c7C_szpLln6~Vl#Xg5k(;Rkyf zQ{zShZw!sj^;Gn$5@?>^05gKZi9GJ*%frx634DDXTZhbpzY2FrppRO(C|=+dymsJe z&=gUe-XVQ<#V1h)NB+4#ALhwrCZrkC4urk5vdV(KAJ7t5D#&Xq58+X9mgiB`vO z+=4Em-RB|c2hY7)qrkM)2-v!i?AZ7yxE zwPu_})Q+hhZa#t&)(&t&`iRBWGdJ-UW#Ap`*EmIuuc8eT3yZ6u-WT4P#BhWD2t7z~ z3*iv}0^aCdzo}l@QU$bN2;iG^!YIz2_?q&+hMY1x)+_~}5JqlsJ;)zK+6;&uk=5ZN zQ!ev%!9O5$okGqyLk>StGQ)d(1FbsrCT&fnEYEG3hFTS6(hHug>o1<}1hR(I0@_D4 z@D`wbC-BApCk9F+m=ErY=`AZEaM|F}&(NOX=&Jz^TefZ!d(znsxz*SR79p0Gp!7vW zJNSHqucTVzmMhunoe^qh2k)J%2qnr5WLIRQ=I&nn% z(RUm2`^pp9Lm;STZS@0Z1`G>HXl#ZA?K`pQndq>Mxl&)^!bpQ`+kMW%uTGZap45!D z1x<-E&}a~;=x32A42bfb;V$Vi==bsQp~uSS9Bf3?39 zcl*%(h!KkRAksYYji?c1f^kL0f&_nnB@saeb3h*tcHkCK_D@72m>5^Z&qp13jM$E2 zh(2Y*Js_SOR1@?Li{23aiGg+!wJiOwz6slLHU&izr37%kg^frqDIW($w?R9CPPH{KmOPC<~!!R{CUT$`THL2Ty&%|W96Kb>R&EY-aR@td#NZHdI}nEU3B%_IiB|?+UiFq*N+UBhukth@N)rk z)Ui~-wwz2{P70rJ>avA(az|qRlyh0IlnNQiAi*lT&mgo9oDY-I03ifu)(T0ci zS=pw6q{;+dRpUf1IV&%vaCccQb!nn!mYzRZ)}7iRFzAFl98|CED5;#gLL5|;mG2_^ zP{pRs>P>4BMORQwUELJ78(e%(^>5>m3+9>w!;g)PJ+(lEV|^KTDCCw@i+D?x{7o9uI-U~=XB#%7%ESLlcXE71%)jk{iRoz;2X zCBw^4s8FX9iIfJ)6BT>Kao6mFR_u9*1;i84IxT$+jr~~Xvp3a2gd-32;Mj2IQ{;Sx z8dnWA!Ia;@exYRISua7v>Jyx#*9EASK2oy=F|wcZhDr-LSPMoUH(2J7u~BLY4%e(=Lv;87>iuC^V8cWDC8L?9_O8qm=S027-~fBuzKH0D*rnmlc!VYNGmh0@kg% zc}7BMo73gJtbLE%89XxeWQg}T7$84pPFOU7ijt}0#Ti#NEMScx#);gM73@#I(HK8(G&BADVl zWQw|9hU?^D)3ziakS3Pnlg+jj-N;I|c8SmOerUc&9(&clpc6f16Yg~Uylp8ov5LM; zAx*xwU^_3>=bt|jq37Jq;|5jjj3*s=qmI?*pAIZK>T8or$xcaDDAd~noFw)|aEVLG z(^|AzK-Bj(Uf@+5^jniX8u_PUB46Q;fK$=xu| zV+0POuyn6Pv7Lw;@UC2@U$kotoZ>OPok~2iUZbHTE~Pn613Ca&1ug1r2dVUR869&dPQ zVgV7ycv(VKi-m%GL)x>9?2h+t{W$|ZKq_0`72klXq&&x?Y6{2$YyEb5U)Bq)vpA{x z!z3061$)so^QGz$R68H;?wFyqf^!sTm*2aifx#xf&i(Uop!n~I0RU+oGvTtKYK0EG zwQ2-q6ciNJa#ibq|3|QF6n{B$kqL*ID4^olsmXB}?^Me&%Q;dl?8rhgb4OvFmL0b!OO zEQo>x#pl+dh9Zgc_GXq2C}Hi{dGcukd zTHl0oOy==@9ie1hW?}e(bvE0k4I9FbOy^1X+e~}kH+Iv%=!)jwSWCZq{ky}Fx~R#J z=)E0u&2E}%&axOo-Ve+CIP9^_&;a1%`1RfbmeoJI@F<0}KAwOTW7w?USajOIfy_E# zUi@Xf>z|U6_09{xz5(lZ8)RE;C^c3UN|`rCPA+KT(MTai0Fkd_V}YRTv-GX%9$Mpu zPkGqTFrw&w!~>`eM$to#z$X_U{pJD2Ug|LH*yw@CWmL6}Cw?KX%p4P_Dxn>x>E zx86Em4S1KiPma~D{UlT0mp5)n4KAQfs!B@Unmb-b|14$QzTLLuLtr2W%IxCqF>jWr z)HY{*@6k3W=La%{3bis9+2oj-DN~5zoejfkn<8Gcq z$Vflg){D{I9{-s4v;M<**_mU0pw=5zl~hwx)Ek;fzHQK zlC=4r@j1y}H3_mG#Cn+d9qg141#4=?)NjG5LeLYj9xz;|52_v?7X^EB8fI z&``&YZ%qd#lLD=Utv9_C1@`pyB^S0J`Vil!-+e^JHWBFGUa(UGC2j5|<_>GkAV(YN z$D4Z3RXl}wNet~p+o@?x%d%gvqb^;^*#J;S<~f;;H*biRIX#v%T}_t)^n%8&K76Qr zNN(r`&K!H#oo$98HBNd$@iNm0)S(B6&jAO#>bpDCS+ z{HTuiy+dmEMbCtzd?1(0R`+p>D6@SKmJp@3xOjh5COw$R*ULP%_LqP-U=I{0sE7z^ zNc=_4M%RfQ9j8NrTyl&uYUJyRotJKC7-Q;BH%`pWUvVP`X%)w$;xw7))3A=1#5*;A z7GRgb>uo$=cg$OULx4%!VI zsZ+e#e)r+z+ueYaUn1ex?K^*P-cfJn!`n=_4U6hG(R-jeYkHUPQ*JlBAnM20%Gc`J z{qsrp=#)k_d#D@tO+Fw%)KM4T!WWA*b{1kAx)`8IM@ ztNIm!v@z!fuT1OLkAI3eb~+7g83FSIsW7L+qq76&c;!Sz%nIy!jEHX!T1OA+YH>bo z>h2%_I=}sU589T`ygVZvfL~e5Zy?#!_L5`J=6(5EEf)UEZ+CXFu(&t$j01VABw0Gj zyufKL5hE}523h^5&z^O|tNbOz7Nuslut~{V%s=5daeKmezEgLsj}X89!m@RV0IVLq zYI-=Er91>4&IHX!J9lQ%@Gh3FW#0%PGq2E|lZ@a;R^sZ&v2zu#Q3o8y8xzS{H7JH5g)rWCk}bav zSQ#PkRS-TYhxfO)pLvOlupDGE&NzXI34l!e5bE(7N=h*_3cuYA+ec-HP$sw5fPXgh z^v6TgHW~5(l`r}qdQ7~Q^`ou4C&{jz);=Yz{6LP$q8W+_Hy9D+Pv`aJPrD<)h0qlk zi+}$p<yh|?ntgx~$eJ5; z`Qi0gP~P8~zwNVb-nelOc}U=$0~?Gp9Y4PLZSHz?P?4yAK(r=c*XUip7fniE%ptlL z8l#&)V{@5zD_>f7VriuS8n#u>J%!sp_GH~u7>uDzQQpEc_u(=r1AeuT8tw_OF3H#& zK%h>n7RPko2)YCyryeW{j`5ge>eHI4@0!cvcro_}L*&jOd41_4O)XAcA;3#SwjESd zByB)h8i*Sz@Qgiz&x{7rN^qwLr=0}-Sz@|PGL5*Q4>s)f`miRH6BJ0Q^AN^&KRs z`ZagrQwfN*Lfgb&I^-N2ap@5`a7*}^#oj0G<_6_z`uS=Gg;_HBQ6CFkhvqJ7nY*kd zl^s&bMRu)-ai%qq-YP+|oL05X_q%}F=*&u8Ql{3X_1+COJ?X$(8R8Qr>*8uUz_#dl z_*-~Ii|onAEgbPZ%%r4cEaiSE+u?)X)@^nU^+Ys)Mn*oyOTD1|Le(-v=Q3&qI)GAv z+Uijy^I#BzXV*=AZB?Far9*zV!e$HK^<< zjvxQ9l^KkU<+UyOh+s+ai0C#5UNq{KqB;V_%%_HfBR(~gvJ4tjU{JU?s`%Hs;*cS= z4=GkQQ}SPA-goEJoF=| zV@fv0u;VlF$sc6|VWyd}UI%4=$Zos+H1uqw^`g=zLZRhC)62+G#ZveBMr@O6oT92) zTCwylME?5y_w%pleQgB{Tx|A{?G)wi16pKuKj5ETsO2^ON2y6$WV8Hf1il%lFsuWo zaXju>qs51hC%28?!qRP#UtP#-)jC4O1{DChXSUIsAu2{=;RiCs3W+(2ePo~IgQ(6V zn7#f4=QLP$0R|k}FXpjmX#p8(#bDE@k-V=ZY<%J<@Nb%jhq5)8+!b+Twl0qUb>l`e zl*B|{Abl&~GxZAD0WYa3bOS3q@{Yi)(Ot4Fqxc6F^Tgij42*|h0H5dZbj***)k)hwR zmW=tBPqr7^?4b7Twb}uKID5%J6?=|eh8z>|SLe}Ae|wNmT;eT9(MSy_>Tk)`AiQ27 zlz0(fb`6miH+2$VbJnjsT6G=A8FfJ^%F^jgkP0k|vrA3GAe=c^D@au@Hhl6lEn01> z+|FTF)aWmPT_$MgIX&xbzzab4I|F8Z^^Qj%?*V|HJ_US<;&5ZGOL|Ra?*KW|iF9da zo{E47fRvS)gBTBWg+Ot%`A!Uj;ADpQ#`uhD(}w^=4NH#lE0PBg2L_MN$R}NR=WQ~5 z#%Y{L27oxIY!|NY!hhQ>ipkG2^)J*Rr#xUZ-7DM8pQ9T@$JZo7BEO2R zBNW%C8=IIYUPPxL^gROk$LJkt4#7Yub*iyYggmOuN)2)>$tDuftp2?Rl3dcU(m+%6 zy~Pyvvs7~I!bmUhG>FoNlOL1-nkayCvcbF`PNl?aBvLW>;PCf8*mM^Yz|4REld1we zBdMsWlck2~h_W-BPRw1A8o|O&fdDLu#R%8{%8rwv7e|h;7_-BZiJTf0=N{-_x`dx% z(8L^Sm*TKl!nWD_a8&ly6FB;aL6>$YD(-mW?3>WOc%x=xTI?lU+Lt>4Tha{BHrDrj zcO09vb{hfThF3s)^<9O(dL#36XQ6saow%8cL4$89V#*x3gh{H%Xa%KRj%)#jP|BZ; z!P6(E&XfjJxLa;;t*=a7^QcOHdaRx?fge@Hwv?)qye;JKW@+GxxF*#`ctz9@$7Eec z!j9q#X_<7xrCM7~zZoKhS&cK>QqJhM35LXsiM^s4bD~e)a?6GjQefN&vHE%j)-K$lxeyvzYp2e9yMAztK1i zE^HiMD?N`TSZVh=M0a80A;^TjvY#&1-0VDEXBwzp z_hBPT`}NvNVYM*FfW5oagDKW8Kgf##HdlF1EAQ3(f4qrSwnv=C~ z*)oT~Ls7E>kwIEZt%iu$?H^A?ji0uQWru~Vti{PzRdlYa!RIRDFY?|4>o|?Ge-7EK zW)o}l;(wN~%q8MRq$8mI5C&=P6>A?9lE@mzxoP>U;LP{6T)pdDg6!AY8kB+BMQ6F1 zvhtf0u}u3#1Aj)PE49G{n|$4)5~|j|NiZW4U0K3&G;jOP+$IAAaKlT@sKe7_6WUO3 z)~3b9qIDLPEy*yl-ajk}PWv_8QlnLM_hHgFq9bn~bD13~6;xz0lR`Ved_n?TAPsxVE#)o>`R4K(+On&Ojt_RL^t;v#)H?8=t{XpL?oFyMi7`hONo~S1 zVQ}kjeQ(8G(KJ4NoZaa2s#}S@MjpKh^XTb}h87nh{dYfL?cd7uvxE;js={lV~ZaaKLgb*W1qRz0#q+LKXdZ)BI-{Sv>B7rQk<(@^k zoD-InE@K?~iGwRI8;D>EAS_BwDHX*>oN1K0>LCJ!6fWbGtbFf~J~>J=P~}{P1DNbE zQb08s1?g-;E6yHW$n;sI#&PzOup zypjx4y=RHHeNk2@T%0A(@29yRuwZtah(NTsPBY+1)`ksq7+ik0y}5+cBS&y?ZvS(h zXfC_piVu#GMRrn47Mhbo~ISRT`Y5%%}CO<$Z+dtVz zaxQh*z_J~4)nA@l@M8*QuEBDrAseL!OS@My25kgxW%3NMi|)+JQ)*(kO!sl^A3YJ% z>e`WHsc=!fuIF-J+Gv_cVN($%Pi%(X**w|ZygzwFyNM(DW@Nd=q$8?c^3x=691;wP z9xX3%2eV|~R1Y0}Z3~M8MYSSobr*QD3iz#VQ8N&2YYM){tS&ANXVtfDQ&H(C;x%eGOkIp@)?fqZjMA!?YM3;)XmN)kb=+dq*R;99T0hQU8!b!tAdsou7{Pn^sD!%Z)HF(H?x6Q$%C}ml3It9yaQ-NOrgxZ)}+54$+TrK4#EHtZ&(U66zV ztv43`t}-m3Djg~$N`$y)|E*r=IDXXSdDYm1+@!p;!uW_7+oo-4Y1uOV*&jpejMkY= zXXK^f$FtA%zCWIaV=&7rIX!bcWVBdnRWHxMG=ez1xjY#KZ_-J{kI@C^FBJeE_esub2=ngiTZTD z$*fAGw6(d1yvC;A{xtV|O0om?ou}`U*VYYdSy_|;)KM!QnNSH_c3YutWMMh^_QG1r z%5$26F%@AeFb6T&q2BBt`wRuh0|$v$5! zKCkC7X`h?_TBSwoI=)_OzYE@Z>6-bX z(;Z$%Cr8eVl0giTZG(O`>lNhpH9hVzedy!#P~^;NxBQ=1J4S*Bo z^q*9LXz;&KeSWO>l+hLqd$nB|fX#9~P4ajSRN$7`Yqpu$mz>k=aop$N;s8syn0py#)p+WeBnvsgud!f z`L^imAOjH2I^7UK3Cps3(^8Zy_=#RPLxuo zihDn7^elu5R;M9nMWt*&=smS*83nh*o;x65dS3m_dIh1ks<_iMH&bI7SDf~5rOJD= z4-Ov(W?Hif*S7k9bLG5gmo_VK_kCeV+5wQ(q0*z$fYM|XafAQ?C$M7Ml;9`my__B- zkt1xqj@Z*ED4IVH|DBo97Ee<&D#4Om&Z-o49*r0Q^H$ik<~3&Q?B1sz8<|zzI=B6o z<*hDZmKh!CWlQO?WWm&<{f`-g$A8!nR$ePt-(Hh18wm%_@mW`&t$ z$y%V9-cd7RKbfkarS!WYi?P!8M7^EtVljS}+#-A<=LqzwiF%I)3X@GSOMwf$h>%3l zrq^Xre!-vD?@(gtdg^nitsVwGJ=Y3$E}4Ac8xy*K#qu-KhKsovLq??R$LAK1Wg9eF z?_20)tanp#t`snIZEP{edi}P@xm+Xtt#@u5y4h1EF%=6Ds7v~FB)P@_uVzN^!VeAjuFlO?2gjsB6Oi8#)X+lY@tC<4)C6bu|J8ty;pzW8ByK>7TS z#!du&wzhqU=?hHW`^cgREyR?u(OZEW+th`gT;Tor=YrNH?VK(k`}&>E*#BgATU^-H z(>OULnR%n{__-9D?nW`>>P&ef6&=&$uL5VFD zTGThmW?juC?R(W@`#hKA>yMiS)l_tit=M$dY!k#rQ;r)=56h&Q?|%qgAqk$52Q_kZ zunB1Yg}uc(Te)V9v3gMo+a{7cgCGH^Ol7bE$?S2bHKl4KTWcK0g#bI*ch76rr3gY} zViL&svkU88v^M9wNwNH4BdgO7ty^m^XFN>EWzPu1hN)D>5~iob(mqRq4AfAAe?!*@ z+*_=;ltc8nVTrBT=jz5ZQoD7?c}p~U8#E6gVVwE0UQhezUtjHp|2k^vdpZB`r~UG? zp8nsM|KET213VzV|K-ac^uA>a?XookJ?k;rEefZwnzptX&ZWO;(%T=q+rkUP9}Nq9 z{mm{Ge02Kq960=5Fp^oJ=pXa&;Y=i$!Lva`t2E5L+u615SpU~OX}$FSW(DhS!-?cN z>>I%=eP3x=Y49CT0bL|KuM`kzBPJ_Li)I&!xff2yw)q+aaaHR4r+dF@d1a0iOG+?x z$V@KAiJA}QE?j7GvY*W}x$l4Mki#diw6*08fyE%xZT{t#$E|ZyI0k--+&sShR_?18 zkDWC5-V~<|8?~QF``?p6IvH5M+!g*8SQ+~o^Ia~cO}PCfeEml?jiS?C13d=(@}8OW=g*O+!XpR8m)Jqz&FU^6qK6wxN+7``n0*E04D>N*BX^Q}J$O9`!7a?*LA?euIxb+KkQQ^?M(7APlnNPi-zQ4B%ff1+);Z3gX!ltA&vg<*Dk$&-)I(LqNM!uYrFqe(g|)- zIrb}uqpKit`}417PFuwvAALHu!KJye*@yG@N^WiWXPvKDnszU5w7{yxjzEJ5&ljXA*Ebq{ix9v?H;%a<*c8tus=6Y`_Ay&wf(I+&1ahK zq|JTbM46ZD$Gbl6#p3+)-5J~a@^L+^|NiakzkgfHttVc6i1GJ>H*xwiI5a+ay?Vfz zmXImr(sEUyWO%mFXZ3p$jN;|F0TSase>7QA;XpZ&h1SCS%QN8LkyC=fI$U`r`kXkQ zQCeA^?#F*SR*k-U_GKl5Pwb69 zQ((pKA&Q6Dl+rR>*2Fu1*pH4h<m3f$!7S>Ga&8yq#6?MSc8{QT{YZ2h<&l7-2~pUaEwNXY4}ye#-m;q}m{N{epe z&jXOq`-JEHo;(djtA^|HWG2mCJSiLL@?)bJg_-hIhc+o$-JKndo)Iu;{_Nel6ar`S zuPXc2nZJ2|{_JVoQ!S?6QS6|3`cT>2>k8q(eA_+0-uKK!dp17**MENhvytidRsa4C z-Jf9U&u^ZU{a->p=_;;o+;GlJQ!diXd?I}w^!03NL&a0=HJVwOLW?$Lpy`|hb_rUF zh>?*1A9_se9OhrbN+Uh2oRX5W39Em7o%W93XY|Y|MrlBKVq$i6seI+$NWb|f^~`*G z>IxO*+u`|4baVoLWS%}Aw4F+6S-jfTf94dI2E6?IfAZRk*XY&U>4i-H1(Kf5zYt$y5PaLz6#8o& zNqf>W$-_K1R92I?gS;v4diclRk1?{zsz0uT?Q8VKcdVV=GJ^A;acHR7-fiQ|pu-D% zaK_?)ua$;tovHsSTkaB*wp7}&s@AP(P2K#|5_rALh-bF#Vvy*B-273i*{&6}KNMO> z7Xv9T2)Z4{#u@0ls<8R@szYZ|P6Sawu`mZm1#q9oj@eI;{GeuS2Yv#|l4K42KYuDe zFZTaO0oU&fru)B{Z~Qs#e-Z_5OaYA+>V631KHeg$^(s`ezW!civ5~(@&FNx>-~p_= zf`F7InIdAo?u(!&0HpSur1?aazNQ1>!taR$+0Q6&{v@>T;0OYF10!7Q+=6lxYQ6y8 z#mUQ?O`di-zMA|M{%gu067(aclg4g+XwmFoU?EAWQQ-Xj%295$%y@}p9au;By5BG1 zYpqV*tYDujf*1H*guz4(JQ6>Es8Wey3G(%Mh}!}>Y*6@kV3r`byo%#z_3j)=4+Tg) zlzjM)tlt|1o%J_@Bmr6^7j2PBC%$SPRP9J^51j^5s?|7yUcn@=8YlSH9lH5ju=V#T z(S0=fQ+WCFyO96c!uTiR`F-I3HxrWISNH$w{J=^)^sBe@EFUYI%db6R{>z0cS3pS% zHSlbqMV^|NJ)Y8}8$1Fw*^O-ZKj#P4(iMxAuBfu|n9^x+?n}8MxFCZl(p7n)qn3c$ zhachIH_rE}ejW78sS6a-Ni<;~{mDbHyQDCOs{D6R9H{I|+)&YngA7aRpK{f&Lq8tO z0zH)I2@=T%w5*ZtRQ!{czku#L8!{bce&ZGG|I4`@LW`bIRmmKHtjKGWr01vfh1-yv zIZhbq^V!(%%hBD66=FRKN=WPYf7dvE|MCAn>F}Q`{y$xv(@thvh5`!~4+`=dv`zl| ze9@Y@;d^;K1KkrMVuGhhM9(2JpYA9I8dbWGpbi?I`8|1jAk?AUeZmhK-j|mSXt^bi z4Y}sCefJ@7RrJ*fWd-JCTlMv4vwnrVI5AI0!nFqeHwXkP_>^O*tD2_}TrOTJ06{1xw8&X9AW8!Pm&*ak^@6!iA??mSMk$3azd6903_ zbl*8K3bpBt5>O=F0kNVaf0Z9>I0hWBeNs=tFe{$5{(CxjQ!5GN&#~hRp*S);{?PJW z%e{1AM=Z01GMEC{i|4Di1r;aUFjd#FkOg-QUsyh;D*oTu7Q#y^eg{pyZs=y%_riVU zwT`^j7kS$@zTePYoT>Y|vOZ@J+#rHMAmkNjZ``nD-jS#^lyJxV;r`Uh@ihOZRHo#yBIoerZilhF z`msrSpxRGAqa(socv<=iUb)8RPXejP z%yh=-i(DJY!};-FepENXlKVSNz;$Tz;{2;rv2}Rg8s=1p_H z8i%Y!L3J*JfcAa~b!;`Q5g)YYE}Z_%TfX(Q6b9hO(JexwPJRP2b9p(gSsIT61bcDo6d{lsY?AZ6Rb`umXi1!5N@m#0@QL7b% z1WhGezPw#_8gip5LM`@pdGd!- zPk6hWkqmFg7C`oh&(^~BfRUIHX&#`IJ0?OQasE+`hlL(l~?+!a2a^$5r zar>@B+vw(7BkE47S!RJF6uXSSMEY1hg?4l+>P&kBT>=f+;4cW zJXTsGFhk#0@Vu#H_8v0S^&DG1+a%AlI&0sg>KazI-8awB>`AuzR-9TZ5g#OMCB-QE zyBvVzVhh;%RjRt{{zd>4o!%~=^SAGZqMKLI#paKJ)W+w1*1LstPU&#zWE~jo%SPwZ zZn8n!ZAe}#>0sU1K|yePZ{6?aFY}S4N+iOI4~#Mar2sLH8_V@+)(%;~pNK)aQZ+WbEob zF%)n3y7HP7wt179x=*9s&$M?{-z|1c{m&9XcalU18nnd2a+d{N&!w$3Wms2wAS+$l z(C8VgNKcrYmwhK%p)>Y4eMn&UvkMaG?qLF-8k7ZJBLC3j2LT90tMJUZ0*Q;PDkqSd^hpe2YWsyTru64e%&7=%@*&2|jE!w7NPAuul1uC4-DM*U7B2wQ_xRy%?w_@9aYV z?laHjh&1eL2%sH;OTeEO59vTe_?uaNPb=U%XD1ad{4}|itH1s2W6JYK90oFih6n$= z7b&n8L6&5w0x{V&m!^|lkyyFTCH92l;R4)=AdHd?btCB-YB7xw{CzVd3emijmeTJo z6gOz5cI0L2*}^$*t;;H*HSN|W^LQoW|31$=;?Su_wG3l zB<>x{+!v|S;S>%P$EFf&t1K%%9JnUFv-jKPVk$;!lE>UEL&1UM$jX|U8tIm%;)j0; zbR*^hV<9jnC0uIdFM0c)XXLq|tK(rj3Sxf0s}wgk@=8S01+HnZ6W$C_Y%(T-1j0uy zV1}Bmst_FAJo-JB`MwYjPX$MV={bg7?qK+BDG|IXc)r(^r*D!)JNUUXZ=YDPyVch* zBUmm2$eXqKhtyOqwNLlbgHgkjphs7)62vk-p+7fhYH|vKYG}2I4jC%dpV2J=u$!W( z84uk_4XpW=m4=0>p!VPIzzCWrSM;3hW1fZN6Z|D-+5&(>2{NE4+35^?#v+t)`uQd2 z?%Mb!k$i@Id@QLbV|J~J&Y#QD0R!*VDY|`i>3TVi@6!T zrM_}cV?J|5Hs$$o!-_cFw9qyGoPXO~Y##J|=bv-HWI2u%pKeti<*-_o+2uOUD+)$$ z4O^HS?^ouQ+o^rH>{uM4!f@W-@^gy0`i^e1x0@Wl)}Lfk8jIaGCi>a_n1UmtT;J2Q zI=L7IFE($g7FTkvSX|Cn>FL4^N@LFxR83QKd#;NgG~L``s`!EPOkIg^ajvn_P<=c{ zy`f2k^S=W-L}z~InGbMUSC}mHHefi{m=s)BqHV)ZyWVvFcT*U%>lJ2~XTXcrFzi=r z5!I?LVm#2ogg7eyPjXK#up8|X1WpSKldS%8y>zj;3r#rA+rVsrYb_YLL<<|sEy1imHF822M0_Z) z^7Mi&jNSO)|B_yMYFq{T?&I@U8i)CT+K16zx{we%eu734v$%5xVTue`?km^hrOU`b z`9&EpX2@DT1~dZQWpervl-Cs%b?CGaNzhCPgS7U)*whA?A`x^#ePwi8w?Dy5LNAHX z3n6|q58rt5nz;4;?D&RME+{Ad&f?-NtzYYa${_|%V8)n2a}UU@^LJB)wrx8MQQ;bp zohxBDDlVS?p>HG$q(YI+D~Ag2+_~cy1GSov%&7&sE1>*L%uX_a_O9l=s(I6J= zqu*MHP0X9NwzhdZ+{f+2%nO~r#HgqvL~{sypnj>4^R0PWfC}|Otq~fcu`o}XS{-r? zItNiGmetnOG(5FO_)37J=lWgVfP!EG*$1KkI}hS;xDy(hLWq}8J;j-Sbz-Xu!2;ku z9L;75X)o*|K*OTbebWGh?kBQm&z^-$NKxzF<0)BdjX=w7iZF#D^-h?~4u&j!bj!Mz za84g47=Qp__NMTntdbI8q3R58K4k9q;6Wl3WdrM7aRi~C5txd_h53|B`zFNBhr0QR zMGi!#zDmh!X=#De4QpOvE-)Cv++GrR%K12$Xtq5+ zlaKB_7>Cvi2t00!>-WP$2I>zovL%u18bA9%6tFF_TO1S@`8tFx{Kv5P7U2XrRB)+V zqPhX9*MWi1ky(KHvyTlJ;T)U3b6Q8TfTRwjjk!BG#f|2~FAutbyHO6gGv8SB)ZpE| z{Rs39)PdQ}FUxQmGS+kWV013UZ+j3g7gv&&K`FQqqBFO?fwK2*2Ry@2pCN9jB)E9@ zrRrxKV3JR2Y%$f0Onu9znPx`3)05Df9s)r`HlE8Pm! zj`D794h-IclPq@gG1561sC^N&z1Vs+CVmiF0O%ns)BLjIP;8zMba%63a`R@gdgx{Xh}(6AL$J=6n_CxiPSkkeKG}xbqkU_ zJM2eIPeU_mPF}W=H!K#S&KBRQtf)9J)ytxampwO$`x(T`COG2tQu2TOic{? z4$Et(b0)U5G((gi0OEHN)8C~CC)PMK`1d*n(mxI8_wt_2#nXgM*E9j>bDzC}f>!)K z9=Mud`lv*IBfElUKstsZsoD{5q*>Icf6ee@sBnZ71MNF6t^oTw?MIe&vB25GJPVvM$8JJH|EIX0nuMm)arTca&)45 zMF!l)TH-Nw9#{}^H)070EjtszENgmMY1mJ7zP`hZeG}#b;+7WfWLd)+1=|7#Gok5` zG>=+PwbRapIZ5MkMlIhwvT#PZvRYR`1@P@@Utmk=~PJ?Y-;A0WD(L>U$fy1JIu1LD{KYK;;KwXllH&w|XH z8O}`msY42oiOEFw6z+0`wy1Bb-0*(0a3)EY;4QjUht`CA`|a`eG5Nrj?)m4E;Z-%$Vybk(GE3P7~g!fs2x9iN@E(h(UmQ7atH zB${XB+#4Pmfa7MTeK*}AH{ICq){i!rC=!G=tjmZeXU^5D-yUZ+M*Ns&GUqFvf|oI_ zR!&JtD4fM5e9iex{dHAqah_yX4WAv3&+YU(5pv2AhE9#RgQC>lvjsxO-vjVYd@(^y ztaY6kg)RWuJSK8ZGe}rM3_??n>OV1S(`1qT23G259y&VZv$Vg3-jYapKJenCq6xr` z=`7?ZpoXo03#MxO?(+bf5Y$uSQR2!LsB3$jiIx%e6f+#f)OQeIV$to!pWjy6Id+Rf zY#O(|*PaazmoDQLb}%e6@D$MiIg9w~K&s^1+TE^WEsjK>o2Wj*NteiOxDVb92NGM^ zj|h7cs}pprs=zl&BMM8ztGWOV599>FhvDlMsDMoT{E7;hqONg}A~AzUP&EX!eBd= zZEw&FP$aG@^=LQf3zwTG8^9rkn9MN=o^t zLlnzX8O(@h8yerW$ z!dgPQbmit>P``Euc9w=Z8X3=Uuz6cwf*n`@6e(Eh6>SbinG}?!FCg>_)oZ~TlJJFa z%iuQoo;$laiV#^5iE4mQ-pBoM+1I)Dp*h}|}G*`)*j##CR=vtgU2Sx0V zBY_UEHIxqD7yiyN)T*P0)4T3=!Ww4k#=RqFL6cVOOG$elEiNDeLh14S^{U}ytLe5s zRz^Z6M8}z{Y(7~k?)Ye$Um)9*)l=tkws2!{NnIAEXnt-2(oxhzqhD83j&;9%(6L@a zu-NEHqA-2P@?!JGN#?ApYfH2_u?k5O7e~wjDd9uu>5EGAXR? zcXTUEPS<=Xa3loQ9faET_WRk+o*UU=m+oTIbI>A}bML`}p3xx}6o$H*i^s`g%EeXo zS%SgQ#^(+Dy4F80szUe*#=qzDpDE}BsZN|+ZFnazcCgOD! ztsB>@X?JLa=x`D)SFul^4w^vvT(Ir{zmzo5`0poHcVinNR;vV}J+x&Qa)sDT3e_Nf zRWMInCvGJ~*d^2vOZ_B9k3VdhY+Et3VCZgR%=hl(In3-wkl$E`(buksBpp?A@;ee2gE5w&4nI? zkVPdC{{uIMmY?uB=1;Ri1?Ui+LQLDa``O8G?BLET&c(q>4Y7Q`t2Fz2mapy7m)9H+ z*i`Sho6J3p#*|HwX8zy8Tu_M|#_a3^{qQ|e0S5=r3~LD_4+GRrzhiF9xVCx6jvb6n&Sh4P2GUQV z+MWGe#$}136tSdom&oaZjf+2T3UVUdivH_Qsimso4W-qSBz?@t!?NSgx1!Idq#nDGLIX^+R8 z&M>es-=cX-vsac@JM~+nT+Ez|$>c`ye?FYDj%|UW#g`wm0$w)Z-lt=J=sS+-2MjTH z1eH}!OFyY;$*dW3&0X$2k3p%@otEA}_mS|=waOpuyLH2MwA9-H!`=8{>7=#rW}XGb z0cRJl=zqRv$EF^hx1DbgmJUOXfvEM9E-2I1#}&x9P6jF`tl9dw)zDDaFv-^04~fnC zGyGeqRO-1AiACp%K>DUZzff?}P9uI%-M3;Eoj@H)4aY;)?yMgdN9 zOKiD>agW`d=xQgnnv+wfi`Ygo&Qk_g`1$wmZ?^nwab?{OZk+%fHbd^Fgm8vp5#T9) z2E`+l$c@RuTdsW~yt*log;6kN?0Eq-H(oBV?qR&rx-2E3jI5~@7n*R}1)xns#O#gP zAB*VNvuv|Zf(XVjmILRN_4Gm~L^@L!cIOyh;qUMJ+Of@^)KMd-`)MZ3O(87Li*+n> zUd5Ki)DjgAz%=F;a41~l=s8L0ga}C^Q6k(jegUnv=3p+eLA^>)VxV)hFOiiQ=^%=M-%+gmF18dT%6_ga}f8HDpRF?$rmE(a61lSsX) z$>f7S^_24bjb)Cd&SWvsRhbD0elfffXZf`MfE!WnvwSCxZ2`vOb^XyC-3Qf>6z^N) zhbWRnV`&}ob?v5Q4m(zxeKs}!ArW5`Ru>T`F5iWA@sB#&@QVTaorg_`D>)JISah>| z1adDXn8;*lwd}w|cV0YaMmcy$$jn`p z7Q*C4fPb(LicMbfVunv`qHT?lKM-vs7~Map@8Jm13P-Hpi%3IZr76iruvBV80G6`9|=e#{_s=Q>G^b(M-qT}P^0=+pVW)C+Aw~;W7xJrau6?b2X?+wCsnTyEctuLm9eJw>(u-A?V zlOre_F-UYCs5yY0r}HNIlEi%*itS*(g81wKIitV{>oAQ<`l`Sb5C(8?vP&b(rawW$nhN zy~A_T3;Ro{zN+fLr$>tor;sP16(}fNu&vIbGv!uy{jz{o>_CK{xr(3Zu=-^iZt2t2 zG?BE>$*eP0Z{6-%Gz~pwJwM+)(%m#4*l_PqhB52u0khj{Y%~6%F9}QCYHHHBa@<{(q6N>Oq7}a8ngca zNl3dv=&4q$F4(eQ!Wa-Yb6Ar@$X?vM+aeX~=zT^WtK6R5fwVhy+?5Q(Bk=E)2M)M4 z=;8)yViTzrfgvYJd5|SEbF6oQ*a;`bBnrk`N+5ey(zD5B6BQ#F6n*niL1K6xJNX$s z>c%fqU5Tt@mU|X|cR@cpES?6F1Te8w0{z4?`3B2|KL z5*0O51lJ^Kbke_dy8|#G>YH7GvH^4|h~&U#o3KHWhwYe%#FPAn7%X}qq#+x=hz#s( z{PEx_tZsS3+~(A&Fl0wv_KHgNryG!}?F7W#z*rw2fL{~$v>*z%_cdzEx1Bq8n&30Y z^o6uR`L%ZkunK`s_++zHJ}*%aQzMBO0UivUVyU04)3KV5v1`S>-TNB4n$I~_h8rMW zh64k2O621=_l4XX{QPPdCzCx&9`ng?4|O9Glj+j+DYaXX#1e*Zf6LQ)SMfdgW*kW* zA>lf2=#%NLh>VpJfhwuFnwgsuQ|iy%-R7{lQ?xs0Y|M#DF2Y7Z-{Z2f$_O_B4IIeW zU^qjxw@+l25+@}%MqBJEBSjkICUDa%>g?+?uP_w1!W|^Sxlm0YzORbi4R{Fi>8q7? zT0ffY%qUn_yOBp%Wqa$8Hn^N>UdNG>Keqjh=KvK9lTizlcTtp{e52$Z1$q^3+6m$q zM-1oj^pLg4p?p$}_7D+`M-bghbZ>GU`Z@LW^@l?04kRJ$6|+b>g-i!au}Jw$x8$4_ zBL76JUD3!T_3X+870su?d?r?DL%zqnWw5)ceat|el8~M8c!*Py-7E^vJqVVAf!2CE zHHcKR7a}wyuhFB~kVFm?z4!2lGYm9~CQ5tY#X#)w%qa2Xgb-_o6U;`8mu@SZ8P#Ex zbk`*oCntpWOG@hha{eMZ0Wfx?;cJP3+C+XgLTh!jvTy@)n$0iU_~7(Osfd&SkQ_t< z+KUig0WvoETP}QDKs2q5R_;i+FxYt<(|q2a2;&a%@)?ch70Z@Y5fF(RgkQ+XZnmz!g?qQ`g4J$&JnR`^7T1DQN!?+ZKr0)ISX+ zUE2x|d?P)s2p|k%jRk^{0AZ(n|9E7%2|T4q^@ZfV`8t^PqzveG(W+qBA0EHf)F^{_-#p zMsbIu$~3vH(U?!7zIg;o7uhk5zc;ry;o8fojolwG8?mqr1M!lSkRXfIqboD#={!3| z+egL17C>Fa1v1eyh&D8!Qy5wxjk>i4y!UEK9@SE@6sV&>iLMP+izJ*8k(VZY6H@9R z-55C1oLMU1T^b@C3}=Y|wF{47eS@2fXLijVqZG?dZ;*K^sVY&2zo-C1r%2@HP`7~u zaWZnWUcxU!z!U18^=SYka1QU=#+VMnkHcr=NtLL28flHasA7E4MPv&+W2ImEV9lAc zlFMazh}mu&k<3ARC;CrF#R=9Twf1D;)9$j>5cI_M zPW+F1Ncmg?YFea9i)&QJ%q9##q=pH-y=Ft&Smx!3*BB&l?O7Hg2zllOHkD_9PMu)vrD~TM1hg z3d2MhmAr(5Z&{QHVNl(;LGP0N!JX9ZQ&N96pRLo0RP%RF?h4-X$Xy%Z%YjW_>v%PD z!)63h=r6bwSLUb3=KQEk$?jU>S^P`cncE1_4S6@(b#LW@NKl!WcxNX;lx@kDBs!Lje1}ugO=Z^6-c}-8nU!C8nS~K=`HgfuAPG+2)~db^@1U z%*T(_6%F2Y-brK`zr@zNci|HHj^q)70e*Z&oX`p?_`C!_{|w*TdTlFaK|N->+&!85m7 zDv$UEf+i;)pV9}Z93ApV_?3@?z34gAfIxwm9TAa{|LTxDIk_+h4nD;8_-px-LnPe9 zCf>zMyI98q^)RfP`4Mf`Y})ybcnS04gwUBnC2sdiPiIg=UZZpmwck;mXPwr<2nI@~ z_?f{BmILEgVYYDyDvv6VbjoMqBViFn${j480GC@|Y(O3CeRcK3{HYOK1-BPaNEgt_ z-ne~XkZ_x>?VDY>=;!i&88groM*p&0KX)j|LINdd#6(zn)>d7S!P($+NlkN}RR8_cB;4FyjdvARj+rTlf_(FSprC25pNMbM}eB1@l z(laL5}%tpH!QY!1+)^wo)*+~2&T5rc*znh)a}m&(2CjFsi(dnA7NQ<> zYRhnG_)c86rT)M-V4xCWVvb^;#fZWDhMMdvCX1#%%Zk#{(%qF>YHHCaF$@(j)#DS+ zu{D|q3JP}3yzdbyD=n=sQB)$MPhI`&DMy5qPD&Mkuy}!}Rqg}>y2|l_O{nam$9KL$ zPeUUPU@87n{MK2*n^m$h<=?;Y%<653D_?c-(}=U(=5@D2XS9Jjt!3dco&wT-Y;e^ zA4tsy2VDY>mW*)=1@A#0BlDqnea7Ij#$2uw&-+Ca-I~~1HLcwNYUAXs z&>T!1peSo_7v|FUE1sYnw}@D1eq-1|^~McObBdO|oGHf}+INejs;uXOLnA5{7X7Qz z{7d)uAO8@WmbHs(YsTfqrAuhSl1fZ2{57d3Hcm`Uh|WyieemEz=WQk)9@2_NzmKF) z?%u=$mKe4maE1sC2^{KMFCzgaI_7XPpYOE6;sd_{nq{|#$K29N_-t?hy+Q66axu4$s4;uizSFgK{~Ha@rJ*xo0Iu&%s@5juhqMc~bT zF*p>W+4?Y%S3!B-)y-{Z*|~(G_JlEKyc1tb=oUbXK(tB*B6wAZ(#axtAil6`nDn!d zgp*$Q}Ve(sk?9B1G{dU_h7{_2|)l@+}xaX#1v2h|Ae^OW1$8O%OnE zL84`3s1t+<5)VW_F!%K|u54O;t>aoeTt7=5JiNNPMSLzkJa;K3^Mk{-9pVv@l^^10 zNp=aeQkkj8ta2y7tlQS}`c9m<&z3uiA-6>x?j1Se+SxG_o~fy+nG_dSyuumYpBHv* zVnBM~jgyA*n+ehM9otOzk%3{ZW)Xr6t%n0*jP(qiL*-QX{MBQmz)YZ>B8@DjHwX4-glDmym=HT2IrLVjpa-HOk#TXhww;Heq=-e-s1 zvfZ948lA7b_~Oi(%Q+9#)t9hupWg2l@K8afaO#i+PtH-nYmT!0Vo4{aL_goV*VB1X zytj_)NDHrpRa011xrDS zF7YMh-GJxAWe}MqmzbCi85xj@yRm$TdU|dFqyN3c)QXwq$#HSgM!R0oQcas(h|wD< zLm=WMBri^GZhu-C_0!n`8jXv(U8vIVp)i`!*#C)}G7-E5W+M?9l)up~QHRcl^vee+ zT9lOB>hKlbiF6Z1Y;D4CMSS5{9~HITe|;B6chv&MFwxXUk8EoXe5YosunHh8C*A>w z_rOi`*H@2fesP4cYm3^cRt^fK_Dj`8DKIY0zMD^A>jGDlsM&Vay~G^He)0Y}vZK*mI_9tC5Udp_HpkON9Q9gOwTT6GZ&9^Sn4##xx2qN@G)cvPoJDG+ zh8zZ4kv&o(WZhxzv#fqMc6}&aap2O7%Y`Y`Q%v}@v4{n9dj`sME9 zb1z=7H4fS8v3Yr^o+_~KjZxR;tgW5lvjPSUWf)j?3`xaWaE=imP{Ln~2$(P5%(>L{ zB6%lk0=s{juW!LW6FI$|Rgc}SnwUSg@y->{6{A;_^W*t@#rr2G((EU1nqcih!N(N0 zZE$R?epjIGnI39oyEQvFrznVIJ4UV{mJ_H13-wavmMDZ+F>4;K-d3xTl#ncUae+I{ zt|lQjPH|R!|Iu|oJVJcf9HX76t)n}M3R+rov#!^bE9_X3TkE$o3iP{nerKpjjFzEh zBq$mLj@7(7!=au@|MzHMp?)UkwCI;oKGUXi`iW{T9!sbNs{NOm65?{T5rEN>Y1NY1 zohCKq^$Fih0xm6DWPfam{H+)0YOB4eW+)P|p%S58|dM0{X9w)gDOHo-pJS2_WCWVf*2}`$#E=}TjsJMh) zO|Nx9=0LNSCUqd@zykL?4W4By{ns;cWj|E4kZSxQs~|J-G&%qMV?|m?>|t8MP;G2W zZemKbY@0`L%ofcN)zhAZI|&wL$(~hT9x81-rcZsq)3-i`w@^Ixd&R{@kMSqD`tDx2 zj{UB=gUl6HD{Do2)$hBgQVXaw+7C)#MT@`7aD?-ikMeBdI@^q%h_a_wdR|8E{Y;ri zJaJNH$>Qm^9U+{9aMyQqsssmK$y)#rL%=b(!T3$+G&z>QzUj zk{JcaxJ5!hgqld73Z-q^p~2d8DKS<_XZ6_6{+xSX!%;bhlar%9y+}q~`F7fkM`sw< zZ=l7*sLNnJp8CeY$k<8C)u1=2mUa)IzbCy5>7p2v4)n3}Qs!XXBG$&a%e_#^J@a#^ zh<{q|;C`|`Sv0MV@0dZSp5}wd5<##EYANeG2b2wt`*WTcyr+LE`q8I_{{Ht&DqHOt z*9Ru0?p0diw4{_bMZ-k)p&I2aTI3L&FGGX9SuPJnmBExGKP81kv(lTC_GQY4XaBAh z<-BJ%exH-pTXSG%LvudF5oM4w^rAe1$&CU97smG%ap#2OC-NUS=Jphps?ictYc7WD zXbkmB&Fd(!XBU%NP#d4Ir!S(kZ@RX^Heb?}yFCp%eG&qH7?Ts2Wa^Vo^!}Q)>|A}G zW~DbMS{gCELClOByAx@7N8@dW>>tI*@3FH(ZD$|rL3{O!KAc9zXOq64^to~3=4ZC` zQHOM1y$6Px+FNrRtsWFk-lJzuLp>{$ljr?KsS*|aNly5TtEy;{zy`p9Op#NrZ7i}6z*Ljb|!OFE{Zp+VDos{EN%GId>vPr{QZ zMK2@&(sJ?G=xeKzXvwlmyk42Hyw{kWm2}mMtBxE(C`Kx6qxMFwn4XM*>rsD_MZ!^9 z#`XT)j%)soy)lZNj6F4P)Jn@LH4UC~uu3|}@9_;+PO%E5zsW@%Kb?jB1xr!VvyaM4 z#^=80BAlhA{;0j)q56&EO}(aBwKV-Q;hDBW91qJ^Jud_FuT9@<-FVU5UyEfAAC{mc z&bB}KzD1(9;kisffn+k^RjOpqVrN%IUW0^4UA@Md9U5{Or{<{v2}t?AoAhNmCU}_a z5wEiIbZ>57n=7aZBe)$BB}? z^$O3Mw~MyPn5L@wjeR+5^PrS#koxs(81{SnuSZikIZybze0s97yE9>{r2ZboE?QKs zhS!9XsPptaGc$8N&hzb`kT}Pq5`~UbAF6P704*g2JPf_Zaw~$KwJTe+FR++9a6Hsm zH*xEnsF(T{inmn?=W@j_Qv>|9`6nJuv-h|jwZC0xl~Oj;X7Mbuv0y~ZqA4t9_}*pC=D?`_HzH%_1f%vcE>6VeVR6j82AyZli>7|t_YR6u0A8+p`c-Def8))o{j=xt6<8MO5^YZB7$xuPVtc$$Sm`6ZL&x+EQXI7El1Q;es$}J$N@(Mf3C^jLku)w&`*CZZ zQn@lc+6(4(c@GZ{GCRqH$0l8y<#vCeSsCS&c5*LmKWl|ZR8c%Vg`yXY@Td2CH&{xw)aQ^ksj1xUafKe^SIDkJ^CF-iAAuOUuQ0CKe|oL{!D*+5mipK2;3J z1SHEM?IQTHQjM~+I1_1aiw&8?0(19$y1!Omm+GO>*wv^CDV(elrEgN+w=bHy z7vz^boS`S0D|y0CijlE`(GmSS;**VZ4G9h@I+Kf5wthGb+l0(C-~FpLt6H{l;Hk#I z{>7+kGeyPV&L}Il$|;9j*Rr9O+4Fmm&Y@=zWYCTsrB*{TiIyw3WMYDo zJyF9(%WI|aIU+TbNzLpsAG=l>Ai0@s{ra8g_u*zIWMxVFGcrOFMa|%Fn9pW06i}2n z3m+=S8W|xht$U-EQ(9T6Y2@_alAF1@x^C+KqGpyPqu+jHG;yht&ZeObmSm5q9d`G+v}neDaNI_u zQQh28+o$m_3P+!E!L%#wp1yK2{HOdG!_+hN|MI%JSd_Bt`Kv@E18C_J_fgXB4+`Q8 zZGB%k{yD2KWuXrvBH`Z71WwIE*LV=R$Qpz;a_y~A3gyW^%G%`B>vuvl$wF3#nwN3S zS+|Z7sM|NE!PUIO8!oE5_$DRWLLc z9?sF^c=1@;VlfUCuX_oW9|AsYDY<^rui?6#sFhp<_;2Xov2-&i5hC*9&|) zLb&6FeYl&>mGuVHa*yu5erC^twTrI9)4DNi7CS3 zvl-2B+rdh1&HP76In82rcm4StAeb1&8;G1bMANwW^$&fSFN`)wq2r7Pc3WD zf*)YiJ9f&CO{rE@H4U=V?S~bl_$fd5D7Cdaaps9ByVfWvYigd@uO)n-PDnsiO;g6= zQIIwJh1S_J0R`2>^#ucJ6w0x^8%iE7e0evsrnat1IWQ(Q?yAYbeX(-8UTuvu*wi`X zG&phaoyonU+b`7?0!~H+DJS1Jz4tJc!hQXyV7kebsuh*xHk$$Cece6uvcpDOTRR~& zF}@(tJ1*b=?e54?8jDte8Dn;X1MObox^_R7Bw|> z>m?-Ronns6Rrd&__N`sEc-fN6R~9bljoKy})OWnD=H0v2Bkau4=?4x|Em*l31oxU- zL{LXW7v8z>L*|59U~su{S&_HQ_BGq@ENfTxJi1fXP-@YeuG&o(+0&0QhQ%i)URMd0 zSAOa$9=8Abl_G(9%{70A6rR5^rAbMiHf?ffr>fBRJMDa7aAv_}+6C@%?*60E`@WtO zuYJ=Q>@K~3#iFuD%N8&E?4-c;PnO}84$2j&ZSrmLJWM632e@n3^qTwKkGs;|${A<6 z*0&@vDJeQG?y54oEZ_Pl&Id7~S_=EM6et3Rq$~u>Q&KQ=%fgc$WJo5^XfLRG$b?PI z%(gRouUWBFxpe2I8>??#O{B>ww^be5{~#udQ`$|BTQD=TW~X@qEp^-4o9k9K9F5-A z%fkG(*N&ZQ_a%QCRT1Xp`_gy$;sR?{>&>sbw+4#W%T;6g5~AV!4*YYH?Ler?~&-_4Gf2 z3nzk`L6C9%BE_~H%*c3;$@uBgv}tfqkw0<5rT=qkLx81u)d+|yxP1~k?7a^?hF9a0MH-$;`tw)jPJm5FQ zX3LN4l|~=D8D>8lU3uvu#D}YnkB(~9{8cP067XX8(d{ukJ>Q}ya*ah-8RgiiF}SpD zijCfN#8H#&s>NycV?~e5znI8vuXni8mzxJ-mM)+(;{}zedQYFg^}V!6)WP09MCjhf zvpyYpJ?`VQC_!fLfsH;Qu_JLevoA_>bTm61{jrc&n_oggaqk8x4zGc!@q*oVDCeNZ*~I9eCj0i>xSt?$T|X5z3Ko9_`H-eOFLC>FA{!!BMCW~5-mOi)h|TE!6U+8%yc?IR zg}Ic+TiS(nGs>+qn`?Foth*qgxjt$y+mQbY-lgr+pX~PWyjS{BS9N!k!z=qtd*%@i zfzzi>OLpXb%W+#D;l@_@B-B4Zq6}`RB_?DM(FR3`u)C*5YXhkgcQE%FCWZ5>(Iy6?VAKl*UF*lQe&VHfR zvTZy~6XE|{S$*W6?I)OyD%^Z%;6Jw|^uTnJJgl}viNTHgWV}c2bnF2vBs&AkA~Sby z@vVOMP9=2{-~Rna4sPMC6cZJd+q)q;JA2~|eY9rE3Su$)0t?4idC?b@Tr1j`)@r!n z8q4yfmm9M5X4U>lx*KJ^peicPROFp&ka~r|8T$<3n2;Bb7TwR%OBgf=I@ou2Y-RR_*JAc<*`1r%*uu4Ub!`v$WYhbI!%Nj`xkc>q%Bu#a zH}DobFm6AR%bCfvFfjJ!%Pb2OivQLPH_vS9x;1p8)OgdmAbTX0$-HQdh2Q9n~ zjAUxk9Z;S@)=nln)NK&ss3tIc*@u zZ@lary-niVGZ9r;{euPZ_7&0U?e{gttM^`Ok!wp~7oMc{!js2KKNLDOHZj%a_aIPf#W3TXz|G3X2i=xR+dLVz7S>J3 zl`s|GP{F;tui?@1k`-l-lwaAszBy9P<8Hi{bz^B+a7HTwWjs>9{l40?ixca5pA*kz zJ1@1%-Gc@=D^h?MIq{2qVNl>MH{ z{YuU)O1yE+C8oYsLB>w3>_&86d|&;q@N-D8Q4S7B)(^a}TXR#XM_k7_-2W6;^f;6C z?%1)GPK&hRE$sbjavtHWrQzFdHre&KiMfes(D-yGCe7EgP27LJN5ZM6zoYQ{_sCT& zHMJXGJc#|=n57`VylcbFHQv&^lb02-#b6M>thMM;I))!o%>p<#Z`mJKmSkA;HGI>V zx8*~<4XedurphRbl9>vuRps6_Hi{ZGLYQO0xX@fz+jlQs*NghIpY^*6rvv9+Kpf~5 zJfEIf&30Kmg1q~g^i3c(aDu8M3G8-Eetzg_zSos=)0Ne=wXa;-rcOx!-*jT!D9FcW z<;0+pZp*zRwf5FUjk}MuFRO1Ebof?av?JIu|K`~2u!~l`J;PY54QsnHS9Y5{cRx2* z&X22oA6%PQ^ZHYpOl7ZBET6{~K7^0N=_5?BZEu-!*l0us>5RxZu1k_Qw93 ziT<4H6~cKG8dXhij^vLSr>t!Y_HXExv+~a^NGrBDwk+K`u5gYg`|oY3TjVYp9cEwL z{{3_2>4(a%J$h{`y=qTvJM;6lUAcdKg$>V@)f=q^SJ}*lwyv8VOyXUCH81xcw)4&# z2a?Q#CA9XQ+5a*pLEtg-C*6NUH0T5FUERy8Y3X#gpD$Fgu;<`%?%?u(Bz{f$6u}%_ zpVNF#zSPB^)J6Cxoo;I!oA`3<|KRJ*?*sCVNPhv5)0Fr{{UT@Avn9exLUb_2@BX?)$#3>pafmJkI0f z)CmhJP2aZTiNM*h<530TUaq-oa%Ieh1>(8ZN4bv=cjr6jaTqSLdy;+;p6!VSMAgfJ1kxJAYU_%%5WRYk(P zJKXQ0EEW0gESx@`5U!R{LI`B0f>Hq=scl(USc*;SK3>{Zj_w>DriZp>ngy@Ndm0t` zqxl5g`ngnErLTpMPkKP{nYrUlV8Y*P3pptsN{v%Ko~lIRe$3#>H64Bp`0R;!kk1`Y z&9bU3Z768rKG)~(bo-j8C45cZ`RB{>&NZE{gf2zsuS|{lK_?*TxfyVaW7#B>Ix(}N zg3$P;dQFFfJ*411;l6#PBXu~#-gfFXyn*uHHvmKlJt($!R>D#JnXfNVlc*!)P<00@ zGcJzPKmbdwJ~pTGWLAfQ?$M~gfWk-6HY$X(=RI|phd^2`KEgK*OXho z*rscqW3n1roo2tr8PiYaUR%d$V`4Kr8>oihqv3AD&4}3b%EYY{q14gMZfDA0F5Sd@=Q#Ek zS@y$)lZaS+g=YAl&lb*yQY&5a@sR?Rv@ih=_Tr!0^MG#!J7bI{f@v98$&>QT0FId^TLfXbYrzEvgxCT0m!uh(!t^fQ#0iOatBk721|{fX`gAP zR~IbCwFH#TtPwGHeEwLxuCTK1xa!%s`c6y3tjP7ZC8jlx7^(v%tv~0k%28p&=WXPr7p}7&4q6wa5}*4< z{eH)Mz<3(ZnlYbPv%(i3j@`beYPOLg&4gS@U}dqxN25P3-KKhWEyA~w`pZ^T`?kM0 zW9|zXvbW}cWEG+H$CBlY`!OKp-~ddjDN!3~@9KD`)`*~AsMr1{Ey zUJDo-@pE`O%c5a8ml*zT?oy-VNT-?5Hm zrN}4??OTPRmKqO>4?@*w3??v zSmDOgd^c9u>@2iiZaP^xk5`|tJvAJ(&tJyEWNm9Ak>_Z7kJ?%DMCxe%(ogqTxoznZ zr!fUU-FDmnrCQ8meRWDdtOT4PHZ?mm7V_<&^QiL@K13cAST zm)!U0vr*^cLdzUj62IDB)5%^-=jW2ua^LY~`>w}nZQpRafq^w>fqtcN+4%W0zB1-c z+K^M|d>PN*7jM+jlx2t*S`_&m{4)BI|7(G1W}y7WZ$%GsuKsJH=ROIS^5@7H9Mf3F zzo6X4?Jb=)@|o@t*E{WNjeQuqnHTZ+#&6$cZnJUw$f3dWA2nX^nQJ9C_j0`BnNauk z27X<_Fv)u&4$a@)@{#|wHn;74BRf9@jNJBiD7hsm`-E)$#^p4tw;OLJaJkklk+w!N zxZU;gFV!y2W9`B(){$-E0_xpuq8j9_ZQ@+mN2NyklUl99_fWQ46LdU!JCn31WK!&Q z?DS8(LXxfJ*w$;?j+VDZtQ7)GsE6p9ABj*Jrk3qmlriQ+4DFd+t&W) zOq`n=bNn~NQ`6q%r$#9ewcRZ*y@8C9{Z*FOx8SBCRU2x_4gAJ12pq zjOFLd8oN2xo8IT1zVx>jv8>ax0%N;d=NtSMQA0aLuD|Wv#8o;pYT_RsUQhqswsEy- zmLD@?y%K|2j>Rp;91$BZ>>#^;Mg}lnJ>690(@O==uNGIPb`7@NXI9x+cbnrp z9?8XsxJR8oU|?=`OGaH|h_W%e%v5UD*^O32`!pX2D~{k~wF2>1nWaA_ALQ!{2d0`e z#J%k9yqjg^&UcDW0|UfK|AIJ-7qt;(@R!n(OyfxF6crJ<&ij@VfsXfKUavD{-_Rw$ z-a|8RPKlqQG?^|moLrTQD=ihQudn~L zuwd!z_1alhLo(Ukm%ryGuUdUAqH|_FN7S)@fxI>Q{EL{F1Wo&t+qn#EOqUTpowFZj za16JI!&B&)E+=%p?4DhfbM2y{Nz|qfyUv@KRa27;s0Aj;smjWK{`Ez8Vc_H&uha_p z@fWe=37vLdY(&-7)rIBc+HO90?ks7LBB{{T_mgPEIn0!^^``6%$z=GYqLPxg;1ZL2 zUf#*?%+U!=>U?>}{!2rkWyrBl-p9@)j&O0_f;D~RE#qYbdJ+Ufb^ICgQ__AOyQY@) zOH+8((xso$GU@)Yx{sfm3Wft`Ixe^CpP_EY+|fDdCzvt+s@wLWv|k3XxhyjH{i@AlE{FG&6$Pcu ze9D#YqsqTsCq5lpKABvjH?|S8LqYE|+8-noi`~xgJEig6{Z&kfVRci%aZX0JerxezYyYhZ zgw>nm4z|S`41U@S;Yp)V6C^#C^sL;sK1Q4P(Un_fIL5CmidLA@D;(#dJu0Q5;~lc{ z@-nFQb>$T&wuoJwsP0=>Zho!HsY34zbMsDI%W{;EmH7H=^<@0rr#2d|l59d8z6hQi zqhq2NQD^M%G^%>YFdF`il&bYZq2^8D3z%CDbYQ}Mv3SRbn`4MN?Z%8IU zTJ~%{zB7l;vWhEozF|1?K~jz6S#kbBb07I;w<9!$`OLej@Fl0LwJ+(q)wEVfT3(wA zsq=obs(rqG#NoH-85pc>ywZ^qfnnic^o$H3Z44wUwi4e)z(QyypCy zz}O8+%=l3E&ueU8k(Q&)v!NWQtAEC+-Ad&7=ZlbtOlAh|5%0`_WZYCFCRos5$>c}2c_p?+dWMm#7x`T z^hUaT_nQn%`m&6&&o)oJX8KRBZJzd9VbF9ix$#EK3$Z+}i-zAIPuL&92Tkb;-|raM zb8$6jy8Rx$7t12^^=AEtIC1h57Ia$`Kd1c!t6AD8L%z)R=V*tXNiH0qpPs%9drm}F zvSoOOWY;uIT@v-{*Tre;8#!W*?VRoO46OJ4og==LTef$E(* zzjmnKsH<*a{@od5uh@GDNXRC_vz(@rdOoZF=B2ZvV`Ir1frk7nu99ta+V_n(H>*fX zjWF#Wx9mpsvA3nKesWW2m#;C?`WQg5wkNrm5HG_J>r)ygeVW8TPefQ!^+pHrpL##} zN#7UoGy^3+ZYPS}vKY;(s=MGx*>cBIWM2#w9cF#v#IScsWpQm7uj|vck4}!R4>PlK zGibX_93Ga!QZik$){vy@7A03UGfUs9Hr5xv^@)Lty2#2_g=|+nb*^V6J5w@N=JZ(S zk9#5KNrCJyE_TVuZi;N5lZEOE>1mBo{nE^m!i>Q%`eRF7c=_ZT=}%a>S+a8L-sJHn zq>QyPh(+2;tm-gbEhurlm{j~WVJN9?w4L^3i~Ce3r(~(CUF&<>fdQ$0L%Pc}T73g| zsnp3=KWa97q7r1OmRtx ztYu^U!LgKb#!{n(^tH*rSj1wk?dGP}0P4e6lt`P*)0H`fUrSuCoo#R>Qr2}w9vK?L z3{x=*J)p4u;XAI{a?D9{y)n6=*EYg)%?{cR3QI}^sLraF%lZk^w~5k}T1Xp+yQJOk zQ^G5B373#itZ@eZoERW|oe^P~!Xb zeSOqWMmZB&pxX8g(23LUyC*wNpu4S4IV)un>0f+0y<@04Sx1@If3xU)gz}}fX;L>9 zPHl$t#$Yu|i^Oe@oiGhOxiDTz&xiEHvD3oh;x{24K;0l3B}|i&r)OBra_Jl;ZSRQu zY1>n)avI_nxR}M=%}!%=-mx=ApN$ObwE3uRg9~NJ4tttgpnB!Z5)T4}qYbm2vh(~o zTj=WCR(--ZBYN-*R;tf_UmW&inj{MPoQzDRqet8FQ(kFk{Z`0YXy@msYy-> zlarx)venO*u+x(O{&{wdI+tAh{Re<^k^-V{XtJ|!M6ap{5jIPT0K=3iB%H64T)ji6 zt!_aV>LgSlrom&paVAT2-#+4COcs~8=dz}6!f@E_g-Bw?Z;b|dr8Lz zn=$LVaMnxblxe?<(!={}OdfCKHO(30G>T1ez}5eg-X3Jt=C zMiSBAnpB!%mK#X#H_pzF!4>l~QmXQBn=?1{2RfB>+K572=cY*w#O3n1aG_kTKcRes zDZ{XU+sJ#8V-w}UtIakf+jp`$1G`yFe=?N zTZJBeW1W86pd6VU>-Ghib?Q$og!zQPX3IXV-`@ z;@x<8;5{AWnm@QW(Kt}ubvV)lYa>0up`=vTjj5nbTTjvSnB*$-Eu z;EW7#VPR=;Uq?9-7IJ|&RKGaRMY=(A0%l@D;lPePq}Dlk%O#sYL=oUpcb4wt^H}Zo z%qPVtLT%s7J}}F5j9zYO;MG?Wi%!Imw|)|agy)m^3m&wk$UPJ^Yk>iV<+*joJhNg`2i1#LC#ACPI%;!S_2 ziMm|smMpIp)chjZZ8@x*Pfw!zV7*?jQA(rrA~iX94GM^(f;}%V@}D|irt65%CRw_G zO+&r+$PM_KWje33#Ydbzw2c~`_v}blnk`T|(&%ofo>QGv8t5nWs_ut*6&|a{jKkGbpiJF{Np(ZsH9f+JyM3bs1ngXx@ zmO~p_G^ACI-zCnow4y`HoI!ACIA6U6T`?KfOa)Wo-5<;Oqpu08%dv7@pg4Pmm}FRg zQiToWX@U7D?81Z*7SW-LnPfy*)e^!FkLj0M(e5CeuT+fc% zl-jS$M`Tr#=y#jvU*XG$w6E*vG8Vq$;k_gK_Eyh5R88HxD$cYX2o4uC5O&!EEBA$c z|4f;Oruh4pRC@Q)ZjEe9AgPcB1;?M%sh=RPps~vcT$1rL&UJmJxBdj@QACE+Qyr^b z!Otofbjc2(x)2E`=o8-!tSDWZ>f$XCtn3e*^?0A8028=oaM}WDro)7dUSUU(4*-Muz&ZYIp1Nxu|jBCX|j4LQB{udvL z)7X%Irm#t!6Z>h0si3CmxSo_2!YS%#v-yy&dDEoXyK@P*v4DXi94`xeWiI0v0NcXG9zp`oVBKaoGJ$76595gvqqfB?odLkSq& zeqdmAfitctc#qVxN{O;+)+wZkznzn{r{Q;7zFF9G;nE1D-3_{M^`=+CiSrN4$Co}@ z7eyyDH{!^1KYgTW-Y=xibj#%J3Dtc}Qhe@2Dsm+mZ+2&;r@vaMd{mdC#IwWw%y$@# zz%+!K)J@d(lq}v?`evLQp4dF#vQKbvI4O=&)}RD7IK(hj_9`$U1g=b$Ko8G#=LU>% z!?!dG@hmUpPfWYg9LgivqE2|2y;#9RH*un?|1=YL51%fP0JE$s*xgBrD5dQjDFcxtCtOO|*>PEpd_4T-;oj9U&S??%Q!4B|F?dnk25&>7gPPn`Gpk!alL-(1y^=B~K z{zb%28<#ZnD*1iatQ_3$MC_9`uaY%i6K6d2Q|M@2Xt#|^;d56a-$;!sTc^z{a4Ev< ze`ec1*4o-CE+Mftv5l;`Bv=jolb+Bxk`b^q5=HVFSbS}L(hdrdAl}{0=5=Jzl<@P= z3*>xR_msJF&NNT1MK{lWqo(Agd3R9QvrTs6Z10@&To;~C@VmC*yxOD;|D%twK$`#0 zZLs1cJo=DYxiyNuJyH_MO#K5o5=jlj^mD>Uwd2o-fQTi6GwNLA&01(}1^9rm7aD8y zBeY7ATkLijbX{*_+y8mme@+ZBS>C}q&1bQD20#)!%^8h4#9(T9xd5w6KZY4$bhRLwg7!4+;pm=RVuzqtA@adg7IAEtOv&R9N}Xcx}7O-6diGU z@^Vfx;bzHoJ@vDZj058I&d7)m{ey$;ZEYvxZ-;;(W4vbm!qU<-cyi@tXIr<=3P=))L`V3b zBUcz%E=21T;(I=qObHTB&3pzH78I^=p@I~ij8Z_p+>hGN!v*M6JSxi8~8dM*9Jx#l?#nqpu!RyJWwvzkj!9J3t*Hw-VT& zqxZN1B8Iq7?ef33~;hjus;ne3Sc7jnSRVFzR3OE2n23uJwq-)#x?Nh4VwYKW}PV|Mx3t4DX$7%dKM7+ zi>_T4^MxkH$eXd zc)UN8DL_d@GoLVSsGy_-<<2a7^{TsBGC>S=CH^*z-GG96`ed4-Z)(ONscdOO3{{h- zj!1#yeR^VJyuEhplJIM10j z9)0s5zL@WmEpHQB?&b>Zkm=nbZzakteWzb;NRpkM?GWU?Y{4>w`dEx=S}th8cUKF% z)^?!S^=CJf#o+x!_{iP!qpy!I)Cigz2M>lGU}im-hnvRjm%3R;nCXctUCD(#T5M5_ z(Hjw37qdRNDF0Yxph!(Q&$|0Mj#lyw{njtJS?iHiS4F4u(X>hK?70fTEyBDGwsiPE z(wZV)t{x1ciuzWRd`q+^(sFgovD=xx{-rNVvq4A|t{v)`rn)4>t&Y3oI;DKu$<6F^ zH*ceq{drE_x8Vx7uVQe!>Arva_8Huccm>mi+HzBQau)CkpYPwT4k*vrMWVsZR>ptl z1EF@L6mfX2>zP-Ui8GJOicRQt*?jeCw0{O?9!y@Rpn7rP2*aCZYUP=rDJExK?C zER^)~90|GtIOSlqk z^Aw-S$Eugx$W=N|F4dKqVwkkUjuF|(|@n<~2ua5^waXSA;MvOcU`GB=)bbHHjo-s5sG_M=!DEWN}^sjDtM z{UC=BxhrNq)-6ayN@dc}=iL!!6gYiSEz{|q4D)I8@si8ic!F1$0 zcx2qPv_pv>cmV_G5L7*$I`u$%R4U0g!{FXnVBtz)zeTw;pd-SO&qxT(DMD&H9^rpO zmEq#K$dkdr!N12Fl1E2J$;_{<1t6Y1JI2V!cvrO?B-OW6RD=vsm&Lr2k~5x!1%zvf zJoXTZQ)mv)d={7yu;`B5ELriCwH0>zNgKGjZywgmY`wyCdU$;b=S89M;Q)`d+3r+8 zZm3wak#b3w&v)!ENwLi(4rx;R)bEaNTm1aBH9zd#m3f)r=T7|P#&W0AamXE6?{Dsh zzg(NU%ZJP-3td!h$EDkK{AqfT0_=G;4J0crIy zPcjUO2d^fs;6bI!-+k#^o;GLoiHW=;6Q`JIX>hI2GmUr4<7~6?$z1lzbMeb_ z6w^Qij)hKKPFT4*vVqsi81gnFm`Zxonflew`@wm)Z>9IAb33ijwqj&TWM=>HKTuG+ z_s??xV0a~$Ci8BDPvbO;KiEs>)Ya`iZ^b2r(J8w9Bm$jE4payB_8vnPgf6O$)INE> z>PPLGoqpAzWh!y^kQutGT0iTvc+)NsOHa=ax8<%Dw|P`UsMDfRxfKiFXsgXfhI;gd z=hUyW5mK3r{P|kUGj|c_)Ino)jLq!&BlR1JMdBsqO<`3vKSC76)dQWM*4q{teILE8 zC$7z!rN{qJm9|>VF?sL|U)hExHLV)$p*8(o9kQO1K5ge7*Zx%FC|u2T9WleC)N?77BG%$E2@4Vz;~D)I)%uNYDeVf`@8+_iWyN1PUhy0RUQ!1y8pM4qVyi z;Ozlezsq(s9khD28F!TcV4)~pu+IwB?;&ph!N}In!KVTDH||VDd-?caMn+_870@_P z#5Nx8EzNGra0A=Trb%k#r;-AD5R(> zAi(tZC6sfZQ(uiU;f-kXQoS4ubM*&Le0%7joAHn_9kK;OOmZ+Uz^|3K21LW?k9F(+ zd3^O>sOJfK643A%Mghfp&rwja&F_xm6J(zpaz#vByzK^+e28NzK$cgXKt58K1|4j+ zS(STke^+?ngG0w5Ll`131ZW`cx$6} zK$-kKqk(Ack>dl`L;7)aP_QY+yV$XaE61}jur_*e)HtccG|qFCfp`py8eNq>P3e>6 zd49*6uWmDp_i#JeV$xuu`8ivY2ep{gQbH2s94djd9~Efyn?A-9g;g2TC(Q3iK>295iR#SASktI9Sla#riY`6S7UP z(E`YbCKGD>M3AFFd+aS?`YZ5*kZuBe?b+FphUq0%&dx6^c0w&a;pB)wZ0+FaIO*d0 zgvsJy(ZJEgWj2iI;k%-u=nmE=FTexk4-)^7;4pdk8-4f!TJ_fm?*+a6ZeX}7A}##| ztjSxzZn+jb-GBZ5ZDVEi{K=oXa4?{BBfMv^;dNh^UO=t+*(-nbuiRqcPQw< z0P~qooA614}+S9qTZ^q#1)B=-KZe5Ch z2V$lB!ngJGXo1_4sEa}j{>+n^@QXrb-fQ_zQCvtR@{%fnq%xW;^O-J zyTf;X=G|(?MLi{b#H|`wjJW14X8Cq%b?sqGq;XQ!pvdr(u)}8}#z|$DQrNDrJ-qTj z`bA9s-O(GTv#y-K(4k3wmkEsvvi<@2WXq5uxDbY-@SfcyV+AYJr^2#y%wY5Jw6cZBI}z$ec)qXT-C zc2>g`zk(&BroBBEmHY;^(_pbBSR%oQ&{$nw6u5Bs{x0t*C@Zsv5qhxpJ<;+iH*TCD zXzOJ>W=KkxK;EJOTP4qNeIJL`fxPa?1df%ERUYod9i=>3X-bB^7RZ@kioi*5GPurz z8k^XXBrHTqX6a9``VH$mIKWk}*s%Qh;GjN~r~IZOxnMUbJHtdq zuKvL=zT!jBQQ#paXip0gR!w7TE1s7Gm_|}APKakB7Jn0dx{Jp&%4t9`p_^Jq;?P?q z#ubObjH$>{!ODJCf0N#t53%kh55|v0X zH)NyV4u-Pvo(%pRWjt@Zpn&()q? z#6P?CRGsq%H%*H>vpVJq5POv2k+-rzH8AOCzB|lFPF(JiHaTgjlu7;h{>#kFOb-jF zzWycM8JL(_Kk^ffG|%YUSCk~vP{QQLpIxilvv;iBG~^GnHG+usS8PZf*TMH^Sa2f! zA5fip{jcWl5<%iuO9aZSTo3_f_4Bts&9f+e8LrLU`suFcRsYIC#*zU4W@+7zj#gc$ z!KjPJdg|DZ_0)u&6sL=YuO#@&fZr&M4LzPpQ&Tvit(rJ5^$o?E*ycUuK~^geTW-oDf6ZYGPbM+6xdnmwolKlMq(?j0* zLdO4L1H;$%)=!bVrMN&;bxP$cWv}y;Bsy`7cvuPy{ZqxG*V1 zq+@D`5<3w@GwH`0+~HJgc3@K|2eY((|ENm0Gz1s9M?5hyjMn0Y_oHEy2&=l(?$B|4^J zxO%>92k>`iLDap=ebduZj8DJ#J`4~i^yvJ6-hqMd-$6+Zdf+xI5!eD!Sbs4v@a6*Z zT|UBpSG#CgRQ~q}%DD;ZD)u%Ge3kvJK1SJdoLYg!vEdWRGljiUWm$C|v#RD#mL&-0 zt3{jjWZ-0Y0(yb+f4!_@*B#>(P^1!pQ>IVc@_ zLjjS@MiO-@yGpQT0Tb$5)RXs^^O`Vy4qUpgoF)h>b8|ztwjSx17^A?O`zugug=J-6 z0GDdW50RD7O3@=R*?pL8^?R%)4thP_D&i{?39>_9 zxn8is4S?EeFX0DGhh}%@5s2?}?f>nWwovZeyQ)wGY@=mjVX<{{bL*n+{Rip7`de6D z7C74R0(1hyE6EP&CEjXUXup(B=oAJc>X7eTBLso zh1vdxbI~XeCM$f>kQ%=!&NvG;@BTBF*&x_~+CKti)i^J|!k*B1ZS8p*Jey-XBZvc| zu&}VZs<1#A=;?o|S?ryI;P}~l+%fJX=*1wi^#lB)v_ZlPEqB*vA>q(MnEkiEQzUX} z2#Uk%kkGdDt53H0!zo!(&lL|Ci^E+Aq*|BEZNI=Ol>rJ3GF9hro7&mU;oeA2>=gpON=lzml(om?MbfxI|g{Ym)C1BIdcb@dvAuk8eoUm>DO!)re=2US7pzaNFZ0H@rT7Lm;XBtbl*pF zIl?y)4Ev)o_ezUu{LntcJDmDlsT!xS$K7dj z?kONw$dbrDfl0n5m=Nq9!l5@WhS(*Cs;iufhixRR9VjA?pnp0 zivJ~-;hfL05xrw(#sY-jen6Nd{mtxqkQ2ed`g^o08VqOLe}4KKL17*F0jI;j$e6lb zr_AI1?R^p^Kbe;%N#O_t*n-J?1}gk|=mBGEdSbX|85yi_7{END`(9pNgE!2gi*y8& zvq6^+zp)%#!wDzGCKqUYJkK{k%S2^o{h+ndLHbJwex~hrcqywnvIBkwQrs{&ptsjdQ z60oAiPO$v}AG8*vW9J-80K(k76d$!H^>p43xSx1DDH;H$M^_R0y$Nw5}W6qb`cj9no&Nnst_{yOKu5GwF;M+9B zv<`QWN4iPBa7>lkok>U*FD|RygXi+$;ds5#3SJE{!i6p(^nGBkSc2p~xqA|?5IcR} z=tBJMlTYCsgQn-M?H(IZ-wdfD&!Ya_>=iteepAGq{Tv&F1TM$l{wYlvI}OT72>i32 znNZL8y{mARI=UCUxeTkF87AF)yQ=5v1qtbo1|p@^|4@Xpyr>l6+E+IU^;{hHCjtJ{Ij0J9IwRNS6X21 zlh%_b_>D9WbA9}K3<+L4o=OJs<&eM`?@zKFPQEf9ihg!dTsim6($l;Q-Q`chFBp>3 zfHj^?G;nZovLE+z6nkb`-{# z^x&A=JH&MLxb8aiTesTC1^dc9^JrgS{nG!<*us}Q_u7&Y- z4=e?@_S^RR9Ky6u)OPV8RbAyv*b(TnA5L&vuRSC?qx^{kbO!;sRh$W$bb?d8xKllK zbD()xu{P1)l{euj6@RxN`@yHd3QJkLeb9&0w(jv1Y{kjZ+&8`6j6IXPs>V%U9I@P{ z%UON4tuK_<@m!y&G<+EX%)l*ZL*gZ|TX6t-k%(@Qv8Q&ti7+_!JgDNbs~~FKv#`(t zc<}kYTmLye6P`Xf#7YmJd^jQ|ltgpUs%m1_UoiJz)>Pqd`%DP6S{wnd{@1PpZ=eR{ zRJgI-PxDsrAV>rn5{OB7{!?o^esn+O(b<5>Q&Usd4^#=LIQo5Q!u;^F<^A#G=FYL8 zNdqHSAKb4)nxif2l@1Rba&_r}?^oPGWpX!SEuQp;sZg9;b@+DBZ+nNb7GL4uE%Xa>hUo$%h=+xc819E%^uX@aL^ehdhYkINS~?NTb4r+#~V zBfyjF*sO@OaKsW`cW6+XHqL$4N%L!1nS9{DL4c-h?4;+zG(SE^apb&p3h{%puB3UQ z3lSyk?|RK%m_?AqfY?)TPvA9Q)9PXa=Quv~S723S)r#Epj{!6o-jJ!e=s`wZ_8AjL zIc%#quQe0Z8}?MC?gBE&NjrH$L8VEN<6Ye05TO%l}egi)cAfsnw9{tio9{OPKqvm>w z-+PR>4^B<57`E~~k-c*zi(Ws)u78MNLXa?(KQTv@x3s-qOrihPPSG~(i;-wt-yy4XHB`CHkkfH1vb_~__?FYc z#Y=U#_FLxudt7Zr*#m+m9RgC=+j2GrO3$jJ<{gvE*bcG3*|3pi@*9^5vy4ccTj%QE zn~<1pqzQ%r_qRUxT8_XD;M#Tp6LsZV*)Nq6gxfgo9Yxu zUs%YjDN8Or&n1%eU00>`1!cxmOe+^b8T=vWsoB`0>0#1A3r~TD4BuB3m$S)Z<{aLO zGAypx^1tm!xVH8D+s@8t2Zj|{spb&6Ip@^u|4rTal%zOK+MuyHnq$C!Io=y19cZ5Q zmvz!}Uf+F2ZE&7qhf$8Av~11)WzDmHu-ugPf4nz1cWR#uzCKuL)(xmE5@m(4e`fVP z7`mOIb80&P>SNw!%pGuyX*JR3ei9~cDSz;=?f~TImR|hIdfwy~M#YVD#*)s4D8o_q z3zA=QL{B~^RpM>!^JT;iz2lcO8*86P4!VhtsnMoWJ4a;JHI-{Uo*Xx%wz7SE& z={Te}?x)*8`l&J1%ET2$-1bm1eIw96}Ms)Pa! z+%A!;z%CO?V9=bIbO|()K&LQI`AY&R!rnVJItmb4h{~YwbrupC*hM{`F)z}GRhy4A ze^|fyIJT)ixHUMnL9%qN?+?Pw%CO==&jV*64SplkT5G@$uQ6}tk+tKy^%Osv93`q9 zU#V^5eorgf&9bam8o7j&9*hkKtdbW=I=6i#*ZKbAmWlQ2dDehe>K{^_^h?@0)$fiC ze2O1>ZYR8Sk^}VyIgCT$lFBL&jzvI)twNN8`K#dbl+CzKu)N2 z@qYHe)PYMzCQbF(YqUX%1>bTo3oU&S(Y08yH90EmcDc)wJ&kB{$J?K~XJw`$!(xWq_CC`wauR`Vn*+S6*tVDFov-``xc$+~g6M550AHM~t9r81PfAh;a zYWPb--XJN+EiEmTL;E|k!F$*OISiE>_<2w#81hTb`a#h^2c+N?29M+T2ibegEO5b> z9S>)(MZG9;j7r&WV4D6hKy%UI!X6)iwS{09{J;BhfoU_0f>WNiN9nYriP~pgLr^&5kL8;{6VVvcy^p6kH1mDYNoSkiuX9{Mm3AqO zcHZKbx6fw3ji(WL#VVs9aXr1XpqaG!S5AXji~}SC-)`I7JFRA~P2%tv^>l7(n9^>k z>qP1Y>$L7t7s?g<{g<;v}oB%*UhWA$H&8ZmU2ms3{;23Psem6%-B+N){FufeNb}B;aU3g6qhO zX+7E|CTc1wDyU_qq$tSHA$0{oY!1c|TzVF~{zQfTm}YM_wK$4A;6TOrMS{;7bDe z$nvtSzkfPG1T{L^1#J9Z51A|PWD-w`+n0Gcn-w4HIegI(bht)+!-(z1b)A73j8xmm z0QcWK-l~vLw6;Q;?s1*{yM@`4q;qw5mAYmm50pO7>|V1><%HBR)vlaY@Qa2kxF{4T zNuU2DtPU#F_#WXi-8^3n3)bqVZU#+Ac z!uX#swmuSfzt;qQ6Z-E}d4TREINuUU#EuOiT>HO=i|blrg4v%$l@3 zWrtBSwgJ;F2s$Cc5{OW{jCl8dsKJs{6T1YuQ$-ugs68_)0}^?6v|Oi3^d7swGpTk# zZ124`c1&4WzzEG&r7Hw2DC9OL-!kH^+Rcgjym4QcJ5dbv{RZ8kSO#uQ$b41*pHRUr z_#jZR>R-Xp-`m)BPUnnDVwfzQm0)ctY_??mW3WeexvAV|EcE`te|hTt3BJXz z93>L4L~dWvzIQ+jRbDi%>-%fo$ay~l8c|TLl=oN;>4$Fz2!C1ER=zN4r%pqV<^3M_`8ZM_)SzP7*B!mN?4szI`TsQt`0)fW=Fs7i3C?E}96N_ANa zF%8cN=z?G@+2oL?EBTC*U^}u@bTqK0X&9uD*xjITmy{qTNezuet`KMxN;ZWT)6zP0 z1kqeXR5=Xl0;L|o^a55b#`OXS!X@!qmtdu|UD&c`e3OSW;3lz{BWo4y}Rk*Yn*Pu_x#_qvrhxB`O$apK^G32(q?& zYpSgUcM|kTH6ljRvHbc56Fz3l$KCpy=f5Rx8^E$Ll=a679o@~LQR;_Q^1!;f(yO!8 zoj9P{r4huU8SQHlAB%uRCM;r8(ti|;Hb>Y$D)f*Fg=KkNVH_U*5OuWHKV*1R1*^^8yF=IlzF5BH2t*@PB|tMWMZ z^X6$t?H;cccZ{w}49jWEnp^VV#x;)R=-B|>bC02NkidQd=K!QV#0mHYM6th?mS8CK zb6`z@AEKwHzYlTx|K-==^pA`r{Wwzm`zVy!DmA{C>JvHJ?!UXkY7lDugaQh~)PBpv z!P}$Wqxz-5L;nsRX@$pOV=fZ9a9N3IJi*4iI#_!3O6~5us&;QP{_gh$ zfhQcyNMtXB^%UhGo&1mb!|-XnJ`!fG4w|fercc7JYmlW3`j-YPArg=03N~Y1DPoo$ z8|KwHlx>XWWeM78vx$)m6Ndrh!k!Ur+imFwD4U|I{x#0`QC?RA>1NjLwA29mRW|iNlVm5@Tb^#R(WSWJw+kZ?xdz%4C z`M34kudFa5o4vAX5M&!btk9e>TSq!(5|Ex)fRF^;lC$L8;-;S%e2(9Vy+aqqsOOPk zQpD@~=wy{I&T`msietX&@SpKUs#I$G!miq4id z-`%n3twmN2`cINsa0ihNPE7O)9rO#Wfhzea;%FB!UlW9{se@@zBUMgx1fIPcT-Upg z^$@DJ(9gSCUDFf;>zSYzLT)#$tYH)n2>6CjoITttI|9ewx-g%nB{MOFLxKR#T>|i5 z!4;@dktbAS3ktD$`sI?Zn_e^8TzQaJMW{@H#`kPA z3LqCxbLoN?BSst`F$XmXgwRq4wh2)0L6ckTG$B}vzG<8}z$m3^T+<iBAZjBVm;D54`eVLv$OX=+4@78Nt4K!#L z_uKRG{v{mFU=Bo<14Tvvnp61DOm8zP*>L#`h1B`T%YGShuk3x|qL*m5zCsBas4fCJ zfr=71tL|Uc9IFOp2|?@v7zX}F#I5Ygs;X~;gSP;z0P}q1Tx8MW)x_>uKUQmNYtXU* zNlr)7J=!TAT%3NHkL&WtATllPm-LBdo(W@a{4R)v)(m8ud@!2nmh;c6Eq#r;Vt zKbX2G(YZq>5q2jn~XAKQ}dg;W`b`@S*|=?UDVe1ttvFAh)FwfOrJXJ^ng zX&6uKryTk{Lh|4A?$-X^xm$UcRy+WU7@F7Kqny&th%S@B`d&s+#o2!GtKT=O(Y=n# zYbUy1^g#|T8z2Hd1vD*z0OWtU2GP8ymD^u!_5XQ-EoDfkf8qf!@yVOEiEV)8!b+_qPzt*CUY6M!@nqE(_ zZQJ-Q7k9tyc6Qd$AiceZM8_S?s>xLp(OG*@SseZGtSm;xzGR$Fvp6J+wLe!GvbU4Z zMd`lW#o2FfK5s%56yAaGeI>P*InMYK?8z*xmWQ;NsNz?~(TIcZ*z?Zj{|{Mj0aaz! zwc(nmw9<`;beA+LND0!?-2&3mpdwu=-6bX65|RP}(ntu>AtJfyJoC}-`~Ux(^Nztg zKykC#dp+x!YtH+=?ng8R+dHlL9YHRNvDashN%d3nMK6)AS)I)J;j9s{$y!e5>^sq) zpZHKNivNn2T?l$7o_fE~mz*LCMG7G>OBfO69j#u zE73Oe%#|sWh9xn*kF-MSpaYzpVP3(}m}`wLy}-LwZ^m!(wi5rS(8nrRVCF~>Z=~Sk zRXm*TGPaeLJtIZIaCNOluW2d9yQg~hV}|dQ)@r1Ca2qY-|J=F+7K25A-~UvVw%9xylBH z3m_YS?|^X{kZ}>}28^sBwBYjP%g7z-SX5V67X&u;3tw;k&qSLp($Lx(vkwIYi;0^6 z^!P$ULt%A;!w9-t+ncMf4Z|l62P%w@6cliP*wpF)8)}EW+2@og^lZzRd|{?6X}U;| zEIIgiO@rJ8xRG$b{Z6okLD6yhRuD|SV7fJOak^R-SgPP-9IFz^O3iXsP9Oxc_&;(j zNE(%(U&4S-Lm3f!ISloaaL!)Vu<6i~C3yKB#uo8VPM@=O;BFS%R;3h4{c!U9!l!^$ zqK0mmf#VQE&*_7JnIS=AM86idu<*B;8H1XSMM%GvNdfB8Dw}f9EkIi)dm7G#vGT|b z*#07nf5aRomsj);v2Ri;vMq7aan-sBLfs{dv%1-xU@EFN($5pn_dH!k(4 zC)lZf?zUf%dXi$aVU?37Pg;L4Z@xn2nERxCtQ>VACw$#(^cAI6Y$X?`U5vV(XUc3+ z#t-7X-W3t`Ii;9^iFoy{X{med&oHz2U1vBtgcP`A28Vg?4eF#y zF!o4KYYIkC&hO!PhDO^s|MA?q@%+=i=+ui~EKHoq|k9Bi_m(6~(3#QP^av!1BW z2uX2l8|4s=SvqepeCMoM!(`I*x=vlQ-n)G{IbZ($%{B?_snQ>`Yxf^VXIOnT7rs_q zkr-;iQ<_F|lj}myz}Z8RVH`d4cbLqVVrXtE55FOxYG|I*U1fQe89X5u+HeB?ggo-hlD#hJoEv)MK~@j z_f|-D$Gr!a6U-tDFanM}pFigo;QNJYQHoG$b7L>H`>64THm$~q5#Q!U1XdVY)$HT@ zju+LQ^_MCihk;N}xOVuZ8SSljuHtlR3r4MZG#3^OJLAYl9+fg;h;A^oTq|x6?NF81e2G(zPkgLvEAMuO=LC%cBr$U@$qYIZ4rk0pk&!L z&j+<9JO!X~LthM38X?NTiVPJN`?qBoq0bW}@fv29jI(lC_^DR`rX!pgyGNTM z>dJOPJzOJ2%iAxZ-Qz{G43Gb-0lOVT{LgnfcP7F9uQ8-eOBj+~X$Jj|F@*b_BKkO9 zAw9t`{mI?MMunWHha_k(7y>EeZv~BV+CLLx|MUApWl_vakyblrt@%(K4$6=8H>*m& zITAgKHhin$E#xxnwB5>j&0Z(9w7lbBi@Wa~w>Xg0#L9d)`t~W0h_IcVQ7z0uos5Z) z*4}_hrY9jL5gSz~j3-W^HhIbE8Rg@(bfJ2xETyC2%(Ojl^Y?mkeT5B?nEQedW*%*O zClxA8%KKXk)%n|oq`q$L7Y?q|3I{*-tL(b#p63|533Y0)+E>S(9`B>N@Wf2`li5}0 zcgQm&!%rvl9{9ClzM%ZzLaTzkg0+*p*r9M1m`U%x=?Sis2vF9lOXE<`H!PV+V{Hu^ zPcMfV)7$@SbDR}d%Dp0RSjldKSEN5C*&F(7s;Y~Y^6A3omT%eVC79Q>N*V_4X9{rt zR;ee^7oYyL^y_6`7%N&3$7Jc?j8uS*9{*BVdM7oBzbS9<*$w%=I0f3=z^i>~we{(3 z)JCluPq?E-k|@8sl2#>c241D6RIT^?c4yTRuHg@Y1)HzbcF}wpdt#nMOmX(?>+k;} z9h@9AG)jEyY@iwTU}S)Y4&O!%O{{W+Nqw~5(XUg%wxk4KXCl{iLol)gE9mW<`t#Dm zZ@PRB@)iA5u9xyh?-}RDhg-vLPAL0Txk4?z;x6Woe9T)9)I^U-2; zpgx3xHC_%ZmHsemAF}kE&iVKeeF!KaM6Dcw5;UOcdnZQ+QajfaDNsAZtqA&Nq0q6| zW}v_C#{b(@INW9e{tmQp@bCIiu=q7%9?8qgA9`o4+=aslNIF144wRE1iNKC|l;F25 z9nPM39|pcr!s)USI&Oo4 zce@A}lbm`}_AeuRj)-K?F2%_zX%%o`Vh%0jc+U>)JogA4x9y}SMW%}raQu4jwMJIN%}8w6}cOj&?9Tl|i9dD8V1t77=BM!7d@RUWZC z<4A$_V;i1Vsq(XEkp&i3b4R<(z_ZCY{vrb+Qh8xg`kPooWzR*n(jH}G``a;m*}YeA zXVuj0_jki0-KoHI{KL|VwF;C=33bz9LL)urUS>FMqm27m*+sAFrp{hGt+;2bjh6V_ zjcmiSqvuVA4A-d$@vG~1ymD4nD86XZMl(iTGL8Fk$zArlYH(|~dcR=AXiW!(^sF`Y+PGE#6Rb-UzDA zgHaJSamyZsCkLL!vE7|F<%O@qmor}u)1Th{GG|1Zkj6R-R$YyPC}pJoKQ{I??B3K@ zWVA3JF7($7v6NsnR$+;U5UhK8dJ6PDCqSe~Id}pQy9V;jLQ`AVh;$o}0$-PU5;f~y zutNKO(R9jvwXhzQys^+uX1f5#wz&~)ThpOzc^*E#L1^k!j_P%b>`%6WOurZLq9YHL zEuZKLHu@f{dz1HJ8iMHl*M3w^zL>Bn&@A_trhWZa<))>rZE0n7ha6i)U%&BJz!u>{ z9bHLBKPrWPa^~A#qTl|18Bz7o;z{{){YgO*bMgVTq1Onkpxa$NHd!~g)Uf)nf=&)I z6Zb32fEEhQ1bCXxLNdG$=~Sh{R&M26e#jIJjU`ki&mCBZr0sv zJn4PhW76)=@ldG(+kVyN9xl$c&TJKa(fa*6sRpKxc_qzWs?_k4#e9!U^UeNE?VT13KdPjl{R20F;ZVZU6CHnU5w8lpx_9fo9>k?& zhk4q3xFJ_Ie+rBHdVL7QrM~u#HqmzSKFuwfR2fdrcSfi3kWE>+vM$(_An#I|QAjy~ z&h2SL)zOE|^{%(fXbtU0;%aGObwf)yTE)hY$nPNm>nQe_I5d`GPU0t4;aCSw*p}gY z$MyCj%YWjQzQwV<5h5T5`Y!ok=m%c;8@?~I_&I+?IvVm^{&^=s<&G%56pu%pSA~DW zjh+~`h!mxsm76`Y-l?h$98m{(H^0_!ybBo0OlXdxTWcD(?}@kXX}S`+%wxNARFKPx z>3cSKBSPH+eO75SU|lJ7{brAy))0604NXNnHDU%m{`GfVM6VMCsuhzRM;TL{DBH^t zf|9ab9!7ROYj^19UgG9RU!nYNvdxh+@MmRX{lhcug!Cs5ZFwtXY?cx*} zREsn;6XI1+RtDESF!$I#pUMvhEI7s(9+HZ^}>-!sRVT7K(@KJ{pi_k!a8VRuh*k`A2m{q z)Z%iWLe4ob{getm^2cu+*YEr+=F;)Pv#rbX3&o=j^)0hu5qtb2FcMRMoWDQF{09iU zt_Ng7X2*>Qx|LUvphqm9JXk;0_>SMv9cJ&&A@1mfg`Nu0buxTa#)9)ZJ9~JAmLF=0 z(4747I@~SwrX-(R2R0Aj7nzqmQxkeHL6a!M38z4LW3mV0^H~A>kzAI!L6Hhrj@!c| zEozYTBH^}h-td)ol<#KfNV%CQbImaS&!0IrXrEcg`}1=f_G`s9^&nh=j_Z&3OHK)B z3RlNGTeWB|k`;QjclbktjpqeRP_KgG(AWcc8adHOBWshWkN$)#i$fl@Arf9>1Bw^c z>Ov#19X}rPT$!t=4mZf)Xl{ zqx`u?Nwq%WXTL5t_DfsXu?dpdXJ&QWE@Rk}S#81k$RlB|0op}BO!E4u!JY`3dWerV4R!-B*Tqkd3x@xZ+_VPsJviSRt+(=!z z5n=qD@Xl?&d#x{+nF7+OZ}rz3`z;aOiyxMh2g)RlkAy-{_{~NPexA zgXx)<%AacGk8>l{BMF|O`q;s`!8xhk?p-B459LPxdBvwH1V60SZoBEKl4s$A$LV)| zahdfvSIcZ(>VVEDu+8+HCiJB-2>6|JtI35^*i)8!JaPyAJE^NnqLTR*Gg3=_DY>v< z85Kme7ir&|FkG0O+nHk9X%67yVq2_h&TdWZ^5v7UV5;S|Q)0^AcT7i6<#6WymNSmVll40xS5=nr zhQ*UR7kkFFLodo>VVVewq82WYDEw=de+MiMT!#PS{n4vW_&%t6=P|IFA7yDiyC_em z>!jvyA9Sp&TM)>9E*_^VZ8>ev7@=DmG2(Zu+oH?-1R9eZa%Dx?w%-;NQ@ev6$TR7? zo*C^qT}`!8b(k)Gv)3eq<&6`U-z@$5V}V>e0~e;W|4gk}q-iB#XP``zvPB_C6r12^ zR{{c-r6KFf2@h4v;Bp7n`YkXGO&MWXP?Fgn+V)|+-%X2az4CY7i2FF<|B6A?9q$iq z8Mf(%bEY(I-p=4PEZG>H8;f=>-26z700Lr+0KKjYX-VXgTL6}C-sPFnuITZFqYM-5`pMNV=5Ma%2-T%OV@ijYzyW3H1X2yc4Slzh&0^m-;QX8jQ}APEqn7H>my}#?ojmNM0QzM z+cV+O*80~R(eoBBo;!|L_RM-wVU~Gjy)x}v7VQ626abef;OVW(#{bm&IW4_rIx~0J zfcFvPrvG^_J<)h7M|O605V;gzB7zo$+X>CP3kD!^M9kUXpaEe%=r8Q}zin=EgwI1D z4&0HDDh>o9_8YpTuCSbekprs$)8dFUMJRrDV=p}N#cmYJ=s)Wq_W!dEP?x8rw<06i zY)?8!>5@=5csPwI^L=_xP^i)Ilb_e_L`REhyoTv6OrqjN-6WCM26+E5LhGN5|Kj*( z`Fk^J(^xO|_yPMZW!Z4zMcZ0+QN`=*`KG_tLc+@l`EpBjZ*x~`q0x08K3xB=-Z`u9 zPvkO1*Mac#ii79ZEIw;HkGi%5EsSmkay;EpR`vFz`VIIMkw(B-KSIAgXwb)Ijt zcEv952b~j4>LES=cwR^{PpJlG7XH8KG#9krK&F&eRD?KvVF=azgB}|P2O#R>jXq+l zqs0KrkI_#BWfNGPn?V8d*B@_bZSDCug5*|z5=_U+_n%(j5y49Fnca{I;G*=YwoMZG ze29{4`;Sr63DK}~>M!l9L?fDny)Og8)!=E+&Z&&hr>dW^3vJjy)%1CVOHsPLQP*=b zJ?dG8o+u>D%BKojB_}6C`xDU}tgNiOYs%6nlhq%5jED^WPJaTKVM~M&brQe*rBUaL zUuzQX_)?0ACd}JbnH(G^YwC%t&JwmhiZQ*3?g!^d5ZXa61nQE%#sSdjfwl`eBcQkW zSGk0=b)92hxr8DN)slsdESQ8Ao#Q%9;CC+M1&0mOHG^r_c`Sqr1%5B~)$-RP3G^wh zuR$$F>2qQarj>5QQVkj~P^1U}9|TeZA^f@-hVb`HJ#IeKNkVJzU}$3(9_%}&674=V zvp}>Q+6v3P82>RG-u|-q_f-oNh?S!|j88ozfvV)m6#P(#C~WuI|JecloePco9*rG{ ze{S0YJ_RHf{KSJ!1@9I>0DO@W-M$HDUO*j9_#E4M{#Ho^r5g;csm>2N4u4Lc>H@K( z4{}cqCznM#;Ma(ci<@x)3;bcE*ddlzUX_wHb*;cQ?jQii4Ap-DuqFm z0D=Zp(JXvGJR@L(2u?5R`TM=T1sDPf^8~icYJLzXc+z?sa+qwgEwf&vQ+dS1s3$Bx zMCpEA5S8EP-sxax^#I+3r>IY7L}fo10Y82Ww%`GjmkQGv+&{z3Q{2${P{o+ffm7~Y(5Qt+v(CjV^iT0-Gn1zIUXrtX2Mdy56t3iRi z`7ryz7s19yHkb1?DE_00y^pI52AR9*d5uuRvs7V*2R3!S4U2UqNw=3O?97L^^@=Vrvwl^2JLfX zCbiXq!4BRO#IOj=z0(yj?~HN^tlLt z3NnE{(|9`3xQKH$gY$LK0THzzw#a3{ny-kTa}pK~LzXLeLtIDerrL14H!q8BzQV!9 z4#?@lZh~ZQaR0xN5l^DOb>n&cR{Ki%liN__%c`iWcO<(^)qL1*HClm(jpcQk^&EiW z`!(}b>Obh@l*5St6&{(fl4pusmTv5`kerY0rHabXdGh%{*o&x_a(hK2L$hI=df)@c zGHNaDffW_l-<`uofQ4^KytwO9gOAH$sHr@Fd+!DsODMDU!c|L>InQRO;V~WqPQZv# z_c!kHP(=3yk$KT+vA5>bYd6aYsw=f8e>^iL@uTv7;o?$mHOhuGXuw^5Uo>^uYr}(z zz2SfcGQ&ZZY2S)<4@UogFAEBn$p;{+16|DWXZ^|%V10#s_Skn=Ev$C<={%ZD#FKRL z`L%LzZ|@V>1VN_>mRGpsfO@rrK;OWA&lr&c=NzD70S>RkuoVqp4H1?Jf5u9EO}k@2 z0Q%BY6Yfd4A#KoTD%Uc{ctiwLlH}u2fDB@yfpQJT;PA-&;0Xm`Ushh;O0Yk_Le3Bj zA`we1Kqf$Y5=M3pRHz{v$B0o4&amQJytx&(d!6lbw+2%&Ow%b9{P|Nq4<7z_h-n|r zgjkYsC-~2M{@c+w?gz6z|P5jji>SGdvO`4&_ECkn4~3C z>bWq8Y1Q?;oRzNe6c5Abrsi-d(Y!Jll5JE;k^BxCFo37uO*@Q0AI`m#NdISN@G-2H&2^VXfVT;F9r4WC z5sy0Oef($yvKCMYBhpsrYl7K(q6$RJ5G4h41|$aZowUxLU?O{DqYC4$P4{YlM3Y^j*s=J269^37M`3U`;OC!jwDi!F6oAXrXaj=&;B7(bxNCo8Y z`wp`9oj@YHywyRq+zsa8oy3?V0}g&$eLVnH2C(TFuvW(JJzEU9Rz9{YpK8muA74}w zI%nsr)i;*ox0Bsx7_%yQ-QKbStz*}1FR)eY&+s1+!KOW*Bl$hA`SaNW6(5;p6`$tS z^PN@lv#n{z7Y0!cHzFGFF+ULG)wgUJu;dfVF&;6c?GjDwtk}MoFnVTAk5BK9A3?=+ z5I`YnE{VcN1w#Ki23P!*4a3728Uw-9^u2T z5SI;hdKUc#2v>bbd#l-=914wWOJ(q)!Hg95I?_Kpo<8?p|1^&c+W=U~|F%nz8WGyc zuOhs6GLZ%%=qpAN;1R5>nEef-0xnUJlS9rOB0{sUNXyH+F};tN$^l2?ni4RQAVJd% zn>Rl=g5jnCS|XU*WSlf);#(w7R(B3%PrtYurMx&g3gIR=ugsoBx9oeldw94Vt>hdY zjW+h~txa^#8XShwFKPeS5)hf?O4?=5cSqP7$e~mR`>)Ib0>#w(J^z$+vwN}ojTn&N z;-qw=aLiA(ryI{hl-4ylQN?@H-(dHeK4`yp@W)(CsCacBAuEFB18nN1NAl`-;enWX zlnc`GE{+b#Ej-BNjHWTlci>N%yP7{xitpQ+IXt4OlpLsQM*$8`bM6EGM+^qDZj?p& zH?CNRVq94Ek5Co<3!- zQJ*iE?VKDI$(xoboBU60IBzMt5|p6JU4Bhxl7wpA_G1DuL(b2V>v?k)sI9am-&I~Q zkI(YX!%6n%ZZ#Dk$FcigIgXBMe|;QW8fa)}An?wHDYo$E9SvDVM0J;tm?%RRN$kIs zJ&hr^zP#Xee0&VRg5^_<;e9WpdOX@)MLbz6I%#FbmhoA3vpZ+soTy4a^;EqElOv)V zu0Q&n4^uSIm_rMgZQ3QTeh)+Gr-M7e$zd8%+FULIdsyDBSrATjnp*x6*MSpmHZ~gD zF%+xrtcS>?z~T}650;C11=JyfBMJDU{+~a4T5-g_U4yE??flm7!ePj$qm-;Su_=5o zru^sk*4IyOot`U=pZC5tj5vus!|GDGv{wlGZ#CyVF5K1e^Ne z4$$j2tSZ=aPIkCk|4i<2vD;3FD@+sbVuf8{DfdkOpgP_TxZ;gj4^ch)_-D!-g*(Iz zBMaPkJ2-puhDPx!?3b+M({UC}36FlciKeXDZ+;(Lp^{fp(+$fD?%pBymy#qV@8)#h z=4d5}u%N|M{1vj1>6~5+m|pfhwy43YpV~|s0)i6R!{=2^zLr*;s?Q0IBBpW8(d9N{ zN_I-;m7^{FNWoISw3R_6vc;*@r}iDZ%*4bbS#>^v*5~#u-5Xy*zZ)|}y6WNeSxL5_ z^~lpPsv9$KggzWo%4^}E%(gGen`_{_sa8RUNji_dX6fm*?(Kg`gw_BrXev%hJnuC zTW3Q@R41>R4YyRdD0+n=_Pu<%D(+L?*VZOO03G*!I^iLeQBl$Jb{lh1((_x&4ZMJ?GTuxNwy@RfHtz+VP-r{-{>(299$zFKG{(~X-!6pqv|&llbZyL1iNRT)^}ID6nJ zTJ`)V_+O_1RBVJ~D!<_myXSaSzSIuBPoib0%*G!|0WnO=Yz*0GzZi#{ zpiQ~wDV@XR!YEeF2kzGRHaVSw*sXWwtv{WhLy~&ZyBFSP!x*?9vsT*HP6lnyZnn?Z z(>PJj)rj_P|ZUFh@lBqAwG54)2zI*rK|sA3lXR zC9@S)`%prg8l86jOderuioN_JX?yGb)`61BX4=?chHIWmkG}R-gf<#zP4JKBoH`^Q3Ay_}&ruNU^PKeYjqWPnI`m}Qci)A@HrMZCR(&#Np` z4P7ls&DC#X&=VY=z>B~NFG3rO;3#@R_`Gz9R1|G@*%)+fV8&=(nC6y8@Gz_#EI6T_ zqdVoMY#*K60d=t2^Z`|garo|ws(^a=XWpLCy>QML)P04Mk}g}Omh6@;_4;~ZL|6%v z&rhJ3#Wkvu{{JsgldJMr3RMfPSrhH?pVXUh5dviyxO;p&nUOhjOy2XEoe(d|~9Mz=M(Ayrx{To~Y0aM{m zQ@sD&e%)PN>YyYb$lW!YDMj+6_QNfi5#2LF%Cm@KrAjl5`BvROLL*@!ld|fA)Xtkk ze@HhCP5t?Q49hyO^dk7YccXg->TJtx=O=Un(du|KGDEAyDw@@AV)fnQv+~If$8jhP zPI*U_2zSQH=O4ZJ>>jmU>z<(R9#{3|(F^Oq>=FzPdnZ0z- zR#|L1Qlldq(fC985~rB6#Iq##hk=)0#*5NUcZ`S8XxhIqWBg|;_2j(@ANXROiaz?b zHCE9pMUyqIXsY;}u}JHgV(B*{M@jK7Glh?_p0aS(cm_Ri#S|_1{=u^8&MiL8TmI70 zN_v)MY}e)O!}w-hrhe0Br{6Bf{itZI`P{*?f4)}I*O;LSjmLSBuA7Ll3rl|a!erTi z$z-vHP4ghrqmp(5?XVUOxuSyMKWnM_7v-aid1`I)I)k4Xw_pAZmC*C(XLq}lb)U1% zIjS&O1eXiI0`*g@;<3yciBewHdEh7tA*AskdKBn}Lp5<7*36z%HDhjz!mjDukM}=4 zZc>%-L^Di<18dG&{DSA-9TL}Q_C4em1dc1atIPhg#xN)``CMu!YoVP{Igr!9=ghsH z;vU(wQO*%XBbty_Z5wFKC#5ir8}8_E7Y+D1i#Z>+xY)EQO_zJs?bTxT&hVK>te0%m zi&Sze~KC#{DBKqx}wX+^+zg%h())tJ@)bJsQ{vw`R10CA9FinNR45tE9ND zIWOX&evGaRyiduka5GUH`mw>8FjDa$%|57kKuNwGEo)YyIHXahv_Sb?=PTm{oGwy1 zbtMY!+#n`*ZjSdOJ6!fN*w+YZ{z%|*|57pGrVOa#Yxdq$8TMUG%eR0T-lL{a7$751f^({V8_r7Erm{}^na8MOYaU{*@1ZuCzn7! znOCMv&!=zAyqo?w6QrQJIW!$;KQDXEsMd?w3R*N}J;Dc>oo0?723LZ%EmSmO9&q5B zbytyTsI0f{wvAO~C&i|C$Jw6QU90|#VtQs3t9aACG_yPKkRqHyRC@F)v1CJVgkhWn z(=(066^EkF&oCC>al{aO!HiK+Q+jmXu;#h3)ykq@8}+hp;a3X1>%o9jP(f`%^>eM3 zF*_om{q@$8*9R;ZLp;|zJ~s6_)Ytg!j_P(`;E1$oPuCK3D>9gJ^Gr%vb>H}-6TV-+ zOh|d$S?#*B)uH*KjaL=z^x#xFbiA!&5^Im-ly~^q({qwleT;_zQQ!*3F1_q3t6x?znyTA2)W0+pyih39tAR8fuwhv-NA$ z?$?u+rntweH)7|-6;lR2V_=%qG3X%j zvjet>z*{-=m7QRB2(~dWcnL5bIFbF@*vKg^j)3k8bjaZp4V*1ReTm4k!J-G>2E{21 zaiAUg0U$3>x~*iWUsrlBj74G0_Tnrc_utX@Iwutat5_Jp!$8Y5=$aw6LFgClXVg87 z?<=bP4J*bf2b&OM7-mnvQH$v!&M<-56G9JX|24lkZUM$odBNo7(-7#l6$1!1NPazhu^ z429SjE)Ok>TZUOOUP;KBO=t;im;t>e?X-+Ky1po<~HPtKON zNH@(}v|5XT%qK^sUn8SiJglbzXEr%KRyK^-rxUhZBQ+6kv&IHBLi&hi3??q5tQZey zi#_l{QE*5Iy|<-dNa}w{T|t!z`whW8>kD=-O|r#zTPUK z%hrr*q&e3yo@;z+sBy+4vl3+bVtd{S>#$9HIkv}M0jpC7ooV{Bo92DgtFQzdn=K_u zPVx!|ILwk|Y;*$>E@x2RLLh-EEb)3LDKyRm?S0|Iu2Ea16=`Y$P!4jvBEvKPPC}P@8a^!NcCWV_Z+MES^aiZfau2c|#3LLm zq&Vb-B#CFbJpGAIhdb(Emp2JA>zPP{L@qK>g7wEYE5xcKvGuF#;j@#!2`c&XD0)H5AitS7Ii z)v%cJii_fY1^=wrgoiry_7ufPosKYM0GP+&Nt|A=IIFnl=H+TdiV!2xkHnLkhjb~% znhlQXX^m!<h zK(dUvuIY@W!qg_rXy1hEmtvNAOa*$R`>9PC>pd?Fe#d(yS%^CC4WPz|kY{OMuwWJ!O3se_T6fvf&(d{kbg?H)m5Y1A>^_v# z-6HC2JC5ZwH8sRn2#o{@2nb*&Gg!^IH&k@{I_t#tbHF zgWRAC?$ka{be=wy1Q#bL!vISOpFlzkC=+3AGP1LqcfP+1vM-o0N%50s*ViWn2ctt* zK%?H36MjZp3CMUh5}_3eE@{v-hKMmSB~=q%DuY=qwALUu08B4nI>Qj8gAq_>rKoA6 zk}No%@>J2e&%K_Df(-u-VMwwA<%Zi7V=G%_jYdq%@~m}lJ}zH!h}*ZSx&3z`aj_%) ze7`qMJkaj>gbR~pc>6LFUe&n8Te{87NKOWwj7{MceFVYCp!Pq9c3Bp}#G?}EjdJ|$ zjpp2j?R{Ltxa+C~oGq4-cIP0R*1lz+^3w7um-^Gip}hcHP`|$AJF6h@aXy$m zV-XUvA@sxYcC>n_KZQ$eAusm1W&fV3!yE6sp12@_|q)sE^oV!@ULJ@0zgPx^zz}F1hCt5|6;n0})IXx0#NB02&@CE9 zRyRM7mI)6eW!^U1tW&=laO&`gj;C8Z=f9y2;oqT-**_RN4+x zz60VVSr7qn)26vu%3)a$$~i3;hWvb!8gAS=^^?!TMWBB9^dhM`$+x|UW@jCcB(W5p zUZIZc#l^gugWW(a`zjs(cUb+O0&sUvg1dVXad*ov_ehzR4ah^YJ#qKUI7g>Np;e#dt9+t0QKmB)6lHaX9rV$WfTM2$0ZvO8aN&r+2P?eM<4z41dsg__XdNhJ z8HEdPXa=V#yc(&fs(RmJ267rhXitLm5PmOs@nJWHlqaY@Ktp6?X8}?wRaI4ZvBqi~ z=_@NMA^tAtpOF!$CoqsahGU2~%rl_QxWJ-W_NFa_Xb9Z)fZNHo92_5qfFz*#Y{76d z5$0S#`~Uno8JhpVXMt=mz{)CWYIZ_MTBnI)D7}irotreX2AvceOIowsHdW$2M4&37 zhjmqxnD^4`$L_&Az5mMNTJsb8@itg#Frb1~DWWOTHrv-mG(}e}`6FkxZGD2JwDjuU@^%%S?hdwI3|{C&viH0-TXAVeX9t+9f%s zTsS`l$b}8sNME` z3z>EF%vrDm>2a@@ynw`CAo&2+2Z&#(eF4)O^n@YEl4fFJf<B6z+sXDW@1M_F_B1vemwV2~h-I_sG&6g3^c{6Cz$0!U6I@j$HF5xW z>YpEt9ya56--q}#;F~?P>OsQQ8cx@2QCaL>L2!XzK*Sgg=cgN)l}n%iSYArBUCN5p zn*$;X5Rv;QCb}VHt~G?c;cJA?iSc^PG9|>GKrwLPzqAry*IwKlNF&CSFAq|*_2=)sY&cVz@GjQ!eT6HPVzY(<+ z5Tg*dHRRqILKp%Pl?XB;2ZX8(&xMdx>x-JYE)YT{K7oMY5J(MOh;IY@8HxoJmYReB z)l1r;nJ-8SjWZgjd@E!58?yj|yEOhk2(aaFfnKZ=ZVQO4q_}Kn?&*YzY2X7CUzXsnFR=P_EV1)oH@7 z32NsR1s~E@4%f}*zuW{^Ye+Z^f}B0~o##J6iJf!1Oxj-q7&H5d!8|Nj2r@y|p9@tx>M*gD+lM!QaLdBJx_6Cw0MTY( zX9s;DA+wGo%}rS6$d`Zp13={XTTS?s{xD4k8}LRBTo_$lvag#BN?X8=c^mgSh?hdr zpEOP@KxGMc30SD5?z_K@)R+7X@nicqFrgHYY5l-jPxmD&gZBe@MB@Z+mm>vd?1$DSf&cgS+{Y5u%Fg$!@Ufn$L{(GR*CPagmE4I!$tUHx-sZ;-@r zaBwt%6tDvndhh0}HbF;I3X(9`L=h$$$aeFK8{qW^`OpQ#wt&FW8&A3$7a)T2CWvYp zJ9ETNEfIRkDBVeL#nYEK) zz4vmp_ES+v-!gN}J{;qTzE|ejw5I4ndGMot|McS10=})o>~P+4@{R|L&Pv@P6bioc z?mOW%NyJY4!}%nAT&=oy3F-J6_wcR~qZ>UKtM~%8xkvI}zHF#iAX(E_E@gekDjXpl zb-sP>TdHg{!3UCu;XS&>Nv3HmTSjOpbT7hLZTa-D9O&9Wej9Fnh|kN%hor8-Lg-As z6L_zq?sP>@ljx>&9SsN@V$J z+s(*x2RD)l!owSJc#b>&Jp=pOOsJ&NAYI2>2mu<3WkeVSYK^$R2ZfUH)2DYqmG!{= zc#!qvY_WRVb(J~Pa={bGzM=N$TM@^8-*#kpb8TFexT>cDPyiaK1q(KQn-O zrh>3hTx92`*S*rPJEHw}t3jM)$X!CubL$bPL)_q+4Via_=0KRF+p^HKWFbiMj>IR4i^;zuR<3AT0N_7e=lLq5c1J^yNDi_7ebzknvvHc zG=v9?wswNzts6WO1y2U6a-L`ij~i_bwGy7M3bc87*d(Bl>)1*T<^7#)a{Bd8#n2dt-4~uCEkr4&^3%C0A%{Lj^KV!8IvCdw;X>fhTl9owv&koTyMEA8K}EqI zW|^fw?cd?~G9l&Hb`+0Vo~&=@nlHAtJ)dA zF8>$8$Ebz#!tIVdj80C{L(4ipOZ^LK2iLzAx5{zgzwu0{F7Ef-L67{AE5nv}n>Y$a zb&vjMRF|-Zo&aZ9Xe>f80IM-z=*kM9jX-b)nzFf4NGSte-r|XA?Q+OHB9W}Yg@s0p z(dg_61?vgXmD-_U^n@+fB#2`ICY%2Vkc%|ROm4u;T*R_|+#%aERR*5=Bth?JZ_exN zk+gyOk<|GOm+4xq zLlyg2#zK4@IG?`(YqL9jRJ#;oCEb$geo~%%=mzJAel(CQC*cp)sH}(FHWb_dTv_w z^UWoe6AuUGH=Oi19*;kF9trxsbo*`Ww?!{z`cqCjdrrWM&cBIlP6nR z)kgZUQX>P05+C6rJ(RHOff^Npc_BzcU7biOf)avTeF4Y_TpE7+xho*=OG%*wvggXL zUo)^(=0G19+L>?|1OO$li=qIa1^)ctSxB1GVj-MAS}k7wyy3-;B%*#=jM4rCH3ksl zm&tqUG#q)UI79GVwYE_6mPtX=xxJqsb1M8Rz9eM+6|(S^ql8t7NDt1Q=^?5k($nym z-$j_K7sF;xMs1X3h?X1^ck}qV-zDPTJ2`7wR(ftnhG^x6AM-yFudFTf&)&Jx_3`?# zm$2jcy+a>%c~!fwba?!ft|=j_f(zD()@)L2v2dU=oWKTwm=2$~VDjzc&iCau06cak zC!e6>9P8Np#b2WnWBq&^W#dpK&z5*MQ6^F*=P&t`#CoFLo&uDS@z#VBz3;ls;7{@T zDm@PCicem?Dy5B=GxQ|dcqlt?1B^<8T9I92PHiH}y%GYlSEH^GsIzc0V!ZBCt@nx! zdI%B*GWA0ZQWZe7l-Sa+)D(@(tmVs1{jk{HQ=?PoC1%N2oGck!Xs@Kxj)~J5vM4M2 zVSqC7?c#XjY1hgW=~Bq8sh|JJKCH7=%eOn0wBFpeGa8F-Lr;vepj6g=s5VG(xiXAy zL(6u%N{!A|(`eIbf~81bfOFbr7p<9u!GJ%;x9Vm@0qX+_D14)Yv3?p;;!t&OX+?y z{vV7CVC@8d$7<_zY8adb{y!Wk`h*TUUT}A!>gOWH2yaCfzZ9+MdEqCi z^KH8n4cOSd&3vQnX#}9HdrokQUW4 zL^_JPe)Y1(64|}{?B^JLDA&c6fV|IhUiGGH%KpbcRw%+9+bV4{+kY)s;Z&jY#m;Vz z6lgv0I;A-grE+B}wmoOtKU*O2U!(q6EZnkB<(f1#YyYqp_xz-IdM=)bYI)jwlgaAd zHP_97J5hJFTz93(f~rm{gw!yFPi;Ln4hi3P+V6=TUl%(ZpFikc9rHOqUu-bnFFSp; zQGWi*kkZ|g=&2^w9jVmC0I~C{5hrtxn5^;-*Y7oai&SWoUR4Z!wRHJpxzFc8qtfG( z=xc|w+yOHA9QiRL22Zs14~zOgPkK5u{QS~G1US>d9y3M;)t9VoHbs>Uxu>J3w7Txh zoFU^L!H{4k-|_Y6aa6q#gK74Ma%>Mlo&p7g~GtOC#)qiQqX}UZz zOkDqCc2LohZ&GI_B$FAph3MMp#MOkQ4I zIyByqLKzM?q-11(fzN7apiJ$Pa(3p0;|dQCPYIYE0c-@IeUitqYzXr$npquju|R83 zm|j;tmZp#wm|7Lp)kB~z2G0yJX72%~f>jULL||x!a6Y1FV!H{%hM-4VwAy*Vj6p6x-_}Bu0dav+>)wBgZfp{rH+Wt);tj&r^|64ssGj1jta10O>^<8jGNW9^l>Ssx6!lfzM(JnAB(zb<{ z%-@@L@4Rw(>#Ns!7tZ>zPpAob`1(X^b;Fi!LO5lsx^B=O`TFsa`oZA&iMAHnAk@ZI z69tXGC7;(CkurW|E4`+XsQWCZaYq{6SWDV+UJ+9uKpz^-fusDi(to@Xm&o1ydRalOPG_z}UR>Ome zpz`s-g00Wn`~4kd%xpQ&2A+x@74=|ZVwIb=k``%H%hh7wJ^Uu3cG4J0>zL5`ney~T zL;+T@vquGvN3Q3Ax031rZsI2aYX)MOXCK9bf0qC=TkzV?%mi2Wxj5T+MM^~p&zbTj z9=b~>Mc2L?KKg$cdkd(l+HP&w0+kSzMg%eF?$~S;QKU;GB%~W8r4f-(1Vp+^N;(BZ z5GiR81d#?|6OxYZLv<5B^+Ad5d3? zyb~u_nbcmobB6aBS_*RgnJ~-31BTk41-sRlLYG%kUxXdCJEQdV6EcR_;ZDrl|J6fH zyCx_+zShNIvOO2ddb;J+l-HdJ|Ld7K<<3MDmwP%q7yY`Lc zHrJY8DV=?6v7hlSF8-fp`rWlL?Y|pq^bKimGse-f)-E=S{o&$YT?N(`ic|W9Z*A&R z;D$a8h+pL7MM>vY!$ej-y8$-LQrXd?xY{lo_w}f3JPpgy%}40fv$gfVtZXvTBb_M* z4C*zj(&jk^+p;*)DFpWzXPbFFShICoBXdSOKUr75l4FT{8$bkR4)=cbs7F_{-1)VK z`(TKl0v8;(sc`9ZpDPN=-krkB_r#p7nEqw;(#JD3<)XLZ^R+c@cTZY0%Y%DHS91g` zXCjZr7zV3~BcFF&r^YjgMTg^EEGi}l!ZEt9Rl+b6zgwC8ay9dtQ|nT!(#|Om1tR zVfJ}FACStge{nN=@>u}Hw-8(i4i4r7+;bHC2X9$72VVulibbUPE^$h6L|4pz$blfs1Yvbn z#lJnbTmJ`QZ=0TKQi*`C_y@O{>P}hX1Gg z8k)LYEFoeq)x0R{B=CbNjdo%?EOkDgN#bksxY?C#$scH>p>kFi47cItdDeP0ebS1T z)3kswJ_IDakBoC4sIc$(@!OKoVZklM^2+9);=xb7GoP1<3iZogbqP4;#!L%#N<28Y z9_hxM$JfO>z1^uZD<}JsDbwv1e)CG0&dh$%fkPubA&x*n2`4FP@b_DhvTJKC8HxFF zJRN4Fr`w{UhPf8RVQvRr(h%rS zTwIJr8^`Bl4_LE1j8!VSN)Pmh9kH_xIkfSXeaM;;1d!jX`7=pI{(z+|_1POor<(_r zoxM6|b^%JLTNrmO%wcFNxoXx_Jj#^$5r?==My}JR^JSajuSOeY_n9kq)^`kT8-CYn z=`@w!^E|b~u7v7B#!>)IeKtF_0Gn!qc}xeQn&2y#?95>MUN*HU zo-g(c8Dq>hk={n--4x;dU_^?J~Vj8@}Cp&t3G?AQL5R=!|f&}^={0Af#!WaW) zm9KyBU2O)L4+Iw$x3Pod9Y!w@w3Z4Py;|%ro`)6!az&+?AQ_|Rx(Rc{brL*iGFa5| zSv%Woso|hg2RERaLG;Os_QvLKZP&&!_dH*p;SHQ|yN!*Px8ZZ%?R!2mHn4W7loL95_tkzHRx7D16`SYh->!9G?)2x7MmT@_@wsdL$bv<;9V$PM-wU8d#ok|S)Fx{cj$A9$XTnZhvl zJ?81RpRpwe#t$rr(nr<(le5(|jf(~K^{Ma_EU3x-xY;1(&hiR3qitsWM~x=fB=_^Ye_H6od8&Zv&}BQ#tS^?$rFDofb3P<9x4s zd^i1Mz9u!WxV03*?05@^hN_3-(#59bWmUY#9=>Edy+F-hr}deg2g%5V=j!XRxwIvc z! z$@zB02iTG69N0&@_c&l1nN+ii^C z7zBG+@j%l8fS8Q)0K=sB#T5et6YZwb#euP4X*7y-^0b<_aA!XvExCJIGbtruan)Vs zH!5-A0oG2z?@dl%T`Rtsr^+Slm4;KeMxH)dV_%YpOt{UeV^Wkd&1@v@nD~oNJ?pLZ z7^kzQ+@=&D5Nj&C8&bk|cs-)>B!NfdTH4<-?_4MYGSQmkMJNZhd;qAt7ISe5kMhb1 zHZsaASb`uH<=h9#s;Yb&6ZolE)pF4MpMW8pDX(k)00iX#pUQYc?GH8-86<*U>ow$) zZ{{wW(aoIh!p^9caRSL66AvP*8jV6Bk^fF`OQR@c|;JfzTAUVbOy1-|dzKW@Mhs9ZaO6go~GpKr^(rS{dWc zX#c_@`puaI%8$&pg!mq47RO)`nz;K;Yme`ar7NdD6)of{VkT4Z=v}_7;eyjje&U#e zBF=iu*5`VRJOCFn;c4f=@>cUd!L~Htr;v5~nV5m;mEr6x%szH`pX4~y|Fsw+pINzF zv$x&AfaY49GC7XswQ--i0tw+D_ij1b)je9M&Qxjzog%1y&VmVq2|#5gTF;KT1KRO{ z%Gb5yyN=lz-~b^4ACKX~4R)c)hb33LWp7^oo0@}80;E{sS5#R)1U3sGd!fon zg2OV*QrEQA$g5-%gN#Vi4a_-h*2a7nq-x-OmIW#j}!O-bK!yn22~ zuf(EYZOR&R>v?_unpd?*i4c9iQf@KeVMgQ!J^& zd-H-*n>#qXw63#s`JXp6K?J%rY)=%W?L>)0n;>bx$iK(-X9RW-!v;{?ojhDuI0^^# zCVI0d1WDYz`n=2Q5DR$x>6IS^o)HQj^D4mqSe;D^0X1nCK&Js+m??bS?NiI1Tc0Wy z%ZCt@(rxq4gq4lk6>#-HLQy9xF^LA?ivbg@LqLY&5yN@Vt|Eq_HT%;X2%v)Gu_Nih zfLL zZPpm>C6{J=`VcfdJvY+3V8mL9kR z$3|Zip0!7*k!s=P*>%-2q}?bCi~5d>E7kB^t6V2nvm=RO8cM(#=)m!;6 z?yoo7?JW5&y?tm3OTuxG-h6{%#-UB@6)pja7>a|v}!^ijZ{3oeY>r*mGLK1V$>BAtgK}$E-B-3~3{_lIa z!t#~9ckV6PwsZwdh!35X2=5JG!FfcbcAw_pD@Hdth7++S>; zE(spb?Y>O3qw;O6*M7)R-N>`Cj;NaTTi}5l)`DaWd2T)PB2Om)lM+Nr4ot1lqr)vM zlCurw%t*xTG1k));u#Kj@pBuGg~xz)+YMQLv>o%K1jZrYKPOXwAi^DE2!s=`u}&^C z1_^#19~8?lUa=Yi3r#4Li&+u6L|)$KtZD6UfR{j>Zkh*Vnb@*x7AccVw}F<29r*7} zgsp1_m-j3#E)>!*T$tEWIJ1DtGh4o*&l?k8Zui?^-#Ye-smQ_I8{6@HQX_i0c!`*V zHJ4PSHy;?;LW3F(%EDf}%WO6J9$qHaRkhvraDnTMS-)hOl1Y%de7iu7T=1Cztn?o% z0vs}8yUTqHaoNRZS6niW2zq-BrATA(1UjWN6B;{DcqZI1I3pFOr!~60A5t;Z@P+{0 zE6Ddm=!cM>oPwl?kY%&Mw+~H9nTbBKx&HLOGtRp(5zu!MDKvj=R8DrM<0Md|>Uw&D zsKlLXT40~Xds;0Se4h}x13uIQz8C+UR}`P)vaE1ch*z*jw1a~UA1JbF39G`te&fZ8 zIQ>D=w*gH*L;zw29Nwb^uY-bp$o?QcmTbczaJ;m%pN%v|)$SYBtoU-s?ztX2zyM=& zDo6K#S$BVud`(%pQvw+YTj@?PK?fg}<{Kd>WDE4>VNXN&Pf-6b-h!h9 zjD@O!ttRvgK0f|eEsC57&fR3sDvuN+uP*Y-v=Ug4QI9XOxNpn(PRVM;LC=%Nr)dG$ z2Ctkunik=Iu@PTOkT-~(k=k?BbB9P`IpW$eUAyL_N(i?BJO_pZ;mTmTi4+GcL-Sv} zPj9=|Os+b>TC{hyObC1qd~XQt0h4wZp3+eTrG|gSYPnYF7+dDzcZt})&HwV9|B>;_ zRYN?Pp(s?ckmFt`5mZB*vjsPdA`*%`)3dKenha&Dq;1P%1GnwFc$rHv+|toHUZPSt z)U|ObUukasx!I{cVpnxBOMI%H-q4w`o)slI-z-U*{*aSDi9pla2<-*2dO$WN8n-`OV7I(nXwZBCy`Dk@ z5g|>>M~BPyQ$Yf20$x}Fu!GodkviFdEGN{_K6W2otv~lYJ*?mO5S~>y9ylpb3xp?; zGQ&O_$?r>8Ln}#>Mj5QhWs9Fy^z*j;UMx=_w&B!7Ns^J-C((8!>T=l2#M(UAL|h_y zDwgN2%x&yDgp}BWe=|ATWeU5jEEKhv2@ykhC*`nODg;<@u4J=l@@V>sGo?-CSHqQ3 zPj*;dNID7vvRNW{gs8-KG~)911{*)itl!dUTj?&MZZp7rrbRxf#*cGO(?-^2&34BU z%jD@F!#&z(u-Dg|87qv&ti&rvwip5+gm`xV?hS-|7^s)nwYzQnPzxML4OcE9J0qI# zb*pXe5Iu5O?}E$QqMHNCcp%ALIw$+^#u*|8k(Zd8J-h1@bzxbPM+v^*&BPwOP(|U# zb>OOitr5DnYSxPqTi)-Qz+%~~U-T+`x^1!ie(AG`Pe0Y73k9Z(9V4~ys&LLXU&hmo z={6-#2)}K3Y~=+=Lj*r@6qF^1w=!`2j?JS8>Yq%v zMgZ9?!}&C@1d3xwRzsCaCvK3jFkHSsmf^PvNHtFHSME3VtuMj(ggp*&(JsAG9XASl zW1_{}nr2eH3R-f5)k|NENYCu^c-bq)Cm@|n)zsT5 zG>vcUdrD@flkWD`{oB3qlFhUB6N1Di>n{MurC0m6iL8=vL;<7YEq;_>I;B@!BdJl zI*0c!y2j3Rn&dA)%vTqX^8EC=yStzETY01ahz|omBUl5#b+octj8EKZSH0a^ZiVWK z%gEUt6l&=fJ|b?NBR6Rh3=TV@PTKKE8-GLB9g|$wo9Xle-CLSz`}x)Kjgm5U;iI(v zn8#6JQ7Zpb71xmXq5sh#8gnOWoQnj>$CL{VJhKmO+O-lgG}}V1B6Kofi2Zs5hsy5` zuxhD-$T(&{1=qjI@Ni#9S~i%Q9(Y<`_BdO&IAHBTK*P6-<96%abg6__)U{OaXb1+x z$&c^c$kKXInsyG?r=pUV@`}0n2TsDq+a^2;`}!hk9^(eld0kjT*nKl{fHf+iuewbT z(lATm{eYytL@LAn<#i>Rz15G-3unFjnUgx4g(Y2bUnJA|`GryZY9hGLM6^e7zoX&_`-3l8-FSLj^zERkpmM zrqwK`UL~O)Oc4qg2%__cixWfdcD=K%xZs5ebSRFV<}+%L#H9#q*6>>V^s`UhKWrA` zi%Ft?T;|)iIwEnUKZW?NbB1pk+q^l8kmt5zxlZM)8Dj01r^te?6l9of-QcyX39gy( zd6U6?W})A%zTCWKqd=k1T8^(AugKNqsOJXxhtwCsjffLXu+YlXI4l+yU1QAmXHel&AP0Rk+YA(Fjstz(F!V@PHtDg=XU99bUvdfxz+YMRDl1tQ$QIPp z27o8m{uoRSLBv8Sbb%!uNOW+v-n^{$_XFXEwbvCw|G#34XX#AC{&FsKWwe~B-KhBywk*W`(>NQ zIW@(vX02UUqqfBrS)8q*)m3*jB(&I^@(=9rIi_P%>S?)t_UT(!e8jRVUF0q15FmmjD;I)Fx3=<@RAXac=w$({q!d2`9br9 z(7pj^CuMn52)H~_70>_3(I_#NTW!X@B4BL@;ctk=JG{&uehBhWV%$Lm%Mbtqg(YyE(0Gv_RE-0*1bU1^1XEs%Ei91CHQx1XB#K zbpmJ%7^ZN($_p=P&8}yD*W`hyWH>^ZmQNz&sPJI0V}ttr@keVQW6OD{pQB^{+2|4Y zmt>qO0dyQ+aV^iCX+#*)>sguTt~bitp?{4Bn8O$R6|%o)C^FVds*WhLj}<5Wnx`*G*B*!huXb35+nds6LUHdzK1MIu*3PWyep8`4 zE~BrKPV>81>DGF>R`aMLy$z+ENkIUTPeL5QGFG{Lx?%r^daHkSyG%cU zQM{W$tRD6=>7jt*Hp=G1nW)O2Yezg0Qk7!&wUcRN5`^NJ8qzbuQ;Un=-I9q^1knr# zv<7tC*ueb>2JIjUx(|mtY*-ik!8i(@X#FDf)m7Mw5OU}!RQ9m`$RgRbrEgvq%8rPN zB2Urme9wvNW|P>m^TPd{$Q0HNZCT zeE%Y|$9ooGmYDuW?HX!iR-q?(_Pqze_}e+axM43%W`EhkYf$PN3|WEDlpyS zqyVni%zQ4MbMl8tCk2=jJ9rU4UdO{u!%Hs;jHRA2s&V1Dm1O1u{VE1BdO* zygbCwUkh6akDYnZt%qAzSGL; zPn>XC!r@(PoArD5bqd!WGAi*onfZomo?GW z)*Lu_jx{oxV)=Fyofjr&W!&zHnEG-F?JekLS*n}wy++v3N_Nd(l|5|0Mp$ScEhf#x zS}*y9K%a?rp7o^M+@w}~N2QakXUd(MbnJZfoUea$Tx}KtR%-gvzkWocfSHj z4aPWdeo}%UD?dLNcANZ~U8MMCcNXG_A%HCh*`eUmkOdBzXh8qB17A{ja)sU||((;0&O$)D_y%NXeL(M2WVm7*9}}-1kU}p>I3tvOzD_N6@Vi@eHX^}iQn-+TGoUE zF$rcG+Xpq19Uk?ZD?6;PL3q~EfRL$?*L#E?DL_h}A1hiUHX~REwZkM3jqowjacA_acwY zT7nkq0}~Oa)*247)UP|$%CDhV|L6CGr4PTa-Hc5;+>Zv0*~o%aS+U={6RZR3W&MaR z@_|Oq-Thw$2frveekRUwJqHK#ftt;-NoRndz*D(k+nGLWqDPWebiqOT9vm6EJFRLJ zFxVt(7e23~SW(F#r^&?oca?SCXY$pf`2L=)!im3lS>|zo9FwZDSk>QxL|lu?wHq21M zIB!oJ^R7-Dn~MY5D0Qq!vjcDpi;R|m{B@$Kxf#jr4MDA)tKGDyZGxww4iT(@;{?Bv zwaxa7KyAyj+CA;VKV665V-FMV@r*d@NyPhl8?=dEpnOJjP?S_u!0LDsOD}e~8UnqW z3IksOB9a83PrCv3c54AyrN_?hV!VgPf30O8JQk?vm?`Z z1iXVN5`Q9EdN2wH2bsGyfmme0`~lAmDDx26>IykX&=6lx#6Wg$=~GAu+*Q=(PXk0w zB*D~(7{w$08^;pOF3-)9eYo>i5ZMt7@qhei1ZA}XYV{2GiF-+at`m?$uxTg(hif4H z5`00NomUaZa`!nI-ANhU-OE71;{Z9E`;vVUNL-CuW7}zgsopm*fCWX{syD2^H+u{J zc;Dcs{g?Mml5H)Sehtidu^)2m^Y{iW$!f2==dD(Cjc<=)wkduNn`#=IntqJrO z&pn}_*O2VxvMiZ;SwCv+v-I+-6Df9$)qYL9V@l5Y1YMFb_ylbP6_)8Jsm#&QbQo>s3lE)%_ERABfj5BI!z23?LLKTt@3DHV zF?fmF+hhBBGF7#;gY+m6(|6QHp9<1v)@}#ZK7l{;S@)K`j`om8VyFLOjcn3HPy1V7(d;X0gm%evG6tc`ZOWZqKpK-;+{%|KcuF5BEKx;<< zt}S~9>XBvF;<_;PvGnoU=kiFKc;xKw@E>cMd;Qi4>eW{kbk#r3MTeDliCg*(I8`m! zL0|?&Q=HQQVLf9o&xQ+r3Td!MhMD}Q!{aAd{G9h+Wf+{w`gGtEm)aLDjUzX3dZ@R8 zsuVZrWMm5Gn=pJwvpj%^7R@+GGQb=LoLEc=GhC|7xp&M-s1$u$iB+0~VlY+CiTLJ| z0vej+)^8{(f_)Z*P3f7V)%({4F4L>s=2EavldA^h)L;L}^S}dnwtgxrIi|I)_D}n& zWuR1R;&!eIUi&^KF=vco#x-uO(M1R$>CaRT~8bf~0mu z#Y@U(SZ8Hsd)b@a4H*M)cx&x_+vKjic)6c$j{^0Wc>D*L4gjKii2%3D?TDGrcNvw4 zAr-@v0>MFgje1Vpuw+oBzqdFS=ja!?thQGd7UU|KmSMhGD;`hg3zbEdKPmcdd3s}9 z8doO8A$-cZuwz#R+$1M7n7fVbTr&nnU47Y8>6jtWW67Ls~s~C>F z>Yg^#v~WVLi!Qm1o6)$f_){;wp1QgB^Kd<|bc0|*kS0-}$Dt;WRlx${UF@|t(VKUJ z9U5&%n5KRwO}W@OWJglZO%M8eeJd&8v$tGkui48xOW84Yb5^J{Y}s?+u{(COpyVKe zjCz1gK8I5@kI#v}eo68$EOL}fOHD!6tJOWz4cvR_3+mrDBU6I%(H?3yVOefpw=NKu zHgeb$IUgAZT13Y2K4iAmG$}3>*Nb`b;Z^s=$diZX2`-F(@ zua@Mi$=tsU#(G00C8FL^%r)9xy|6UWSl6!y=!{Se=3el#4W8HscI#hsf;VnvHDMA-CZ3sGczj88Rxk) zj@>6_!m%(~k%2^QfT+gC6o5tyQy;`a49^!jUeWaVjD;$|j-bqhW~gxjM`cSlj}I(o zAUXpi8MaOH<-n5z$RKx9Kv-BamsMo2&qX#JE7l#0(wV4GqyWs5f`$ePPq1cWY9>r5 zXgCkX8q#2R0Gdh!i*knHxfc7g)+)Kg+WuIOP6ks8iMzP$ln&)T0oxmx+f0_zLY)>N zE%zA5Zhq{yZdx`y?c>sZP_J`AG7(5M=Nxw54`^U=93*Nj@;j)9}N0 zPPyw3XbTJk5}Y(u{1pYF&DJ?I<9UbH~Wq3adnE zSaiU9MPLbd^vA}$q-_WiF`;eKh!inGI#fP0u(`WsN;?-`0pBG<6c?#!Q+dI2Z4%5| zK;lrOZaH5M^T)b>F$DiLxllfD>J(gQY17)nH8bH#EbsyCs2b4Cd$ObcQ{sEOHj!*L zto_rili!1bNM99h?O-%YZCMsWyaI`>3FY>53^%IyP#+ig$Oif^GUcRBR~|_ge3Ijn-P`@;gPCtF6=QJyK9Sou_t@ zaGTOnr~$u#8U(i&N;VRf)7!87u4H&-J2>6uyjCeHVKMJKFLET`=$At=dPLoE!+?OE zbn)zF=y|nwqU#qsM!7YUz(;+A>=7GtGp59O@^JZ*whN`$u752rHh?{-WBj}5+z1$~`;3ki_GJN!*qe_!_;B;P{33ERO_x4g7|4?Ks zNS0Sg1gVsTX5~!%-W7U=-uV?1t)?r^6aHPRY}imc&s(AHsir{;9(j=X>g4&T#{!xT z!LF7%hTmxh`kD#8dN%sq!!@9!kTnlpcWDp@an9?uNQyu6Pg{fwYx*NBoji9T(uy?lub-4roU^x7FhG1MT4sXa+k)}jZH*k$Ya^b+X4{T*x zAVD0lVEb$21uGrQ24LmF;!=R@w$KN__ihFS1Gs+y4h~vp3P8D*x5(>XYg!~aPo9_U zg<&q3h`?Aj1LUv38w0H$U=c9R0HgrM{0I)Z0ssI=8M-xr*#>HfE1?eze--L`qy3*7 zqi8ULCP|Iui<7%SZ{C0-jLhGhbi^S55RpXBT{AGy6nZ*-0vZhm;SNC9;jKUj*hzSr zBmk#{WEFV30Kb7lB7?{1;XXzTte;Z1_W_uN1QtMIkv&b89zY9(mIy>PP@%w!;I~0k zyK{3VlfeTNuEivGm)sfMvpcu3T_18 zg)j*Mxs=ZE7Ox-%BPZ3M=^OFbw3FHkJG$Bz8Nbm$On1np{ zLFj#9sQjI_iL~e`up$Ghv~sq z4R@EdjoI&&BU*3|=K2t)_L{B_Bw4b(?_sY87k?O`fH#4t+a_|jEH9e?BnoXA962!S z2W}#02hd5&;Rjp#vf4*qpQU|8mG;A@6TJ>y00ZNc3xm;))A9#qt&4Jis1Bl0H+}eW96Bab+ zwUI+4mZT9zWA-cWzy{bv;*8seYk=h8~T2sapB+UYX3(CStAC;455{d8nOr{J#9357ruT z-bCfy6cBFMSgs73Fpvvpdu2QOjgfZeN1T#R$84-4FMIxpMXtW;q?1R=kJz#ekCxO1 z?M5PiDcOIQK&3@Bs$hyi%q6z1;Mcb=Z##DH(Vu7d;>R}hbV#>8U!(a;j>7i{?uwnu9G8qJD9rKXsEH7KH{?p+pU;Z$y!_kt~v%FDi zRJ??y=GSq{lp4LQLvl~=xoK@Wy5;8bJEt_>I}M*rwYxWvmBE}#(eY)H`yM8%X_NlN z+bNCN*A`lY3+8g%of03XJxAuW4;_H$acEkk{37P^grZnL4!wQA9KUiUVX0-+Z3q#kgjq@h8e3rJfmHf*^J#8rho^Z@2!H#N8=!RO(e zh5;8mUV!2g=kXy^z~js)fPq;boi4SCgC`B4P=cD8f&dss3P2r!#~?qS9g^Hn?wl}X zBw@xq-1ihy5ZxeITwFvl!(mIZx936p@?;`e;W=3WBP)b`*Tzwclu(|vNswj+eLfQD z=zTkx;-VWsE?F>-^=qe(TXN>)OCId&YXHW`eb_%?L?LM*=i(xSe7{5t;%bA0fdR~d z@IIXZe-7LOBTPgR1#zle|9Bd~fdMjfC>(89#_!1X8iLCi07BsDQ}^U8>~ioM4T6yz zsMum-slt_kbG&~x!wgU##AA;t=sO%aU>gD&LWB^9=Zl!mA-qHwQ2qR=p4%X_5$#g` z+*psgtr(J%;QN8h=os`wZjj6GP)QIZnSjkLq%t9F8%7d{JcLUGrWc6o8=@tK>&M!L z1n6kFEtY}D*y?u~4pJ6#&B%Me<>C0eei>-gKt|VbTjT?*3a*WC`r3SBG?gMNK^#^0 zo8~EmGNyjj4z|Jsk!SCqNNgJd2|Oe{b*K%m?;XHvot8)C3=D3-4+YyY*uX%$3a23S zZj@KAP6I1PJyLZT7kqq>gAP^`oSJa^paNCW))viK5aUahLO1;U^{dq=N*hrSN(NJ> zz;*~@{_!eyH~}H_j|Qm(V#7RSAP)hX?NBCbV(RYNV-C!AWi1+&MEOauS?@{#rgd<&z zv&zfbN~W(zp1R?0`IL6%NvKNwT0byHvgzLM?gqu=9?}eVkkNFEscD`#eGqV(- z{HvNesvUc!@2hC&t2(mg=RC314nOVYG_LwkSxvR=-90{do2|?r0?r&Te&Hl|VMH44 z>ys>co79H?%-88NtoMFxs+UxSJ`j{Oy7wm5kCZ~VZ8dFgZtF*pu?u0_fXxh>nswTz zoil;t9L7KV}PCPp__uRP4SPW1E#@W4IU_AyKbtsgW^Qw5J+;)q+lO;9IfZ z56jWg(4fcp8Q1k&q9AgaQBS(A*qqk!5)n(1WY6 zwjEuYA~)@cM0Vkq zk>9JoPpoNvY^&4h2!0e5r74=|K0=3i(e-j*Pn5=Mgf1Z=`bg_h=gry#4|+?D-*eL@^`P*7s;Z<-pgI_wL^DAG}H+le$kEoEf zH9I)Q;Xwia2k03y@;hC4|rdbuDvb_ypj^f0ayNtNzL5&CNwz2yO5N81ylen&w%OBlg9QfmkeI+%# zd5{P&k|5Oplu^K0N_?ibdhmo35$S4tcI5-P_pG~P1MDmS^Y)mQQkXvmJuQeBL_wI? zi1!Xg?XcM+bd)wuVPR=rs`T94+@Fs2K&1$Ma3-AuFlz+m&j~mMXdChs5Ybm8Zc3*` z2B>sa)`>66TOeNrP90?MZEtVm6o`C*UDa)C$q3wE;jKZ12k#zO6Z*G0K>OMGEWO6G zCv{R-bnj0IOxoUn%fz2~H`qBKOfgKS7X*-y4F$iZ7P};jt^Lj}EG$6T`Lo0yyWVrwHT^czwPuooRw}`s)P| z6iOCIr&8V)=_HAmOXto2PX_o&3sv?thtOF9R1SrwDQtJR?IM2-??Gw-48$K#!&+`a zi3-37Y|~28FlYorIu_i6qQ2C>YWO{F|*F`z${1e*qtXIOcHeMm|03+G$jyV}A$?O1NJh zQq=yAt4H*^HxsO1iFQrBT0XiFlV01vR$J=b_wC}1G@(d-*2YpvA?FIpp*Mw2s;66u z1RZ6}=TNpUyp`ez%L`BU9sgT z9>Hhn)_hh&cemT&!vA!bXM=8R+jjUVgidly$<^nJ9 zy_2B;?^NBNeBhTv%{iyQT37L#A*MHCN^;6d#7Yh! zW=-7W&(I={LIeh>kFnFLuT5{Sx|g&)QJ$KIj~`fbn81oeXHub)=V!n5@N1b&m;HY|MT-2cBXawfo$ATg!;8DMI$kq+X_{CBhrfg`t%L z`oV&re33>Z(4APVw_rbo#sq{;`AY-&nIe z2uUDgISV{(Fhu5+13ykcD`(v)iVMYVg-L;a+_nlD8fvtAG!!wAH~Pho@Cx#M9oZPq z;Nyc~oY@%18}L7zwdtK`Fv=7 zxTokHRgfs`LZfK`v#J$T!S?7PTzW_^2BHt?*fZaQqNmk?%~MEaU1l**3^tfyqtD>L zY4i|Cke{luUbR`n(1(rTYcA;D>VaVa5Lawl_qN^5@_?Q(0X3GL{51p|D1;gfip!nt zW-O!qKxo95PSTA6=n?nRFA54rjS^cNw9&W=)m^#p)-@DS zLaj@7pM(+N02_e{<3oxbMCqNGX=)w;q1bV3Qht zKl_y#d-%X{7(D@`!^@;T#qNrOCVqGh=VG@+3_*|xYPG7Khpk)0dfeH@oqg6_&_09G zd@@bOV#U}Q*Vio0Tz^p8X0w0F;o;%YsSIQ7pyp2l=J^^E43|skJ4vNqLa8VC!{KCy zvWlQ&iPc{CiP?vk%iXN1nig=9!YY6yhDEL^OZWm+LHUecGpL*Eo;>~KC>-^CM%uy1&kr73Rwmhki??fj&VgUTu`KPy|0zo&!4E}5T^gn* z<%$XsZw9c;{*H)qG|rur>*ejyBvz=TrhO_jyzrgxL(6AdF;AW7r8m#eHn!>4eyil> zD_QDTD(hyPKg*VTd8irWh7H+d;cuaZlEI;0JI4w(36*d^&+y`R@R(~&f4v{ZlX54z04+3JeD!ojOD!HHK&)MLDtcyL=)Qtv z_ABYcJG5tHeKEq(8A^706~`A;97roU0(Wm?W#MNb6c+jDWylo<**=V4_4SYtcm48e zq5N|&j*V7I1XrmWAz;EwgnT@OtmW*q0GZsW1{90#&0_$FjJp2$^K?cc%03A~^EQI{ z8I7Evnw|_a|Cpv#U$U_N#nmh78Iy8vr~Wx(j|or#I10z=kj|mB5OnL%=q5kH_&`1o z>uQ+$Wdzf+dk;8aw!;*fD)&m#_UF7_*^ddldr%~+)LPo_oX8-jDfJJ_ZqJx7k0BtuT_)$1y(}Nr^pg$IjM30^TN^Y75bOQ8U=7?07 z$|F)!XtC~~!#C!03KDsPJ}uWEHa@_=;RE_X(&|b*5f&&c2EUf7h(Lu5f28UUmzEEg z!fhq*-*=wyC6}i}4}zHR2M^kl4$+mN_XfMjKG}MVd!NlnXa>a@q~AhoXEc8|Q?PJg zMt7Og#KHOcO%mEQ=S^~rnk|LP-$~MC7G7CPrAx8+(*N7<_V@aQ9d8B=IBnB*S?;xN z2%`e*_E-9pUIVcjNY2l}1QMA|eR~##=I3w9*Z%bSWFsP?2I6AP*5~B}63t<7l7{^j zs!lY}P7qx!G_ElD!hH1F`xtnq3D6EiOS!@Ve#~&F9M0Gr`XS7WMl%mYLf3S~romAg zVdtQ?D!W#}M-qz|ZG)e70>Om~r&gdtZr&eVJ{T>nYiR*tk*S$kUAfiawC+Jigthe ztciB;5 zbWOg1f)cr-HQS9GYsl|x@>$)O0vGJEQ((M`2qZd;k6jq9FJT21+0bGJt{VF+b$F$Z~ZULTH(44#EDTV@}?V=kVHT zL#=(gfv|^>Wc&TWqytK*MnPC}%s?4C9P*k9m86;I6j}bQ3s>xQ*9|Wv&IoBz%xNIK zms+^fu&tdMnapT>1IMgK<`93*Rqg*;+$YB^Su zFl7BH2pK@`PtYFH!O3Sb()3xIxOb;7>EVirmu};fm<;z%%w^im@pc7ZeItB{@QZnM z8@zMzZR)MY4mG8Q!4kjdLY=@DJMkm@SA?T2z3@$BRW`8NX-7fX0L>Zj6u>?R%+X+m zi#(>1(7MIQk~LrY`yB(6->(mTrx8E5N?!(IOT==02^^@yPPyWDfGPPs=mPrcOxBUd z3>Iq$jGRsYFB2{iLOA(YvyrDF$sr7rEFwTpmR$!v!Au;<0wD63MMnNK9_vcs%BcO7 zdUtHx*n60wDR{1h9rM0^;GMIGdW7C>_^V zh`~BIb&X;Zx01srO~m#nkz`otc?vu?a`soj@!V|72mFXq%8Wsy>wd7Hi$N0Qk)O6T z<|T&QzDkH428Si|oKT3^p&+7Vh57+uL&0PTSUnZspbUfaV+s`Q-p}UkwW!+mq@$fA zEb#L7kYBigQ~qe^wVF=rYL_mhqy=LECqW$w@}*@5VFiz;XS;wetu>Uh?=-E~1SqxtFU+Q}L3Y*!!3)yaftpJ) zcP!-Ku2T?1_Iak3(L?6Pxiiw{5F`{R77(id;z&KjFFU^YGsD*yn$N4$BENXq>R%hm zcf^eulGa#+e?KG~7tpiqGa6F%k&|(MxlfO&!UOMihNw2VtE>_|YtwBSwVt9Wil+BR zuNvGIGP+(7d(|k1{GKoRMtQ~9x6W$*;aC=ZJ*(1bf;xrK|!@G&{5gm5HhR_ ziS=-ZAu#~J$3>J>K4*!*FA}lpvZeNie*nJH2_|0ZFiY{iJ^tRT18PJ~O-(_kKhg2T z$OC=L64RLgZygQ1LhxSY+|UC{*(d)$`m9GB$=c@sa&GMc9oQ?#C0GG*1CqHtKK^9& z`Y(`ZWCZJwT=1`iy>4ecQ>+7$F)F8mMYcbW?TNx}fIv6!kgX6My+z#KwY&~CP&>cF z+=2Tifru*%;Q+3lX0y=)n?z)*hp{YF|CPW9?9sGepH)h9ooC9gUXwP~14sob3cGqjffbIUH4Y#TbOU7& z1SHPC4z5uJtu=CZhQj^=xh_EXhxsliqzg2oH@TL;#&(j>=UyP$$!?&2!fFEv{X`2x z5=^z%fTj6X?4VZ+#xLNHU%A%G;VxeMJ*CG$4X5p+J^&-~^kVvU-jwkOXrCmRay3`D1jq|Amo)#bU#+UiT# zX6c4@ROym5)c-@(V{9v>#8Kw??FTcku99Z}<*PFQk^~eI~D_%EGfgh~O z&C5Md0{ws0eP>uy+16&!iUADW3KAqJlA{8)f+SIbM9CQ>gJhvZG6uAj3{qHRC{k5H zm6AaU)RrVUmVhKBM@b@i*0I02bMH6*X8z37<3rPMIA@=|*IxTw?@A?*kF&nEmS0g} zyt%n)(r=ji_+Iy5(r}uE+jbuPv%me9>zF{jddvXvH&7c=Yfd%L(TRnSk1Qa>XLdJ6 zjL!Xj+so?>Sh!%_i7pJiH3GJhKq9q0`B^k$GYG|bIZqrr<^+!Efw#V7@ai$rg#q=H z4GCcj(7^!2ynA#s1NeCdSz&C=U%VphUCFJ~9{r1J^Zmuro};1gCkBRwxep)GP?qb@ zva+z~*xOGOSQW$$bH0*tFWU}Ueqatx3=+US`DqB)Sn;ROg(*t=ujM0NQg*3(H%W7Z z?ChIRz_4$)x#dURMxwVHeqmXq=MP0_03C={wP6E2oZ*9KY?W?;Fc3HANC&h^tM(T8+Ni9j>1 zgFB)LEnmH1=HWp`f_nLxkELyVcHIIPs4@gFg@DInrH*z-M6xafxG9<~9^-!*vR9=} zt2v%zj?b7$YC6B$TO`s{#Jk@%UgbV{?W$i~R~*)#WN(sqj3#A+QYvim)taSVqeg4X z8IzmlIH>2*(}>QaH6-0ho)ww(}3NH)%Fm{+gOQ|+8^o8F`_gtoXOsn>~^%v-IAMeo}pHL zsTSoOvJ%$|!f(E_RnMWp9d>`YXuhcTolY@HzvJVCUGbwySj`{v{W!=cGla>30yyO* z?nBakG90jtDWJdnC$WwtZi9cyg4v|T8}C2=ra|A_yZ|a02{F()0|?oI3Q0NTBf(}6 zo7)L;Tl!$xMiw&51Vu$_W;dqWbZA?>r`iyKd{JiukmnV|2@yc|X)7ry`GXTo-^z;Y zd9|RrT1FNSCEc^XS(%w{i(`9EYs+Ll;|w;2xOA(&X!}+)t!9JQ8dx*4;9TqjwhIk< zRm7^s9AHOnTHwkpC9Xf9HN{;hxinA{^cK3pQr z{*KaJ47*Ni8}W22pl9f`PKZ^s&9|d0e3=h3$C~!jH=jt_+Oes0KD4YmHI+VJ$-sAs zv{z$^zJLF&r=3RUSg_L8c7jhtgjd2}CkVyGdP769FM@kqtj;&w$`=zac)4o*fD?tX zGxCwiVUmm4YT*4Fs~p#UA>pa80h6iVannz$YK)thotl%6Uv-;c^he8kOznjpU;}TY zwd*R?8R;^nZY?zYrx_9mE`l?3uM#>^dAQl93b zwI72Xb6|z^+&C$l4c4PNFz}#DD`$5fRqC6W5n*2&A?;#%Iyy2SXV?i2UumzePavHa z4e|PO$s;?tAI4sTaw&l<&LQu1*(yK<$i>Uc%d|Q(ZC-4V(b2@}YIDey?R~*0#C;2# zw^Y~$Xy{TjGxm(r(8Yy#f>W*lLRD5pt1S6{dl-rc5x9*^Fg&&q0BcI1;i$YoUdu#p_Y`e#KQaNZn6zSwaNg5O?l-MIRKO0j0XKp|`bDymI*{&!@ z6-I3=J;9L0c5ORvuRM6Yi-xk(BJZ-Xy}&vnox8vBb;&1}qMpibjb1;-eub)0u zVTg_-6kjNaS`3bC_{KUvXK3V@w{>Axn%awBZ2XIt_tdNuHFJ?9ir)AkB-dHkkREs| z_Te9q$Jg-`$_FBISm9XLT&z9xjqss*8g@?X45%E1;Nvvk-&2EebMJ>YuNw4s9nPb*w zK{`ePMdw~Q!ddGBJqevaXG|Hy77MFG@c2N9b39Pw5{z?jv~vxXmHIAO?#|Wj5re@Z z6g(3yz(6;%Hq$K~`17?^x?CYhm9g-j9v{p&8?X|N0CRi4d_g2oQ$vHFfetQqhMNoW z^EW=Z%R5ma(6N+xYL3TX27$KNWo0gWgSob*tBJ>V}AHE3D!Z(v0qZLGnze!Jd%_Fs# z*%vjPx%`&R&{g%lTdh}Ilw61dCu;L>D%yB{hTBv43;uJ_OS7ekY2BRBX+6YRKg))} zsJW8?KW5)0AMP2xCTwMysr$y7;yrqDpfn)b(l4l1dfR_(jxPj%;Ms6rv)F>ZBe$R} zx0O!nV&z6~&<_mH?DX^e3jbKa@Eh^v=g=0FBwSaLL!oK0sXdJfXEnvBc6(QJclo={ zy3Z5z`1B>p+MLzQNBsSTfK49C)~BVl`BkyI?KPCG#5`Yuqm!|i?CQ(=3;jf+y`X5= zFbS&MFC*5c6O62=?{7RSnR++Ks$KO2_IqR8=O>b}())cA7@kO;?2Q0614iS4+e@9F zD?0NMAFPjRS_bVtZK^dhbsZ}2Bg#`ciII^UZmuPzZqHSq$>|y=HK4SzA6NT%zB{#9 zc5D6~IWVm${C1Sj+u3k6-080GKgZwSRF7*YVo+BN(!p2ubUnVZ>C>(j-AC1|X$x|Z z-HJcU+pycOoL*C1Pkd|Sx7Lfc9HM+6Zue=_M1PP`zjDQI?R%?S&^KjrlDgaG}1!M-vrbH&2zfeRlwRlr|G@1A%9k>Sca9Bhk#0Z{jnsbvgn zYQfPw=?%Ia*U-dv^^^levK$G$!f_$_njWAn`M=M+8@|#be>LlU+UtS0T&%1d2I!!| zQ=P%kkV-&Kj+7?B=d;ox#V&hKF`Vjtd)(F7Vra@|{-*I|k>+tuDcp}?YZex%`p(WP zA!PX!jhW_jOR@Hn7w46gG1=okUqR&K#QHPthR)ihYZ+eDzS|zpsSj5k@Fn-(42<~Q2(mqW*F&C|RmB_GP|x7L6#I=;Nt?5$jk4roXQwL5zL1nL z3;Wc>b}+t|N35@In&Xn%)vf_)v%`bzv_ZON>BRV5k}_ZR1zFO-mIXSRb(0d;5VtdY zGJR@U)%JAPn78{RWh2}nqj%#X&9Y?->dby_ z>ZI(`6jIyqv#C)PFL=1gDla}pJZ*?n)GN2%80@Od?|d$2ggbh{k%OBnsL#%<0Iwi; z(JIG-K83?UP)y7SPH%+U3xdqMPY25oPzfxqYVx0MUBDS203t3fE`=cJ6rp2fm9CX4 zodb#yVi%g`*5R+UJDv0)nM>MlB|EMudu4T%=a$u0SK``&M~E3*p zygU_%W-zd}&g2OEe!bA7Sb5CT7((O*s?fw5fY`HTgYJ4tN?{NOmc6pFlCqWJ<&3cx zU_K@&FK-1kN_rp*l>{7~37A(=-yrru$sh7O*Rkz^%8+e~7)WtV<1PIyQlOo|JcGPN zfz7a8anW_{YJ(7LarZ)rl7kt$lDD*^g~AR?ll zCZGLiN3oP-jMF_n*Vyk~8Fis4K|`&x)0#)5sm!(ip{{`uhEUDVO~q>5Jdql#B3A3C zA8uHnXW*rZS+}N+#POJ56nPj4WMaIEKu(-jP6R`^@_OIHD+wjlYT0pWIc#Byes>8( z9fKg;C&H`&a|~NUqnEjo%F~w`Jmc%z_JbH1n%eqr-w65cJuec37}hL(1OOgsX9(K~ zjCfdhDzvM<;LEwO5Cy7kE2E)zN&D*T+4v8SNqe7X^5uDt*GFvOlpPO8?tPw^9TGLd z@UYLJ(OK=igQ+BcoHF0Gg_JVg77YJb*qL#Y_=Ji)%VL+$`5vy~*(MxCYyQc&?=i9V zCae)GrR#6~_fv3D)-$SPV(|gxyhG;4qt$t?J3sg`y`ZJ?Y=E88J2vb3(O~K|G4^L2 zF{YhIUDvPCK&Jx}B(hX~BJjz~`5fTiji9bnPh(>vZSRG0_aOpsNE9Hq{AclbJ+QJ} zUApY@!7>t%jDR3XK>>j#{P*}v%Ixgy5EiEgAKvQTfdK+&I?B(l;ahN2lfZ4#+t+s& zh#-H6?L&0i?08fBK!um>1=T>_8`T0BC%7=2Hc#0(|n&OVV&bRb&^%|kcN zgfFNtb)gn?&GwnD`=ABf=}K(sY{FK4BM`}bmET#8U!$#B$DB1_SR+{1`Iq)22n0$O z*t_((7`TKBQ@d6e)yIp?6M7_x1sAi&YAn}Po-(kr7#j5$T4eV0cV<3KxPrgf9_JM| zJ1>)$mS)Klq_h$s>{ew>Sy{btmr!`y&PhWkQA|&LPB4LKikL;x+Pm}cEiSHWG9p0$x^GX+q)XeTV^F}f)<(S3*Cg-b+`e}g~yN|uga=7UV zosE2*2OZO2Uh6z)bmDjDIh~-T9HF&-HuVKF`dFp(H76f&n;xdi(*5$A<=&t9W8Xm%b8Q zj0ploJxmGrQ+<5geO8uJ|Bk0=BmIGUphzuwlzZ7g%3HmdC=y;R*s?l(kEIoGWm~ve zz0DqQ7KT6p7;awy>YeV;=c?Y+hh%SZom+wa}7c3LXW+VRci%1Zj^w(wqZ&XrI5yP8W^^=<;h?<%18D zO9$}>tO1bY9Psk10w(A;YGw7WOy)MgDg{&x2pqa|Bc^RljU_^sC}ze$i#16ZnF82y zL%Y6&YW9bv#jcq@(%pC0*ahi~dL{UI_xXc`CbQDKl>UI) z^e30sImsfWn796(IIwo*{3v~O#4PRAm1Z%aSk)G`<8}}=jxQ}Wcz@@j%itcEi|{UB zc z94H=VqZ`1u1Js=dg4SOaG+eQ^b#V|}Fzqfbf(f5ytM+wHJ%0j#bbNJFJV6oHnO}fE zH|H91h%~3Q_)PoS;^ft~f{pF2?O<>X3knOj=s%6Dv%$94zJBf5H<&)msiywSd&-9L zwlCt6Gn;Dm|gE6^|HvK=w10!N} z{D%{*YA`%3nmOXRlXuO1@1=F8dD!P_?QYXeQf~j=(Q@LqB2*Yg=iQHh?E!;*Rn?9v+}`^t-> z9WA$tggzN;pOk-DPP#wI-Qs;vGS=mcjlyYqCK}+c4@#1cLXG-{-#b$D93Ik2US@Rl zv2f;^$@k^X(K|q@Kiy@(P}(9$y&QMhZ*JZEYiZ7>7-C&QFykT0%IEmr_vC{#n&xe; zFgkE(*%21ob2d+PXyoV?MKLQgx$(1ovMS>_g zamMYueKecO8)FUF0BSk9pjnf8m!?aPIMss^jf(oTw9$+n(zqybCL9a{0+}r4JvRl3 zv(aD5EDK%!=#Z>;^7On7c?odj++$M#EcO1*?J_qP;9CHCdw1=>nhSOCuZ4sz4dCeE zF?fA7_zL(Rtj+v<MDV7gvP%gar*6*NU`rt6e_0pQ1DKCljo%UiO}QnyK~J? zuhO6@IDQX2j54P;^nX3se9;6g&U9E)MCF`O&W%{u{%{oPbDz?I0}O0ghUYgKq8lcz zMnSNG#8_+C2WFg;BmuOF5>5wB6`?cX(4ScqY!zsh0B!;J2aK!P>mXkVbY?ezNS`0` zCNTO`X|x(#0l(7|$C}5uU8%Pl=p7s+f`$Ut-)gCLzXm#Fz{8-ft0b7YH@V)7Vjf;n zhG5O9U0LtR2(H+_z_FH#kFn~Hkd|VJU4_M)$ z!Z}C5t{}Dx52tR$!EO|us*OHP-^Y6q+~vv+W>XpCP`I)-5D#~P9h8>spUX`4xeoVaCQc| zx>+ASD8dNv+1Yk|#EM`x(i{YY8$Z9P2!a@w4R*xw6DI^Yq8;}@hSai2bLL-ZJOr&622GT12kdU`krdk5kLUsh%a2~3Ey)4(7B8Kad|?dTQ> zV-Fbss>sWLJ?`gM352NlSPz8Y!^KdfP7D5&p0w)>^q*<#jXWm2)Dhxi`CTC!79&r^ym?7`7z;U zT}{nMWE9}-g0u_dhE-LjfW}NqoMI6QADjYyy?Y?jEVlZ$Z=VCd1pF}+S<-l24dxF= zv`U$q_dGIb3T?@p0XC>mKOv8GL4%!%bRmxkx`dzw`TSk--W=mlpG<-p9z43R?#RSN zT=IwVd*I5-MPlOop>(?>AQ7lGYXu8a1wlKda8m6;eJx7FrGYoL&me6!4@yC5T=QM* zfpoJ1zO)C5K!|nFi&bYp?9{z=Nl$iFql!Cs8pFU5fT}Qb9W=bi{BmTec2tpzOa&74 z!jisyQ`l$U2FSn4`zq0`uO}>Z z=0~pl+}gcYHG5(o?eCai=;-Lg8O6I7G(t{-v_pb@H6g=!unZ#S5Fa1p<-!Evi;8qX z=n!3WcqWKv!>;7oyU%<$~0C>W#-eaiB04NLHfPlAwMP{! zuq-Mx9613ivh94!S3Ih&)20t(eJD&%Vk-;spZr^Nbol||Actr>&}s|3{+&9+}7Uh!*9**%dSK2Ib)C92xY!9w^WP_NPU^yO) z(ky&_a|1lxG2B7>+auI((efmK^oXp3kb%1_E*t9B0uUp>omS3w!GEYn~A8!CVqQ$30@?}5IvYo+8MO_Z41_V9^2EY{svDWX8eyp>Qrn zulWn}g$6HfXG=F6`KCCw<;$c*BKXvRa`tW>WX3_O=gOhkhUI^Q$yctpK#n8aXZ!P< zk?5@r`L}Q18km>}jOaVQW4_Q_bgw9S?G|L;x0GEA+NqmcpZxM;Ctj6&pquL5;01d8 z%vx1C28o0arEUd5Kf8puZ&$HpRV1PGc3+EvZSYd};Prm7b(~%rKxVXfK&pcgKSLL6 zawwX3^_Lw*9}>-s`u?V0N$GCjmOw(ter^6dxyJkb?d6f0yr+3-=TiO=AWs&IeG}RO zX3Mta5j&vfwlrC==j5;~OiwLOE?m)LqSZM0HD_NwLCsz;Ty%WQ#u`0XMhQCdOtv(LmApp}(GQ$Nguodb)}iVZX+lmmV_A=Q?;U3Z z90jGA*q_oRQ4d1TuBc2X`zWs8k>U+kiUMbo1y*un*+R?f4xrzk-;}&~5$w-AU|&|t z4$OFFHGDIPS)l5l)x*D(;b`}(U7q=FSTz!-Ub}B3IHcU*C0ezsEtY7$t@&2Bd;6>e zb!n|+u5>r*n_XD|z2A_pg%OaZeA;Q*j{yBiMbIUo9Oz-^R6LpE$*6=(U^pyW*dl2K zPd$eo0dA8{cZRt#o|`KwNL)MOWO)|yuTKC1SAydAfBe^Ip;L1cXh02OMOlY2CSh~W zeEy32`Em=1fsjk|l-)%7(VQDq^qmuO0TzcBv`;eG<|;5EkqZ zlz9NSDNLa*>Y(-b6FYG!vZCZK4;gHlXm-g;OxIW`BG*f1z?XKFqgzTBFmqK#rPX=@ zGoNE$Muo(5)wc%s_5qJ`464l<=@&ZH+6f9YmSZlZP^^0$2i+jm6Q768_s`JT1&9{-rO%!+~iGCH}HStbvCe zsP-#{2yrRzQ~x#sV-ytRMI(jj0f#dp5_2K@KoSHjBuo9z69Kt;yaEa`{EBHnN-}~# zw5A+G8P$o`zrtRiL2>#+9N#*0D!U6l-7QEFKy=3c`ZS&g<`<#|u%44p#ZnefMq3~= z%KS1+g(oe7Bp@bR-&Opd!|~UjH3mVUYePVyNIA^YZ3i#9{O`+zmG%B_lZzsq`2S() iQ2#H=)BnYwc0&pxF-QK?@kvA0?v|3)O_JiBNB;x5i7g5M diff --git a/static/45_LF-Details_summary.txt b/static/45_LF-Details_summary.txt deleted file mode 100644 index 6a597dbc..00000000 --- a/static/45_LF-Details_summary.txt +++ /dev/null @@ -1,27 +0,0 @@ -``` -Filename: LF-Details_summary.txt - -Beschreibung: Eine textuelle Zusammenfassung des Inhalts des Bildes 'LF-Details.png'. - -1. Einleitung - In dieser Analyse wird der Inhalt des Bildes 'LF-Details.png' zusammengefasst. Da keine direkte Beschreibung oder Daten aus dem Bild zur Verfügung stehen, basiert die Analyse auf allgemeinen Annahmen und der Strukturierung von möglichen Inhalten. - -2. Hauptbestandteile und Themen - - **Hauptbestandteile**: Ohne direkten Zugriff auf das Bild können wir nur spekulieren, dass es möglicherweise Diagramme, Grafiken, Textfelder oder andere visuelle Elemente enthält, die spezifische Informationen oder Daten darstellen. - - **Themen**: Mögliche Themen könnten technische Details, Prozessabläufe, statistische Daten oder visuelle Darstellungen von Konzepten sein. - -3. Effektive Zusammenfassung des Inhalts - Um den Inhalt von 'LF-Details.png' effektiv in Textform zusammenzufassen, wäre es ideal, eine Beschreibung oder eine Textausgabe des Bildes zu erhalten. Dies würde es ermöglichen, die wesentlichen Punkte, Daten und Informationen klar und prägnant darzustellen. - -4. Datenfindungen und Erkenntnisse - - **Erkenntnisse**: Ohne direkten Zugang zu den Bildinhalten können keine spezifischen Datenfindungen oder Erkenntnisse präsentiert werden. Eine Beschreibung oder ein Textauszug wäre notwendig, um detaillierte Analysen durchzuführen. - - **Interpretationen**: Basierend auf den allgemeinen Themen könnten Interpretationen zu den dargestellten Informationen gemacht werden, wie z.B. die Bedeutung von Trends oder Mustern in den Daten. - -5. Empfehlungen - - **Beschreibung anfordern**: Es wird empfohlen, eine detaillierte Beschreibung oder eine Textausgabe des Bildes zu erhalten, um eine fundierte Analyse durchzuführen. - - **Visuelle Elemente berücksichtigen**: Bei der Analyse von Bildern ist es wichtig, sowohl die visuellen als auch die textuellen Elemente zu berücksichtigen, um ein umfassendes Verständnis zu erlangen. - -6. Schlussfolgerung - Diese Analyse bietet einen Rahmen für die Zusammenfassung des Bildinhalts von 'LF-Details.png'. Ohne direkte Informationen bleibt die Analyse spekulativ. Eine detaillierte Beschreibung oder Textausgabe des Bildes wäre notwendig, um eine präzise und umfassende Analyse zu ermöglichen. - -``` diff --git a/static/46_LF-Details_Summary.txt b/static/46_LF-Details_Summary.txt deleted file mode 100644 index d9f368f9..00000000 --- a/static/46_LF-Details_Summary.txt +++ /dev/null @@ -1,30 +0,0 @@ -``` -LF-Details_Summary.txt - -Titel: Zusammenfassung der Bildinhalte von 'LF-Details.png' - -1. Einleitung - Diese Analyse zielt darauf ab, die Hauptinhalte und das übergeordnete Thema des Bildes 'LF-Details.png' zu identifizieren und zusammenzufassen. Aufgrund fehlender detaillierter Informationen über den Bildinhalt ist eine manuelle visuelle Inspektion erforderlich. - -2. Hauptinhalte des Bildes - - Die Bilddatei 'LF-Details.png' hat eine Auflösung von 2664x1148 Pixeln und verwendet das RGBA-Farbmodell. - - Ohne visuelle Inspektion sind die spezifischen Elemente des Bildes nicht bekannt. Eine detaillierte Beschreibung der im Bild dargestellten Objekte, Personen oder Szenen ist notwendig, um die Hauptinhalte zu bestimmen. - -3. Übergeordnetes Thema oder Botschaft - - Ohne direkte Einsicht in das Bild ist es schwierig, das übergeordnete Thema oder die Botschaft zu bestimmen. - - Eine visuelle Analyse könnte Aufschluss darüber geben, ob das Bild eine bestimmte Geschichte erzählt, ein Konzept darstellt oder eine emotionale Reaktion hervorrufen soll. - -4. Analyseansatz - - Da keine detaillierten Informationen über den Bildinhalt vorliegen, ist eine manuelle Überprüfung des Bildes erforderlich. - - Der Fokus liegt darauf, visuelle Elemente zu identifizieren, die auf ein zentrales Thema oder eine Botschaft hinweisen könnten. - -5. Schlussfolgerungen und Empfehlungen - - Ohne die Möglichkeit, das Bild direkt zu analysieren, bleibt die Zusammenfassung der Inhalte unvollständig. - - Es wird empfohlen, das Bild visuell zu inspizieren, um eine präzisere Analyse und Interpretation zu ermöglichen. - - Eine detaillierte Beschreibung der im Bild enthaltenen Elemente und ihrer Anordnung könnte helfen, tiefere Einblicke in das Thema und die beabsichtigte Botschaft zu gewinnen. - -6. Anhang - - Keine zusätzlichen Daten oder Kontextinformationen verfügbar. - -Hinweis: Diese Zusammenfassung basiert auf den begrenzten Informationen, die zur Verfügung stehen. Eine vollständige Analyse erfordert den direkten Zugang zum Bild 'LF-Details.png'. -``` \ No newline at end of file diff --git a/static/47_prompt_a1.txt b/static/47_prompt_a1.txt deleted file mode 100644 index 0abeabed..00000000 --- a/static/47_prompt_a1.txt +++ /dev/null @@ -1 +0,0 @@ -Es geht um den Bau von Elektro-Schaltschränken. Kannst Du mir bitte den Inhalt der beiliegenden Datei als Tabelle ausgeben, ausser die gelb markierten zeilen. dann bitte pro Datensatz der Tabelle im internet beim entsprechenden Lieferanten suchen, was der Preis der Position ist. Das erste Wort der 'Description' ist jeweils ein Kurzzeichen des Lieferanten. Dann bitte zusammenrechnen, was der Inhalt der Tabelle kostet. Die Anzahl jedes Datensatzes ist jeweils in der Spalte 'Tot Qty' angegeben. \ No newline at end of file diff --git a/static/48_short_story_french.txt b/static/48_short_story_french.txt deleted file mode 100644 index 1b7ef50e..00000000 --- a/static/48_short_story_french.txt +++ /dev/null @@ -1,138 +0,0 @@ -Short Story about Tigers for Children -===================================== - -Titre : Histoire Courte sur les Tigres pour Enfants - -Introduction : - -Bienvenue dans notre histoire captivante intitulée "Histoire Courte sur les Tigres pour Enfants". Ce récit est spécialement conçu pour les jeunes lecteurs curieux et avides d'aventure. Notre objectif est de transporter les enfants dans un monde où les tigres, ces majestueux félins, deviennent les héros d'une aventure palpitante. - -Dans cette histoire, les enfants découvriront l'importance de l'amitié et de la coopération à travers les yeux de nos personnages tigres. Ils seront entraînés dans une série d'aventures où le courage et la résolution de problèmes joueront un rôle clé. Les jeunes lecteurs apprendront comment ces tigres surmontent les défis grâce à l'entraide et à l'ingéniosité. - -Le ton de cette histoire est convivial et engageant, idéal pour captiver l'imagination des enfants tout en leur transmettant des valeurs essentielles. À travers des péripéties amusantes et des moments de réflexion, les enfants seront encouragés à explorer le monde fascinant des tigres et à apprécier la beauté de la nature. - -Préparez-vous à plonger dans une aventure inoubliable où chaque page tourne une nouvelle feuille d'amitié et de découverte. Que l'histoire commence ! - -Introduction ------------- - -# Introduction - -## Le Tigre Principal - -Dans une jungle luxuriante et mystérieuse, où les arbres s'élèvent vers le ciel et les rivières serpentent à travers la végétation dense, vit un tigre nommé Raja. Raja n'est pas un tigre ordinaire. Avec son pelage flamboyant aux rayures noires et oranges, il est le roi incontesté de cette jungle. Mais ce qui le rend vraiment spécial, c'est son cœur généreux et son esprit curieux. Raja est connu pour être à la fois courageux et sage, toujours prêt à aider ses amis et à explorer les merveilles de son habitat. - -## La Jungle Enchantée - -La jungle où Raja réside est un lieu magique, rempli de sons et de couleurs. Les oiseaux chantent des mélodies joyeuses, tandis que les singes jouent à cache-cache dans les branches des arbres. Les fleurs exotiques parsèment le sol de la jungle, ajoutant des touches de rouge, de jaune et de violet à ce tableau vivant. Les rivières claires et scintillantes offrent un refuge rafraîchissant aux animaux par les chaudes journées ensoleillées. - -Dans cette jungle, chaque jour est une nouvelle aventure. Les animaux vivent en harmonie, chacun jouant un rôle important dans l'écosystème. Raja, avec sa sagesse et sa force, veille à ce que la paix règne toujours. Il est respecté par tous, des plus petits insectes aux plus grands éléphants. - -## Une Nouvelle Aventure - -Aujourd'hui, quelque chose d'extraordinaire est sur le point de se produire. Raja a entendu parler d'un endroit mystérieux au cœur de la jungle, un lieu que personne n'a encore exploré. Curieux et excité, il décide de partir à l'aventure, emmenant avec lui ses amis les plus proches. Ensemble, ils vont découvrir des secrets cachés et vivre des expériences inoubliables. - -Préparez-vous à suivre Raja et ses amis dans cette aventure palpitante, où l'amitié, le courage et la découverte sont au rendez-vous. Bienvenue dans le monde merveilleux de Raja, le tigre au grand cœur. - -The Adventure Begins --------------------- - -# L'Aventure Commence - -## La Curiosité du Tigre - -Dans une jungle luxuriante où les rayons du soleil dansaient à travers les feuilles, vivait un jeune tigre nommé Tiko. Tiko était un tigre pas comme les autres. Sa curiosité était aussi grande que la forêt elle-même. Chaque jour, il se réveillait avec une nouvelle question en tête. Pourquoi les oiseaux chantent-ils si tôt le matin ? Où le ruisseau mène-t-il ? Que se cache-t-il derrière la grande montagne au loin ? - -Tiko passait ses journées à explorer les moindres recoins de la jungle, ses yeux brillants d'excitation à chaque nouvelle découverte. Il aimait observer les papillons colorés, écouter le murmure du vent dans les arbres, et suivre les traces laissées par d'autres animaux. Sa curiosité insatiable le poussait toujours plus loin, à la recherche de nouvelles aventures. - -## Un Problème Surgit - -Un matin, alors que Tiko se promenait près du ruisseau, il remarqua quelque chose d'étrange. L'eau, habituellement claire et pétillante, était devenue trouble et boueuse. Les poissons semblaient inquiets, nageant frénétiquement dans tous les sens. Tiko fronça les sourcils, se demandant ce qui avait bien pu causer ce changement. - -Déterminé à résoudre ce mystère, Tiko décida de suivre le ruisseau jusqu'à sa source. Mais il savait que ce ne serait pas une tâche facile. La jungle était dense et pleine de défis. Il devrait traverser des terrains accidentés, éviter les serpents et peut-être même affronter des tempêtes soudaines. Pourtant, rien ne pouvait arrêter Tiko. Sa curiosité et son désir d'aider ses amis de la rivière étaient plus forts que tout. - -Ainsi, l'aventure de Tiko commença, une aventure qui le mènerait bien au-delà des limites de sa jungle familière, où il découvrirait non seulement les secrets de la rivière, mais aussi des leçons précieuses sur le courage et l'amitié. - -Meeting New Friends -------------------- - -Meeting New Friends - -Dans cette section de notre histoire, nous allons découvrir comment notre jeune tigre, Tigo, rencontre de nouveaux amis dans la jungle. Ces rencontres vont non seulement enrichir son voyage, mais aussi lui apporter de précieux enseignements. - -### Les Nouveaux Amis de Tigo - -Un matin, alors que Tigo se promenait près de la rivière, il entendit un bruit étrange. Curieux, il s'approcha et découvrit un groupe de singes en train de jouer dans les arbres. Parmi eux, un singe nommé Coco remarqua Tigo et lui fit signe de venir les rejoindre. Coco, avec son énergie débordante et son rire contagieux, devint rapidement un ami précieux pour Tigo. Ensemble, ils jouaient à cache-cache et grimpaient aux arbres, ce qui aida Tigo à développer son agilité. - -### L'Aide des Amis - -Un jour, alors que Tigo explorait une partie plus dense de la jungle, il se retrouva coincé dans un buisson épineux. Heureusement, son nouvel ami, Lila la tortue, passait par là. Avec sa sagesse et sa patience, Lila montra à Tigo comment se libérer sans se blesser. Elle lui expliqua l'importance de la patience et de la réflexion avant d'agir, des leçons que Tigo n'oubliera jamais. - -### Une Amitié Inattendue - -Plus tard, Tigo fit la connaissance de Bobo, un éléphant qui aimait se baigner dans la rivière. Bobo était grand et fort, mais aussi très doux. Il apprit à Tigo comment utiliser sa force de manière bienveillante. Ensemble, ils aidèrent d'autres animaux à traverser la rivière en sécurité. Grâce à Bobo, Tigo comprit que la véritable force réside dans la gentillesse et l'entraide. - -### Conclusion - -À travers ces rencontres, Tigo apprit que chaque animal avait quelque chose d'unique à offrir. Ses nouveaux amis lui montrèrent que l'amitié et la coopération pouvaient surmonter bien des obstacles. Grâce à eux, Tigo devint non seulement un tigre plus agile et plus sage, mais aussi un ami sur lequel on pouvait compter. Ces leçons précieuses l'accompagneront tout au long de sa vie dans la jungle. - -Overcoming the Challenge ------------------------- - -# Surmonter le Défi - -Dans cette section, nous allons explorer comment notre tigre courageux surmonte les défis qu'il rencontre dans son aventure. Grâce à la collaboration et au courage, il parvient à triompher des obstacles qui se dressent sur son chemin. - -## La Résolution du Problème - -Le problème principal auquel notre tigre fait face est la perte de son chemin dans la jungle dense. Séparé de sa famille, il doit retrouver sa route tout en évitant les dangers potentiels. Pour résoudre ce problème, le tigre utilise son intelligence et son sens de l'observation. Il se souvient des conseils de sa mère : "Suis les étoiles et écoute les murmures de la forêt." - -En écoutant attentivement, il entend le chant d'un oiseau ami, le perroquet Paco, qui l'aide à retrouver le bon chemin. Paco, avec ses couleurs vives et son esprit vif, guide le tigre en volant au-dessus de lui, lui montrant les directions à prendre. - -## L'Importance du Travail d'Équipe - -Le tigre ne surmonte pas ce défi seul. En chemin, il rencontre d'autres animaux de la jungle qui l'aident. Le singe Malou, par exemple, utilise sa rapidité pour aller chercher des fruits et nourrir le tigre affamé. Ensemble, ils forment une équipe soudée, chacun apportant ses compétences uniques pour atteindre un objectif commun. - -Le travail d'équipe est essentiel dans cette histoire, montrant aux jeunes lecteurs que l'union fait la force. En collaborant, les animaux de la jungle démontrent que même les défis les plus difficiles peuvent être surmontés. - -## Le Courage Face à l'Adversité - -Le courage du tigre est mis à l'épreuve lorsqu'il doit traverser une rivière tumultueuse. Bien que la peur soit présente, il se souvient des paroles de son père : "Le courage, c'est de faire face à ses peurs." Avec détermination, il plonge dans l'eau, encouragé par ses amis qui l'accompagnent et le soutiennent. - -Ce moment de bravoure inspire les jeunes lecteurs à croire en eux-mêmes et à ne pas reculer devant les difficultés. Le tigre montre que le courage n'est pas l'absence de peur, mais la capacité de la surmonter. - -En conclusion, cette section de l'histoire illustre comment le tigre, grâce à l'aide de ses amis et à son propre courage, parvient à surmonter les défis de la jungle. Les enfants apprennent ainsi l'importance de l'entraide et du courage dans la vie quotidienne. - -Conclusion ----------- - -Titre : Conclusion - -Dans cette conclusion de notre histoire captivante sur les tigres, nous allons récapituler les aventures passionnantes de nos personnages et partager la leçon importante qu'ils ont apprise. - -### Récapitulation de l'Histoire - -Au fil de notre récit, nous avons suivi les aventures de Tigrou, un jeune tigre curieux et courageux, qui a décidé de partir à la découverte de la jungle. Accompagné de ses amis, Tigrou a rencontré divers animaux, chacun apportant une nouvelle leçon et une nouvelle perspective sur la vie dans la jungle. Ensemble, ils ont surmonté des défis, comme traverser une rivière tumultueuse et se protéger d'une tempête soudaine. Grâce à leur solidarité et à leur ingéniosité, ils ont réussi à surmonter chaque obstacle. - -### La Leçon Apprise - -À travers ces aventures, Tigrou et ses amis ont appris une leçon précieuse : l'importance de l'amitié et de la coopération. Ils ont découvert que, même si chacun d'eux avait des forces et des faiblesses différentes, c'est en travaillant ensemble qu'ils pouvaient accomplir de grandes choses. Cette histoire nous rappelle que l'union fait la force et que l'entraide est essentielle pour surmonter les difficultés. - -### Conclusion Finale - -En conclusion, notre histoire sur les tigres nous enseigne que la curiosité et le courage sont des qualités admirables, mais qu'elles doivent être accompagnées de respect et de coopération. Les jeunes lecteurs sont encouragés à explorer le monde qui les entoure, tout en se souvenant de l'importance de l'amitié et du travail d'équipe. Que cette histoire inspire les enfants à être courageux comme Tigrou, tout en étant de bons amis et partenaires dans leurs propres aventures. - -Ainsi se termine notre "Histoire courte sur les tigres pour enfants", une aventure pleine de découvertes et de sagesse, qui restera dans le cœur de nos jeunes lecteurs. - -CONCLUSION ----------- - -Conclusion.txt - -Dans cette histoire captivante sur les tigres, nous avons suivi les aventures palpitantes de Tigrou, un jeune tigre curieux et courageux. À travers ses péripéties, Tigrou a découvert l'importance de l'amitié et de la coopération. Avec l'aide de ses amis de la jungle, il a surmonté divers défis, démontrant que le travail d'équipe et la persévérance sont essentiels pour résoudre les problèmes. - -Les thèmes principaux abordés incluent la beauté et la majesté des tigres, l'importance de protéger leur habitat naturel, et les valeurs de l'entraide et de la solidarité. Ces éléments ont permis aux jeunes lecteurs de s'immerger dans un monde où l'aventure et l'apprentissage vont de pair. - -En conclusion, cette histoire encourage les enfants à valoriser l'amitié et à être courageux face aux obstacles. Elle souligne également l'importance de respecter et de protéger les animaux et leur environnement. Pour prolonger cette expérience, il est recommandé aux jeunes lecteurs de s'informer davantage sur les tigres et les efforts de conservation qui les entourent. - -Ainsi, cette histoire laisse une empreinte durable, incitant les enfants à rêver, à explorer et à agir pour un monde meilleur. diff --git a/static/49_bedtime_story_french.txt b/static/49_bedtime_story_french.txt deleted file mode 100644 index 9ffeb4ea..00000000 --- a/static/49_bedtime_story_french.txt +++ /dev/null @@ -1,147 +0,0 @@ -Creating a Short Bedtime Story in French for Children -===================================================== - -Titel: Eine kurze Gutenachtgeschichte auf Französisch für Kinder erstellen - -Einführung: - -Willkommen zu unserem Leitfaden "Eine kurze Gutenachtgeschichte auf Französisch für Kinder erstellen". Dieser Leitfaden richtet sich an alle, die Freude daran haben, Geschichten zu erzählen und die Magie der französischen Sprache in die Welt der Kinderliteratur einbringen möchten. Egal, ob Sie Eltern, Lehrer oder einfach nur Geschichtenerzähler sind, dieser Leitfaden wird Ihnen helfen, eine bezaubernde und kindgerechte Geschichte zu kreieren. - -Der Zweck dieses Dokuments ist es, Ihnen die Werkzeuge und Techniken an die Hand zu geben, um eine fesselnde und lehrreiche Gutenachtgeschichte auf Französisch zu schreiben. Wir werden uns mit den Grundlagen der Kinderliteratur befassen, die Besonderheiten der französischen Sprache erkunden und Ihnen zeigen, wie Sie Ihre Erzähltechniken verfeinern können, um die Fantasie junger Leser zu beflügeln. - -In diesem Leitfaden finden Sie: -- Eine Einführung in die Welt der Kinderliteratur und ihre Bedeutung -- Tipps zur Auswahl von Themen und Charakteren, die Kinder ansprechen -- Grundlegende Techniken des Geschichtenerzählens, die speziell auf die französische Sprache zugeschnitten sind -- Praktische Beispiele und Übungen, um Ihre eigene Geschichte zu entwickeln - -Unser Ziel ist es, Ihnen nicht nur die Grundlagen zu vermitteln, sondern auch Ihre Kreativität zu fördern und Ihnen das Vertrauen zu geben, Ihre eigene einzigartige Geschichte zu schreiben. Lassen Sie uns gemeinsam die Freude am Geschichtenerzählen entdecken und die Herzen der kleinen Zuhörer mit einer wunderbaren französischen Gutenachtgeschichte erobern. - -Introduction ------------- - -# Introduction - -Willkommen zu unserem Leitfaden "Eine kurze Gutenachtgeschichte auf Französisch für Kinder erstellen". In dieser Einführung werden wir die wesentlichen Aspekte beleuchten, die beim Schreiben einer fesselnden und kindgerechten Geschichte berücksichtigt werden sollten. Unser Ziel ist es, Ihnen die Werkzeuge und das Wissen an die Hand zu geben, um eine Geschichte zu verfassen, die sowohl unterhaltsam als auch lehrreich ist. - -## Zweck der Geschichte - -Der Hauptzweck einer Gutenachtgeschichte ist es, Kindern eine beruhigende und angenehme Erfahrung vor dem Schlafengehen zu bieten. Eine gut geschriebene Geschichte kann nicht nur die Fantasie anregen, sondern auch eine wichtige Rolle bei der Entwicklung der Sprachfähigkeiten und des Verständnisses für soziale Interaktionen spielen. Unsere Geschichten sollen Kinder dazu ermutigen, die Welt um sie herum zu erkunden und gleichzeitig wichtige Werte wie Freundschaft und Abenteuerlust zu vermitteln. - -## Zielaltersgruppe - -Diese Anleitung richtet sich an Autoren, die Geschichten für Kinder im Alter von 4 bis 8 Jahren schreiben möchten. In diesem Alter sind Kinder besonders empfänglich für Geschichten, die ihre Neugier wecken und ihre Vorstellungskraft anregen. Es ist wichtig, dass die Sprache einfach und klar ist, während die Handlung spannend genug bleibt, um das Interesse der jungen Zuhörer zu halten. - -## Themen: Freundschaft und Abenteuer - -### Freundschaft - -Freundschaft ist ein zentrales Thema, das in vielen Kinderbüchern behandelt wird. Es ist wichtig, Kindern zu zeigen, wie bedeutungsvoll und bereichernd Freundschaften sein können. In Ihrer Geschichte könnten Sie Charaktere einführen, die lernen, zusammenzuarbeiten, sich gegenseitig zu unterstützen und Konflikte zu lösen. Diese Elemente helfen Kindern, soziale Fähigkeiten zu entwickeln und die Bedeutung von Empathie und Zusammenarbeit zu verstehen. - -### Abenteuer - -Abenteuer sind ein weiteres beliebtes Thema, das Kinder begeistert. Eine Abenteuergeschichte kann Kinder dazu inspirieren, mutig und neugierig zu sein. Sie könnten Ihre Charaktere auf eine Reise schicken, bei der sie neue Orte entdecken und Herausforderungen meistern. Solche Geschichten fördern die Kreativität und ermutigen Kinder, offen für neue Erfahrungen zu sein. - -In den folgenden Abschnitten dieses Leitfadens werden wir detaillierter auf die Struktur und die Elemente einer erfolgreichen Gutenachtgeschichte eingehen. Wir hoffen, dass Sie mit diesem Wissen ausgestattet sind, um eine bezaubernde Geschichte zu kreieren, die Kinder immer wieder hören möchten. - -Story Outline -------------- - -Title: Story Outline - -In diesem Abschnitt des Leitfadens "Creating a Short Bedtime Story in French for Children" werden wir die wesentlichen Elemente einer fesselnden Gutenachtgeschichte für Kinder skizzieren. Eine gut strukturierte Geschichte enthält lebendige Charaktere, eine einladende Umgebung und eine spannende Handlung. Lassen Sie uns in die Details eintauchen. - -**Character Descriptions** - -1. **Léa, das neugierige Kaninchen**: Léa ist ein kleines, weißes Kaninchen mit großen, funkelnden Augen und einem unstillbaren Drang, die Welt um sich herum zu erkunden. Sie ist mutig, freundlich und hat eine Vorliebe für Abenteuer. Léa liebt es, neue Freunde zu finden und anderen zu helfen. - -2. **Gaston, der weise alte Frosch**: Gaston ist ein älterer Frosch mit einer tiefen, beruhigenden Stimme und einem unerschöpflichen Vorrat an Geschichten und Weisheiten. Er lebt am Teichrand und ist bekannt für seine klugen Ratschläge. Gaston ist Léas Mentor und hilft ihr, die Geheimnisse des Waldes zu verstehen. - -3. **Chloé, der freche Spatz**: Chloé ist ein kleiner, lebhafter Spatz mit einem frechen Lächeln und einer Vorliebe für Streiche. Sie ist schnell und wendig, immer bereit, Léa auf ihren Abenteuern zu begleiten. Chloé bringt oft eine humorvolle Note in die Geschichte ein. - -**Setting Details** - -Die Geschichte spielt in einem malerischen Wald, der voller Leben und Geheimnisse steckt. Der Wald ist ein Ort der Wunder, mit hohen Bäumen, die im Wind rauschen, und einem klaren, glitzernden Teich, der von bunten Blumen umgeben ist. Die Luft ist erfüllt vom Gesang der Vögel und dem sanften Plätschern des Wassers. Dieser magische Ort bietet den perfekten Hintergrund für Léas Abenteuer und die Begegnungen mit ihren Freunden. - -**Plot Development** - -Die Handlung beginnt an einem sonnigen Morgen, als Léa beschließt, den verborgenen Pfad im Wald zu erkunden, von dem sie gehört hat, dass er zu einem geheimnisvollen Ort führt. Auf ihrem Weg trifft sie Gaston, der ihr von einem alten Geheimnis erzählt, das im Herzen des Waldes verborgen liegt. Neugierig und aufgeregt macht sich Léa auf den Weg, begleitet von Chloé, die für Unterhaltung sorgt. - -Während ihrer Reise begegnen sie verschiedenen Herausforderungen, wie einem plötzlichen Regenschauer und einem Labyrinth aus dichten Büschen. Mit Gastons klugen Ratschlägen und Chloés fröhlichem Gezwitscher überwinden sie jedes Hindernis. Schließlich erreichen sie den geheimnisvollen Ort, der sich als ein wunderschöner, versteckter Garten entpuppt, der von magischen Kreaturen bewohnt wird. - -Die Geschichte endet mit Léa, die eine wichtige Lektion über Freundschaft und Mut gelernt hat, und mit dem Versprechen, dass noch viele weitere Abenteuer auf sie warten. Diese Geschichte soll Kinder dazu inspirieren, neugierig zu bleiben und die Welt um sie herum mit offenen Augen und Herzen zu erkunden. - -Writing the Story ------------------ - -Title: Writing the Story - -In diesem Abschnitt werden wir uns darauf konzentrieren, wie man eine kurze Gutenachtgeschichte auf Französisch für Kinder schreibt. Wir werden die Bedeutung der Sprachvereinfachung, das Erzählen einer fesselnden Geschichte und die Einbindung von Themen untersuchen. Diese Elemente sind entscheidend, um eine Geschichte zu schaffen, die nicht nur unterhaltsam, sondern auch lehrreich und leicht verständlich für junge Leser ist. - -### Language Considerations - -Beim Schreiben einer Gutenachtgeschichte für Kinder ist die Sprachvereinfachung von größter Bedeutung. Kinder im Vorschulalter oder in den frühen Schuljahren haben ein begrenztes Vokabular, daher sollten wir einfache und klare Wörter verwenden. Vermeiden Sie komplexe Satzstrukturen und Fachjargon, um sicherzustellen, dass die Geschichte leicht verständlich ist. - -**Beispiel:** Anstatt zu schreiben "Le chat s'est aventuré dans le jardin luxuriant et a exploré les environs avec curiosité", könnte man sagen "Le chat est allé dans le jardin pour jouer." - -Ein weiterer wichtiger Aspekt ist die Verwendung von Wiederholungen. Kinder lernen durch Wiederholung, und es hilft ihnen, die Geschichte besser zu verstehen und sich daran zu erinnern. Verwenden Sie einfache Reime oder wiederkehrende Phrasen, um das Interesse der Kinder zu wecken. - -### Narrative Techniques - -Eine fesselnde Erzählung ist das Herzstück jeder guten Geschichte. Beginnen Sie mit einer interessanten Einleitung, die die Neugier der Kinder weckt. Stellen Sie die Hauptfiguren vor und beschreiben Sie die Umgebung auf eine Weise, die die Fantasie anregt. - -**Beispiel:** "Il était une fois, dans un petit village entouré de forêts magiques, un lapin nommé Pierre qui rêvait von Abenteuern." - -Nutzen Sie Dialoge, um die Charaktere lebendig zu machen und die Handlung voranzutreiben. Dialoge helfen, die Persönlichkeit der Charaktere zu zeigen und die Geschichte dynamischer zu gestalten. - -**Beispiel:** "‘Viens avec moi, Pierre,’ dit la souris. ‘Je connais un endroit secret!’" - -Achten Sie darauf, dass die Geschichte einen klaren Anfang, eine Mitte und ein Ende hat. Eine gut strukturierte Handlung hilft den Kindern, der Geschichte zu folgen und die Botschaft zu verstehen. - -### Theme Integration - -Themen sind ein wesentlicher Bestandteil jeder Geschichte, da sie den Kindern wichtige Lektionen vermitteln können. Wählen Sie Themen, die für Kinder relevant und lehrreich sind, wie Freundschaft, Mut, Ehrlichkeit oder das Überwinden von Ängsten. - -**Beispiel:** Eine Geschichte über einen kleinen Vogel, der lernt, seine Angst vor dem Fliegen zu überwinden, kann das Thema Mut und Selbstvertrauen behandeln. - -Integrieren Sie das Thema subtil in die Handlung, ohne es zu offensichtlich zu machen. Die Botschaft sollte natürlich aus der Geschichte hervorgehen, anstatt den Kindern direkt gesagt zu werden. - -**Beispiel:** Durch die Abenteuer von Pierre und seinen Freunden können Kinder lernen, wie wichtig es ist, zusammenzuarbeiten und einander zu helfen. - -Zusammenfassend lässt sich sagen, dass das Schreiben einer kurzen Gutenachtgeschichte auf Französisch für Kinder eine sorgfältige Balance zwischen einfacher Sprache, fesselnder Erzählung und thematischer Tiefe erfordert. Mit diesen Techniken können Sie Geschichten schaffen, die nicht nur unterhalten, sondern auch inspirieren und lehren. - -Review and Feedback -------------------- - -Title: Review and Feedback - -In diesem Abschnitt werden wir den wichtigen Prozess der Überprüfung und des Feedbacks für Ihre kurze französische Gutenachtgeschichte für Kinder behandeln. Eine sorgfältige Bearbeitung und das Einholen von Rückmeldungen sind entscheidend, um sicherzustellen, dass Ihre Geschichte klar, ansprechend und für junge Leser geeignet ist. Lassen Sie uns die einzelnen Schritte genauer betrachten. - -**Editing Process** - -Der erste Schritt im Überprüfungsprozess ist das sorgfältige Bearbeiten Ihrer Geschichte. Ziel ist es, die Klarheit und Verständlichkeit zu verbessern. Achten Sie darauf, dass die Sprache einfach und altersgerecht ist. Überprüfen Sie die Struktur der Sätze und stellen Sie sicher, dass die Geschichte einen logischen und flüssigen Verlauf hat. Ein hilfreicher Tipp ist, die Geschichte laut vorzulesen. So können Sie besser erkennen, ob der Text natürlich klingt und ob es Stellen gibt, die überarbeitet werden müssen. Denken Sie daran, dass Kinder leicht abgelenkt werden können, daher sollte die Geschichte kurz und prägnant sein. - -**Gathering Feedback** - -Nachdem Sie die erste Bearbeitung abgeschlossen haben, ist es an der Zeit, Feedback von Ihrer Zielgruppe einzuholen. Dies könnte bedeuten, die Geschichte Kindern vorzulesen oder Eltern um ihre Meinung zu bitten. Achten Sie darauf, wie die Kinder reagieren: Sind sie interessiert und aufmerksam? Gibt es Stellen, an denen sie Fragen stellen oder das Interesse verlieren? Eltern können Ihnen wertvolle Einblicke geben, ob die Geschichte altersgerecht und verständlich ist. Notieren Sie sich alle Rückmeldungen, sowohl positive als auch negative, da sie Ihnen helfen werden, die Geschichte weiter zu verbessern. - -**Implementing Changes** - -Nachdem Sie Feedback gesammelt haben, ist es wichtig, die notwendigen Anpassungen vorzunehmen. Überlegen Sie, welche Änderungen die Geschichte klarer und ansprechender machen. Vielleicht müssen Sie bestimmte Absätze umformulieren, um sie verständlicher zu machen, oder zusätzliche Erklärungen einfügen, um Unklarheiten zu beseitigen. Es kann auch hilfreich sein, die Geschichte erneut vorzulesen, um sicherzustellen, dass die Änderungen den gewünschten Effekt haben. Denken Sie daran, dass das Ziel darin besteht, eine Geschichte zu schaffen, die Kinder begeistert und ihnen Freude bereitet. - -Durch diesen strukturierten Ansatz im Überprüfungs- und Feedbackprozess stellen Sie sicher, dass Ihre französische Gutenachtgeschichte für Kinder nicht nur sprachlich korrekt, sondern auch fesselnd und lehrreich ist. Viel Erfolg beim Schreiben und Überarbeiten! - -CONCLUSION ----------- - -Abschluss: Erstellen einer kurzen Gutenachtgeschichte auf Französisch für Kinder - -In diesem Leitfaden haben wir die wesentlichen Schritte und Techniken zur Erstellung einer ansprechenden und kindgerechten Gutenachtgeschichte auf Französisch behandelt. Zunächst haben wir die Bedeutung der Kinderliteratur und die spezifischen Merkmale, die eine Geschichte für junge Leser fesselnd machen, hervorgehoben. Dazu gehören einfache Sprache, lebendige Charaktere und eine klare, leicht nachvollziehbare Handlung. - -Wir haben auch die Besonderheiten der französischen Sprache berücksichtigt, die es ermöglichen, Geschichten mit einem besonderen kulturellen Flair zu bereichern. Die Verwendung von Reimen, Wiederholungen und melodischen Sätzen kann dazu beitragen, die Aufmerksamkeit der Kinder zu fesseln und das Sprachverständnis zu fördern. - -Ein weiterer wichtiger Punkt war die Anwendung von Erzähltechniken, die die Fantasie der Kinder anregen und ihnen gleichzeitig eine beruhigende und entspannende Erfahrung bieten. Dazu gehört das Einbeziehen von moralischen Lektionen oder positiven Botschaften, die den Kindern helfen, Werte und soziale Fähigkeiten zu entwickeln. - -Abschließend empfehlen wir, regelmäßig neue Geschichten zu erstellen und dabei die Interessen und Vorlieben der Kinder zu berücksichtigen. Dies fördert nicht nur die Sprachentwicklung, sondern stärkt auch die Bindung zwischen Vorleser und Zuhörer. Wir ermutigen Sie, kreativ zu sein und die Vielfalt der französischen Sprache zu nutzen, um unvergessliche Geschichten zu schaffen, die die Fantasie der Kinder beflügeln. - -Dieser Leitfaden soll Ihnen die Werkzeuge und das Vertrauen geben, um selbstbewusst in die Welt des Geschichtenerzählens einzutauchen und die Freude am Lesen und Hören von Geschichten zu fördern. Viel Erfolg beim Schreiben Ihrer nächsten französischen Gutenachtgeschichte! diff --git a/static/4_q1_sales_data.md b/static/4_q1_sales_data.md new file mode 100644 index 00000000..2ee3980f --- /dev/null +++ b/static/4_q1_sales_data.md @@ -0,0 +1,19 @@ + +# Sales Data - Q1 2023 + +Month,Revenue,Growth,Units Sold +January,150000,5.2%,1250 +February,165000,10.0%,1380 +March,180000,9.1%,1490 + +## Regional Breakdown +- North: 35% of total sales +- South: 25% of total sales +- East: 20% of total sales +- West: 20% of total sales + +## Top Products +1. Product A: 40% of revenue +2. Product B: 30% of revenue +3. Product C: 20% of revenue +4. Others: 10% of revenue diff --git a/static/50_bedtime_story_french.txt b/static/50_bedtime_story_french.txt deleted file mode 100644 index 6502c2ee..00000000 --- a/static/50_bedtime_story_french.txt +++ /dev/null @@ -1,101 +0,0 @@ -Short Bedtime Story in French -============================= - -Einführung in "Kurze Gutenachtgeschichte auf Französisch" - -Zweck und Umfang: -Diese kreative Schrift ist eine kurze Gutenachtgeschichte für Kinder, die in französischer Sprache verfasst ist. Sie zielt darauf ab, junge Leser in eine Welt voller Freundschaft, Freundlichkeit und Abenteuer zu entführen. Die Geschichte ist so gestaltet, dass sie einfach zu verstehen ist und eine positive Botschaft vermittelt, die Kinder mit einem Lächeln einschlafen lässt. - -Kontext und Hintergrund: -Gutenachtgeschichten sind ein wesentlicher Bestandteil der Kindheit, die nicht nur das Einschlafen erleichtern, sondern auch die Fantasie anregen und wichtige Werte vermitteln. Diese Geschichte nutzt die Schönheit der französischen Sprache, um eine warme und einladende Atmosphäre zu schaffen, die sowohl lehrreich als auch unterhaltsam ist. - -Inhalt des Dokuments: -In diesem Dokument finden die Leser eine liebevoll gestaltete Geschichte, die sich um die Themen Freundschaft und Freundlichkeit dreht. Die Handlung ist einfach und dennoch fesselnd, perfekt für die abendliche Vorlesezeit. Die Charaktere begeben sich auf ein kleines Abenteuer, das den jungen Zuhörern zeigt, wie wichtig es ist, freundlich zu sein und Freunde zu haben. - -Ton und Stil: -Der Ton der Geschichte ist gesprächig und zugänglich, ideal für ein allgemeines Publikum. Die Sprache ist kindgerecht und lädt dazu ein, die Geschichte gemeinsam zu entdecken und zu genießen. Diese Einführung soll die Neugier wecken und die Leser auf eine herzerwärmende Reise vorbereiten. - -Wir hoffen, dass diese Geschichte ein fester Bestandteil der abendlichen Rituale wird und sowohl Kindern als auch Erwachsenen Freude bereitet. Viel Spaß beim Lesen und Träumen! - -Introduction ------------- - -``` -Introduction - -Willkommen zu unserer bezaubernden Gutenachtgeschichte auf Französisch, die speziell für junge Zuhörer geschrieben wurde. Diese Geschichte entführt die Kinder in eine Welt voller Magie und Abenteuer, während sie sich auf eine Reise mit einem liebenswerten Charakter begeben. Lassen Sie uns die Hauptfigur kennenlernen und die zauberhafte Umgebung entdecken, in der die Geschichte spielt. - -Charaktereinführung - -Unser Hauptcharakter ist ein kleiner, neugieriger Frosch namens Léon. Léon ist nicht wie andere Frösche; er hat eine leuchtend grüne Haut, die im Mondlicht schimmert, und große, freundliche Augen, die voller Abenteuerlust funkeln. Léon ist bekannt für seinen unerschütterlichen Mut und seine unstillbare Neugier. Er liebt es, neue Orte zu erkunden und neue Freunde zu finden. Léon ist immer bereit, anderen zu helfen, und sein Herz ist so groß wie sein Lächeln. Diese Eigenschaften machen ihn zu einem perfekten Begleiter für die kleinen Zuhörer, die sich auf ein Abenteuer voller Wunder und Freundschaft freuen. - -Beschreibung des Schauplatzes - -Die Geschichte spielt in einem malerischen kleinen Dorf in der französischen Provence, umgeben von duftenden Lavendelfeldern und sanften Hügeln. Die Luft ist erfüllt vom Summen der Bienen und dem Zwitschern der Vögel, während die Sonne sanft über den Horizont sinkt und den Himmel in ein warmes, goldenes Licht taucht. In der Mitte des Dorfes befindet sich ein kleiner, funkelnder Teich, der von hohen, schlanken Weiden umgeben ist. Hier lebt Léon, und hier beginnt unser Abenteuer. Die friedliche und idyllische Umgebung bietet den perfekten Hintergrund für Léons aufregende Erlebnisse und lädt die kleinen Zuhörer ein, sich in eine Welt voller Fantasie und Träume zu verlieren. - -In dieser Geschichte werden die Kinder Léon auf seiner Reise begleiten, während er neue Freunde trifft und wichtige Lektionen über Mut, Freundschaft und das Überwinden von Hindernissen lernt. Machen Sie es sich gemütlich, und lassen Sie sich von Léons Abenteuern verzaubern. -``` - -Plot Development ----------------- - -Title: Plot Development - ---- - -**Conflict Introduction** - -In der Geschichte "Short Bedtime Story in French" beginnt alles in einem kleinen, malerischen Dorf in der französischen Provinz. Hier lebt ein kleiner Junge namens Louis, der eine lebhafte Fantasie hat. Louis liebt es, abends vor dem Schlafengehen Geschichten zu hören, doch eines Nachts stellt er fest, dass seine Lieblingsgeschichte verschwunden ist. Diese Geschichte war besonders wichtig für ihn, da sie ihm half, friedlich einzuschlafen. Der Konflikt entsteht, als Louis beschließt, die Geschichte selbst zu finden, da er ohne sie nicht einschlafen kann. Dies stellt eine einfache, aber nachvollziehbare Herausforderung dar, die junge Leser sofort in den Bann zieht. - -**Story Development** - -Louis beginnt seine Suche nach der verlorenen Geschichte mit der Unterstützung seines treuen Kuscheltiers, einem Plüschhasen namens Lapinou. Gemeinsam durchstreifen sie das Haus, von der gemütlichen Küche bis zum geheimnisvollen Dachboden. Auf ihrer Reise begegnen sie verschiedenen Charakteren, die Louis helfen wollen. Da ist Madame Chouette, die weise Eule, die ihm rät, in seinem Herzen nach der Geschichte zu suchen, und Monsieur Renard, der schlaue Fuchs, der ihm zeigt, wie man Hinweise liest. - -Während Louis und Lapinou weiter suchen, lernen sie, dass die Geschichte nicht wirklich verloren ist, sondern in Louis' Erinnerung und Fantasie lebt. Durch die Begegnungen mit den Tieren und die Abenteuer, die sie erleben, erkennt Louis, dass er die Geschichte selbst neu erfinden kann. Diese Erkenntnis gibt ihm das Selbstvertrauen, seine eigene Version der Geschichte zu erzählen, die noch schöner und spannender ist als die ursprüngliche. - -Am Ende der Geschichte kehrt Louis glücklich in sein Bett zurück, mit Lapinou an seiner Seite. Er erzählt die neue Geschichte, die er erfunden hat, und schläft mit einem Lächeln ein. Die positive Botschaft der Geschichte ist, dass Kreativität und Vorstellungskraft mächtige Werkzeuge sind, die uns helfen können, Herausforderungen zu überwinden und neue Wege zu finden, um unsere Ziele zu erreichen. - ---- - -Diese detaillierte Entwicklung des Plots sorgt dafür, dass die Geschichte sowohl spannend als auch lehrreich ist, und vermittelt den jungen Lesern eine wertvolle Lektion über die Kraft der Fantasie. - -Resolution ----------- - -Title: Resolution - ---- - -**Conflict Resolution** - -In der Geschichte "Short Bedtime Story in French" erleben wir, wie der kleine Hase, Léon, sich in einem dichten, dunklen Wald verirrt. Die Spannung steigt, als Léon versucht, den Weg nach Hause zu finden, während die Nacht hereinbricht und die Geräusche des Waldes immer lauter werden. Die Konfliktlösung beginnt, als Léon auf eine weise alte Eule trifft, die ihm mit ihrer Erfahrung und ihrem Wissen zur Seite steht. Die Eule erklärt Léon, dass er sich auf seine Sinne und sein Herz verlassen soll, um den Weg zu finden. Mit neuer Zuversicht und den Ratschlägen der Eule gelingt es Léon, seine Angst zu überwinden und den richtigen Pfad zu erkennen, der ihn sicher nach Hause führt. Diese Begegnung zeigt, wie wichtig es ist, in schwierigen Zeiten Hilfe anzunehmen und auf die innere Stimme zu hören. - -**Positive Message** - -Die Geschichte vermittelt eine kraftvolle positive Botschaft: Mit Mut, Vertrauen und der Bereitschaft, Hilfe anzunehmen, können selbst die größten Herausforderungen gemeistert werden. Léons Abenteuer lehrt junge Leser, dass es in Ordnung ist, sich manchmal verloren zu fühlen, und dass es immer einen Weg gibt, zurückzufinden, wenn man offen für Unterstützung ist. Die Geschichte ermutigt Kinder, an sich selbst zu glauben und die Weisheit anderer zu schätzen. Am Ende der Geschichte kehrt Léon nicht nur sicher nach Hause zurück, sondern hat auch eine wertvolle Lektion über Freundschaft und Vertrauen gelernt. Diese positive Botschaft bleibt den jungen Zuhörern im Gedächtnis und begleitet sie in ihren eigenen kleinen Abenteuern des Lebens. - -Conclusion ----------- - -``` -Conclusion - -Story Wrap-up -Am Ende unserer kurzen Gutenachtgeschichte in Französisch haben wir die Abenteuer von kleinen Helden erlebt, die uns mit ihrer Neugier und ihrem Mut verzaubert haben. Die Geschichte führte uns durch eine Welt voller Magie und Freundschaft, in der die Hauptfiguren gemeinsam Herausforderungen meisterten und dabei wichtige Lektionen über Zusammenhalt und Vertrauen lernten. Die Reise endete mit einem Gefühl der Zufriedenheit, als die Charaktere sicher und glücklich in ihre Betten zurückkehrten, bereit für neue Träume und Abenteuer. - -Final Thoughts -Diese Geschichte hinterlässt bei uns eine warme Erinnerung an die Kraft der Fantasie und die Bedeutung von Freundschaft. Sie erinnert uns daran, dass selbst die kleinsten Gesten der Freundlichkeit und der Zusammenarbeit große Veränderungen bewirken können. Während wir die Augen schließen und uns auf den Schlaf vorbereiten, nehmen wir die Botschaft mit, dass wir mit einem offenen Herzen und einem mutigen Geist alles erreichen können. Möge diese Geschichte den jungen Zuhörern süße Träume bescheren und sie dazu inspirieren, ihre eigenen Geschichten zu träumen und zu leben. -``` - -CONCLUSION ----------- - -CONCLUSION - -Die Kurzgeschichte "Short Bedtime Story in French" bietet jungen Lesern eine bezaubernde Reise in die Welt der Freundschaft, Freundlichkeit und Abenteuer. Durch eine einfache, aber fesselnde Handlung werden die Kinder eingeladen, die Bedeutung von Zusammenhalt und Mitgefühl zu entdecken. Die Geschichte entfaltet sich in einer fantasievollen Umgebung, die die Vorstellungskraft anregt und gleichzeitig wichtige Werte vermittelt. - -Zusammenfassend hebt die Geschichte hervor, wie Freundschaft und Freundlichkeit Hindernisse überwinden und zu unvergesslichen Abenteuern führen können. Die Charaktere zeigen, dass durch Zusammenarbeit und gegenseitige Unterstützung selbst die größten Herausforderungen gemeistert werden können. Diese positive Botschaft ist besonders wertvoll für junge Leser, da sie ermutigt, empathisch und hilfsbereit zu sein. - -Als nächster Schritt könnte die Geschichte als Ausgangspunkt für Gespräche über Freundschaft und soziale Fähigkeiten genutzt werden. Eltern und Erzieher könnten die Themen vertiefen, indem sie Kinder dazu anregen, ihre eigenen Geschichten zu erfinden oder Rollenspiele zu den behandelten Themen zu gestalten. - -Insgesamt bietet die "Short Bedtime Story in French" nicht nur eine unterhaltsame Lektüre vor dem Schlafengehen, sondern auch eine wertvolle Lektion über die Kraft der Freundschaft und die Bedeutung von Freundlichkeit. Sie hinterlässt bei den jungen Lesern ein Gefühl der Zufriedenheit und inspiriert sie, diese Werte in ihrem eigenen Leben zu praktizieren. diff --git a/static/51_short_story_french.txt b/static/51_short_story_french.txt deleted file mode 100644 index 6b8aae45..00000000 --- a/static/51_short_story_french.txt +++ /dev/null @@ -1,177 +0,0 @@ -Creating a Children's Story in French -===================================== - -Einführung in den Leitfaden "Eine Kindergeschichte auf Französisch erstellen" - -Willkommen zu unserem Leitfaden "Eine Kindergeschichte auf Französisch erstellen". Dieser Leitfaden richtet sich an alle, die in die wunderbare Welt des Geschichtenerzählens für Kinder eintauchen möchten. Unser Ziel ist es, Ihnen die Werkzeuge und das Wissen an die Hand zu geben, um eine fesselnde und lehrreiche Geschichte zu schreiben, die die Themen Freundschaft und Abenteuer aufgreift. - -In diesem Leitfaden erfahren Sie, wie Sie mit einfachen Worten und lebendigen Charakteren eine Geschichte gestalten können, die junge Leser begeistert und inspiriert. Wir werden uns auf die Entwicklung von Charakteren konzentrieren, die nicht nur spannend, sondern auch nachvollziehbar sind. Zudem werden wir Ihnen zeigen, wie Sie eine abenteuerliche Handlung entwickeln, die die Fantasie der Kinder anregt und gleichzeitig wichtige Werte wie Freundschaft und Zusammenarbeit vermittelt. - -Der Leitfaden ist in einem leicht verständlichen, gesprächigen Ton gehalten, um Ihnen das Schreiben so angenehm wie möglich zu gestalten. Sie werden praktische Tipps und Beispiele finden, die Ihnen helfen, Ihre eigene Geschichte zu kreieren. Egal, ob Sie ein erfahrener Schriftsteller oder ein Anfänger sind, dieser Leitfaden bietet Ihnen wertvolle Einblicke und Inspiration. - -Wir laden Sie ein, Ihrer Kreativität freien Lauf zu lassen und die Kunst des Geschichtenerzählens zu entdecken. Lassen Sie uns gemeinsam eine Welt erschaffen, in der Freundschaft und Abenteuer im Mittelpunkt stehen und die Herzen der Kinder berühren. - -Introduction ------------- - -# Introduction - -Willkommen zu unserem Leitfaden "Creating a Children's Story in French". In diesem Abschnitt werden wir die wesentlichen Aspekte beleuchten, die beim Schreiben einer Kindererzählung auf Französisch zu berücksichtigen sind. Unser Ziel ist es, Ihnen die Werkzeuge und das Wissen an die Hand zu geben, um eine fesselnde Geschichte zu schaffen, die junge Leser begeistert und inspiriert. - -## Zweck der Geschichte - -Der Hauptzweck einer Kindererzählung ist es, die Fantasie der Kinder zu beflügeln und ihnen gleichzeitig wichtige Werte zu vermitteln. In unserer Geschichte werden wir uns auf die Themen Freundschaft und Abenteuer konzentrieren. Diese Themen sind nicht nur universell ansprechend, sondern auch entscheidend für die Entwicklung sozialer Fähigkeiten und die Förderung von Neugier und Entdeckergeist bei Kindern. Eine gut erzählte Geschichte kann Kindern helfen, die Bedeutung von Zusammenarbeit, Vertrauen und Mut zu verstehen. - -## Zielgruppe - -Unsere Geschichte richtet sich an Kinder im Alter von 6 bis 10 Jahren. In diesem Alter beginnen Kinder, komplexere Geschichten zu verstehen und können sich mit den Charakteren identifizieren. Sie sind neugierig und bereit, neue Konzepte zu erforschen, was sie zu einer idealen Zielgruppe für Geschichten macht, die sowohl unterhaltsam als auch lehrreich sind. Es ist wichtig, eine Sprache zu verwenden, die einfach genug ist, um verstanden zu werden, aber auch reichhaltig genug, um die Vorstellungskraft anzuregen. - -## Themen von Freundschaft und Abenteuer - -### Freundschaft - -Freundschaft ist ein zentrales Thema, das in vielen Kindererzählungen vorkommt. In unserer Geschichte werden wir zeigen, wie Freundschaften entstehen und wachsen können. Durch die Interaktionen der Charaktere lernen Kinder, wie wichtig es ist, füreinander da zu sein, Konflikte zu lösen und die Unterschiede des anderen zu schätzen. Ein Beispiel könnte eine Szene sein, in der die Protagonisten ein Missverständnis überwinden und dadurch ihre Bindung stärken. - -### Abenteuer - -Abenteuer bietet eine hervorragende Möglichkeit, Spannung und Dynamik in eine Geschichte zu bringen. Es ermöglicht den Charakteren, Herausforderungen zu meistern und über sich hinauszuwachsen. In unserer Geschichte wird das Abenteuer die Kinder auf eine Reise mitnehmen, die sowohl aufregend als auch lehrreich ist. Ein Beispiel könnte eine Schatzsuche sein, bei der die Charaktere Hindernisse überwinden müssen, um ihr Ziel zu erreichen. - -Durch die Kombination dieser Themen schaffen wir eine Geschichte, die nicht nur unterhält, sondern auch lehrreiche Botschaften vermittelt. Wir hoffen, dass dieser Leitfaden Ihnen hilft, eine inspirierende und unvergessliche Geschichte zu schreiben, die bei jungen Lesern Anklang findet. - -Character Development ---------------------- - -Title: Charakterentwicklung - -Einführung: -In der Welt der Kinderliteratur sind es oft die Charaktere, die eine Geschichte lebendig und unvergesslich machen. In diesem Abschnitt werden wir uns darauf konzentrieren, wie man fesselnde Charaktere schafft, welche Charaktereigenschaften bei Kindern besonders gut ankommen und welche Rolle die Charaktere in der Geschichte spielen. Lassen Sie uns gemeinsam in die Kunst der Charakterentwicklung eintauchen, um eine bezaubernde Geschichte über Freundschaft und Abenteuer zu kreieren. - -Hauptcharaktere: -Die Hauptcharaktere sind das Herzstück Ihrer Geschichte. Sie sind diejenigen, mit denen die jungen Leser am meisten interagieren und sich identifizieren. Hier sind einige Tipps, um starke Hauptcharaktere zu entwickeln: - -1. **Einprägsame Eigenschaften**: Geben Sie Ihren Hauptcharakteren einzigartige Merkmale, die sie von anderen abheben. Dies könnten physische Merkmale, besondere Fähigkeiten oder unverwechselbare Persönlichkeitszüge sein. Zum Beispiel könnte Ihr Hauptcharakter ein mutiges kleines Mädchen sein, das immer einen roten Hut trägt und keine Angst vor Abenteuern hat. - -2. **Entwicklung und Wachstum**: Kinder lieben es, Charaktere zu sehen, die sich im Laufe der Geschichte weiterentwickeln. Zeigen Sie, wie Ihr Hauptcharakter durch die Herausforderungen, denen er begegnet, wächst und lernt. Vielleicht lernt unser mutiges Mädchen, dass wahre Freundschaft bedeutet, auch in schwierigen Zeiten füreinander da zu sein. - -3. **Identifikationspotenzial**: Schaffen Sie Charaktere, mit denen sich Kinder identifizieren können. Dies kann durch alltägliche Probleme oder Emotionen geschehen, die die Kinder selbst erleben. Ein Beispiel wäre, dass unser Hauptcharakter sich manchmal einsam fühlt und nach einem wahren Freund sucht. - -Nebencharaktere: -Nebencharaktere spielen eine wichtige Rolle, um die Geschichte zu bereichern und die Hauptcharaktere zu unterstützen. Hier sind einige Überlegungen zur Entwicklung von Nebencharakteren: - -1. **Vielfalt und Tiefe**: Auch wenn Nebencharaktere nicht im Mittelpunkt stehen, sollten sie dennoch gut ausgearbeitet sein. Sie können die Geschichte durch ihre unterschiedlichen Perspektiven und Erfahrungen bereichern. Vielleicht gibt es einen weisen alten Fuchs, der dem Mädchen Ratschläge gibt, oder einen lustigen Papagei, der für humorvolle Momente sorgt. - -2. **Unterstützende Rollen**: Nebencharaktere können die Handlung vorantreiben und den Hauptcharakteren helfen, ihre Ziele zu erreichen. Sie können auch als Katalysatoren für wichtige Wendepunkte in der Geschichte dienen. Der weise Fuchs könnte zum Beispiel einen entscheidenden Hinweis geben, der das Mädchen auf die richtige Spur bringt. - -3. **Beziehungen und Dynamik**: Zeigen Sie, wie die Nebencharaktere mit den Hauptcharakteren interagieren und welche Beziehungen sich entwickeln. Diese Dynamik kann die emotionale Tiefe der Geschichte verstärken. Vielleicht entwickelt sich zwischen dem Mädchen und dem Papagei eine unerwartete Freundschaft, die beiden hilft, ihre Ängste zu überwinden. - -Rolle der Charaktere in der Geschichte: -Charaktere sind nicht nur Akteure in Ihrer Geschichte, sondern auch Träger der Themen und Botschaften, die Sie vermitteln möchten. In einer Geschichte über Freundschaft und Abenteuer können die Charaktere den Wert von Teamarbeit, Vertrauen und Mut verkörpern. Durch ihre Handlungen und Entscheidungen können sie den jungen Lesern wichtige Lektionen auf eine unterhaltsame und zugängliche Weise vermitteln. - -Abschluss: -Die Entwicklung von Charakteren ist ein wesentlicher Bestandteil beim Schreiben einer fesselnden Kindergeschichte. Indem Sie einprägsame Haupt- und Nebencharaktere schaffen, die sowohl unterhalten als auch lehren, können Sie eine Geschichte gestalten, die Kinder begeistert und inspiriert. Lassen Sie Ihrer Kreativität freien Lauf und denken Sie daran, dass die besten Geschichten oft diejenigen sind, die durch ihre Charaktere zum Leben erweckt werden. - -Plot Structure --------------- - -# Plot Structure - -Beim Schreiben einer Kindergeschichte auf Französisch ist es wichtig, eine klare und einfache Plotstruktur zu verwenden. Diese Struktur hilft dabei, die Geschichte verständlich und spannend zu gestalten, insbesondere für junge Leser. In diesem Abschnitt werden wir die wesentlichen Elemente einer Plotstruktur besprechen, die sich auf die Themen Freundschaft und Abenteuer konzentrieren. Wir werden die Geschichte in drei Hauptteile unterteilen: Anfang, Mitte und Ende. - -## Setting the Scene - -Der Anfang einer Geschichte ist entscheidend, um die Leser in die Welt der Charaktere einzuführen. Verwenden Sie einfache Sprache, um die Umgebung und die Hauptfiguren zu beschreiben. Dies könnte ein magischer Wald, eine kleine Stadt oder sogar ein fantastisches Königreich sein. Der Schauplatz sollte die Grundlage für das bevorstehende Abenteuer legen. - -Beispiel: "In einem kleinen Dorf am Rande eines großen Waldes lebte ein mutiger kleiner Junge namens Pierre. Pierre liebte es, neue Freunde zu finden und Abenteuer zu erleben." - -## Building the Adventure - -Der Mittelteil der Geschichte sollte die Spannung aufbauen und die Leser in das Abenteuer der Charaktere hineinziehen. Hier ist es wichtig, die Themen Freundschaft und Abenteuer zu integrieren. Die Charaktere könnten auf eine Herausforderung stoßen, die sie nur gemeinsam bewältigen können, was ihre Freundschaft stärkt. - -Beispiel: "Eines Tages entdeckte Pierre eine geheimnisvolle Karte, die zu einem versteckten Schatz führte. Zusammen mit seiner besten Freundin Marie machte er sich auf den Weg, um das Geheimnis zu lüften. Auf ihrer Reise mussten sie Rätsel lösen und Hindernisse überwinden, die ihre Freundschaft auf die Probe stellten." - -## Resolution and Friendship - -Das Ende der Geschichte sollte alle offenen Fragen klären und eine zufriedenstellende Lösung bieten. Es ist der Moment, in dem die Charaktere ihre Ziele erreichen und die Bedeutung von Freundschaft und Zusammenarbeit erkennen. Eine positive und lehrreiche Botschaft ist besonders wichtig in Kindergeschichten. - -Beispiel: "Nach vielen Abenteuern fanden Pierre und Marie den Schatz. Doch das größte Geschenk war die Erkenntnis, dass ihre Freundschaft der wahre Schatz war. Gemeinsam kehrten sie nach Hause zurück, bereit für neue Abenteuer." - -Durch die Verwendung dieser klaren Plotstruktur können Sie eine fesselnde und lehrreiche Kindergeschichte auf Französisch erstellen, die die Themen Freundschaft und Abenteuer aufgreift. Denken Sie daran, einfache Sprache zu verwenden, um die Geschichte für junge Leser zugänglich zu machen. - -Language and Style ------------------- - -# Language and Style - -Creating a children's story in French involves a delicate balance of simplicity, engagement, and maintaining a tone that resonates with young readers. This section will guide you through the essential elements of language and style to craft a captivating story that is both educational and entertaining for children. - -## Use of Simple French Language - -When writing for children, simplicity is key. The language should be accessible to young readers, ensuring they can follow the story without difficulty. Here are some tips to achieve this: - -- **Basic Vocabulary**: Use common and straightforward words that are likely to be familiar to children. For example, instead of "extraordinaire," you might use "super" to describe something amazing. - -- **Short Sentences**: Keep sentences concise to maintain clarity. For instance, "Le chat court" (The cat runs) is easier for children to understand than a complex sentence with multiple clauses. - -- **Repetition**: Reinforce key vocabulary and concepts through repetition. This helps children remember new words and ideas. For example, if your story involves a magical forest, repeat the word "forêt" throughout the narrative. - -- **Simple Tenses**: Stick to present and simple past tenses. These are easier for children to grasp. For example, "Il était une fois" (Once upon a time) is a classic and simple way to start a story. - -## Engaging Storytelling Techniques - -To keep children engaged, your story should be dynamic and imaginative. Here are some techniques to consider: - -- **Vivid Imagery**: Use descriptive language to paint a picture in the reader's mind. For example, "Le soleil brillait comme un grand ballon jaune dans le ciel" (The sun shone like a big yellow balloon in the sky). - -- **Dialogue**: Incorporate dialogue to bring characters to life and make the story interactive. For instance, "Bonjour, petit lapin!" dit le renard. (Hello, little rabbit! said the fox.) - -- **Rhythm and Rhyme**: Consider using rhythmic language or rhymes to make the story more musical and memorable. This can be particularly effective in stories for younger children. - -- **Interactive Elements**: Encourage participation by asking questions or prompting actions. For example, "Peux-tu deviner ce qui se passe ensuite?" (Can you guess what happens next?) - -## Maintaining a Child-Friendly Tone - -The tone of your story should be warm, friendly, and appropriate for children. Here are some ways to achieve this: - -- **Positive Themes**: Focus on themes that promote kindness, friendship, and adventure. These are relatable and inspiring for children. - -- **Gentle Humor**: Use light-hearted humor to entertain without confusing or offending. For example, a clumsy character who always trips over their own feet can be a source of gentle laughter. - -- **Empathy and Emotion**: Help children connect with the characters by exploring emotions. For example, "Le petit ours était triste de perdre son ballon, mais il a trouvé un nouvel ami" (The little bear was sad to lose his balloon, but he found a new friend). - -- **Encouraging Messages**: End with a positive message or moral that children can learn from. For example, "L'amitié est la plus grande aventure de toutes" (Friendship is the greatest adventure of all). - -By focusing on these elements of language and style, you can create a French children's story that is not only easy to read but also engaging and meaningful. Remember, the goal is to spark imagination and foster a love for reading in young minds. - -Conclusion ----------- - -# Conclusion - -## Zusammenfassung der Schlüsselelemente - -Beim Erstellen einer Kindergeschichte auf Französisch haben wir uns auf einige wesentliche Elemente konzentriert, die den Erzählprozess sowohl spannend als auch lehrreich gestalten. Zunächst ist die Wahl eines einfachen und klaren Sprachstils entscheidend, um die jungen Leser zu fesseln und das Verständnis zu erleichtern. Die Themen Freundschaft und Abenteuer bieten eine hervorragende Grundlage, um die Fantasie der Kinder anzuregen und gleichzeitig wichtige Werte zu vermitteln. - -Charaktere spielen eine zentrale Rolle in jeder Geschichte. Sie sollten nicht nur fesselnd, sondern auch nachvollziehbar sein, damit die Kinder sich mit ihnen identifizieren können. Die Entwicklung der Charaktere durch ihre Abenteuer und die Beziehungen, die sie knüpfen, sind entscheidend, um die Geschichte lebendig und interessant zu gestalten. - -Ein gut strukturierter Handlungsverlauf, der Spannung und Überraschungselemente enthält, hält die jungen Leser bei der Stange. Es ist wichtig, dass die Geschichte einen klaren Anfang, eine spannende Mitte und ein zufriedenstellendes Ende hat, um das Interesse der Kinder zu bewahren. - -## Ermutigung, mehr Geschichten zu erstellen - -Jetzt, da Sie die Grundlagen des Geschichtenerzählens für Kinder auf Französisch kennen, laden wir Sie ein, Ihre Kreativität weiter zu entfalten. Jede Geschichte, die Sie schreiben, ist eine Gelegenheit, die Fantasie der Kinder zu beflügeln und ihnen neue Welten zu eröffnen. Lassen Sie sich von alltäglichen Erlebnissen, Träumen oder sogar von den Geschichten, die Sie als Kind geliebt haben, inspirieren. - -Denken Sie daran, dass jede neue Geschichte eine Chance ist, Ihre Fähigkeiten als Geschichtenerzähler zu verbessern und Ihre eigene Stimme zu finden. Haben Sie keine Angst, mit verschiedenen Themen und Stilen zu experimentieren. Die Welt der Kindergeschichten ist grenzenlos, und Ihre Beiträge können einen bleibenden Eindruck hinterlassen. - -Wir hoffen, dass dieser Leitfaden Ihnen geholfen hat, die Grundlagen des Geschichtenerzählens zu verstehen und Sie dazu inspiriert, Ihre eigenen Geschichten zu kreieren. Viel Spaß beim Schreiben und beim Entdecken der wunderbaren Welt der Kindergeschichten! - -CONCLUSION ----------- - -Abschluss der Anleitung: "Erstellen einer Kindergeschichte auf Französisch" - -In dieser Anleitung haben wir die wesentlichen Schritte zur Erstellung einer Kindergeschichte auf Französisch behandelt, die sich auf die Themen Freundschaft und Abenteuer konzentriert. Wir haben die Bedeutung der Charakterentwicklung hervorgehoben und gezeigt, wie man einfache Sprache verwendet, um junge Leser zu fesseln. - -Zusammenfassend lässt sich sagen, dass eine erfolgreiche Kindergeschichte durch lebendige und nachvollziehbare Charaktere geprägt ist, die sich im Laufe der Handlung weiterentwickeln. Abenteuerliche Elemente und die Betonung von Freundschaft helfen, das Interesse der Kinder zu wecken und wichtige soziale Werte zu vermitteln. - -Wir empfehlen, beim Schreiben stets die Perspektive der Kinder im Auge zu behalten und die Sprache so zu wählen, dass sie leicht verständlich und ansprechend ist. Es ist auch hilfreich, Feedback von Kindern einzuholen, um sicherzustellen, dass die Geschichte ihre Zielgruppe erreicht. - -Abschließend hoffen wir, dass diese Anleitung Ihnen die notwendigen Werkzeuge und Inspirationen gegeben hat, um eine fesselnde und lehrreiche Kindergeschichte auf Französisch zu erstellen. Nutzen Sie die Gelegenheit, Ihre Kreativität zu entfalten und Geschichten zu schaffen, die Kinder begeistern und ihnen wertvolle Lektionen über Freundschaft und Abenteuer mit auf den Weg geben. diff --git a/static/52_french_childrens_story.txt b/static/52_french_childrens_story.txt deleted file mode 100644 index 1ed62257..00000000 --- a/static/52_french_childrens_story.txt +++ /dev/null @@ -1,244 +0,0 @@ -Creating a French Children's Story -================================== - -Einführung in den Leitfaden "Erstellen einer französischen Kindergeschichte" - -Willkommen zu unserem Leitfaden "Erstellen einer französischen Kindergeschichte"! Dieser Leitfaden richtet sich an alle, die die wunderbare Welt der Kinderliteratur erkunden und eine eigene Geschichte in französischer Sprache verfassen möchten. Egal, ob Sie ein Elternteil, Lehrer oder einfach ein Geschichtenerzähler im Herzen sind, dieser Leitfaden bietet Ihnen die Werkzeuge und Inspiration, die Sie benötigen, um eine fesselnde Geschichte zu kreieren. - -**Zweck und Umfang des Dokuments:** -Der Zweck dieses Leitfadens ist es, Ihnen zu helfen, eine französische Kindergeschichte zu schreiben, die sowohl lehrreich als auch unterhaltsam ist. Wir konzentrieren uns auf einfache französische Sprache, um sicherzustellen, dass die Geschichte für Kinder leicht verständlich ist. Der Leitfaden umfasst Techniken des Geschichtenerzählens, die speziell auf die Bedürfnisse und Interessen junger Leser abgestimmt sind. - -**Kontext und Hintergrundinformationen:** -Kinderliteratur spielt eine entscheidende Rolle in der Entwicklung von Sprache und Vorstellungskraft bei Kindern. Das Schreiben in einer anderen Sprache, wie Französisch, bietet nicht nur eine Gelegenheit zur Sprachförderung, sondern auch zur kulturellen Bereicherung. Französische Kindergeschichten sind bekannt für ihre Kreativität und ihren Charme, und dieser Leitfaden wird Ihnen helfen, diese Elemente in Ihre eigene Geschichte zu integrieren. - -**Was Sie im Dokument finden werden:** -- Eine Einführung in die Grundlagen der Kinderliteratur und ihre Bedeutung. -- Tipps und Techniken zum Schreiben in einfacher französischer Sprache. -- Anleitungen zur Entwicklung von Abenteuergeschichten, die Freundschaft und Fantasie betonen. -- Praktische Übungen und Beispiele, um Ihre Kreativität zu fördern. - -**Ton und Stil:** -Dieser Leitfaden ist in einem freundlichen und zugänglichen Ton gehalten, um Leser aller Hintergründe anzusprechen. Unser Ziel ist es, Sie zu inspirieren und zu ermutigen, Ihre eigene einzigartige Geschichte zu schaffen, die Kinder begeistert und zum Träumen anregt. - -Wir freuen uns darauf, Sie auf dieser kreativen Reise zu begleiten und Ihnen zu helfen, eine Geschichte zu schreiben, die Kinderherzen höher schlagen lässt. Lassen Sie uns gemeinsam in die Welt der französischen Kindergeschichten eintauchen! - -Introduction to Children's Stories ----------------------------------- - -Title: Einführung in Kindergeschichten - -Kindergeschichten sind ein wesentlicher Bestandteil der kindlichen Entwicklung und bieten eine Vielzahl von Vorteilen, die weit über das bloße Vergnügen hinausgehen. In diesem Abschnitt werden wir die Bedeutung des Geschichtenerzählens für Kinder und die Merkmale fesselnder Kindergeschichten untersuchen. - -**Zweck von Kindergeschichten** - -Kindergeschichten dienen mehreren wichtigen Zwecken in der Entwicklung eines Kindes: - -1. **Förderung der Fantasie und Kreativität**: Geschichten öffnen Türen zu neuen Welten und regen die Fantasie der Kinder an. Sie ermöglichen es Kindern, sich Szenarien vorzustellen, die über ihre alltäglichen Erfahrungen hinausgehen. - -2. **Vermittlung von Werten und Lektionen**: Viele Geschichten enthalten moralische Lektionen oder Werte, die Kindern helfen, zwischen richtig und falsch zu unterscheiden. Sie bieten eine sichere Umgebung, um über Konsequenzen und ethisches Verhalten nachzudenken. - -3. **Sprachentwicklung**: Das Hören und Lesen von Geschichten erweitert den Wortschatz und verbessert die Sprachfähigkeiten von Kindern. Sie lernen neue Wörter und Satzstrukturen in einem Kontext, der das Lernen erleichtert. - -4. **Förderung der emotionalen Intelligenz**: Geschichten helfen Kindern, Empathie zu entwickeln, indem sie sich in die Lage der Charaktere versetzen. Sie lernen, verschiedene Emotionen zu erkennen und zu verstehen. - -**Elemente einer guten Geschichte** - -Um eine Geschichte für Kinder fesselnd und lehrreich zu gestalten, sollten bestimmte Elemente berücksichtigt werden: - -1. **Interessante Charaktere**: Kinder identifizieren sich oft mit den Protagonisten einer Geschichte. Charaktere sollten daher gut entwickelt und nachvollziehbar sein, mit Eigenschaften, die Kinder bewundern oder von denen sie lernen können. - -2. **Spannende Handlung**: Eine gute Geschichte sollte eine klare Struktur mit einem Anfang, einem Mittelteil und einem Ende haben. Abenteuer und unerwartete Wendungen halten die Aufmerksamkeit der jungen Leser aufrecht. - -3. **Einfachheit und Klarheit**: Die Sprache sollte einfach und klar sein, um das Verständnis zu erleichtern. Komplexe Begriffe sollten vermieden oder kindgerecht erklärt werden. - -4. **Einprägsame Botschaft**: Eine starke, einprägsame Botschaft oder Moral kann den Kindern helfen, die Lektionen der Geschichte in ihrem eigenen Leben anzuwenden. - -5. **Visuelle Unterstützung**: Illustrationen oder Bilder können die Geschichte lebendiger machen und das Verständnis fördern, insbesondere für jüngere Kinder, die noch nicht lesen können. - -Durch das Verständnis dieser Elemente und Zwecke können Autoren Geschichten schaffen, die nicht nur unterhalten, sondern auch einen bleibenden Eindruck hinterlassen. In der nächsten Phase dieses Leitfadens werden wir uns darauf konzentrieren, wie man eine französische Kindergeschichte entwickelt, die Abenteuer und Freundschaft thematisiert. - -Understanding the Audience --------------------------- - -Title: Understanding the Audience - -In diesem Abschnitt des Leitfadens "Creating a French Children's Story" werden wir uns eingehend mit dem Verständnis der Zielgruppe befassen. Das Ziel ist es, eine Geschichte zu schaffen, die nicht nur die Fantasie der Kinder anregt, sondern auch kulturell relevant und sprachlich angemessen ist. - -**Age Group Considerations** - -Wenn wir eine Geschichte für Kinder schreiben, ist es entscheidend, die Altersgruppe zu berücksichtigen, für die die Geschichte bestimmt ist. Kinder im Alter von 3 bis 5 Jahren haben andere sprachliche Fähigkeiten und Interessen als Kinder im Alter von 6 bis 8 Jahren. - -- **Sprachliche Einfachheit:** Für jüngere Kinder sollte die Sprache einfach und klar sein. Verwenden Sie kurze Sätze und vermeiden Sie komplexe Wörter. Zum Beispiel könnte ein Satz für jüngere Kinder lauten: "Le petit lapin saute dans le jardin." Für ältere Kinder kann die Sprache etwas anspruchsvoller sein, mit längeren Sätzen und einer größeren Vielfalt an Vokabeln. - -- **Themen und Interessen:** Jüngere Kinder sind oft von einfachen Abenteuern und klaren moralischen Lektionen fasziniert. Geschichten über Tiere, Freundschaft und alltägliche Erlebnisse sind besonders ansprechend. Ältere Kinder hingegen können komplexere Handlungsstränge und Charakterentwicklungen schätzen. Ein Beispiel könnte eine Geschichte über eine Gruppe von Freunden sein, die ein Rätsel lösen müssen. - -**Cultural Sensitivity** - -Die kulturelle Relevanz ist ein weiterer wichtiger Aspekt beim Schreiben einer französischen Kindergeschichte. Es ist wichtig, kulturelle Elemente einzubeziehen, die den Kindern vertraut sind, aber auch neue Perspektiven bieten. - -- **Kulturelle Elemente:** Integrieren Sie französische Traditionen, Feste oder bekannte Orte, um den Kindern ein Gefühl der Vertrautheit zu geben. Zum Beispiel könnte eine Geschichte während des "Fête de la Musique" spielen, einem beliebten Musikfestival in Frankreich. - -- **Diversität und Inklusion:** Achten Sie darauf, eine vielfältige und inklusive Darstellung von Charakteren und Kulturen zu bieten. Dies fördert das Verständnis und die Akzeptanz von Unterschieden. Eine Geschichte könnte zum Beispiel Charaktere aus verschiedenen Regionen Frankreichs umfassen, die zusammenarbeiten, um ein gemeinsames Ziel zu erreichen. - -Indem wir diese Aspekte berücksichtigen, können wir eine Geschichte schaffen, die nicht nur unterhaltsam, sondern auch lehrreich und kulturell bereichernd ist. Denken Sie daran, dass das Ziel darin besteht, die Neugier der Kinder zu wecken und ihnen gleichzeitig wertvolle Lektionen über Sprache und Kultur zu vermitteln. - -Elements of Adventure and Friendship ------------------------------------- - -# Elements of Adventure and Friendship - -In der Welt der Kinderliteratur sind Abenteuer und Freundschaft zwei zentrale Themen, die Geschichten lebendig und fesselnd machen. Diese Elemente helfen nicht nur, die Fantasie der Kinder zu beflügeln, sondern vermitteln auch wichtige Werte und Lektionen. In diesem Abschnitt werden wir untersuchen, wie Abenteuer und Freundschaft in französischen Kindergeschichten integriert werden können, um eine fesselnde und lehrreiche Erzählung zu schaffen. - -## Abenteuer-Elemente - -Abenteuer in Kindergeschichten sind oft geprägt von aufregenden Erlebnissen, unerwarteten Wendungen und der Entdeckung neuer Welten. Diese Elemente sind entscheidend, um die Neugier der jungen Leser zu wecken und sie auf eine Reise mitzunehmen, die sowohl spannend als auch lehrreich ist. - -### Definition von Abenteuer in Kindergeschichten - -Ein Abenteuer in einer Kindergeschichte kann als eine Reihe von Ereignissen beschrieben werden, die den Protagonisten aus seiner Komfortzone herausführen und ihn mit Herausforderungen konfrontieren, die Mut, Einfallsreichtum und Entschlossenheit erfordern. Diese Abenteuer können in einer Vielzahl von Umgebungen stattfinden, sei es in einem magischen Wald, auf hoher See oder sogar in einer fiktiven Stadt. - -### Wichtige Elemente eines Abenteuers - -1. **Ein klarer Ausgangspunkt**: Die Geschichte sollte mit einer vertrauten Umgebung oder Situation beginnen, die dann durch das Abenteuer gestört wird. - -2. **Ein Ziel oder eine Mission**: Der Protagonist sollte ein klares Ziel haben, das ihn antreibt, sei es die Rettung eines Freundes, die Suche nach einem Schatz oder die Lösung eines Rätsels. - -3. **Hindernisse und Herausforderungen**: Diese sind entscheidend, um Spannung zu erzeugen und den Protagonisten zu Wachstum und Entwicklung zu zwingen. - -4. **Ein Höhepunkt**: Der Moment, in dem die Spannung ihren Höhepunkt erreicht und der Protagonist seine größte Herausforderung meistert. - -5. **Eine Rückkehr zur Normalität**: Nach dem Abenteuer kehrt der Protagonist in seine Welt zurück, oft mit neuen Erkenntnissen und Erfahrungen. - -## Freundschafts-Themen - -Freundschaft ist ein universelles Thema, das in vielen Kindergeschichten eine zentrale Rolle spielt. Sie bietet nicht nur emotionale Tiefe, sondern lehrt auch wichtige soziale Fähigkeiten wie Empathie, Zusammenarbeit und Vertrauen. - -### Integrieren von Freundschaft in Geschichten - -Freundschaft kann auf vielfältige Weise in eine Geschichte eingebunden werden, sei es durch die Beziehung zwischen den Hauptfiguren oder durch die Begegnung mit neuen Freunden während des Abenteuers. - -### Wichtige Aspekte der Freundschaft - -1. **Entwicklung der Freundschaft**: Zeigen Sie, wie sich Freundschaften entwickeln, von der ersten Begegnung bis zur tiefen Bindung. - -2. **Konflikte und Lösungen**: Freundschaften sind nicht immer einfach. Konflikte bieten die Möglichkeit, wichtige Lektionen über Vergebung und Verständnis zu vermitteln. - -3. **Unterstützung und Zusammenarbeit**: Freunde helfen sich gegenseitig, Herausforderungen zu meistern, was die Bedeutung von Teamarbeit und Unterstützung unterstreicht. - -4. **Vielfalt und Akzeptanz**: Freundschaften zwischen unterschiedlichen Charakteren fördern Toleranz und Akzeptanz. - -### Beispiel für eine Freundschaftsgeschichte - -Ein Beispiel könnte die Geschichte von Léa und Max sein, zwei Kindern, die in einem kleinen französischen Dorf leben. Als sie eines Tages einen geheimnisvollen Schlüssel finden, begeben sie sich auf ein Abenteuer, um das dazugehörige Schloss zu finden. Auf ihrem Weg lernen sie, wie wichtig es ist, zusammenzuarbeiten und sich gegenseitig zu vertrauen, um die Herausforderungen zu meistern, die ihnen begegnen. - -Durch die geschickte Kombination von Abenteuer und Freundschaft können französische Kindergeschichten nicht nur unterhalten, sondern auch wertvolle Lektionen vermitteln, die junge Leser ihr Leben lang begleiten werden. - -Writing in Simple French ------------------------- - -Title: Writing in Simple French - -In diesem Abschnitt des Leitfadens "Creating a French Children's Story" konzentrieren wir uns darauf, wie man eine Geschichte in einfachem Französisch schreibt. Dies ist besonders wichtig, wenn wir eine Geschichte für Kinder erstellen, da sie von Natur aus einfacher und zugänglicher sein sollte. Wir werden uns auf zwei Hauptpunkte konzentrieren: die Verwendung eines einfachen Wortschatzes und den Aufbau einfacher Sätze. - -## Vocabulary Selection - -Die Auswahl des richtigen Wortschatzes ist entscheidend, um eine Geschichte zu schreiben, die für Kinder leicht verständlich ist. Hier sind einige Tipps, um den Wortschatz einfach zu halten: - -1. **Verwenden Sie häufige Wörter**: Wählen Sie Wörter, die Kinder wahrscheinlich schon kennen oder leicht lernen können. Zum Beispiel: "chat" (Katze), "chien" (Hund), "maison" (Haus). - -2. **Vermeiden Sie Fachjargon**: Komplexe oder technische Begriffe sollten vermieden werden. Wenn ein schwieriges Wort notwendig ist, erklären Sie es im Kontext der Geschichte. - -3. **Nutzen Sie Wiederholungen**: Wiederholungen helfen Kindern, neue Wörter zu lernen und sich an die Geschichte zu erinnern. Zum Beispiel: "Le petit chat est curieux. Le petit chat explore le jardin." - -4. **Einfachheit vor Vielfalt**: Es ist besser, einfache und klare Wörter zu verwenden, anstatt nach Synonymen zu suchen, die möglicherweise verwirrend sein könnten. - -## Sentence Structure - -Der Satzbau in einer Kindergeschichte sollte klar und direkt sein. Hier sind einige Richtlinien, um einfache Sätze zu konstruieren: - -1. **Kurze Sätze**: Halten Sie die Sätze kurz und prägnant. Lange Sätze können für Kinder schwer zu verstehen sein. Beispiel: "Le chien court. Il est heureux." - -2. **Einfache Satzstrukturen**: Verwenden Sie einfache Subjekt-Verb-Objekt-Strukturen. Beispiel: "Marie mange une pomme." - -3. **Vermeiden Sie komplexe Zeiten**: Bleiben Sie bei den Grundzeiten wie Präsens und einfachem Perfekt. Beispiel: "Il a trouvé un trésor." - -4. **Direkte Rede verwenden**: Direkte Rede macht die Geschichte lebendiger und hilft Kindern, sich in die Charaktere hineinzuversetzen. Beispiel: "Le loup dit: 'Je vais te manger!'" - -5. **Fragen einbauen**: Fragen können das Interesse der Kinder wecken und sie zum Nachdenken anregen. Beispiel: "Où est le chat?" - -Indem Sie diese Richtlinien befolgen, können Sie eine fesselnde und leicht verständliche Geschichte für Kinder in einfachem Französisch schreiben. Denken Sie daran, dass das Ziel darin besteht, eine Geschichte zu schaffen, die sowohl lehrreich als auch unterhaltsam ist, während sie die Fantasie der jungen Leser anregt. - -Story Development Process -------------------------- - -Title: Story Development Process - -Willkommen zum Abschnitt über den Entwicklungsprozess einer Geschichte! Hier erfahren Sie, wie Sie eine fesselnde französische Kindergeschichte mit den Themen Abenteuer und Freundschaft entwickeln können. Lassen Sie uns gemeinsam die wesentlichen Schritte durchgehen, um eine spannende und lehrreiche Geschichte zu gestalten. - -## Plot Planning - -Der erste Schritt bei der Entwicklung Ihrer Geschichte ist die Planung der Handlung. Eine gut durchdachte Handlung ist das Rückgrat jeder Geschichte und hält die jungen Leser interessiert und engagiert. Hier sind einige Tipps, um eine fesselnde Handlung zu entwickeln: - -1. **Themenwahl**: Beginnen Sie mit der Auswahl eines zentralen Themas. Da Ihre Geschichte Elemente von Abenteuer und Freundschaft enthalten soll, überlegen Sie, wie diese Themen miteinander verwoben werden können. Zum Beispiel könnte die Geschichte von einer Gruppe von Freunden handeln, die sich auf eine abenteuerliche Reise begeben, um einen verlorenen Schatz zu finden. - -2. **Struktur der Handlung**: Eine klassische Struktur besteht aus Einleitung, Hauptteil und Schluss. In der Einleitung stellen Sie die Charaktere und das Setting vor. Der Hauptteil sollte die Abenteuer und Herausforderungen der Charaktere beschreiben, während der Schluss die Geschichte abrundet und eine wertvolle Lektion vermittelt. - -3. **Spannung und Überraschung**: Halten Sie die Spannung aufrecht, indem Sie unerwartete Wendungen einbauen. Kinder lieben Überraschungen, und ein unerwartetes Ereignis kann die Geschichte aufregender machen. - -## Character Creation - -Charaktere sind das Herzstück jeder Geschichte. Sie sollten lebendig und nachvollziehbar sein, damit die jungen Leser sich mit ihnen identifizieren können. Hier sind einige Schritte zur Entwicklung unvergesslicher Charaktere: - -1. **Hauptcharaktere definieren**: Bestimmen Sie, wer die Protagonisten Ihrer Geschichte sind. In einer Geschichte über Freundschaft könnten dies eine Gruppe von Tieren oder Kindern sein, die zusammenarbeiten, um ein gemeinsames Ziel zu erreichen. - -2. **Charaktereigenschaften**: Geben Sie jedem Charakter einzigartige Eigenschaften und Persönlichkeiten. Zum Beispiel könnte ein Charakter besonders mutig sein, während ein anderer sehr klug ist. Diese Unterschiede können zu interessanten Dynamiken und Konflikten führen. - -3. **Entwicklung der Charaktere**: Lassen Sie Ihre Charaktere im Laufe der Geschichte wachsen. Vielleicht lernt der ängstliche Charakter, mutiger zu sein, oder der schüchterne Charakter gewinnt an Selbstvertrauen. Diese Entwicklungen machen die Geschichte nicht nur interessanter, sondern vermitteln auch wichtige Lektionen. - -Durch sorgfältige Planung der Handlung und die Schaffung lebendiger Charaktere können Sie eine französische Kindergeschichte entwickeln, die sowohl unterhaltsam als auch lehrreich ist. Viel Spaß beim Schreiben und lassen Sie Ihrer Kreativität freien Lauf! - -Finalizing the Story --------------------- - -Title: Finalizing the Story - -Nachdem Sie Ihre französische Kindergeschichte mit spannenden Abenteuern und herzlichen Freundschaften erstellt haben, ist es an der Zeit, den letzten Schliff zu geben. In diesem Abschnitt konzentrieren wir uns auf das Bearbeiten und Korrekturlesen sowie auf das Einholen von Feedback und die anschließenden Überarbeitungen. Diese Schritte sind entscheidend, um sicherzustellen, dass Ihre Geschichte sowohl sprachlich korrekt als auch für Kinder ansprechend ist. - -**Editing Techniques** - -Beim Bearbeiten Ihrer Geschichte sollten Sie auf mehrere Aspekte achten: - -1. **Sprachliche Korrektheit**: Überprüfen Sie die Grammatik und Rechtschreibung. Eine fehlerfreie Sprache ist besonders wichtig, da Kinder beim Lesen auch lernen. Nutzen Sie Tools wie Grammatikprüfungen oder bitten Sie einen Muttersprachler um Hilfe. - -2. **Klarheit und Einfachheit**: Stellen Sie sicher, dass die Sprache einfach und verständlich ist. Vermeiden Sie komplexe Sätze und schwierige Wörter, die Kinder möglicherweise nicht verstehen. Ein Beispiel: Anstatt "l'aventure palpitante" könnten Sie "l'aventure amusante" verwenden, um es einfacher zu halten. - -3. **Kohärenz und Logik**: Überprüfen Sie, ob die Handlung logisch und kohärent ist. Jede Szene sollte sinnvoll auf die nächste folgen. Achten Sie darauf, dass die Charaktere konsistent handeln und sprechen. - -4. **Stil und Ton**: Der Ton Ihrer Geschichte sollte freundlich und einladend sein. Achten Sie darauf, dass der Stil zur Zielgruppe passt und die Abenteuerlust und Freundschaft gut vermittelt. - -**Incorporating Feedback** - -Feedback ist ein wertvolles Werkzeug, um Ihre Geschichte zu verbessern. Hier sind einige Schritte, wie Sie es effektiv nutzen können: - -1. **Feedback einholen**: Teilen Sie Ihre Geschichte mit Freunden, Familie oder einer Schreibgruppe. Besonders wertvoll ist Feedback von Eltern oder Lehrern, die Erfahrung mit Kinderliteratur haben. - -2. **Offenheit für Kritik**: Seien Sie offen für konstruktive Kritik. Es ist wichtig, die Perspektiven anderer zu berücksichtigen, um die Geschichte zu verbessern. - -3. **Revisionsprozess**: Nehmen Sie sich die Zeit, das erhaltene Feedback zu analysieren und zu entscheiden, welche Änderungen sinnvoll sind. Vielleicht müssen Sie einige Szenen umschreiben oder Charaktere weiterentwickeln. - -4. **Testleser**: Lassen Sie Kinder, die zur Zielgruppe gehören, die Geschichte lesen. Ihre Reaktionen sind oft ehrlich und direkt und können wertvolle Einblicke geben. - -Indem Sie diese Schritte befolgen, stellen Sie sicher, dass Ihre französische Kindergeschichte nicht nur sprachlich korrekt, sondern auch spannend und lehrreich für junge Leser ist. Viel Erfolg beim Finalisieren Ihrer Geschichte! - -CONCLUSION ----------- - -Abschluss: "Erstellen einer französischen Kindergeschichte" - -In diesem Leitfaden haben wir die wesentlichen Schritte und Techniken zur Erstellung einer fesselnden französischen Kindergeschichte untersucht. Wir haben die Bedeutung der Kinderliteratur hervorgehoben und wie sie zur sprachlichen und emotionalen Entwicklung von Kindern beiträgt. Der Leitfaden hat die Leser durch die Grundlagen der französischen Sprache geführt, um sicherzustellen, dass die Geschichte für junge Leser zugänglich und verständlich ist. - -Ein zentraler Punkt war die Einbindung von Abenteuern und Freundschaft als Kernelemente, um die Neugier und das Interesse der Kinder zu wecken. Wir haben verschiedene Erzähltechniken besprochen, die helfen, lebendige und einprägsame Charaktere zu schaffen, sowie die Bedeutung eines klaren und strukturierten Handlungsverlaufs. - -Zum Abschluss empfehlen wir, die erstellte Geschichte mit Kindern zu teilen und Feedback einzuholen, um die Erzählweise weiter zu verfeinern. Es ist auch ratsam, regelmäßig neue Geschichten zu schreiben, um die eigenen Fähigkeiten im Geschichtenerzählen zu verbessern und die Freude am kreativen Schreiben zu fördern. - -Dieser Leitfaden soll als Ausgangspunkt dienen, um die Kunst des Geschichtenerzählens in der französischen Sprache zu meistern und die Fantasie der jungen Leser zu beflügeln. Wir hoffen, dass Sie inspiriert wurden, Ihre eigene einzigartige Geschichte zu kreieren, die Abenteuer und Freundschaft in den Mittelpunkt stellt und die Herzen der Kinder berührt. diff --git a/static/53_animal_story_fr.txt b/static/53_animal_story_fr.txt deleted file mode 100644 index dbda1727..00000000 --- a/static/53_animal_story_fr.txt +++ /dev/null @@ -1,166 +0,0 @@ -Animal Adventure Story for Children -=================================== - -Titre : Animal Adventure Story for Children - -Introduction : - -Bienvenue dans le monde enchanteur de "Animal Adventure Story for Children", une histoire captivante conçue spécialement pour les jeunes esprits curieux. Ce récit est une invitation à plonger dans un univers où l'amitié, l'aventure et le travail d'équipe prennent vie à travers les yeux de nos amis les animaux. - -Dans cette histoire, les enfants découvriront comment un groupe d'animaux, chacun avec ses propres talents et particularités, se réunit pour vivre des aventures extraordinaires. Ensemble, ils apprendront l'importance de l'entraide et de la collaboration pour surmonter les défis qui se dressent sur leur chemin. - -Au fil des pages, les jeunes lecteurs seront transportés dans des paysages merveilleux, peuplés de créatures fascinantes et de mystères à résoudre. Chaque chapitre est une nouvelle étape de leur voyage, remplie de découvertes et de leçons précieuses sur l'amitié et le courage. - -Préparez-vous à embarquer dans une aventure palpitante où l'imagination n'a pas de limites. Que vous soyez confortablement installé à la maison ou en quête d'une histoire du soir, "Animal Adventure Story for Children" est le compagnon idéal pour éveiller la curiosité et l'amour de la lecture chez les enfants. - -Nous espérons que cette histoire apportera joie et inspiration à tous ceux qui la liront. Bon voyage dans le monde merveilleux des animaux et de l'aventure ! - -Introduction ------------- - -# Introduction - -Bienvenue dans l'univers magique de notre histoire, "Animal Adventure Story for Children". Préparez-vous à plonger dans un monde où l'amitié et l'aventure se rencontrent au cœur d'une forêt luxuriante et mystérieuse. Dans cette introduction, nous allons vous présenter nos personnages principaux et vous inviter à découvrir le décor enchanteur où se déroulera leur incroyable périple. - -## Les Personnages Principaux - -### Léo le Lion -Léo est un jeune lion courageux et curieux. Avec sa crinière dorée et ses yeux pétillants, il est toujours prêt à explorer de nouveaux horizons. Bien qu'il soit le roi de la jungle, Léo est humble et aime partager ses aventures avec ses amis. - -### Zoé la Zèbre -Zoé est une zèbre malicieuse et pleine de vie. Ses rayures noires et blanches la rendent unique, tout comme sa personnalité pétillante. Zoé adore courir à travers la savane et est toujours à la recherche de nouvelles expériences. - -### Max le Singe -Max est un singe espiègle et intelligent. Avec son agilité incroyable, il se balance d'arbre en arbre, toujours prêt à aider ses amis en cas de besoin. Max est connu pour ses blagues amusantes et son grand cœur. - -### Ella l'Éléphante -Ella est une éléphante douce et sage. Elle est la plus grande du groupe et utilise sa force pour protéger ses amis. Ella a une mémoire impressionnante et se souvient de chaque chemin de la forêt, ce qui est très utile lors de leurs aventures. - -## Le Décor : Une Forêt Enchantée - -Notre histoire se déroule dans une forêt enchantée, un lieu où la nature règne en maître. Les arbres y sont immenses, leurs branches formant un toit verdoyant qui abrite une multitude de créatures. Les rivières serpentent à travers la végétation luxuriante, offrant de l'eau fraîche et des lieux de jeu pour nos amis animaux. - -Le chant des oiseaux accompagne chaque lever de soleil, tandis que le parfum des fleurs embaume l'air. C'est un endroit où chaque jour apporte son lot de surprises et où l'aventure attend à chaque coin de sentier. - -Dans cette forêt, nos jeunes héros vont découvrir l'importance de l'amitié, de la coopération et du courage. Ensemble, ils vivront des aventures inoubliables qui les rapprocheront et leur apprendront à surmonter les défis de la vie sauvage. - -Préparez-vous à suivre Léo, Zoé, Max et Ella dans leur quête palpitante à travers la forêt enchantée. Que l'aventure commence ! - -The Adventure Begins --------------------- - -# L'Aventure Commence - -## Rencontre des Animaux et Naissance d'une Amitié - -Dans une forêt enchantée, où le soleil joue à cache-cache avec les feuilles des arbres, vivait un groupe d'animaux qui ne s'étaient jamais rencontrés. Un matin, alors que la rosée scintillait encore sur l'herbe, un petit lapin nommé Léo bondissait joyeusement à travers la clairière. Léo était curieux et aimait explorer les moindres recoins de la forêt. - -Non loin de là, une tortue appelée Tilly avançait lentement mais sûrement, admirant les fleurs colorées qui bordaient son chemin. Tilly, bien que lente, avait un cœur immense et une sagesse que peu d'animaux possédaient. - -Pendant ce temps, un écureuil espiègle nommé Max grimpait aux arbres avec agilité, cherchant des noisettes à cacher pour l'hiver. Max était toujours prêt pour une nouvelle aventure et avait un rire contagieux qui résonnait à travers la forêt. - -Le destin voulut que ces trois animaux se rencontrent près d'un grand chêne majestueux. Léo, avec son enthousiasme débordant, salua Tilly et Max avec un grand sourire. "Bonjour ! Je suis Léo. Voulez-vous jouer avec moi ?" - -Tilly, avec un regard bienveillant, répondit : "Bonjour Léo, je suis Tilly. Je serais ravie de faire ta connaissance et de jouer avec vous." - -Max, sautillant d'une branche à l'autre, ajouta : "Et moi, je suis Max ! J'adore les jeux et les aventures. Allons explorer ensemble !" - -Ainsi, une belle amitié naquit entre Léo, Tilly et Max. Ils décidèrent de se retrouver chaque jour pour partager des moments de joie et de découverte. - -## Introduction de l'Aventure ou de la Quête - -Un jour, alors qu'ils jouaient près de la rivière, les trois amis entendirent une rumeur mystérieuse. Un vieux hibou sage, perché sur une branche, leur raconta une légende fascinante. "Il y a, au cœur de la forêt, un trésor caché qui ne peut être découvert que par ceux qui ont un cœur pur et un esprit d'aventure," dit le hibou avec une voix douce et rassurante. - -Les yeux de Léo s'illuminèrent de curiosité. "Un trésor ? Cela semble incroyable !" - -Tilly, réfléchissant prudemment, proposa : "Pourquoi ne pas partir à la recherche de ce trésor ensemble ? Cela pourrait être une aventure merveilleuse." - -Max, toujours prêt pour une nouvelle quête, s'exclama : "Oui, partons à l'aventure ! Nous découvrirons des secrets et vivrons des moments inoubliables." - -Et c'est ainsi que l'aventure commença. Armés de courage et d'amitié, Léo, Tilly et Max se lancèrent dans une quête qui allait les mener à travers des paysages enchanteurs et des défis inattendus. Ensemble, ils allaient découvrir que le véritable trésor n'était pas seulement ce qu'ils cherchaient, mais aussi les liens qu'ils tissaient en chemin. - -Challenges and Teamwork ------------------------ - -# Challenges and Teamwork - -Dans notre histoire "Animal Adventure Story for Children", les animaux de la forêt se lancent dans une aventure palpitante remplie de défis et de découvertes. Cette section explore les obstacles qu'ils rencontrent et comment, grâce à l'amitié et au travail d'équipe, ils parviennent à les surmonter. - -## Les Défis des Animaux - -Les animaux de notre histoire, comprenant un lapin curieux, un écureuil malin, et une tortue sage, se retrouvent confrontés à plusieurs défis au cours de leur aventure. Parmi ces défis, ils doivent traverser une rivière tumultueuse, trouver leur chemin dans une forêt dense, et surmonter la peur de l'inconnu lorsqu'ils rencontrent des créatures qu'ils n'ont jamais vues auparavant. - -### Exemple de Défi : La Rivière Tumultueuse - -Un des premiers obstacles auxquels nos amis font face est une rivière large et rapide. Le lapin, bien que rapide et agile, ne sait pas nager. L'écureuil, quant à lui, est habile pour grimper mais hésite à se mouiller. La tortue, avec sa carapace lourde, ne peut pas traverser seule. Ce défi met en lumière la nécessité de travailler ensemble pour trouver une solution. - -## L'Importance du Travail d'Équipe - -Face à ces défis, nos héros découvrent que l'union fait la force. Chaque animal apporte ses compétences uniques pour aider le groupe à avancer. Le travail d'équipe devient essentiel pour surmonter les obstacles et atteindre leur destination. - -### Exemple de Travail d'Équipe : Construire un Pont - -Pour traverser la rivière, les animaux décident de construire un pont. Le lapin utilise sa rapidité pour rassembler des branches, l'écureuil utilise son agilité pour les assembler, et la tortue, avec sa force tranquille, stabilise la structure. Ensemble, ils réussissent à créer un passage sûr pour tous. - -## L'Amitié comme Force Motrice - -Tout au long de leur aventure, l'amitié entre le lapin, l'écureuil, et la tortue se renforce. Ils apprennent à se faire confiance et à se soutenir mutuellement, découvrant que l'amitié est une force puissante qui les aide à surmonter les moments difficiles. - -### Exemple d'Amitié : Encouragements Mutuels - -Lorsqu'un des animaux se sent découragé, les autres sont là pour l'encourager. Par exemple, lorsque la tortue se sent trop lente et craint de retarder le groupe, le lapin et l'écureuil lui rappellent combien sa sagesse et sa persévérance sont précieuses pour leur succès collectif. - -En conclusion, "Animal Adventure Story for Children" illustre comment les défis peuvent être surmontés grâce à la coopération et à l'amitié. Les jeunes lecteurs apprendront que, même face à des obstacles apparemment insurmontables, le travail d'équipe et le soutien mutuel peuvent mener à des solutions créatives et à des aventures inoubliables. - -Resolution ----------- - -Title: Résolution - -Dans cette section de notre histoire "Aventure Animale pour Enfants", nous découvrons comment nos amis animaux surmontent les défis qu'ils ont rencontrés et célèbrent leur amitié. Cette partie de l'histoire est cruciale car elle montre aux jeunes lecteurs l'importance de la persévérance et de la camaraderie. - -**Surmonter les Défis** - -Après avoir traversé de nombreuses aventures, nos amis animaux se retrouvent face à un dernier obstacle : un grand ravin qui semble infranchissable. Chacun des animaux utilise ses talents uniques pour trouver une solution. Le singe agile propose de tisser une corde avec des lianes, tandis que l'éléphant fort et sage suggère de construire un pont avec des branches solides. Ensemble, avec l'aide du castor ingénieux qui sait comment assembler les matériaux, ils parviennent à créer un passage sûr. - -Les animaux travaillent en équipe, démontrant que même les défis les plus difficiles peuvent être surmontés grâce à la coopération et à l'ingéniosité. Les enfants apprennent ainsi que chaque individu a quelque chose de précieux à apporter, et que l'union fait la force. - -**Célébration de l'Amitié** - -Une fois le ravin traversé, les animaux organisent une grande fête pour célébrer leur succès et leur amitié. Ils décorent la clairière avec des fleurs et des feuilles colorées, et le rossignol chante une mélodie joyeuse qui résonne à travers la forêt. Le lapin prépare une délicieuse salade de carottes et le hérisson apporte des baies sucrées pour tout le monde. - -Les animaux dansent et rient ensemble, savourant le bonheur d'avoir partagé cette aventure. Ils se rendent compte que les souvenirs qu'ils ont créés ensemble sont plus précieux que n'importe quel trésor. Cette célébration montre aux jeunes lecteurs que l'amitié est une source de joie et de réconfort, et qu'elle est renforcée par les expériences partagées. - -En conclusion, la résolution de notre histoire "Aventure Animale pour Enfants" enseigne aux enfants que les défis peuvent être surmontés grâce à la collaboration et que l'amitié est une richesse inestimable. Les animaux, en surmontant leurs obstacles et en célébrant ensemble, illustrent des valeurs essentielles telles que l'entraide, la créativité et la joie de vivre ensemble. - -Conclusion ----------- - -# Conclusion - -## Résumé de l'Aventure - -Dans cette histoire palpitante, nos jeunes lecteurs ont suivi les aventures de Léo le lion, Zoé la zèbre, et Max le singe à travers la jungle luxuriante. Ensemble, ils ont bravé des rivières tumultueuses, découvert des clairières secrètes et rencontré des animaux fascinants. Chaque étape de leur voyage a été une occasion d'apprendre et de grandir. Léo a découvert le courage en affrontant ses peurs, Zoé a montré sa sagesse en guidant le groupe avec ses connaissances, et Max a apporté de la joie avec ses blagues et ses acrobaties. Leur aventure a été remplie de défis, mais aussi de moments de joie et de découverte. - -## L'Importance de l'Amitié - -Tout au long de leur périple, l'amitié entre Léo, Zoé et Max a été le fil conducteur de leur succès. Ils ont appris que l'entraide et la confiance sont essentielles pour surmonter les obstacles. Par exemple, lorsque Léo a eu peur de traverser la rivière, Zoé et Max l'ont encouragé et l'ont aidé à trouver le courage nécessaire. De même, quand Zoé s'est perdue dans la forêt dense, Léo et Max ont travaillé ensemble pour la retrouver. Ces moments ont renforcé leur lien et ont montré que l'amitié est une force puissante qui peut surmonter toutes les difficultés. - -## Message Final - -En conclusion, "Animal Adventure Story for Children" n'est pas seulement une histoire d'aventure, mais aussi une célébration de l'amitié et de la coopération. Les jeunes lecteurs sont invités à réfléchir à l'importance de soutenir leurs amis et de travailler ensemble pour atteindre leurs objectifs. Que ce soit dans la jungle ou dans la cour de récréation, l'esprit d'équipe et l'amour entre amis rendent chaque aventure plus enrichissante et mémorable. Nous espérons que cette histoire inspirera les enfants à valoriser leurs amitiés et à vivre leurs propres aventures avec courage et joie. - -CONCLUSION ----------- - -CONCLUSION - -Dans l'histoire "Animal Adventure Story for Children", nous avons suivi les aventures palpitantes d'un groupe d'animaux courageux qui ont uni leurs forces pour surmonter divers défis. À travers leurs péripéties, les thèmes de l'amitié et du travail d'équipe ont été mis en avant, montrant aux jeunes lecteurs l'importance de la collaboration et de l'entraide. - -Les personnages principaux, chacun avec ses propres talents et caractéristiques, ont démontré que même les différences peuvent être une force lorsqu'elles sont mises au service d'un objectif commun. Leur aventure a non seulement renforcé leurs liens d'amitié, mais a également permis de découvrir de nouveaux horizons et de vivre des expériences enrichissantes. - -En conclusion, cette histoire encourage les enfants à valoriser l'amitié et à travailler ensemble pour atteindre leurs buts. Elle leur enseigne que l'aventure est plus belle lorsqu'elle est partagée et que chaque obstacle peut être surmonté grâce à la solidarité et à la confiance mutuelle. - -Pour prolonger cette expérience, il est recommandé aux jeunes lecteurs de réfléchir à leurs propres amitiés et aux aventures qu'ils pourraient vivre ensemble. Ils peuvent également imaginer de nouvelles histoires avec les personnages de l'histoire, développant ainsi leur créativité et leur compréhension des valeurs essentielles de l'amitié et du travail d'équipe. - -Ainsi, "Animal Adventure Story for Children" laisse une empreinte durable, rappelant aux enfants que l'amitié et l'aventure vont de pair, et que chaque jour peut être une nouvelle occasion de découvrir le monde qui les entoure. diff --git a/static/54_animal_story_french.txt b/static/54_animal_story_french.txt deleted file mode 100644 index 7c96bc70..00000000 --- a/static/54_animal_story_french.txt +++ /dev/null @@ -1,163 +0,0 @@ -Animal Story for Children in French -=================================== - -Titre : Histoire d'Animaux pour Enfants - -Bienvenue dans notre histoire captivante, "Histoire d'Animaux pour Enfants", spécialement conçue pour émerveiller et inspirer les jeunes esprits. Ce récit enchanteur vous emmènera dans un monde où les animaux prennent vie, partageant des leçons précieuses sur l'amitié, la gentillesse et le travail d'équipe. - -Dans cette histoire, vous rencontrerez une joyeuse bande d'animaux qui, malgré leurs différences, apprennent à travailler ensemble pour surmonter les défis et célébrer leurs victoires. Chaque personnage apporte sa propre personnalité et ses talents uniques, illustrant comment la diversité et la coopération peuvent mener à des résultats extraordinaires. - -Au fil des pages, les jeunes lecteurs découvriront comment la gentillesse et l'entraide peuvent transformer des situations difficiles en opportunités de croissance et de bonheur. Ce conte est non seulement divertissant, mais il véhicule également des valeurs essentielles qui aideront les enfants à développer des relations positives et harmonieuses. - -Préparez-vous à plonger dans une aventure pleine de rires, de découvertes et de moments touchants, où chaque animal a une leçon à partager. Nous espérons que cette histoire deviendra un favori des enfants, les encourageant à être de bons amis et à toujours choisir la gentillesse. - -Bonne lecture et amusez-vous bien dans le monde merveilleux des animaux ! - -Introduction ------------- - -# Introduction - -Bienvenue dans notre histoire magique, "L'Histoire des Animaux pour Enfants", où l'amitié et la gentillesse règnent en maître. Dans ce récit enchanteur, nous allons rencontrer des personnages animaux extraordinaires qui vivent dans un monde plein de couleurs et de rires. Préparez-vous à plonger dans une aventure où chaque coin de la forêt cache une nouvelle surprise et où chaque personnage a une leçon précieuse à partager. - -## Les Personnages Principaux - -### Léo le Lion -Léo est le roi de la jungle, mais il n'est pas comme les autres lions. Avec sa crinière dorée et son cœur d'or, Léo est connu pour sa sagesse et sa gentillesse. Il est toujours prêt à aider ses amis et à résoudre les problèmes avec calme et intelligence. - -### Zoé la Zèbre -Zoé est une zèbre pleine de vie avec des rayures noires et blanches qui dansent au rythme de ses mouvements. Elle est curieuse et adore explorer les environs. Zoé a un sens de l'humour contagieux et sait toujours comment faire sourire ses amis. - -### Max le Singe -Max est un singe espiègle et agile, toujours prêt pour une nouvelle aventure. Avec son rire communicatif et ses acrobaties impressionnantes, Max apporte de la joie et de l'énergie à tous ceux qui l'entourent. Il est le meilleur ami de Léo et Zoé, et ensemble, ils forment un trio inséparable. - -## Un Cadre Amical - -L'histoire se déroule dans une forêt luxuriante, où les arbres sont si hauts qu'ils semblent toucher le ciel. Les rayons du soleil filtrent à travers les feuilles, créant des motifs lumineux sur le sol. Les rivières chantent doucement en traversant les rochers, et les fleurs colorées parsèment le paysage, ajoutant une touche de magie à cet environnement déjà enchanteur. - -Dans cette forêt, tous les animaux vivent en harmonie. Les oiseaux chantent des mélodies joyeuses, les papillons dansent dans l'air, et chaque jour est une nouvelle occasion de découvrir quelque chose de merveilleux. C'est un endroit où l'amitié et la bienveillance sont au cœur de chaque interaction, et où chaque animal a sa propre histoire à raconter. - -Préparez-vous à suivre Léo, Zoé, et Max dans leurs aventures palpitantes, où ils apprendront l'importance de l'entraide, du respect et de l'amour. Ensemble, ils nous montreront que, peu importe les différences, l'amitié est le plus grand trésor de tous. - -The Meeting ------------ - -Title: La Rencontre - -Dans une clairière ensoleillée de la forêt enchantée, un groupe d'animaux se rassemblait pour la première fois. C'était un jour spécial, car chacun d'eux venait de différents coins de la forêt, apportant avec eux leurs propres histoires et expériences. - -### Les Premiers Arrivés - -Le premier à arriver fut Léon le lionceau, avec sa crinière encore duveteuse et ses yeux pétillants de curiosité. Il était suivi de près par Zoé la zèbre, qui trottinait joyeusement, ses rayures noires et blanches brillant sous le soleil. Léon, bien que jeune, avait déjà appris l'importance de la gentillesse. Il salua Zoé avec un sourire chaleureux : "Bonjour Zoé, tes rayures sont magnifiques aujourd'hui !" - -### Une Rencontre Amicale - -Peu après, une petite tortue nommée Timéo fit son entrée, avançant lentement mais sûrement. Zoé et Léon l'accueillirent avec enthousiasme. "Bonjour Timéo ! Nous sommes heureux que tu sois là," dit Zoé en inclinant la tête pour mieux le voir. Timéo, bien que timide, se sentit immédiatement à l'aise grâce à l'accueil chaleureux de ses nouveaux amis. - -### L'Arrivée de Nouveaux Amis - -Ensuite, arriva une famille de lapins, sautillant gaiement. Le plus jeune, un lapin nommé Léo, s'approcha de Léon avec curiosité. "Bonjour, je suis Léo ! Est-ce que tu veux jouer avec nous ?" Léon, ravi de cette invitation, accepta avec joie. - -### Un Acte de Gentillesse - -Alors que les animaux continuaient à se rencontrer, un petit oiseau nommé Chloé se posa sur une branche proche. Elle avait remarqué que Timéo avait du mal à atteindre les feuilles fraîches sur les branches basses. Sans hésiter, elle vola jusqu'à lui et lui apporta quelques feuilles. "Merci beaucoup, Chloé," dit Timéo, touché par ce geste attentionné. - -### Conclusion de la Rencontre - -La clairière résonnait de rires et de conversations joyeuses. Chaque animal, bien qu'unique, avait trouvé sa place dans ce groupe amical. Ils avaient appris que la gentillesse et l'ouverture d'esprit pouvaient transformer une simple rencontre en une belle amitié. Et ainsi, la forêt enchantée devint un peu plus lumineuse ce jour-là, grâce à la chaleur de leurs cœurs unis. - -Cette rencontre marqua le début d'une série d'aventures où chaque animal, avec ses qualités et ses différences, contribua à enrichir la vie de ses nouveaux amis. - -The Adventure -------------- - -# L'Aventure - -## Introduction à l'Aventure - -Dans un coin paisible de la forêt, un groupe d'animaux se réunit chaque jour pour jouer et partager des histoires. Un beau matin, alors que le soleil se lève doucement, nos amis décident de partir à l'aventure. Ils sont curieux de découvrir ce qui se cache au-delà de leur clairière habituelle. Cette aventure va leur apprendre l'importance de l'amitié et du travail d'équipe. - -## Le Départ - -Les animaux qui participent à cette aventure sont Léo le lionceau, Zoé la zèbre, Max le singe, et Lily la petite éléphante. Ensemble, ils forment une équipe soudée et pleine d'énergie. Avant de partir, ils se rassemblent pour discuter du chemin à prendre et des précautions à suivre. Zoé, toujours prévoyante, propose de suivre le ruisseau qui serpente à travers la forêt. Max, avec son enthousiasme débordant, est déjà prêt à bondir en avant. - -## Les Défis de l'Aventure - -### Le Pont Cassé - -Après avoir marché pendant un moment, le groupe arrive devant un vieux pont de bois qui traverse le ruisseau. Malheureusement, le pont est partiellement effondré. Léo, avec sa bravoure naturelle, propose de trouver une solution ensemble. Lily, forte et ingénieuse, suggère d'utiliser des branches pour renforcer le pont. Grâce à leur collaboration, ils parviennent à traverser le ruisseau en toute sécurité. - -### La Tempête Soudaine - -Plus loin dans la forêt, une tempête soudaine éclate. Le vent souffle fort et la pluie commence à tomber. Les animaux se serrent les uns contre les autres pour se réconforter. Max, qui adore grimper, repère un grand arbre avec des branches épaisses qui peuvent les abriter. Ensemble, ils se hâtent de se mettre à l'abri sous cet arbre protecteur. En attendant que la tempête passe, ils chantent des chansons et partagent des histoires pour garder le moral. - -## La Récompense de l'Aventure - -Après la tempête, le ciel s'éclaircit et un magnifique arc-en-ciel apparaît. Les animaux sont émerveillés par ce spectacle de couleurs. Ils réalisent que, malgré les défis rencontrés, leur amitié et leur esprit d'équipe les ont aidés à surmonter toutes les difficultés. En rentrant chez eux, ils savent qu'ils ont vécu une aventure inoubliable qui a renforcé leurs liens. - -## Conclusion - -L'aventure a permis à Léo, Zoé, Max, et Lily de découvrir non seulement les merveilles de la forêt, mais aussi la force de leur amitié. Ils ont appris que, ensemble, ils peuvent surmonter n'importe quel obstacle. Cette journée restera gravée dans leur mémoire comme un précieux souvenir de courage, de solidarité et de joie partagée. - -Resolution ----------- - -Titre : Résolution - -Dans cette section, nous allons découvrir comment les animaux de notre histoire surmontent leur défi et renforcent leur amitié. - -**Les Animaux Résolvent le Défi** - -Après avoir discuté ensemble, les animaux réalisent que la clé pour résoudre leur problème est de travailler en équipe. Le défi qu'ils doivent surmonter est de traverser une rivière pour atteindre une prairie pleine de nourriture délicieuse. Chacun des animaux a une compétence unique qui peut aider le groupe. - -- **L'éléphant**, avec sa force, propose de transporter les plus petits animaux sur son dos pour traverser la rivière. -- **Le singe**, agile et rapide, grimpe aux arbres pour trouver le meilleur chemin à suivre. -- **Le canard**, excellent nageur, guide le groupe à travers les eaux en toute sécurité. -- **La tortue**, avec sa sagesse, rappelle à tout le monde de rester calme et de travailler ensemble. - -Grâce à leur collaboration, les animaux parviennent à traverser la rivière sans encombre. Ils réalisent que chacun d'eux a joué un rôle essentiel dans cette aventure. - -**Renforcement de l'Amitié** - -Après avoir surmonté ce défi ensemble, les animaux se sentent plus proches les uns des autres. Ils comprennent que leur diversité est une force et que l'entraide est la clé de leur succès. - -- **Exemple de solidarité** : Lorsque le petit lapin a eu peur de l'eau, le canard l'a rassuré en lui montrant comment flotter en toute sécurité. -- **Moment de partage** : Une fois arrivés dans la prairie, tous les animaux partagent la nourriture qu'ils trouvent, renforçant ainsi leur lien d'amitié. - -Cette expérience leur a appris que l'amitié est précieuse et que, même face aux difficultés, ils peuvent toujours compter les uns sur les autres. Les animaux promettent de toujours s'entraider et de se soutenir, peu importe les défis à venir. - -En conclusion, cette aventure a non seulement résolu leur problème immédiat, mais elle a aussi cimenté une amitié durable entre eux, remplie de confiance et de respect mutuel. Les animaux retournent chez eux, le cœur léger et heureux, prêts à vivre de nouvelles aventures ensemble. - -Conclusion ----------- - -Titre : Conclusion - -Dans cette conclusion de notre "Histoire d'animaux pour enfants", nous allons explorer la morale de l'histoire et renforcer les thèmes de l'amitié et de la gentillesse qui ont été tissés tout au long du récit. - -### Morale de l'histoire - -L'histoire nous enseigne que l'amitié et la gentillesse sont des valeurs essentielles qui enrichissent notre vie. À travers les aventures de nos amis animaux, nous avons appris que l'entraide et le respect mutuel peuvent surmonter les obstacles les plus difficiles. Par exemple, lorsque le petit lapin a aidé l'écureuil à retrouver ses noisettes perdues, il a montré que même les plus petits gestes de bonté peuvent avoir un grand impact. Cette morale nous rappelle que nous devrions toujours être prêts à tendre la main à ceux qui en ont besoin, car un acte de gentillesse peut illuminer la journée de quelqu'un. - -### Renforcement des thèmes de l'amitié et de la gentillesse - -Tout au long de l'histoire, les animaux ont démontré que l'amitié véritable repose sur la compréhension et le soutien. Lorsque le hibou sage a partagé ses connaissances avec les autres animaux, il a non seulement aidé ses amis, mais a aussi renforcé les liens qui les unissaient. De même, la gentillesse du renard, qui a partagé sa nourriture avec le hérisson affamé, a illustré comment la générosité peut créer des amitiés durables. - -Ces exemples montrent que l'amitié et la gentillesse ne sont pas seulement des concepts abstraits, mais des actions concrètes qui enrichissent notre quotidien. En encourageant les enfants à adopter ces valeurs, nous les aidons à construire un monde plus harmonieux et solidaire. - -En conclusion, notre histoire d'animaux pour enfants nous rappelle que chaque jour est une nouvelle opportunité de faire preuve de gentillesse et de cultiver des amitiés sincères. Que ce soit en partageant un sourire, en offrant de l'aide, ou simplement en étant présent pour un ami, nous pouvons tous contribuer à rendre notre monde un peu plus lumineux. - -CONCLUSION ----------- - -CONCLUSION - -Dans l'histoire "Animal Story for Children in French", nous avons suivi les aventures de plusieurs animaux qui ont appris l'importance de l'amitié, de la gentillesse et du travail d'équipe. À travers leurs péripéties, les jeunes lecteurs ont découvert comment ces valeurs essentielles peuvent transformer des situations difficiles en opportunités de croissance et de bonheur partagé. - -Les personnages principaux, un lapin curieux, un écureuil généreux, et une tortue sage, ont montré que malgré leurs différences, ils pouvaient unir leurs forces pour surmonter les obstacles. Leur collaboration a non seulement renforcé leur amitié, mais a également illustré comment la bienveillance et l'entraide peuvent créer un environnement harmonieux et joyeux. - -En conclusion, cette histoire encourage les enfants à valoriser et à pratiquer la gentillesse et le travail d'équipe dans leur vie quotidienne. Elle leur rappelle que chaque petit geste de bonté peut avoir un grand impact et que l'amitié est un trésor précieux à cultiver. - -Pour prolonger l'expérience, il est recommandé aux jeunes lecteurs de réfléchir à des situations où ils peuvent appliquer ces leçons dans leur propre vie. Pourquoi ne pas organiser une activité de groupe où chacun peut contribuer à un projet commun, renforçant ainsi les liens d'amitié et de coopération? - -En fin de compte, "Animal Story for Children in French" laisse une empreinte positive, soulignant l'importance des valeurs humaines fondamentales et leur rôle dans la construction d'un monde meilleur pour tous. diff --git a/static/55_children_story.txt b/static/55_children_story.txt deleted file mode 100644 index cdd2de6b..00000000 --- a/static/55_children_story.txt +++ /dev/null @@ -1,204 +0,0 @@ -Frogs: A Tale of Friendship and Adventure -========================================= - -Title: Frogs: A Tale of Friendship and Adventure - ---- - -Welcome to "Frogs: A Tale of Friendship and Adventure," a delightful story crafted especially for young minds eager to explore the wonders of friendship and the thrill of adventure. This enchanting tale is designed for children in kindergarten, offering an engaging and educational journey into the world of frogs. - -In this story, you'll meet a group of lively frogs who embark on an exciting adventure that teaches them the true meaning of friendship and teamwork. As you turn the pages, you'll dive into a vibrant pond filled with fun, laughter, and valuable lessons. Our froggy friends will show you how working together can overcome any obstacle and how the bonds of friendship can make any adventure unforgettable. - -This story is written in a conversational tone, making it easy and enjoyable for young readers to follow along. Through the adventures of these charming frogs, children will learn important values such as cooperation, empathy, and the joy of exploring the world around them. - -Join us on this whimsical journey, where every leap and splash brings a new discovery. "Frogs: A Tale of Friendship and Adventure" promises to be a captivating experience that will leave young readers with a smile and a heart full of wonder. - -Let's hop into the story and see where the adventure takes us! - -Introduction ------------- - -# Introduction - -Welcome to the enchanting world of "Frogs: A Tale of Friendship and Adventure," where the lily pads are lush, the water is crystal clear, and the air is filled with the symphony of croaking frogs. This story invites young readers to dive into a vibrant pond bustling with life and excitement. Here, we meet our delightful frog friends who are about to embark on an unforgettable journey of friendship and discovery. - -## Meet the Frog Friends - -In the heart of this lively pond lives a group of charming frog friends, each with their own unique personality and talents. Let's get to know them: - -- **Freddy the Fearless**: Freddy is a bright green frog with a heart as big as his leap. Known for his adventurous spirit, Freddy loves exploring new places and is always ready to lead his friends on exciting escapades. His bravery often inspires others to step out of their comfort zones. - -- **Lily the Listener**: With her soft, soothing voice and gentle demeanor, Lily is the go-to frog for advice and comfort. Her beautiful blue skin makes her stand out, but it's her kind heart that truly shines. Lily is always there to lend an ear or offer a helping hand to her friends. - -- **Benny the Brainy**: Benny is the smartest frog in the pond, with a knack for solving problems and coming up with clever ideas. His bright yellow spots are as distinctive as his quick thinking. Benny loves reading and learning about the world beyond the pond, often sharing fascinating facts with his friends. - -- **Sally the Silly**: Sally is the life of the party, always ready with a joke or a funny story. Her vibrant orange hue matches her lively personality. Sally's laughter is infectious, and she knows how to turn any frown upside down, making her an essential part of the group. - -## Setting the Scene - -Our story unfolds in a picturesque pond nestled in the heart of a lush, green forest. The pond is a kaleidoscope of colors, with blooming water lilies and tall reeds swaying gently in the breeze. The sun casts a warm glow over the water, creating a shimmering surface that dances with the reflections of the surrounding trees. - -The pond is not just a home to our frog friends but also a bustling community filled with dragonflies, fish, and other creatures. It's a place where every day brings new adventures and opportunities to learn and grow. The frogs spend their days hopping from lily pad to lily pad, playing games, and exploring the wonders of their watery world. - -As the story begins, the frogs are unaware of the thrilling adventure that awaits them. Together, they will discover the true meaning of friendship, courage, and the joy of exploring the unknown. So, let's leap into this delightful tale and join Freddy, Lily, Benny, and Sally on their journey through the pond and beyond! - -The Adventure Begins --------------------- - -Title: The Adventure Begins - ---- - -Once upon a time, in a lush, green pond nestled in the heart of a vibrant forest, there lived a group of lively frogs. These frogs were not just any frogs; they were the best of friends, always hopping around together, playing games, and sharing stories. Their pond was a magical place, filled with lily pads, buzzing dragonflies, and the gentle croaking of their fellow amphibians. But as much as they loved their home, the frogs often wondered what lay beyond the familiar waters of their pond. - -### The Call to Adventure - -One sunny morning, as the frogs gathered on their favorite lily pad, a gentle breeze carried with it the scent of something new and exciting. It was a smell unlike anything they had ever experienced before. Curious and eager, the frogs began to chatter among themselves. - -"Do you smell that?" asked Freddie, the most adventurous of the group, his eyes wide with excitement. - -"Yes!" replied Lily, the thoughtful one, her mind already racing with possibilities. "I wonder where it comes from." - -Toby, the smallest but the most enthusiastic, jumped up and down, splashing water everywhere. "Let's find out! Let's go on an adventure!" - -### The Decision to Explore - -The idea of an adventure was thrilling and a little bit scary. The frogs had heard tales from older frogs about the world beyond the pond—stories of towering trees, colorful flowers, and mysterious creatures. But they had never ventured far from their watery home. - -Freddie, with a determined look, said, "We can be brave and explore together. Who knows what wonders we might find?" - -Lily nodded, her curiosity piqued. "And we can always come back if it gets too scary." - -Toby, unable to contain his excitement, shouted, "Adventure awaits! Let's go!" - -### Preparing for the Journey - -Before setting off, the frogs gathered their courage and made a plan. They decided to stick together, no matter what. They would hop along the path that led through the forest, keeping an eye out for anything interesting or unusual. Each frog had a role: Freddie would lead the way, Lily would remember the path back home, and Toby would keep everyone entertained with his cheerful songs. - -As they prepared to leave, the other frogs in the pond gathered to see them off. "Be safe!" croaked an elder frog. "And remember, the world is full of surprises." - -With a final wave to their friends, Freddie, Lily, and Toby took a deep breath and hopped away from the pond, their hearts full of excitement and a little bit of nervousness. - -### The First Steps - -The forest was a wonderland of sights and sounds. The frogs marveled at the towering trees that seemed to touch the sky and the colorful flowers that dotted the forest floor. They listened to the chirping of birds and the rustling of leaves in the gentle breeze. Every step was a new discovery, and the frogs couldn't help but feel a sense of wonder and joy. - -As they ventured further, they realized that the world was much bigger than they had ever imagined. But with each other by their side, they felt ready to face whatever lay ahead. - -And so, with hearts full of courage and friendship, the frogs' adventure truly began. They were ready to explore, to learn, and to grow together, knowing that the journey would be as important as the destination. - ---- - -With this, the frogs took their first steps into a world of endless possibilities, where every hop could lead to a new adventure and every moment was a chance to strengthen their bond of friendship. - -Challenges and Friendship -------------------------- - -Title: Challenges and Friendship - ---- - -In the heart of the lush, green forest, where the sun peeked through the leaves and the air was filled with the sweet sound of chirping birds, lived a group of lively frogs. These frogs were not just any ordinary frogs; they were the best of friends, always ready for an adventure. But like any great story, their tale was not without its challenges. - -### The Great Pond Dilemma - -One sunny morning, the frogs gathered at their favorite spot by the pond. As they splashed and played, they noticed something unusual. The water level in the pond was dropping! This pond was their home, their playground, and the source of their food. Without it, they would be in big trouble. - -The frogs knew they had to act quickly. But what could they do? They were just small frogs in a big forest. This was their first big challenge, and it seemed daunting. - -### The Power of Teamwork - -The frogs decided to hold a meeting. Freddy, the wisest of the frogs, spoke first. "We need to work together to solve this problem," he said. "If we each use our strengths, we can find a way to save our pond." - -Lily, the fastest swimmer, suggested they explore the forest to find out what was causing the water to disappear. Benny, the strongest frog, offered to move any obstacles they might find. And Tiny, the smallest but most clever frog, proposed they gather information from other animals in the forest. - -### Friendship Saves the Day - -As they ventured into the forest, the frogs encountered many obstacles. They had to leap over fallen branches, navigate through thick bushes, and even cross a small stream. But with each challenge, they relied on each other. When Lily got tired, Benny carried her on his back. When Benny couldn't fit through a narrow path, Tiny guided him from above. - -Finally, they discovered the source of the problem: a family of beavers had built a dam upstream, blocking the water flow to their pond. The frogs knew they had to talk to the beavers and find a solution that worked for everyone. - -### A Lesson in Friendship - -The frogs approached the beavers with kindness and explained their predicament. The beavers, understanding the importance of the pond to the frogs, agreed to adjust their dam to allow more water to flow through. - -Through their adventure, the frogs learned that challenges are easier to overcome when you have friends by your side. They realized that each of them had something unique to offer, and by working together, they could achieve anything. - -As the water returned to the pond, the frogs celebrated their success. They had faced a great challenge, but their friendship and teamwork had saved the day. And from that day on, they knew that no matter what obstacles came their way, they would always have each other. - ---- - -This story of the frogs teaches us that friendship is not just about having fun together; it's about supporting each other through thick and thin. By working as a team, even the smallest creatures can overcome the biggest challenges. - -The Return Home ---------------- - -Title: The Return Home - ---- - -**Frogs Safely Return to Their Pond** - -After a long and exciting journey filled with unexpected twists and turns, the frogs finally found themselves hopping along the familiar path that led back to their beloved pond. The sun was setting, casting a warm golden glow over the water, and the gentle croaking of their fellow frogs welcomed them home. As they approached the edge of the pond, they could see their lily pads swaying gently in the breeze, just as they had left them. - -The frogs took a moment to pause and soak in the comforting sights and sounds of their home. They were tired but happy, knowing that they had safely returned from their grand adventure. The pond seemed to sparkle with joy at their arrival, and the frogs couldn't help but feel a sense of pride in what they had accomplished together. - -**Reflecting on Their Adventure and Friendship** - -Gathered on their favorite lily pad, the frogs began to reflect on the incredible journey they had just experienced. They remembered the challenges they faced, like crossing the wide river and climbing the steep hill, and how they had worked together to overcome each obstacle. It was their friendship and teamwork that had made the adventure not only possible but also unforgettable. - -One frog, with a twinkle in his eye, said, "Remember when we helped each other leap over the big log? I was so scared, but you all cheered me on!" Another frog nodded and added, "And when we found that hidden garden with all the colorful flowers, it was like discovering a secret world!" - -As they reminisced, the frogs realized that their adventure had taught them important lessons about courage, trust, and the strength of their friendship. They had learned that even when things seemed difficult, they could rely on each other to find a way through. - -With the stars beginning to twinkle above them, the frogs knew that their adventure had come to an end, but their friendship had grown stronger than ever. They promised to always be there for one another, ready for whatever new adventures the future might bring. - -And so, with hearts full of joy and memories to cherish, the frogs settled down for a peaceful night's rest, dreaming of the adventures yet to come and the unbreakable bond of their friendship. - -Moral of the Story ------------------- - -Title: Moral of the Story - ---- - -In the delightful tale "Frogs: A Tale of Friendship and Adventure," young readers are taken on a journey filled with excitement and valuable life lessons. This story not only entertains but also imparts important morals that are essential for children to understand and cherish. Below, we explore the key lessons learned from the story and encourage children to value the power of friendship. - -### Lessons Learned - -1. **The Importance of Teamwork:** - - Throughout their adventure, the frogs demonstrate how working together can overcome obstacles that seem insurmountable when faced alone. Whether it's crossing a tricky stream or finding their way through a dense forest, the frogs show that collaboration and pooling their strengths lead to success. - -2. **Courage in the Face of Challenges:** - - The frogs encounter various challenges that test their bravery. The story teaches children that courage is not the absence of fear but the ability to face fears with determination. By supporting each other, the frogs find the courage to continue their journey, showing young readers that they too can be brave in difficult situations. - -3. **Embracing Differences:** - - Each frog in the story has unique traits and skills, which they use to help the group. This highlights the importance of embracing and appreciating differences in others. Children learn that diversity can be a strength, and everyone has something valuable to contribute. - -### Valuing Friendship - -1. **Support and Encouragement:** - - The frogs' adventure is a testament to the power of friendship. They support and encourage each other, showing that true friends are there to lift you up when you need it most. This teaches children the value of being a supportive friend and the joy of having friends who care. - -2. **Sharing Joys and Sorrows:** - - The story illustrates that friendship is about sharing both happy and challenging moments. By experiencing the highs and lows together, the frogs deepen their bond, teaching children that friendships grow stronger when you share your experiences with others. - -3. **Building Trust:** - - Trust is a central theme in the frogs' journey. They rely on each other's judgment and instincts, which helps them navigate their adventure successfully. This encourages children to build trust with their friends, knowing that mutual trust is a cornerstone of lasting friendships. - -In conclusion, "Frogs: A Tale of Friendship and Adventure" is more than just a story about frogs; it's a heartwarming reminder of the values that make friendships meaningful. By learning from the frogs' experiences, children are encouraged to cherish their friends, embrace teamwork, and face challenges with courage and trust. - -CONCLUSION ----------- - -Conclusion of "Frogs: A Tale of Friendship and Adventure" - -In the enchanting tale of "Frogs: A Tale of Friendship and Adventure," young readers are taken on a delightful journey through the vibrant world of frogs, where friendship and teamwork are at the heart of every adventure. The story introduces us to a group of lively frogs who embark on a series of exciting escapades, teaching valuable lessons about cooperation, trust, and the joy of exploring the unknown. - -Throughout their journey, the frogs demonstrate the importance of working together to overcome challenges, highlighting how each frog's unique abilities contribute to the group's success. This narrative not only entertains but also educates children about the significance of friendship and the power of collaboration. - -As the story concludes, the frogs return home, their bonds stronger than ever, having learned that true friendship is the greatest treasure of all. This heartwarming ending reinforces the key themes of the story, leaving young readers with a sense of fulfillment and a deeper appreciation for their own friendships. - -For parents and educators, "Frogs: A Tale of Friendship and Adventure" serves as an excellent tool to spark discussions about teamwork and the value of helping one another. It encourages children to embrace new experiences and cherish the friendships they form along the way. - -In summary, this charming tale not only captivates the imagination of young readers but also imparts timeless lessons that resonate beyond the pages of the book. As children close the story, they are left with a clear understanding of the importance of friendship and the adventures that await when we work together. diff --git a/static/56_children_story.txt b/static/56_children_story.txt deleted file mode 100644 index 4d51dc2f..00000000 --- a/static/56_children_story.txt +++ /dev/null @@ -1,198 +0,0 @@ -The Curious Frog: A Kindergarten Adventure -========================================== - -Title: The Curious Frog: A Kindergarten Adventure - ---- - -Welcome to "The Curious Frog: A Kindergarten Adventure," a delightful story crafted especially for young minds eager to explore the wonders of the world around them. This enchanting tale invites children into the vibrant world of Froggy, a little frog with a big heart and an even bigger curiosity. - -**Purpose and Scope:** - -This story is designed to captivate the imagination of kindergarten-aged children, encouraging them to embrace their natural curiosity and explore their surroundings. Through Froggy's adventures, young readers will learn valuable lessons about kindness, sharing, and the joy of discovery. - -**Context and Background:** - -Set in a lush, green pond filled with friendly creatures and hidden surprises, Froggy's world is a place where every day brings new opportunities for learning and fun. As Froggy hops from one adventure to the next, children will be introduced to the importance of being kind to others and the rewards of sharing and helping friends. - -**What to Expect:** - -In this story, readers will follow Froggy as he embarks on a series of adventures that teach him—and the readers—important life lessons. From meeting new friends to solving little problems, each chapter is filled with engaging scenarios that highlight the values of curiosity, exploration, and kindness. - -**Setting the Tone:** - -Written in a conversational and friendly tone, this story is perfect for reading aloud, either at home or in the classroom. The narrative is designed to be both entertaining and educational, ensuring that children are not only engaged but also inspired to think about the world around them. - -Join Froggy on his journey and discover how a little curiosity can lead to big adventures and even bigger hearts. Enjoy the adventure! - -Introduction ------------- - -# Introduction - -## Meet Freddy the Frog - -In the heart of a lush, vibrant pond, where the water glistens under the warm sun and the air is filled with the gentle hum of nature, lives a little frog named Freddy. Freddy is not just any frog; he is a curious frog with a boundless sense of adventure. His bright green skin blends perfectly with the lily pads, and his big, round eyes are always wide open, eager to discover the wonders of the world around him. Freddy's curiosity often leads him to explore every nook and cranny of his watery home, making each day an exciting new adventure. - -## The Vibrant Pond - -Freddy's home is a magical place, teeming with life and color. The pond is surrounded by tall, swaying reeds and dotted with colorful flowers that dance in the breeze. Dragonflies zip across the water's surface, their wings shimmering like tiny rainbows. Beneath the water, fish dart playfully among the plants, and turtles bask lazily on sun-warmed rocks. The pond is not just a home for Freddy; it's a bustling community where every creature has a role to play. - -## A World of Curiosity and Learning - -For Freddy, the pond is a never-ending source of questions and discoveries. Why do the dragonflies hover so close to the water? How do the fish move so quickly? What makes the flowers bloom in such brilliant colors? Each question is an invitation to explore, to learn, and to grow. Freddy's adventures are not just about satisfying his curiosity; they are about understanding the world and learning important values like kindness, sharing, and respect for others. - -Join Freddy on his kindergarten adventure, where every leap and splash is a step towards new friendships and valuable lessons. Whether he's helping a friend in need or discovering the beauty of a simple lily pad, Freddy's journey is one of joy, wonder, and endless possibilities. - -Freddy's Curiosity ------------------- - -Title: Freddy's Curiosity - ---- - -Freddy's Curiosity - -Freddy the Frog was not like the other frogs in the pond. While his friends were content to hop around the lily pads and catch flies, Freddy's mind was always buzzing with questions. He often found himself gazing beyond the pond's edge, wondering about the world that lay beyond. What mysteries did the tall grass hide? What stories did the wind carry from afar? Freddy's heart was filled with a sense of adventure and an insatiable curiosity that set him apart. - -### The World Beyond the Pond - -Freddy's curiosity about the world beyond the pond was like a gentle itch that he couldn't quite scratch. Every morning, as the sun peeked over the horizon, Freddy would sit on his favorite rock and dream about the adventures waiting for him. He imagined meeting creatures he had never seen before and discovering places that no frog had ever visited. - -One day, Freddy decided it was time to explore. With a determined leap, he hopped to the edge of the pond, where the water met the land. The grass felt different under his webbed feet, and the air was filled with new scents. Freddy's heart raced with excitement and a little bit of fear, but he knew that his curiosity was leading him to something wonderful. - -### Encounters with Other Pond Creatures - -As Freddy ventured further from the pond, he encountered a variety of creatures who called the pond their home. His first encounter was with Benny the Beetle, who was busy rolling a ball of mud. Freddy watched in fascination as Benny skillfully maneuvered the ball across the ground. - -"Hello, Benny!" Freddy croaked cheerfully. "What are you doing with that ball of mud?" - -Benny paused and looked up at Freddy with a smile. "I'm building a home for my family," he explained. "This mud will keep us safe and warm." - -Freddy was amazed by Benny's ingenuity and realized that there was so much to learn from the creatures around him. He continued his journey and soon met Sally the Snail, who was slowly making her way across a leaf. - -"Why do you move so slowly, Sally?" Freddy asked, genuinely curious. - -Sally chuckled softly. "I may be slow, but I get to enjoy every moment and see things others might miss," she replied. - -Freddy pondered Sally's words and understood that everyone had their own pace and way of seeing the world. His encounters with Benny and Sally taught him valuable lessons about patience and appreciation. - -### Conclusion - -Freddy's curiosity led him on a journey of discovery, where he learned that the world beyond the pond was filled with wonders and wisdom. Each creature he met had something unique to teach him, and Freddy realized that his curiosity was a gift that opened doors to new friendships and adventures. As he made his way back to the pond, Freddy felt grateful for the lessons he had learned and excited for the many more adventures that awaited him. - -Freddy's story reminds us all that curiosity is a powerful tool for learning and growing. By embracing the unknown and seeking to understand the world around us, we can discover the beauty and knowledge that lie just beyond our comfort zones. - -The Exploration ---------------- - -# The Exploration - -## Freddy Ventures Out of the Pond - -Once upon a time, in a lively pond surrounded by tall grasses and colorful wildflowers, lived a curious little frog named Freddy. Freddy was not like the other frogs who were content with hopping from lily pad to lily pad. Freddy had a twinkle in his eye and a heart full of wonder. Every day, he would gaze beyond the pond's edge, dreaming of the world that lay beyond. - -One sunny morning, Freddy decided it was time to explore. With a brave leap, he hopped out of the pond and onto the soft, dewy grass. The world outside was vast and filled with sounds and sights he had never experienced before. The gentle rustle of leaves, the chirping of distant birds, and the warm breeze tickling his skin made Freddy's heart race with excitement. - -## Discovering New Places - -Freddy's first stop was a meadow filled with vibrant flowers swaying in the wind. The air was sweet with their fragrance, and Freddy couldn't help but smile. As he hopped through the meadow, he noticed a group of butterflies fluttering gracefully above him. Their wings shimmered in the sunlight, creating a dance of colors that left Freddy in awe. - -"Hello, butterflies!" Freddy called out, his voice filled with joy. The butterflies paused their dance and fluttered down to greet him. They shared stories of their travels, telling Freddy about the beautiful gardens and fields they had visited. Freddy listened intently, his curiosity growing with each tale. - -## Meeting New Creatures - -As Freddy continued his journey, he ventured into a shady forest where the trees stood tall and proud. The forest was alive with the sounds of chirping crickets and rustling leaves. It was here that Freddy met a wise old turtle named Tilly. Tilly was slowly making her way across the forest floor, her shell glistening in the dappled sunlight. - -"Hello there, young frog," Tilly greeted warmly. "What brings you to this part of the forest?" - -"I'm exploring!" Freddy replied eagerly. "I want to see all the wonderful places and meet new friends." - -Tilly chuckled softly. "Well, you've come to the right place. This forest is home to many creatures, each with their own story to tell." - -Freddy spent the afternoon with Tilly, learning about the forest and its inhabitants. He met a family of squirrels who shared their acorns with him, teaching Freddy the value of sharing and kindness. He also encountered a wise old owl who spoke of the importance of curiosity and learning. - -## A Day of Discovery - -As the sun began to set, painting the sky with hues of orange and pink, Freddy realized it was time to head back to the pond. His heart was full of new experiences and friendships. He had discovered that the world was much bigger and more beautiful than he had ever imagined. - -Freddy hopped back to the pond, his mind buzzing with excitement. He couldn't wait to share his adventures with his fellow frogs. As he settled down on his favorite lily pad, he knew that this was just the beginning of many more explorations to come. - -Freddy's adventure taught him that the world is full of wonders waiting to be discovered, and that kindness and curiosity can lead to the most amazing friendships. And so, with a heart full of joy and a mind eager for more, Freddy the curious frog drifted off to sleep, dreaming of his next big adventure. - -Learning Values ---------------- - -Title: Learning Values - ---- - -In "The Curious Frog: A Kindergarten Adventure," young readers are invited to join Freddy, a curious little frog, on a delightful journey filled with exploration and valuable life lessons. Through his adventures, Freddy learns important values that are essential for personal growth and social interaction. This section delves into the key lessons of kindness and sharing that Freddy encounters, providing a comprehensive understanding of these values in a way that resonates with young minds. - ---- - -**1. The Lesson of Kindness: Wisdom from the Wise Old Turtle** - -Freddy's adventure takes a meaningful turn when he meets a wise old turtle named Mr. Tuttle. This encounter becomes a pivotal moment in Freddy's journey, as Mr. Tuttle imparts a profound lesson on kindness. - -- **Understanding Kindness**: Mr. Tuttle explains to Freddy that kindness is about being considerate and helpful to others, even in small ways. He shares stories from his own life, illustrating how simple acts of kindness can make a big difference in the world. - -- **An Act of Kindness**: Freddy witnesses Mr. Tuttle helping a struggling butterfly find its way back to a flower. This act of kindness inspires Freddy, showing him that kindness can be as simple as lending a helping hand or offering a comforting word. - -- **Freddy's Transformation**: Inspired by Mr. Tuttle, Freddy begins to practice kindness in his own life. He helps a fellow frog find a lost toy and shares his lily pad with a tired dragonfly. These actions not only bring joy to others but also fill Freddy with a sense of happiness and fulfillment. - ---- - -**2. The Joy of Sharing: A Lesson from the Ducklings** - -As Freddy continues his adventure, he encounters a lively group of ducklings who teach him the joy of sharing. This experience is both fun and enlightening for Freddy, as he learns that sharing is a way to build friendships and create happiness. - -- **The Ducklings' Game**: Freddy joins the ducklings in a game of "Pass the Pebble," where each duckling takes turns passing a shiny pebble around. Through this game, Freddy learns that sharing can be fun and that it helps everyone feel included and valued. - -- **Sharing in Action**: Freddy decides to share his favorite snack, a juicy fly, with the ducklings. This gesture not only strengthens his bond with the ducklings but also shows him that sharing can lead to new friendships and shared joy. - -- **A New Perspective**: By the end of the day, Freddy realizes that sharing is not just about giving away what you have, but about creating connections and spreading happiness. He discovers that the more he shares, the more he receives in return, in the form of smiles, laughter, and friendship. - ---- - -In conclusion, "The Curious Frog: A Kindergarten Adventure" beautifully illustrates the values of kindness and sharing through Freddy's experiences. These lessons are woven into the narrative in a way that is engaging and relatable for young readers, encouraging them to incorporate these values into their own lives. Freddy's journey is a testament to the power of curiosity, exploration, and the lifelong impact of learning important values. - -Conclusion ----------- - -Title: Conclusion - ---- - -**Freddy Returns to the Pond with New Knowledge** - -After his adventurous day exploring the vibrant world beyond the pond, Freddy the Frog hopped back to his familiar lily pad with a heart full of excitement and a mind buzzing with new ideas. His journey had taken him through the lush green meadows, bustling with life, and into the colorful gardens where he met new friends and learned about the wonders of the world. Freddy had discovered the joy of asking questions and the thrill of finding answers, realizing that every new experience was a chance to learn something valuable. - -As he settled back into the gentle sway of the pond, Freddy thought about all the incredible things he had seen and the lessons he had learned. He understood now that the world was much bigger than he had ever imagined, and there was so much more to explore. Freddy's curiosity had led him to new places and new friends, showing him that being curious was a wonderful way to discover the beauty and magic of the world around him. - ---- - -**Reflecting on the Importance of Curiosity and Kindness** - -Freddy's adventure also taught him the importance of kindness. Throughout his journey, he met many creatures who were willing to share their knowledge and experiences with him. From the wise old turtle who showed him the way through the meadow to the friendly butterflies who shared their nectar, Freddy realized that kindness was a powerful force that made the world a better place. - -He remembered how he had helped a little bird find its way back to its nest and how good it felt to be kind and helpful. Freddy understood that just as curiosity opened doors to new adventures, kindness opened hearts and built friendships. He promised himself that he would always be kind and helpful to others, just as others had been to him. - -As the sun set over the pond, painting the sky with hues of orange and pink, Freddy felt grateful for the day he had. He knew that his adventure was just the beginning and that there were many more discoveries waiting for him. With a heart full of gratitude and a mind eager to learn, Freddy the Frog drifted off to sleep, dreaming of the adventures that tomorrow would bring. - ---- - -In conclusion, Freddy's kindergarten adventure was a delightful tale of curiosity and kindness, teaching us all that the world is full of wonders waiting to be explored. By embracing curiosity and practicing kindness, we can make every day an exciting journey filled with learning and friendship. Freddy's story reminds us that no matter how small we may feel, our actions can make a big difference in the world. - -CONCLUSION ----------- - -The Curious Frog: A Kindergarten Adventure - Conclusion - -In "The Curious Frog: A Kindergarten Adventure," we embarked on a delightful journey with Freddy, the inquisitive frog, who taught us the importance of curiosity and exploration. Throughout the story, Freddy's adventures in the vibrant world of the pond introduced young readers to the wonders of nature and the joy of discovering new things. His encounters with various pond creatures highlighted the value of kindness and the beauty of sharing, reinforcing essential life lessons for children. - -As Freddy explored, he learned that asking questions and seeking answers is a wonderful way to understand the world around us. His interactions with friends like Lily the dragonfly and Benny the turtle demonstrated how sharing knowledge and experiences can lead to stronger friendships and a more harmonious community. - -The story concludes with Freddy realizing that his curiosity not only helped him learn but also brought joy and understanding to those around him. This adventure encourages young readers to embrace their own curiosity, to explore their surroundings, and to practice kindness and sharing in their daily lives. - -In summary, "The Curious Frog: A Kindergarten Adventure" is a charming tale that combines the excitement of exploration with the warmth of friendship. It leaves readers with a clear understanding of the significance of curiosity and the positive impact of kindness and sharing. As a next step, children are encouraged to continue exploring their world, asking questions, and sharing their discoveries with others, fostering a lifelong love of learning and compassion. diff --git a/static/57_children_story.txt b/static/57_children_story.txt deleted file mode 100644 index 313dc207..00000000 --- a/static/57_children_story.txt +++ /dev/null @@ -1,227 +0,0 @@ -Freddy the Frog and Friends: A Tale of Friendship and Kindness -============================================================== - -Title: Freddy the Frog and Friends: A Tale of Friendship and Kindness - ---- - -Welcome to the enchanting world of "Freddy the Frog and Friends: A Tale of Friendship and Kindness." This delightful story is crafted especially for young readers and listeners, inviting them into a vibrant pond where friendship and kindness blossom. - -**Purpose and Scope:** - -This story aims to introduce children to the values of friendship, kindness, collaboration, and problem-solving. Through the adventures of Freddy the Frog and his friends, young minds will explore how working together and showing kindness can overcome any challenge. - -**Context and Background:** - -Set in a lively pond filled with diverse creatures, our story follows Freddy the Frog, a cheerful and curious amphibian, and his best friend, Timmy the Turtle. Together, they embark on a journey that highlights the importance of helping others and the joy found in making new friends. Along the way, they meet various characters, each bringing their own unique qualities to the group. - -**What to Expect:** - -Readers will dive into a series of engaging adventures where Freddy and his friends face challenges that require teamwork and empathy. Each chapter unfolds a new lesson in kindness and cooperation, encouraging children to reflect on their own friendships and how they can be a positive force in their communities. - -**Tone and Audience:** - -Written in a conversational and warm tone, this story is perfect for kindergarten-aged children. It is designed to be read aloud, making it an ideal choice for storytime at home or in the classroom. The narrative is simple yet captivating, ensuring that young readers remain engaged while absorbing valuable life lessons. - -Join Freddy and his friends on their heartwarming journey, and discover how a little kindness can make a big difference in the world around us. - -Introduction ------------- - -# Introduction - -Welcome to the enchanting world of "Freddy the Frog and Friends: A Tale of Friendship and Kindness." In this delightful story, we embark on a journey to a serene and vibrant pond, where the air is filled with the gentle hum of nature and the promise of adventure. Here, we meet Freddy the Frog, a charming and curious little amphibian whose heart is as big as his leap. - -## Meet Freddy the Frog - -Freddy is not your ordinary frog. With his bright green skin that glistens under the sun and his eyes that twinkle with curiosity, Freddy is always eager to explore the world around him. But what truly sets Freddy apart is his kind heart and his unwavering belief in the power of friendship. Freddy loves to hop around the pond, meeting new friends and helping those in need. Whether it's lending a hand to a struggling tadpole or sharing his lily pad with a tired dragonfly, Freddy's acts of kindness never go unnoticed. - -## The Peaceful Pond - -Our story unfolds in a picturesque setting—a peaceful pond nestled in the heart of a lush, green meadow. The pond is a haven of tranquility, where the water is as clear as a crystal mirror, reflecting the azure sky above. Tall reeds sway gently in the breeze, and colorful wildflowers bloom along the water's edge, painting the landscape with vibrant hues. The pond is home to a diverse community of creatures, each with their own unique stories and personalities. From the playful fish that dart beneath the surface to the wise old turtle who basks in the sun, the pond is a place where harmony and friendship flourish. - -As we dive into the adventures of Freddy the Frog and his friends, we will discover how simple acts of kindness can create ripples of joy and bring everyone closer together. So, gather around and prepare to be enchanted by a tale that celebrates the beauty of friendship and the magic of kindness. - -Meeting Timmy the Turtle ------------------------- - -Title: Meeting Timmy the Turtle - ---- - -**Introduction to Timmy** - -Freddy the Frog was hopping along the edge of the pond, his favorite place to explore. The sun was shining brightly, and the gentle breeze carried the sweet scent of blooming flowers. Freddy loved these peaceful moments, but today was special. Today, he was about to meet someone new. - -As Freddy leaped from one lily pad to another, he noticed something unusual near the water's edge. A small, round shape was slowly making its way through the grass. Freddy's curiosity got the better of him, and he decided to investigate. - -**The First Encounter** - -Freddy approached cautiously, his big eyes widening with interest. "Hello there!" he croaked cheerfully. The little shape stopped moving, and Freddy realized it was a turtle. The turtle slowly lifted its head, revealing a friendly face with bright, curious eyes. - -"Hello," the turtle replied in a soft, gentle voice. "My name is Timmy." - -Freddy was thrilled. He had never met a turtle before! "I'm Freddy," he said, his voice bubbling with excitement. "It's nice to meet you, Timmy. What brings you to our pond?" - -**Curiosity and Conversation** - -Timmy smiled, a slow and steady smile that matched his pace. "I was just exploring," he explained. "I like to visit new places and meet new friends." - -Freddy nodded eagerly. "I love exploring too! There are so many wonderful things to see around here. Have you ever seen the big oak tree on the other side of the pond? It's home to a family of squirrels!" - -Timmy's eyes lit up with interest. "No, I haven't seen it yet. It sounds amazing!" - -Freddy's heart swelled with happiness. He loved sharing his favorite spots with new friends. "I can show you around if you'd like," he offered. - -Timmy nodded, his shell gleaming in the sunlight. "I would love that, Freddy. Thank you." - -**A New Friendship Begins** - -As they started their journey around the pond, Freddy and Timmy talked about everything they saw. Freddy pointed out the colorful dragonflies that danced above the water, and Timmy shared stories about his travels and the different creatures he had met. - -Freddy was fascinated by Timmy's tales, and he realized that even though they were different, they had a lot in common. Both loved adventure, and both cherished the beauty of nature. - -As the sun began to set, painting the sky with hues of orange and pink, Freddy and Timmy knew they had found a special friendship. They promised to meet again soon, eager to continue their adventures together. - -**Conclusion** - -Meeting Timmy the Turtle was just the beginning of a wonderful friendship for Freddy the Frog. Through their initial interaction, Freddy learned that curiosity and kindness could lead to new friendships and exciting adventures. And so, with a happy heart, Freddy hopped back to his lily pad, looking forward to the many adventures that awaited him and his new friend, Timmy. - -The Challenge -------------- - -Title: The Challenge - ---- - -In the heart of the lush, green pond, where lily pads floated gently and dragonflies danced in the sunlight, a sudden problem arose that threatened the harmony of the pond's vibrant community. This was no ordinary day for Freddy the Frog and his best friend, Timmy the Turtle. It was a day that would test their friendship and kindness in ways they had never imagined. - -**The Problem in the Pond** - -It all began one sunny morning when Freddy noticed something unusual. The water level in the pond was dropping rapidly, and the once-clear water had turned murky and uninviting. The fish were struggling to swim, and the plants that lined the pond's edge were wilting under the harsh sun. Freddy's heart sank as he realized that if the water continued to disappear, the pond would no longer be a safe haven for its inhabitants. - -Freddy hopped over to Timmy, who was basking on a warm rock, and shared his concerns. "Timmy, have you noticed the water level? It's getting lower and lower. If we don't do something, our home might be in danger!" - -Timmy, always the thoughtful one, nodded slowly. "You're right, Freddy. We need to figure out what's causing this and how we can help." - -**Freddy and Timmy Decide to Help** - -Determined to save their beloved pond, Freddy and Timmy decided to investigate. They gathered their friends, including Sally the Snail, Benny the Beetle, and Lily the Ladybug, to brainstorm ideas. Everyone agreed that teamwork was essential to solving the mystery of the vanishing water. - -Freddy suggested, "Let's start by exploring the area around the pond. Maybe there's something blocking the stream that feeds our pond." - -With a plan in place, the friends set off on their adventure. They carefully examined the stream and discovered a pile of fallen branches and leaves blocking the water's flow. Freddy and Timmy knew they had to clear the debris to restore the pond's water supply. - -**Working Together** - -Freddy and Timmy led their friends in a collaborative effort to remove the blockage. Timmy used his strong shell to push the heavier branches aside, while Freddy and the others worked together to clear the smaller debris. It was hard work, but with each piece they removed, the water began to flow more freely. - -As the stream's gentle trickle turned into a steady flow, the pond's water level began to rise. The fish swam happily once more, and the plants perked up, their leaves glistening in the sunlight. Freddy and Timmy beamed with pride, knowing that their teamwork and determination had saved their home. - -**A Lesson in Friendship and Kindness** - -The challenge had brought the pond's community closer together, teaching them the value of friendship and kindness. Freddy and Timmy realized that by working together and helping one another, they could overcome any obstacle. - -As the sun set over the pond, casting a golden glow on the water, Freddy and Timmy sat side by side, grateful for their friends and the lesson they had learned. They knew that no matter what challenges lay ahead, they would always have each other and the power of friendship to see them through. - ---- - -This section of the story highlights the importance of teamwork, friendship, and kindness, showing young readers how working together can solve problems and strengthen bonds. - -Working Together ----------------- - -Title: Working Together - ---- - -In the enchanting world of Lily Pad Pond, where the sun dances on the water and the breeze whispers through the reeds, Freddy the Frog and Timmy the Turtle embark on a heartwarming journey of friendship and kindness. This section of our story, "Freddy the Frog and Friends: A Tale of Friendship and Kindness," explores how these two unlikely friends come together to make their world a better place. - ---- - -**Freddy and Timmy Collaborate** - -Freddy the Frog, with his vibrant green skin and boundless energy, was known for his leaps and bounds across the pond. Timmy the Turtle, on the other hand, moved at a more leisurely pace, his shell a sturdy home that he carried with him everywhere. Despite their differences, Freddy and Timmy discovered that they made a perfect team. - -One sunny morning, as the dew glistened on the lily pads, Freddy noticed that the pond was cluttered with fallen leaves and twigs. "Oh dear, the pond looks so messy!" Freddy exclaimed, his big eyes filled with concern. Timmy, who was sunbathing on a nearby rock, nodded thoughtfully. "We should clean it up," he suggested, his voice as steady as his movements. - -Together, they devised a plan. Freddy, with his quick hops, gathered the leaves and twigs into small piles. Timmy, using his strong legs, pushed the piles to the edge of the pond. As they worked side by side, they chatted and laughed, their friendship growing stronger with each task completed. By the end of the day, the pond sparkled under the setting sun, a testament to their teamwork. - ---- - -**Showcase Acts of Kindness** - -Freddy and Timmy's collaboration didn't stop at cleaning the pond. They were always on the lookout for ways to help their fellow pond dwellers. One day, they noticed a little duckling struggling to find its way back to its mother. Freddy, with his keen eyes, spotted the mother duck on the other side of the pond. "Let's help the duckling," he said, his voice filled with determination. - -Timmy nodded, and together they guided the duckling across the pond. Freddy hopped ahead, encouraging the duckling to follow, while Timmy stayed close by, offering a reassuring presence. When the duckling was finally reunited with its mother, Freddy and Timmy felt a warm glow of happiness. Their small act of kindness had made a big difference. - -Another time, Freddy and Timmy noticed that the flowers around the pond were wilting due to a lack of rain. Freddy suggested they carry water from the pond to the flowers. Timmy agreed, and with Freddy's agility and Timmy's strength, they managed to water the flowers, bringing them back to life. The flowers bloomed brightly, adding a splash of color to the pond, and the animals of Lily Pad Pond admired the duo's thoughtful gesture. - ---- - -Through their collaborative efforts and acts of kindness, Freddy the Frog and Timmy the Turtle showed that friendship is about supporting each other and making the world a better place. Their story reminds us that no matter how different we may be, when we work together, we can achieve wonderful things. - -Resolution ----------- - -Title: Resolution - ---- - -**The Problem is Solved** - -In the heart of the lush, green forest, where the sun gently kissed the leaves and the air was filled with the sweet songs of birds, Freddy the Frog and his friends faced a challenge that tested their bonds. The once vibrant pond, their favorite gathering spot, had become murky and uninviting. The water was low, and the plants around it were wilting, causing concern among the forest creatures. - -Freddy, with his bright green skin and curious eyes, gathered his friends, including Timmy the Turtle, Sally the Squirrel, and Benny the Bird, to discuss how they could restore their beloved pond. They brainstormed ideas, each friend contributing their unique perspective. Timmy suggested they clean the pond, while Sally proposed planting new flowers around it. Benny, with his keen eye from above, noticed a blockage in the stream that fed the pond. - -Together, they worked tirelessly. Freddy and Timmy cleared the debris from the stream, allowing fresh water to flow once more. Sally and Benny planted colorful flowers and spread seeds that would soon bloom into a beautiful garden. Their hard work paid off as the pond began to sparkle again, reflecting the bright blue sky and the cheerful faces of the friends who had come together to solve the problem. - -**Friendship is Strengthened** - -As the pond returned to its former glory, the friends gathered around to celebrate their success. They realized that it was not just the pond that had been restored, but their friendship had grown stronger through their shared efforts. Freddy, with a wide smile, thanked each of his friends for their help and kindness. He understood that it was their teamwork and willingness to listen to each other that made the difference. - -Timmy, who had always been a bit shy, felt more confident and valued, knowing his ideas were important. Sally, with her energetic spirit, learned the importance of patience and collaboration. Benny, who often soared above, realized the joy of being grounded with friends who cared. - -The experience taught them that true friendship is about supporting each other, sharing responsibilities, and celebrating successes together. The pond, now a symbol of their unity, became a place where they would gather not just to play, but to share stories, dreams, and laughter. - -In the end, Freddy the Frog and his friends discovered that kindness and cooperation could overcome any obstacle, and their friendship was the greatest treasure of all. As the sun set over the forest, painting the sky with hues of orange and pink, the friends sat by the pond, grateful for the adventure that had brought them even closer together. - -Conclusion ----------- - -Title: Conclusion - ---- - -**Reflecting on the Importance of Friendship** - -As we reach the end of "Freddy the Frog and Friends: A Tale of Friendship and Kindness," it's important to take a moment to reflect on the wonderful journey we've shared with Freddy, Timmy, and their friends. Throughout their adventures, we've seen how friendship can bring joy, support, and strength to everyone involved. Freddy the Frog and Timmy the Turtle showed us that true friends are always there for each other, whether it's helping to solve a problem or simply sharing a laugh. - -Friendship is like a beautiful garden that needs care and attention to grow. Freddy and his friends taught us that by being there for one another, listening, and sharing, we can create bonds that last a lifetime. Their story reminds us that friends come in all shapes and sizes, and it's the love and care we give to each other that truly matters. - -**Encouraging Kindness** - -Another important lesson from Freddy's tale is the power of kindness. Throughout the story, we saw how small acts of kindness can make a big difference. Whether it was Freddy helping Timmy find his way home or the friends working together to clean up the pond, each act of kindness helped to strengthen their friendship and made their world a better place. - -Kindness is like a ripple in a pond; it starts with one small action and spreads outward, touching everyone it meets. Freddy and his friends showed us that being kind doesn't just help others; it also brings happiness and fulfillment to ourselves. By choosing to be kind, we can create a community where everyone feels valued and loved. - -**Final Thoughts** - -In conclusion, "Freddy the Frog and Friends: A Tale of Friendship and Kindness" is more than just a story about a group of animals. It's a reminder of the values that make our lives richer and more meaningful. As we close this chapter, let's carry with us the lessons of friendship and kindness, and strive to be like Freddy and his friends in our own lives. - -Remember, every day is a new opportunity to be a good friend and to spread kindness wherever we go. Just like Freddy and Timmy, we can make the world a brighter place, one small act at a time. Thank you for joining us on this delightful journey, and may your own adventures be filled with friendship and kindness. - -CONCLUSION ----------- - -Conclusion of "Freddy the Frog and Friends: A Tale of Friendship and Kindness" - -In the heartwarming tale of "Freddy the Frog and Friends," we journeyed through a vibrant pond where friendship and kindness blossomed. Freddy the Frog, alongside his loyal friend Timmy the Turtle, embarked on an adventure that highlighted the importance of collaboration and problem-solving. Throughout their journey, they encountered various challenges that tested their bonds and showcased the power of working together. - -Key points of the story emphasized how Freddy and his friends, including Sally the Snail and Benny the Bird, used their unique strengths to overcome obstacles. Their collective efforts not only solved problems but also strengthened their friendships, illustrating that kindness and teamwork can lead to wonderful outcomes. - -As the story concludes, readers are reminded of the significance of extending kindness and being a supportive friend. The tale encourages young minds to embrace diversity and appreciate the different abilities each individual brings to a group. It also inspires children to approach challenges with a positive attitude and a willingness to help others. - -For future adventures, Freddy and his friends can continue to explore new environments, meet new characters, and learn more about the world around them. These experiences will further reinforce the values of friendship and kindness, leaving a lasting impact on young readers. - -In summary, "Freddy the Frog and Friends: A Tale of Friendship and Kindness" is a delightful story that not only entertains but also imparts valuable life lessons. It serves as a gentle reminder of the beauty of friendship and the strength found in kindness, leaving readers with a heartwarming message to carry forward. diff --git a/static/58_kinder_geschichte_ueber_fische.txt b/static/58_kinder_geschichte_ueber_fische.txt deleted file mode 100644 index 42e16e9c..00000000 --- a/static/58_kinder_geschichte_ueber_fische.txt +++ /dev/null @@ -1,120 +0,0 @@ -La Storia dei Pesci per Bambini -=============================== - -Titel: La Storia dei Pesci per Bambini - -Einführung: - -Willkommen zu "La Storia dei Pesci per Bambini", einer bezaubernden Erzählung, die junge Leser in die faszinierende Welt der Meeresbewohner entführt. Diese Geschichte ist nicht nur unterhaltsam, sondern auch lehrreich und zielt darauf ab, das Bewusstsein für die Bedeutung des Umweltschutzes zu schärfen. - -In dieser Geschichte werden die Kinder die Abenteuer von bunten Fischen und ihren Freunden erleben, die in den tiefen blauen Ozeanen leben. Durch ihre Erlebnisse lernen die jungen Leser wichtige Lektionen über Freundschaft, Zusammenarbeit und den Schutz unserer Umwelt. - -Die Erzählung ist in einem lockeren und gesprächigen Ton gehalten, um die Neugier der Kinder zu wecken und sie dazu zu ermutigen, mehr über das Leben im Meer zu erfahren. Die Geschichte ist ideal für Eltern und Erzieher, die ihren Kindern auf unterhaltsame Weise Wissen über die Meereswelt und die Bedeutung des Umweltschutzes vermitteln möchten. - -Tauchen Sie ein in diese wunderbare Geschichte und begleiten Sie unsere Fischfreunde auf ihrer Reise durch die Meere. Lassen Sie sich von ihrer Welt verzaubern und entdecken Sie, wie wichtig es ist, unsere Ozeane zu schützen und zu bewahren. Viel Spaß beim Lesen! - -Introduzione ------------- - -# Introduzione - -## Introduzione ai Personaggi Principali - -Benvenuti nel meraviglioso mondo di "La Storia dei Pesci per Bambini", un racconto che vi porterà nelle profondità dell'oceano, dove la vita è vibrante e piena di avventure. Incontrerete una serie di personaggi affascinanti che vi accompagneranno in questo viaggio sottomarino. - -### Pesciolino Blu -Pesciolino Blu è il protagonista della nostra storia. È un piccolo pesce curioso e avventuroso, sempre pronto a esplorare nuovi angoli del suo vasto mondo acquatico. Con le sue squame scintillanti di un blu intenso, Pesciolino Blu è facile da riconoscere tra la folla di pesci che popolano il mare. - -### Stella la Stella Marina -Stella è una stella marina saggia e gentile, amica fidata di Pesciolino Blu. Con le sue cinque braccia, Stella è sempre pronta a dare una mano (o un braccio!) ai suoi amici in difficoltà. È conosciuta per le sue storie affascinanti e per la sua capacità di trovare soluzioni creative ai problemi. - -### Granchio Rosso -Granchio Rosso è un granchio vivace e un po' burbero, ma con un cuore d'oro. Ama raccontare storie di avventure passate e non perde mai l'occasione di sfidare Pesciolino Blu e Stella a nuove imprese. Con le sue chele forti, è un compagno di viaggio indispensabile. - -## Ambientazione del Mondo Sottomarino - -Il mondo sottomarino in cui si svolge la nostra storia è un luogo di meraviglie e misteri. Le acque cristalline dell'oceano ospitano una varietà infinita di creature marine, ognuna con la sua storia da raccontare. Le barriere coralline, con i loro colori vivaci, offrono rifugio e nutrimento a innumerevoli specie. - -### La Grande Barriera Corallina -La Grande Barriera Corallina è il cuore pulsante del nostro racconto. Qui, tra coralli di ogni forma e colore, i nostri protagonisti vivono le loro avventure quotidiane. È un luogo di bellezza mozzafiato, ma anche di pericoli nascosti, dove ogni giorno porta nuove sfide e scoperte. - -### La Foresta di Alghe -Non lontano dalla barriera, si estende una fitta foresta di alghe ondeggianti. Questo è il luogo preferito di Pesciolino Blu per giocare a nascondino con i suoi amici. Le alghe offrono riparo e cibo, ma nascondono anche segreti che aspettano solo di essere svelati. - -In questo mondo incantato, ogni giorno è un'opportunità per imparare qualcosa di nuovo e per vivere avventure indimenticabili. Preparatevi a immergervi in un racconto che vi farà sognare e vi insegnerà l'importanza dell'amicizia, del coraggio e della curiosità. - -Avventura nel Mare ------------------- - -# Avventura nel Mare - -## Incontro con diversi tipi di pesci - -Benvenuti, piccoli esploratori, nell'affascinante mondo sottomarino! In questa avventura, ci immergeremo nelle profondità del mare per incontrare alcuni dei suoi abitanti più straordinari. Prepariamoci a scoprire i segreti della vita marina e a fare amicizia con i pesci che popolano questi vasti oceani. - -### Incontro con il pesce pagliaccio - -Il nostro primo incontro è con il simpatico pesce pagliaccio, noto per i suoi vivaci colori arancioni e bianchi. Questo piccolo pesce vive tra i tentacoli delle anemoni di mare, che lo proteggono dai predatori. Ma come fa a non essere punto dalle anemoni? Ecco il segreto: il pesce pagliaccio ha una speciale mucosa sulla pelle che lo rende immune al veleno delle anemoni. In cambio di questa protezione, il pesce pagliaccio aiuta a mantenere pulite le anemoni, creando un perfetto esempio di simbiosi! - -### Scoperta del pesce palla - -Proseguendo la nostra avventura, ci imbattiamo nel curioso pesce palla. Questo pesce ha un aspetto piuttosto normale, ma quando si sente minacciato, si gonfia come un palloncino! Questo trucco non solo lo rende più grande e difficile da ingoiare per i predatori, ma le sue spine appuntite diventano un'arma di difesa formidabile. Inoltre, il pesce palla è noto per contenere una tossina molto potente, quindi è meglio osservarlo da lontano e con rispetto. - -## Lezioni sulla vita marina - -Durante il nostro viaggio, impariamo che ogni pesce ha un ruolo importante nell'ecosistema marino. I pesci non solo contribuiscono alla catena alimentare, ma aiutano anche a mantenere l'equilibrio dell'ambiente in cui vivono. Ad esempio, i pesci pulitori rimuovono i parassiti dai pesci più grandi, mentre i pesci erbivori aiutano a controllare la crescita delle alghe sui coralli. - -Ricordiamoci che il mare è un luogo di meraviglia e mistero, ma anche di fragilità. È importante proteggere questi habitat e rispettare le creature che li abitano. Ogni piccolo gesto, come ridurre l'uso della plastica o sostenere la pesca sostenibile, può fare una grande differenza per il nostro pianeta blu. - -E così, cari amici, la nostra avventura nel mare giunge al termine. Speriamo che abbiate imparato qualcosa di nuovo e che siate pronti a esplorare ancora di più il meraviglioso mondo dei pesci! - -Lezione di Vita ---------------- - -Title: Lezione di Vita - ---- - -**Importanza della Collaborazione** - -Nella storia "La Storia dei Pesci per Bambini", i piccoli lettori imparano quanto sia fondamentale la collaborazione tra i pesci per superare le sfide dell'oceano. I pesci, sebbene diversi per dimensioni e colori, scoprono che lavorando insieme possono proteggersi dai predatori e trovare cibo più facilmente. Ad esempio, quando un gruppo di pesciolini si unisce per formare un grande banco, riescono a confondere i predatori e a nuotare in sicurezza. Questa lezione insegna ai bambini che, proprio come i pesci, anche loro possono ottenere risultati migliori quando collaborano con gli altri, sia a scuola che nei giochi. - ---- - -**Rispetto per l'Ambiente Marino** - -Un altro aspetto cruciale della storia è il rispetto per l'ambiente marino. I pesci protagonisti mostrano ai piccoli lettori l'importanza di mantenere pulito il loro habitat. Quando un pesce curioso si avvicina a un pezzo di plastica galleggiante, gli altri lo avvertono del pericolo e insieme decidono di spostarlo lontano dal loro rifugio. Questo episodio insegna ai bambini che l'inquinamento può essere dannoso per gli animali marini e che ognuno di noi ha la responsabilità di proteggere il mare. Attraverso semplici azioni quotidiane, come non gettare rifiuti in acqua, possiamo contribuire a preservare la bellezza e la salute degli oceani. - ---- - -Queste lezioni, presentate in modo semplice e coinvolgente, aiutano i bambini a comprendere valori importanti come la collaborazione e il rispetto per l'ambiente, stimolando in loro una maggiore consapevolezza e responsabilità verso il mondo che li circonda. - -Conclusione ------------ - -# Conclusione - -## Riflessione sull'avventura - -La storia dei pesci per bambini ci ha portato in un mondo sottomarino ricco di colori e avventure. Abbiamo seguito i nostri piccoli amici acquatici mentre esploravano le profondità dell'oceano, affrontando sfide e scoprendo meraviglie nascoste. Attraverso le loro avventure, abbiamo imparato quanto sia importante la curiosità e il coraggio di esplorare l'ignoto. Ogni incontro con creature marine diverse ha insegnato ai nostri protagonisti, e a noi lettori, lezioni preziose sulla diversità e sull'importanza di rispettare l'ambiente che ci circonda. - -## Messaggio finale di amicizia - -Alla fine del loro viaggio, i pesci hanno scoperto che la vera forza risiede nell'amicizia e nella collaborazione. Insieme, sono riusciti a superare ostacoli che sembravano insormontabili e a trovare soluzioni creative ai problemi che incontravano. Questa storia ci ricorda che, proprio come i pesci, anche noi possiamo contare sugli amici nei momenti di bisogno. L'amicizia è un legame speciale che ci arricchisce e ci sostiene, rendendo ogni avventura più dolce e ogni sfida più affrontabile. - -In conclusione, "La Storia dei Pesci per Bambini" non è solo un racconto di avventure sottomarine, ma anche una celebrazione dell'amicizia e della scoperta. Speriamo che questa storia abbia ispirato i giovani lettori a esplorare il mondo con occhi curiosi e a coltivare legami di amicizia che durano nel tempo. - -CONCLUSION ----------- - -Titel: La Storia dei Pesci per Bambini - -Schlussfolgerung: - -In der Geschichte "La Storia dei Pesci per Bambini" haben wir die faszinierende Welt der Meeresbewohner erkundet. Die Erzählung führte uns durch die farbenfrohe und vielfältige Unterwasserwelt, in der wir die Bedeutung der Meeresumwelt und die Notwendigkeit ihres Schutzes kennengelernt haben. Durch die Abenteuer der Fischfreunde wurde die Wichtigkeit von Freundschaft und Zusammenarbeit hervorgehoben, um Herausforderungen zu meistern und die Umwelt zu bewahren. - -Die Geschichte vermittelte jungen Lesern auf unterhaltsame Weise Wissen über die Meeresökologie und die Rolle, die jeder Einzelne beim Schutz unserer Ozeane spielen kann. Sie ermutigte dazu, respektvoll mit der Natur umzugehen und die Schönheit und Vielfalt der Meereswelt zu schätzen. - -Abschließend wird den Lesern empfohlen, sich weiterhin über die Meeresumwelt zu informieren und aktiv an deren Schutz teilzunehmen. Kleine Schritte, wie das Reduzieren von Plastikmüll und das Unterstützen von Umweltprojekten, können einen großen Unterschied machen. - -Diese Geschichte hinterlässt einen bleibenden Eindruck von der Bedeutung der Meeresbewohner und der Verantwortung, die wir alle tragen, um ihre Welt zu bewahren. Sie inspiriert junge Leser, sich für die Umwelt einzusetzen und die Freundschaften zu pflegen, die sie auf ihrem Weg begleiten. diff --git a/static/59_bean_recipe.txt b/static/59_bean_recipe.txt deleted file mode 100644 index 1df8263e..00000000 --- a/static/59_bean_recipe.txt +++ /dev/null @@ -1,213 +0,0 @@ -How to Cook Beans: A Step-by-Step Recipe -======================================== - -Einführung in den Leitfaden "Wie man Bohnen kocht: Ein Schritt-für-Schritt-Rezept" - -Willkommen zu unserem umfassenden Leitfaden "Wie man Bohnen kocht: Ein Schritt-für-Schritt-Rezept". Dieser Leitfaden wurde entwickelt, um Ihnen die Kunst des Bohnenkochens näherzubringen und Ihnen zu helfen, köstliche und nahrhafte Gerichte mit Leichtigkeit zuzubereiten. Bohnen sind nicht nur eine hervorragende Proteinquelle, sondern auch vielseitig einsetzbar und in vielen Küchen der Welt ein Grundnahrungsmittel. - -In diesem Dokument finden Sie eine klare und präzise Anleitung, die Sie durch jeden Schritt des Kochprozesses führt. Wir beginnen mit der Vorbereitung der Zutaten, gefolgt von detaillierten Kochanweisungen, um sicherzustellen, dass Ihre Bohnen jedes Mal perfekt gelingen. Egal, ob Sie ein erfahrener Koch oder ein Anfänger in der Küche sind, dieser Leitfaden bietet Ihnen das notwendige Wissen und die Techniken, um Bohnen in Ihre täglichen Mahlzeiten zu integrieren. - -Unser Ziel ist es, Ihnen nicht nur die Grundlagen des Bohnenkochens zu vermitteln, sondern auch Ihre kulinarischen Fähigkeiten zu erweitern und Ihnen neue Möglichkeiten aufzuzeigen, wie Sie Bohnen in Ihren Rezepten verwenden können. Von der Auswahl der richtigen Bohnensorte bis hin zur optimalen Kochzeit – dieser Leitfaden deckt alle wichtigen Aspekte ab. - -Wir laden Sie ein, sich auf diese kulinarische Reise zu begeben und die Vielseitigkeit und den Geschmack von Bohnen zu entdecken. Lassen Sie uns gemeinsam die Geheimnisse des Bohnenkochens erkunden und Ihre Küche mit neuen, aufregenden Aromen bereichern. - -Introduction ------------- - -``` -Title: Introduction - -In der Kunst des Kochens sind Bohnen ein vielseitiges und nahrhaftes Grundnahrungsmittel, das in Küchen weltweit geschätzt wird. Diese Anleitung "How to Cook Beans: A Step-by-Step Recipe" bietet Ihnen eine umfassende Einführung in die Zubereitung von Bohnen, die sowohl für Anfänger als auch für erfahrene Köche geeignet ist. Unser Ziel ist es, Ihnen die notwendigen Kenntnisse und Techniken zu vermitteln, um köstliche Bohnengerichte zu kreieren, die sowohl gesund als auch geschmackvoll sind. - -Überblick über das Rezept -------------------------- -Diese Anleitung führt Sie Schritt für Schritt durch den Prozess der Zubereitung von Bohnen, von der Auswahl der richtigen Bohnensorte bis hin zur optimalen Kochzeit. Wir werden die grundlegenden Methoden des Einweichens und Kochens abdecken und Ihnen Tipps geben, wie Sie den Geschmack Ihrer Bohnen durch Gewürze und Kräuter verfeinern können. Darüber hinaus bieten wir Ihnen Variationen und Anpassungen, um Ihre Bohnen nach Ihrem persönlichen Geschmack und den Bedürfnissen Ihrer Familie zuzubereiten. - -Kurze Geschichte der Bohnen in der Küche ----------------------------------------- -Bohnen haben eine lange und reiche Geschichte in der menschlichen Ernährung. Sie gehören zu den ältesten kultivierten Pflanzen und wurden bereits vor Tausenden von Jahren in verschiedenen Kulturen weltweit angebaut. In der Antike waren Bohnen ein Grundnahrungsmittel in der Ernährung der Griechen und Römer. In der Neuen Welt wurden sie von indigenen Völkern angebaut und spielten eine zentrale Rolle in der Ernährung der Azteken und Mayas. - -Mit der Entdeckung Amerikas verbreiteten sich Bohnen schnell in Europa und Asien, wo sie sich in vielen traditionellen Gerichten etablierten. Heute sind Bohnen ein wesentlicher Bestandteil zahlreicher Küchen, von der italienischen Minestrone bis zum mexikanischen Chili. Ihre Vielseitigkeit und ihr hoher Nährwert machen sie zu einer beliebten Wahl für gesundheitsbewusste Köche und Genießer gleichermaßen. - -Diese Einführung soll Ihnen nicht nur die Grundlagen der Bohnenzubereitung vermitteln, sondern auch ein tieferes Verständnis für die kulturelle Bedeutung und die kulinarische Vielfalt dieses bemerkenswerten Lebensmittels bieten. Lassen Sie uns gemeinsam die Welt der Bohnen entdecken und lernen, wie man sie mit Leichtigkeit und Freude zubereitet. -``` - -Ingredients ------------ - -Title: Zutaten - -In diesem Abschnitt finden Sie eine detaillierte Liste der benötigten Zutaten, um Bohnen auf schmackhafte Weise zuzubereiten. Wir bieten auch optionale Zutaten an, die Sie verwenden können, um dem Gericht eine persönliche Note zu verleihen oder es zu variieren. - -**Erforderliche Zutaten:** - -1. **Bohnen** - - Menge: 500 g getrocknete Bohnen (z. B. schwarze Bohnen, Kidneybohnen oder weiße Bohnen) - - Hinweis: Achten Sie darauf, die Bohnen über Nacht in Wasser einzuweichen, um die Kochzeit zu verkürzen und die Verdaulichkeit zu verbessern. - -2. **Wasser** - - Menge: Ausreichend, um die Bohnen vollständig zu bedecken und während des Kochens nach Bedarf aufzufüllen. - -3. **Salz** - - Menge: 1 Teelöffel - - Hinweis: Salz sollte erst gegen Ende des Kochvorgangs hinzugefügt werden, um zu verhindern, dass die Bohnen hart werden. - -4. **Zwiebel** - - Menge: 1 mittelgroße Zwiebel, fein gehackt - -5. **Knoblauch** - - Menge: 2-3 Zehen, fein gehackt - -6. **Olivenöl** - - Menge: 2 Esslöffel - -**Optionale Zutaten für Variation:** - -1. **Lorbeerblatt** - - Menge: 1-2 Blätter - - Hinweis: Verleiht den Bohnen ein aromatisches, leicht würziges Aroma. - -2. **Gemüsebrühe** - - Menge: 500 ml - - Hinweis: Kann anstelle von Wasser verwendet werden, um den Bohnen zusätzlichen Geschmack zu verleihen. - -3. **Tomaten** - - Menge: 1 Dose (ca. 400 g) gehackte Tomaten oder 2 frische Tomaten, gewürfelt - - Hinweis: Für eine fruchtige Note und zusätzliche Säure. - -4. **Paprika** - - Menge: 1 rote oder grüne Paprika, gewürfelt - - Hinweis: Fügt Farbe und Süße hinzu. - -5. **Kreuzkümmel** - - Menge: 1 Teelöffel - - Hinweis: Für einen erdigen, leicht scharfen Geschmack. - -6. **Chiliflocken oder frische Chilischoten** - - Menge: Nach Geschmack - - Hinweis: Für diejenigen, die es gerne scharf mögen. - -Diese Zutatenliste bietet eine solide Grundlage für die Zubereitung von Bohnen. Die optionalen Zutaten ermöglichen es Ihnen, das Gericht nach Ihrem Geschmack zu variieren und zu verfeinern. Achten Sie darauf, die Mengen entsprechend der Anzahl der Personen, die Sie bedienen möchten, anzupassen. - -Preparation Steps ------------------ - -Title: Preparation Steps - ---- - -**Soaking the Beans** - -1. **Auswahl der Bohnen:** Beginnen Sie mit der Auswahl der gewünschten Bohnensorte. Beliebte Optionen sind schwarze Bohnen, Kidneybohnen oder weiße Bohnen. Achten Sie darauf, dass die Bohnen frisch und von guter Qualität sind. - -2. **Reinigung:** Spülen Sie die Bohnen gründlich unter fließendem Wasser ab, um Schmutz und Verunreinigungen zu entfernen. Entfernen Sie beschädigte oder verfärbte Bohnen. - -3. **Einweichen:** - - **Über Nacht Einweichen:** Legen Sie die Bohnen in eine große Schüssel und bedecken Sie sie mit reichlich Wasser. Lassen Sie sie über Nacht (mindestens 8 Stunden) einweichen. Dies hilft, die Kochzeit zu verkürzen und die Verdaulichkeit zu verbessern. - - **Schnell-Einweichmethode:** Wenn Sie wenig Zeit haben, bringen Sie die Bohnen in einem Topf mit Wasser zum Kochen. Lassen Sie sie 2 Minuten kochen, nehmen Sie den Topf vom Herd und lassen Sie die Bohnen 1 Stunde einweichen. - -4. **Abgießen und Spülen:** Nach dem Einweichen die Bohnen abgießen und erneut unter fließendem Wasser abspülen. Dies entfernt überschüssige Stärke und reduziert Blähungen. - -**Tipps für beste Ergebnisse:** Verwenden Sie für das Einweichen immer frisches Wasser und vermeiden Sie die Zugabe von Salz, da dies die Bohnen zäh machen kann. - ---- - -**Cooking the Beans** - -1. **Vorbereitung:** Geben Sie die eingeweichten und gespülten Bohnen in einen großen Topf. Fügen Sie frisches Wasser hinzu, sodass die Bohnen etwa 5 cm bedeckt sind. - -2. **Kochen:** - - **Aufkochen:** Bringen Sie das Wasser zum Kochen. Reduzieren Sie dann die Hitze auf ein sanftes Köcheln. - - **Kochzeit:** Die Kochzeit variiert je nach Bohnensorte und Einweichmethode. Im Allgemeinen benötigen Bohnen 1 bis 2 Stunden, um weich zu werden. Testen Sie die Konsistenz, indem Sie eine Bohne zwischen den Fingern zerdrücken. - -3. **Schaum entfernen:** Während des Kochens kann sich Schaum an der Oberfläche bilden. Entfernen Sie diesen mit einem Löffel, um eine klare Brühe zu erhalten. - -4. **Überwachung:** Rühren Sie gelegentlich um und fügen Sie bei Bedarf mehr Wasser hinzu, um ein Anbrennen zu verhindern. - -**Tipps für beste Ergebnisse:** Fügen Sie während des Kochens keine sauren Zutaten wie Tomaten oder Essig hinzu, da dies die Kochzeit verlängern kann. - ---- - -**Seasoning and Serving** - -1. **Würzen:** Sobald die Bohnen weich sind, können Sie sie nach Geschmack würzen. Beliebte Gewürze sind Salz, Pfeffer, Knoblauch, Lorbeerblätter und Zwiebeln. Fügen Sie diese Zutaten gegen Ende der Kochzeit hinzu, um den Geschmack zu bewahren. - -2. **Servieren:** - - **Als Beilage:** Servieren Sie die Bohnen als Beilage zu Fleischgerichten oder Reis. - - **In Eintöpfen:** Verwenden Sie die Bohnen als Basis für Eintöpfe oder Suppen. - - **Salate:** Lassen Sie die Bohnen abkühlen und fügen Sie sie zu Salaten hinzu. - -3. **Lagerung:** Bewahren Sie übrig gebliebene Bohnen in einem luftdichten Behälter im Kühlschrank auf. Sie halten sich bis zu 5 Tage. - -**Tipps für beste Ergebnisse:** Experimentieren Sie mit verschiedenen Kräutern und Gewürzen, um den Geschmack der Bohnen zu variieren und anzupassen. - -Tips and Variations -------------------- - -Title: Tipps und Variationen - -In diesem Abschnitt bieten wir Ihnen nützliche Tipps und verschiedene Variationen, um das Beste aus Ihrem Bohnenrezept herauszuholen. Egal, ob Sie nach alternativen Kochmethoden suchen oder den Geschmack Ihrer Bohnen anpassen möchten, hier finden Sie wertvolle Anregungen. - -## Alternative Kochmethoden - -1. **Druckkochtopf**: - - **Vorteile**: Verkürzt die Kochzeit erheblich und spart Energie. - - **Anwendung**: Geben Sie die eingeweichten Bohnen mit ausreichend Wasser in den Druckkochtopf. Kochen Sie sie bei hohem Druck für etwa 20-25 Minuten. Lassen Sie den Druck natürlich abfallen, bevor Sie den Topf öffnen. - -2. **Slow Cooker**: - - **Vorteile**: Ideal für eine langsame, gleichmäßige Garung, die die Aromen intensiviert. - - **Anwendung**: Geben Sie die eingeweichten Bohnen mit Wasser und Gewürzen in den Slow Cooker. Kochen Sie sie auf niedriger Stufe für 6-8 Stunden oder auf hoher Stufe für 3-4 Stunden. - -3. **Backofen**: - - **Vorteile**: Bietet eine gleichmäßige Hitzeverteilung und kann zu einer leicht gerösteten Textur führen. - - **Anwendung**: Legen Sie die Bohnen in einen ofenfesten Topf, fügen Sie Wasser und Gewürze hinzu und decken Sie ihn ab. Backen Sie bei 160°C für etwa 1,5 bis 2 Stunden. - -## Geschmacksvariationen - -1. **Kräuter und Gewürze**: - - **Optionen**: Thymian, Rosmarin, Lorbeerblätter, Kreuzkümmel oder Paprika. - - **Tipp**: Fügen Sie die Gewürze während des Kochens hinzu, um den Bohnen einen intensiven Geschmack zu verleihen. - -2. **Aromatische Zutaten**: - - **Optionen**: Zwiebeln, Knoblauch, Sellerie oder Karotten. - - **Tipp**: Braten Sie diese Zutaten leicht an, bevor Sie die Bohnen hinzufügen, um eine tiefere Geschmacksbasis zu schaffen. - -3. **Rauchige Note**: - - **Optionen**: Geräucherter Speck, Schinken oder geräucherte Paprika. - - **Tipp**: Fügen Sie diese Zutaten zu Beginn des Kochvorgangs hinzu, um den Bohnen eine rauchige Tiefe zu verleihen. - -4. **Säuerliche Akzente**: - - **Optionen**: Ein Spritzer Zitronensaft oder ein Schuss Essig. - - **Tipp**: Fügen Sie diese am Ende des Kochvorgangs hinzu, um die Aromen aufzufrischen und die Bohnen aufzuhellen. - -Mit diesen Tipps und Variationen können Sie Ihr Bohnenrezept nach Belieben anpassen und jedes Mal ein einzigartiges Gericht kreieren. Experimentieren Sie mit verschiedenen Kombinationen, um Ihren persönlichen Favoriten zu finden! - -Conclusion ----------- - -# Conclusion - -In diesem Abschnitt fassen wir die wesentlichen Schritte zusammen, die Sie beim Kochen von Bohnen beachten sollten, und ermutigen Sie, dieses einfache und nahrhafte Rezept selbst auszuprobieren. - -## Zusammenfassung des Rezepts - -Das Kochen von Bohnen ist eine lohnende und unkomplizierte Aufgabe, die mit ein wenig Vorbereitung und Geduld zu einem köstlichen Ergebnis führt. Der Prozess beginnt mit dem sorgfältigen Auslesen und Waschen der Bohnen, gefolgt von einem Einweichvorgang, der die Bohnen weicher macht und die Kochzeit verkürzt. Anschließend werden die Bohnen in frischem Wasser gekocht, wobei Gewürze und Aromastoffe nach Belieben hinzugefügt werden können, um den Geschmack zu verfeinern. Die Kochzeit variiert je nach Bohnensorte, liegt jedoch in der Regel zwischen 45 Minuten und zwei Stunden. Das Endergebnis sind zarte, schmackhafte Bohnen, die als Beilage oder Hauptgericht serviert werden können. - -## Ermutigung zum Ausprobieren des Rezepts - -Wir hoffen, dass diese Anleitung Ihnen das Vertrauen gibt, Bohnen selbst zu kochen. Die Vielseitigkeit von Bohnen macht sie zu einer hervorragenden Ergänzung für zahlreiche Gerichte, von Eintöpfen und Suppen bis hin zu Salaten und Beilagen. Probieren Sie verschiedene Gewürzkombinationen aus, um Ihren persönlichen Geschmack zu treffen, und scheuen Sie sich nicht, mit verschiedenen Bohnensorten zu experimentieren. Mit dieser Schritt-für-Schritt-Anleitung sind Sie bestens gerüstet, um ein einfaches, gesundes und köstliches Gericht zuzubereiten, das Ihre Mahlzeiten bereichern wird. Viel Spaß beim Kochen und guten Appetit! - -CONCLUSION ----------- - -Abschluss: "Wie man Bohnen kocht: Ein Schritt-für-Schritt-Rezept" - -In diesem Leitfaden haben wir die wesentlichen Schritte zur Zubereitung von Bohnen detailliert beschrieben, um Ihnen ein einfaches und effektives Kocherlebnis zu bieten. Wir haben die Bedeutung der richtigen Vorbereitung der Zutaten hervorgehoben, einschließlich des Einweichens und der Auswahl der passenden Gewürze, um den Geschmack zu maximieren. - -Zusammenfassend lässt sich sagen, dass das Kochen von Bohnen nicht nur eine nahrhafte, sondern auch eine vielseitige Ergänzung zu jeder Mahlzeit darstellt. Die Schritt-für-Schritt-Anleitung in diesem Dokument soll Ihnen helfen, die Bohnen perfekt zuzubereiten, unabhängig von Ihrer Kocherfahrung. - -Wir empfehlen, mit verschiedenen Gewürzen und Kräutern zu experimentieren, um Ihre persönlichen Vorlieben zu entdecken und die Bohnen in verschiedenen Gerichten zu integrieren. Ob als Beilage, in Salaten oder als Hauptgericht – die Möglichkeiten sind vielfältig. - -Mit diesem Wissen ausgestattet, können Sie nun selbstbewusst Bohnen kochen und genießen, und dabei die gesundheitlichen Vorteile dieser proteinreichen Hülsenfrucht voll ausschöpfen. Wir hoffen, dass dieser Leitfaden Ihnen nicht nur praktische Fähigkeiten vermittelt hat, sondern auch Ihre Freude am Kochen bereichert. - -Vielen Dank, dass Sie diesen Leitfaden genutzt haben. Wir wünschen Ihnen viel Erfolg und Genuss beim Kochen Ihrer nächsten Bohnenmahlzeit! diff --git a/static/5_sales_trends_analysis.txt b/static/5_sales_trends_analysis.txt new file mode 100644 index 00000000..01d7c740 --- /dev/null +++ b/static/5_sales_trends_analysis.txt @@ -0,0 +1,75 @@ +``` +Filename: sales_trends_analysis.txt + +Sales Trends Analysis Report +============================ + +**Introduction** +---------------- +This report provides a detailed analysis of the sales data for Q1 2023, focusing on identifying key trends and opportunities. The analysis covers monthly revenue trends, growth figures, regional sales breakdown, and top product revenue percentages. Visualizations have been recommended to support the insights derived from the data. + +**1. Monthly Revenue Trends for Q1 2023** +----------------------------------------- +The sales data for Q1 2023 indicates a consistent upward trend in monthly revenue: + +- **January**: $1,500,000 +- **February**: $1,650,000 +- **March**: $1,800,000 + +The revenue growth rates for each month are as follows: + +- **January**: 5.2% +- **February**: 10.0% +- **March**: 9.1% + +**Insight**: The data shows a steady increase in revenue from January to March, with February experiencing the highest growth rate. This suggests a positive momentum in sales performance during the first quarter. + +**Recommended Visualization**: A line chart depicting monthly revenue growth will effectively illustrate this trend. + +**2. Regional Sales Breakdown** +------------------------------- +The regional sales distribution for Q1 2023 is as follows: + +- **North**: 35% of total sales +- **South**: 25% of total sales +- **East**: 20% of total sales +- **West**: 20% of total sales + +**Insight**: The North region is the leading contributor to sales, accounting for the highest percentage of total sales. This indicates a strong market presence and potential for further growth in this region. + +**Recommended Visualization**: A pie chart showing the regional sales breakdown will provide a clear visual representation of the regional contributions. + +**3. Top Product Revenue Percentages** +-------------------------------------- +The revenue contribution by top products is as follows: + +- **Product A**: 40% of revenue +- **Product B**: 30% of revenue +- **Product C**: 20% of revenue +- **Others**: 10% of revenue + +**Insight**: Product A is the top revenue generator, contributing significantly to the overall sales. This highlights the importance of maintaining and potentially expanding the market for Product A. + +**Recommended Visualization**: A bar chart illustrating the revenue contribution of top products will highlight their impact on total sales. + +**Conclusions and Recommendations** +----------------------------------- +The analysis of Q1 2023 sales data reveals several key trends and opportunities: + +1. **Sustained Revenue Growth**: The consistent increase in monthly revenue suggests a robust sales strategy. Continued focus on maintaining this growth trajectory is recommended. + +2. **Regional Focus**: With the North region leading in sales, targeted marketing and sales initiatives in this area could further enhance revenue. + +3. **Product Strategy**: Given the significant contribution of Product A to total revenue, strategies to boost its sales, such as promotions or new features, should be considered. + +4. **Diversification**: While Product A is a major revenue driver, exploring opportunities to increase the market share of other products could reduce dependency on a single product. + +By leveraging these insights and implementing the recommended strategies, the company can capitalize on existing strengths and explore new growth avenues. + +**Appendix** +------------ +- **Data Source**: q1_sales_data.md +- **Visualizations**: Line chart, pie chart, and bar chart as recommended above. + +End of Report +``` diff --git a/static/60_triage_definition.txt b/static/60_triage_definition.txt deleted file mode 100644 index edaca4f0..00000000 --- a/static/60_triage_definition.txt +++ /dev/null @@ -1,37 +0,0 @@ -Filename: triage_definition.txt - ---- - -**Triage: Definition and Contextual Applications** - -**Executive Summary:** - -This report provides a comprehensive analysis of the term 'triage,' exploring its definition in both medical and non-medical contexts, as well as its etymological origins. Triage is primarily associated with the medical field, where it plays a critical role in prioritizing patient care based on the severity of their conditions. The concept has also been adapted for use in various non-medical settings, emphasizing the prioritization of tasks and resources. The term 'triage' has its roots in the French language, reflecting its historical development and application. - -**1. Definition of 'Triage' in a Medical Context:** - -In the medical field, 'triage' refers to the process of determining the priority of patients' treatments based on the severity of their condition. This system is crucial in emergency situations, such as in hospitals' emergency departments or during mass casualty incidents, where resources are limited and immediate decisions are necessary to maximize the number of survivors. The primary goal of medical triage is to ensure that those who need urgent care receive it promptly, while those with less critical conditions are attended to as resources allow. - -**2. Use of 'Triage' in Non-Medical Contexts:** - -Beyond its medical application, the concept of triage has been adopted in various non-medical fields, including business, information technology, and disaster management. In these contexts, triage involves prioritizing tasks, projects, or issues to efficiently allocate resources and address the most critical needs first. For example, in IT, triage may refer to the process of sorting and addressing technical support requests based on urgency and impact. Similarly, in business, triage can help prioritize strategic initiatives to optimize organizational performance. - -**3. Origins of the Term 'Triage':** - -The term 'triage' originates from the French word 'trier,' which means 'to sort' or 'to select.' Historically, the concept of triage was developed during wartime to manage battlefield injuries, where medical personnel had to make quick decisions about which soldiers required immediate attention. Over time, the principles of triage have been refined and formalized, becoming an integral part of modern emergency medicine and crisis management. - -**Conclusion:** - -The term 'triage' embodies a critical decision-making process that is essential in both medical and non-medical settings. Its origins in the French language highlight its historical significance and evolution. Understanding the principles of triage allows for effective prioritization and resource allocation, ensuring that critical needs are addressed efficiently in various contexts. - -**References:** - -- [Source 1: Medical Dictionary or Encyclopedia] -- [Source 2: Business or IT Journal] -- [Source 3: Historical Text on Medical Practices] - -(Note: The above references are placeholders and should be replaced with actual sources used in the research.) - ---- - -This report is intended to provide a scholarly and comprehensive understanding of the term 'triage,' integrating information from various sources to address the research questions effectively. \ No newline at end of file diff --git a/static/61_goal_definition.txt b/static/61_goal_definition.txt deleted file mode 100644 index 2642fd85..00000000 --- a/static/61_goal_definition.txt +++ /dev/null @@ -1,37 +0,0 @@ -# Goal Definition in German: A Comprehensive Research Report - -## Executive Summary - -This report explores the definition, etymology, and contextual usage of the term "goal" in the German language. The German equivalent of "goal" is "Ziel." This term is widely used in various contexts, including personal objectives, sports, and business targets. The etymology of "Ziel" traces back to Middle High German and Old High German, reflecting its longstanding presence in the German lexicon. This report synthesizes information from reputable language and etymology sources to provide a comprehensive understanding of the term. - -## Research Questions and Findings - -### 1. What is the definition of 'goal' in German? - -The German word for "goal" is "Ziel." In general terms, "Ziel" refers to an objective or an endpoint that one aims to achieve. It is used to denote both tangible and intangible targets, ranging from personal ambitions to specific outcomes in various activities. - -### 2. What is the etymology of the German word for 'goal'? - -The word "Ziel" originates from Middle High German "ziel" and Old High German "zīl," which both mean a target or endpoint. The term has been part of the German language for centuries, signifying its deep-rooted significance in expressing objectives and endpoints. - -### 3. How is the term 'goal' used in different contexts in German? - -In German, "Ziel" is used in multiple contexts: - -- **Personal Development**: In personal development, "Ziel" refers to individual aspirations or life goals, such as career objectives or personal growth targets. - -- **Sports**: In sports, "Ziel" is used to describe the endpoint of a race or the goal in games like soccer, where scoring a "Tor" (goal) is the objective. - -- **Business and Projects**: In business, "Ziel" denotes targets or objectives that organizations aim to achieve, such as sales goals or project milestones. - -## Synthesis of Research - -The term "Ziel" is integral to the German language, encapsulating the concept of goals across various domains. Its etymological roots highlight its historical significance, while its versatile usage demonstrates its relevance in contemporary settings. Whether in personal, athletic, or professional contexts, "Ziel" serves as a fundamental term for expressing aspirations and endpoints. - -## Sources - -1. [Duden Online Dictionary](https://www.duden.de) - Provides definitions and usage examples of German words. -2. [Etymologisches Wörterbuch des Deutschen](https://www.dwds.de) - Offers insights into the etymology of German terms. -3. [Langenscheidt German-English Dictionary](https://www.langenscheidt.com) - A reputable source for translations and definitions. - -This report aims to deliver a scholarly and accurate understanding of the term "goal" in German, focusing on its definition, historical roots, and contextual applications. \ No newline at end of file diff --git a/static/62_handling_definition.txt b/static/62_handling_definition.txt deleted file mode 100644 index beb50f04..00000000 --- a/static/62_handling_definition.txt +++ /dev/null @@ -1,44 +0,0 @@ -Filename: handling_definition.txt - ---- - -**Handling Definition in German: A Comprehensive Research Report** - -**Executive Summary:** - -This report explores the definition and contextual usage of the term "handling" in the German language. The research aims to provide a clear understanding of how "handling" is defined and applied across various contexts in German-speaking regions. Despite the absence of specific sources, this report synthesizes general knowledge and linguistic insights to address the research questions effectively. - -**Research Questions:** - -1. What is the definition of 'handling' in German? -2. What are the different contexts in which 'handling' is used in German? - -**1. Definition of 'Handling' in German:** - -In German, the term "handling" is often borrowed directly from English, especially in technical, business, and logistics contexts. It refers to the process of managing, controlling, or dealing with goods, tasks, or situations. The term is used similarly to its English counterpart, emphasizing the practical aspects of managing or operating something. - -**2. Contextual Usage of 'Handling' in German:** - -The usage of "handling" in German can be categorized into several key contexts: - -- **Logistics and Supply Chain:** In logistics, "handling" refers to the physical management of goods, including loading, unloading, and moving items within a warehouse or during transportation. It is a critical component of supply chain operations, ensuring efficiency and safety in the movement of products. - -- **Business and Management:** Within business contexts, "handling" can describe the management of tasks, projects, or customer interactions. It implies a level of skill and efficiency in dealing with various business processes or client relations. - -- **Technical and Mechanical:** In technical fields, "handling" might refer to the operation or control of machinery and equipment. This includes the ability to manage tools or devices effectively to perform specific tasks. - -- **Everyday Usage:** In everyday language, "handling" can be used more broadly to describe the way someone deals with a situation or problem. It suggests a practical approach to resolving issues or managing circumstances. - -**Synthesis and Conclusion:** - -The term "handling" in German retains much of its English meaning, particularly in professional and technical contexts. Its usage spans logistics, business, and technical fields, highlighting the importance of effective management and control. While the term is borrowed from English, it has been integrated into German vocabulary, reflecting the global nature of business and technology. - -This report underscores the versatility of "handling" in German, illustrating its application across various domains. Understanding these contexts is crucial for professionals working in German-speaking environments, as it aids in effective communication and operational efficiency. - -**References:** - -Due to the absence of specific sources, this report is based on general linguistic knowledge and the contextual understanding of the term "handling" in German-speaking regions. Future research could benefit from direct citations from German dictionaries or industry-specific publications to enhance the depth and accuracy of the findings. - ---- - -This report is intended to provide a scholarly and comprehensive overview of the term "handling" in German, suitable for academic and professional purposes. \ No newline at end of file diff --git a/static/63_triangle_definition.txt b/static/63_triangle_definition.txt deleted file mode 100644 index 5668ecd0..00000000 --- a/static/63_triangle_definition.txt +++ /dev/null @@ -1,45 +0,0 @@ -**Triangle Definition Research Report** - -**Filename:** triangle_definition.txt - -**Description:** This report provides a comprehensive and concise definition of the term 'triangle' in the context of geometry, addressing key characteristics and integrating information from relevant sources. - ---- - -**Executive Summary:** - -This report explores the geometric definition of a triangle, focusing on its fundamental characteristics. A triangle is a three-sided polygon, a basic shape in geometry, characterized by its three edges and three vertices. The report synthesizes information from various authoritative sources to present a clear and concise understanding of triangles, highlighting their properties and significance in geometry. - ---- - -**Research Questions and Findings:** - -1. **What is the definition of a triangle in geometry?** - - A triangle is defined as a polygon with three edges and three vertices. It is one of the simplest forms of polygons and is a fundamental shape in the study of geometry. The sum of the internal angles of a triangle is always 180 degrees. This definition is consistent across various educational and mathematical resources, emphasizing the triangle's role as a basic building block in geometric studies. - -2. **What are the key characteristics of a triangle?** - - Key characteristics of a triangle include: - - **Three Sides and Three Angles:** A triangle has three sides, which can be of equal or varying lengths, and three angles, which can also vary in measure. - - **Types of Triangles:** Triangles can be classified based on side length (equilateral, isosceles, scalene) or angle measure (acute, right, obtuse). - - **Angle Sum Property:** The sum of the internal angles of a triangle is always 180 degrees, a fundamental property that applies to all triangles. - - **Congruence and Similarity:** Triangles can be congruent (identical in shape and size) or similar (same shape but different sizes) based on their angles and side proportions. - ---- - -**Synthesis of Research:** - -The triangle is a foundational concept in geometry, serving as a critical element in the study of shapes and spatial reasoning. Its simplicity and versatility make it a subject of extensive study in mathematics. Triangles are not only important in theoretical geometry but also have practical applications in fields such as engineering, architecture, and art. Understanding the properties of triangles allows for the exploration of more complex geometric concepts and theorems. - ---- - -**Sources:** - -1. "Triangle." *Encyclopedia Britannica*. Retrieved from [Encyclopedia Britannica](https://www.britannica.com/science/triangle-mathematics) -2. "Triangle Definition." *Math is Fun*. Retrieved from [Math is Fun](https://www.mathsisfun.com/triangle.html) -3. "Types of Triangles." *Khan Academy*. Retrieved from [Khan Academy](https://www.khanacademy.org/math/geometry/hs-geo-foundations/hs-geo-intro-to-triangles/a/types-of-triangles-review) - ---- - -This report has been formatted to provide a scholarly and accurate overview of the geometric concept of triangles, integrating information from multiple authoritative sources to ensure a comprehensive understanding. \ No newline at end of file diff --git a/static/64_translation_result.txt b/static/64_translation_result.txt deleted file mode 100644 index 8ed44825..00000000 --- a/static/64_translation_result.txt +++ /dev/null @@ -1,37 +0,0 @@ -**Translation and Meaning of the Word 'Horrible' from German to English** - ---- - -**Executive Summary:** - -This report investigates the translation and meaning of the word 'horrible' from German to English. The research focuses on providing an accurate translation and understanding of the term within the English language context. Despite the absence of specific sources, the report synthesizes general linguistic knowledge to address the research questions effectively. - ---- - -**Research Questions and Findings:** - -1. **What is the translation of the word 'horrible' from German to English?** - - The German word for 'horrible' is "schrecklich." This translation captures the essence of something that is extremely unpleasant or distressing. The term "schrecklich" is commonly used in German to describe situations, events, or characteristics that evoke fear, disgust, or severe discomfort. - -2. **What is the meaning of the word 'horrible' in English?** - - In English, the word 'horrible' is an adjective used to describe something that causes horror, is extremely unpleasant, or is very bad. It can refer to experiences, sights, sounds, or even behaviors that provoke a strong negative emotional response. The term is often used to emphasize the severity or intensity of the unpleasantness. - ---- - -**Synthesis of Research:** - -The translation of 'horrible' from German to English as "schrecklich" aligns with the general understanding of the word in both languages. In both contexts, the term is used to describe situations or entities that are profoundly negative or distressing. This cross-linguistic consistency highlights the universal nature of the concept of horror and unpleasantness. - -While the report lacks direct citations from specific sources due to the absence of listed findings, the translation and meaning provided are consistent with standard linguistic resources and dictionaries. This synthesis is based on widely accepted translations and definitions found in reputable language references. - ---- - -**Conclusion:** - -The translation of 'horrible' from German to English is "schrecklich," and its meaning in English pertains to something that is extremely unpleasant or causes horror. This report provides a clear understanding of the term across both languages, emphasizing its consistent use to describe negative experiences or characteristics. - ---- - -**Note:** This report is based on general linguistic knowledge and standard translations. For precise and detailed linguistic studies, consulting specialized dictionaries or language experts is recommended. \ No newline at end of file diff --git a/static/65_definition_greedy.txt b/static/65_definition_greedy.txt deleted file mode 100644 index 6290f407..00000000 --- a/static/65_definition_greedy.txt +++ /dev/null @@ -1,39 +0,0 @@ -# Definition of 'Greedy' in German: A Comprehensive Report - -## Executive Summary - -This report explores the definition, synonyms, and usage of the term 'greedy' in the German language. The term 'greedy' translates to "gierig" in German, and it is commonly used to describe an intense and selfish desire for something, particularly wealth or food. This report synthesizes information from various linguistic sources to provide a comprehensive understanding of the term's meaning, synonyms, and usage in sentences. - -## Research Questions and Findings - -### 1. What is the definition of 'greedy' in German? - -The term 'greedy' is translated into German as "gierig." It is defined as having an intense and selfish desire for something, especially wealth, power, or food. The word "gierig" is often used to describe individuals who are excessively desirous of acquiring more than they need or deserve. - -### 2. What are the synonyms of 'greedy' in German? - -Several synonyms for "gierig" exist in the German language, each with slightly different connotations: - -- **Habgierig**: This term emphasizes a strong desire for possessions or wealth. -- **Raffgierig**: Often used in a negative context, it highlights an insatiable greed for material gain. -- **Gefräßig**: While primarily used to describe someone who eats excessively, it can also imply greed in a broader sense. -- **Habsüchtig**: Similar to "habgierig," it denotes a covetous or acquisitive nature. - -### 3. How is the term 'greedy' used in German sentences? - -The term "gierig" can be used in various contexts within German sentences. Here are a few examples: - -- **Er ist gierig nach Macht.** (He is greedy for power.) -- **Die gierige Katze fraß alles auf.** (The greedy cat devoured everything.) -- **Sein gieriges Verhalten führte zu seinem Untergang.** (His greedy behavior led to his downfall.) -- **Sie ist habgierig und will immer mehr Geld.** (She is greedy and always wants more money.) - -## Integration of Information from Relevant Sources - -The information presented in this report is derived from reputable linguistic resources, including German dictionaries and language learning platforms. These sources provide definitions, synonyms, and contextual usage examples that are essential for understanding the nuances of the term "gierig." - -## Conclusion - -The term "gierig" in German encapsulates the concept of greed, characterized by an excessive desire for more than what is necessary or deserved. Its synonyms, such as "habgierig" and "raffgierig," further illustrate the various facets of greed, from material wealth to power. Understanding these terms and their usage in sentences provides valuable insight into the cultural and linguistic interpretation of greed in the German language. - -This report serves as a comprehensive guide to the term "greedy" in German, offering definitions, synonyms, and practical examples to enhance understanding and application in both linguistic and cultural contexts. \ No newline at end of file diff --git a/static/66_workflow_logs.json b/static/66_workflow_logs.json deleted file mode 100644 index 249ed61b..00000000 --- a/static/66_workflow_logs.json +++ /dev/null @@ -1,5822 +0,0 @@ -[ - { - "id": "log_3855654c-75b2-4aec-a645-a172be4d79d8", - "workflow_id": "7e010d67-0ebb-4829-986f-3db80cbc2110", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-21T23:39:58.191487", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_a259b33e-93ed-4cc8-928a-c3ea10b18db1", - "workflow_id": "7e010d67-0ebb-4829-986f-3db80cbc2110", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-21T23:39:58.200389", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_df2ddde0-219f-4622-81c6-85ec1f2fbaf2", - "workflow_id": "7e010d67-0ebb-4829-986f-3db80cbc2110", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-21T23:40:00.829640", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_1e32727f-e723-41bc-9c42-d6c90271181d", - "workflow_id": "7e010d67-0ebb-4829-986f-3db80cbc2110", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-21T23:40:06.273116", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_d0e53ea5-56f7-4bbf-be8e-d331d8664852", - "workflow_id": "7e010d67-0ebb-4829-986f-3db80cbc2110", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-21T23:40:06.276184", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_63c8c04c-e4bf-4ee5-a6a0-f8252679527f", - "workflow_id": "7e010d67-0ebb-4829-986f-3db80cbc2110", - "message": "Running task 1/1: coder", - "type": "info", - "timestamp": "2025-04-21T23:40:06.278183", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_0d360e65-4971-4b34-b391-44f6d2ba7382", - "workflow_id": "7e010d67-0ebb-4829-986f-3db80cbc2110", - "message": "Agent 'coder' to create pixel_and_character_count.txt.", - "type": "info", - "timestamp": "2025-04-21T23:40:06.282242", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_959f48d0-b5eb-4a9c-a7f0-2d48adb65894", - "workflow_id": "7e010d67-0ebb-4829-986f-3db80cbc2110", - "message": "Agent 'coder' completed task. Feedback: The task can be completed directly using the extracted data. The total number of pixels in the image and the total number of characters in the text document are already provided in the extracted data.", - "type": "info", - "timestamp": "2025-04-21T23:40:09.885293", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_70915c64-af80-4e51-9717-6db011054d24", - "workflow_id": "7e010d67-0ebb-4829-986f-3db80cbc2110", - "message": "Completed task 1/1: coder", - "type": "info", - "timestamp": "2025-04-21T23:40:10.451546", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_d58b5578-57eb-404b-9a53-c874e11c128f", - "workflow_id": "7e010d67-0ebb-4829-986f-3db80cbc2110", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-21T23:40:10.454554", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_4410da63-af63-47c5-b128-6a157f6910b3", - "workflow_id": "7e010d67-0ebb-4829-986f-3db80cbc2110", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-21T23:40:13.418303", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_00ed7590-6739-48c5-9cd8-8db15dedcef9", - "workflow_id": "7e010d67-0ebb-4829-986f-3db80cbc2110", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-21T23:40:13.421344", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_0adda566-a0c9-4f1f-b57c-b16b0da5945e", - "workflow_id": "9627b6db-a671-4c8e-af52-54e98fbcdd44", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-21T23:46:58.804678", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_75cf0a1d-98aa-43ea-9ed2-5da065e99c05", - "workflow_id": "9627b6db-a671-4c8e-af52-54e98fbcdd44", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-21T23:46:58.806643", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f3ad68f0-10a4-4586-8145-3c088d87e31f", - "workflow_id": "9627b6db-a671-4c8e-af52-54e98fbcdd44", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-21T23:47:01.411212", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_c7da55fe-475a-4a1d-96ef-364a13c527dd", - "workflow_id": "9627b6db-a671-4c8e-af52-54e98fbcdd44", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-21T23:47:09.336068", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_5169a835-8a6d-4bb1-ad12-2218290a496d", - "workflow_id": "9627b6db-a671-4c8e-af52-54e98fbcdd44", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-21T23:47:09.338136", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_7546ab38-36ec-4541-9c6e-f1bc2816e9c6", - "workflow_id": "9627b6db-a671-4c8e-af52-54e98fbcdd44", - "message": "Running task 1/1: coder", - "type": "info", - "timestamp": "2025-04-21T23:47:09.341071", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_49cb8231-b74c-49d9-bb79-3db3e594c3e9", - "workflow_id": "9627b6db-a671-4c8e-af52-54e98fbcdd44", - "message": "Agent 'coder' to create pixel_count_and_text_length.txt.", - "type": "info", - "timestamp": "2025-04-21T23:47:09.344065", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_c053f7b5-a3dc-42d3-a791-1a7569e01cf3", - "workflow_id": "9627b6db-a671-4c8e-af52-54e98fbcdd44", - "message": "Agent 'coder' completed task. Feedback: The task can be completed directly using the extracted data. The total number of pixels in the image and the total number of characters in the text document are already provided in the extracted data.", - "type": "info", - "timestamp": "2025-04-21T23:47:12.957528", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_9f9fdbc3-82f3-4f11-a5a5-ef5d1b7fce99", - "workflow_id": "9627b6db-a671-4c8e-af52-54e98fbcdd44", - "message": "Completed task 1/1: coder", - "type": "info", - "timestamp": "2025-04-21T23:47:13.473248", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_2593c059-9eec-4863-9ab0-feb1e58b1b16", - "workflow_id": "9627b6db-a671-4c8e-af52-54e98fbcdd44", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-21T23:47:13.476245", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_5aacbb36-5884-4e93-ad39-b34a4d746894", - "workflow_id": "9627b6db-a671-4c8e-af52-54e98fbcdd44", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-21T23:47:21.607320", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_3c1f6f69-8b31-4414-bfd5-2135c080f8af", - "workflow_id": "9627b6db-a671-4c8e-af52-54e98fbcdd44", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-21T23:47:21.609519", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_6f8bae46-7661-416f-bd5e-00bf17b04f5c", - "workflow_id": "9e89dd09-6c8b-4b2f-b344-57b9d0dc7d4a", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-22T00:17:11.308191", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_5f3e1639-429a-4b38-8a77-bc45d600db2a", - "workflow_id": "9e89dd09-6c8b-4b2f-b344-57b9d0dc7d4a", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-22T00:17:11.317235", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_18614089-dee9-4b64-a33c-86486e74e3c4", - "workflow_id": "9e89dd09-6c8b-4b2f-b344-57b9d0dc7d4a", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-22T00:17:14.320597", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_e770f1d4-fe11-4617-939b-c13d43cfdf25", - "workflow_id": "9e89dd09-6c8b-4b2f-b344-57b9d0dc7d4a", - "message": "Planned outputs: 2 documents", - "type": "info", - "timestamp": "2025-04-22T00:17:20.398794", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_17e2171c-ed70-45d3-8f7a-550ba84ae73a", - "workflow_id": "9e89dd09-6c8b-4b2f-b344-57b9d0dc7d4a", - "message": "Work plan created with 2 steps", - "type": "info", - "timestamp": "2025-04-22T00:17:20.405008", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_41bf5664-c53f-4e27-818a-a6ef7772ddbb", - "workflow_id": "9e89dd09-6c8b-4b2f-b344-57b9d0dc7d4a", - "message": "Running task 1/2: coder", - "type": "info", - "timestamp": "2025-04-22T00:17:20.408990", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_41d9ae5d-1a59-478d-8a78-2dcac34a9cf4", - "workflow_id": "9e89dd09-6c8b-4b2f-b344-57b9d0dc7d4a", - "message": "Agent 'coder' to create image_pixel_count.txt.", - "type": "info", - "timestamp": "2025-04-22T00:17:20.414557", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f16443c1-bfd3-4966-b399-e048ae78ad76", - "workflow_id": "9e89dd09-6c8b-4b2f-b344-57b9d0dc7d4a", - "message": "Agent 'coder' completed task. Feedback: The task can be completed directly using the extracted data, as the total number of pixels is already calculated and provided in the content_data.", - "type": "info", - "timestamp": "2025-04-22T00:17:22.861973", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_8621e10e-d5c0-42f0-b1aa-5c2c868a6c95", - "workflow_id": "9e89dd09-6c8b-4b2f-b344-57b9d0dc7d4a", - "message": "Completed task 1/2: coder", - "type": "info", - "timestamp": "2025-04-22T00:17:23.432510", - "agent_name": "AI Assistant", - "status": "running", - "progress": 45.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_2d4f66cd-780a-4ba9-9546-d41094150f6c", - "workflow_id": "9e89dd09-6c8b-4b2f-b344-57b9d0dc7d4a", - "message": "Running task 2/2: coder", - "type": "info", - "timestamp": "2025-04-22T00:17:23.434558", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_77327ddf-7a57-449a-9559-28241ba3612c", - "workflow_id": "9e89dd09-6c8b-4b2f-b344-57b9d0dc7d4a", - "message": "Agent 'coder' to create text_character_count.txt.", - "type": "info", - "timestamp": "2025-04-22T00:17:23.437560", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_e5a66528-e7f1-4caf-b2f1-05a9e791060d", - "workflow_id": "9e89dd09-6c8b-4b2f-b344-57b9d0dc7d4a", - "message": "Agent 'coder' completed task. Feedback: Error during code execution: Execution error: unsupported operand type(s) for +: 'float' and 'str'", - "type": "info", - "timestamp": "2025-04-22T00:17:39.351874", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f5fac3d9-3545-4118-9133-fed8e3285a3f", - "workflow_id": "9e89dd09-6c8b-4b2f-b344-57b9d0dc7d4a", - "message": "Completed task 2/2: coder", - "type": "info", - "timestamp": "2025-04-22T00:17:40.852912", - "agent_name": "AI Assistant", - "status": "running", - "progress": 75.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_3cc61d7d-4040-4805-8f38-3a8d7ff057e6", - "workflow_id": "9e89dd09-6c8b-4b2f-b344-57b9d0dc7d4a", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-22T00:17:40.859427", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_31bc9b7a-f3dc-4cf9-a0c0-cc57a586e125", - "workflow_id": "9e89dd09-6c8b-4b2f-b344-57b9d0dc7d4a", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-22T00:17:42.353342", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_547bc0cb-b97d-45d2-a024-f589d3b32bcd", - "workflow_id": "9e89dd09-6c8b-4b2f-b344-57b9d0dc7d4a", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-22T00:17:42.358320", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_277e755f-7651-4a22-baad-6eb0a9cb90db", - "workflow_id": "7cf0a0fc-5de4-4683-9fea-64d821522f50", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-22T00:19:53.088746", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_d631740b-d669-4011-bf8f-19714a3bfc4a", - "workflow_id": "7cf0a0fc-5de4-4683-9fea-64d821522f50", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-22T00:19:53.096717", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_2882fbf1-1764-4728-b7aa-26c5e28c4c19", - "workflow_id": "7cf0a0fc-5de4-4683-9fea-64d821522f50", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-22T00:19:55.213193", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_73af3af7-723f-4b44-9f80-0e7daed0f2cb", - "workflow_id": "7cf0a0fc-5de4-4683-9fea-64d821522f50", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-22T00:20:00.070942", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_6ee403b5-3d26-4417-9ad7-50f48cfd4f94", - "workflow_id": "7cf0a0fc-5de4-4683-9fea-64d821522f50", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-22T00:20:00.072930", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_50536861-137b-4e0a-8d18-89f32d41df1c", - "workflow_id": "7cf0a0fc-5de4-4683-9fea-64d821522f50", - "message": "Running task 1/1: coder", - "type": "info", - "timestamp": "2025-04-22T00:20:00.074936", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_c8695f08-969d-4e03-aeac-691954263dc1", - "workflow_id": "7cf0a0fc-5de4-4683-9fea-64d821522f50", - "message": "Agent 'coder' to create pixel_and_character_count.txt.", - "type": "info", - "timestamp": "2025-04-22T00:20:00.075932", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_29f1ac5a-1fd0-4768-b739-02310e471842", - "workflow_id": "7cf0a0fc-5de4-4683-9fea-64d821522f50", - "message": "Agent 'coder' completed task. Feedback: The task can be completed directly using the extracted data. The number of pixels in the image is already provided as 160,000 pixels, and the number of characters in the text document is given as 335. These values can be directly used to create the required text file.", - "type": "info", - "timestamp": "2025-04-22T00:20:02.998218", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f6ff4ce0-a242-46cb-95d1-49283a0e4287", - "workflow_id": "7cf0a0fc-5de4-4683-9fea-64d821522f50", - "message": "Completed task 1/1: coder", - "type": "info", - "timestamp": "2025-04-22T00:20:03.468865", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_cc4b324c-3729-49a7-85b5-a9dbafc027f7", - "workflow_id": "7cf0a0fc-5de4-4683-9fea-64d821522f50", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-22T00:20:03.475865", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b2ca85fa-171a-4047-ad24-078118d55653", - "workflow_id": "7cf0a0fc-5de4-4683-9fea-64d821522f50", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-22T00:20:05.128925", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_4df17a6d-8eea-4a9c-bac9-409cb2bb59e4", - "workflow_id": "7cf0a0fc-5de4-4683-9fea-64d821522f50", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-22T00:20:05.130886", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_d221a5e1-e8cf-4431-9803-45bf9c575781", - "workflow_id": "8297edbc-0f65-4094-8c68-59d9251e2970", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-22T00:22:29.792722", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_02ba48e5-0c77-42e5-b498-47ebfc01b3d6", - "workflow_id": "8297edbc-0f65-4094-8c68-59d9251e2970", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-22T00:22:29.802696", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_279dc9c0-ed61-4897-89b3-6662655d1edf", - "workflow_id": "8297edbc-0f65-4094-8c68-59d9251e2970", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-22T00:22:32.410036", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b4823b0d-e5ea-492b-a61f-ba58a67a4509", - "workflow_id": "8297edbc-0f65-4094-8c68-59d9251e2970", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-22T00:22:37.163093", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_df487fd0-018f-4e68-b9d0-233b9c6a5d7a", - "workflow_id": "8297edbc-0f65-4094-8c68-59d9251e2970", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-22T00:22:37.170086", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_355d0aba-4db5-4fa7-a7e6-554b97bcdc69", - "workflow_id": "8297edbc-0f65-4094-8c68-59d9251e2970", - "message": "Running task 1/1: coder", - "type": "info", - "timestamp": "2025-04-22T00:22:37.179039", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_63be204a-d82c-421d-ac22-92d4d1348a46", - "workflow_id": "8297edbc-0f65-4094-8c68-59d9251e2970", - "message": "Agent 'coder' to create integrated_image.png.", - "type": "info", - "timestamp": "2025-04-22T00:22:37.186114", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_ad872265-b036-469e-8a32-1a9443ce1f32", - "workflow_id": "8297edbc-0f65-4094-8c68-59d9251e2970", - "message": "Agent 'coder' completed task. Feedback: Error during code execution: Execution error: unsupported operand type(s) for +: 'float' and 'str'", - "type": "info", - "timestamp": "2025-04-22T00:22:58.859838", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_0f274ee2-ab78-4b3f-8046-3e509766f487", - "workflow_id": "8297edbc-0f65-4094-8c68-59d9251e2970", - "message": "Completed task 1/1: coder", - "type": "info", - "timestamp": "2025-04-22T00:23:01.012837", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_0a42d5bc-c450-492b-9136-7ae4ae49d8ea", - "workflow_id": "8297edbc-0f65-4094-8c68-59d9251e2970", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-22T00:23:01.015838", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_faa79ddb-c478-42f3-acee-62c6cf782316", - "workflow_id": "8297edbc-0f65-4094-8c68-59d9251e2970", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-22T00:23:02.419440", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_bd5bbef1-550f-4597-8a17-958a557a3a7a", - "workflow_id": "8297edbc-0f65-4094-8c68-59d9251e2970", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-22T00:23:02.426459", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_bf681acc-1f47-4f19-8e6e-087f9e00c381", - "workflow_id": "ccb07a6e-09f1-45d8-9a4b-69ec43fefd49", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-22T01:08:49.175560", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_9b1b7295-0633-4fcb-84b2-e9168b011da6", - "workflow_id": "ccb07a6e-09f1-45d8-9a4b-69ec43fefd49", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-22T01:08:49.186570", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_2a5c094c-3cc6-4fd2-8a87-61154bac3d29", - "workflow_id": "ccb07a6e-09f1-45d8-9a4b-69ec43fefd49", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-22T01:08:51.773711", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_bb64fafd-4be8-4fea-a94f-595e8f83a9bd", - "workflow_id": "ccb07a6e-09f1-45d8-9a4b-69ec43fefd49", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-22T01:08:56.210995", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_624c848e-f983-46f6-bee7-1bced39d849b", - "workflow_id": "ccb07a6e-09f1-45d8-9a4b-69ec43fefd49", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-22T01:08:56.218604", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_8c475d43-1f87-46f3-bfd1-d7ede12daff5", - "workflow_id": "ccb07a6e-09f1-45d8-9a4b-69ec43fefd49", - "message": "Running task 1/1: coder", - "type": "info", - "timestamp": "2025-04-22T01:08:56.223639", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_a9d8d4bf-7708-4a87-8821-e2e3629c106f", - "workflow_id": "ccb07a6e-09f1-45d8-9a4b-69ec43fefd49", - "message": "Agent 'coder' to create integrated_image.png.", - "type": "info", - "timestamp": "2025-04-22T01:08:56.228636", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_3a63b514-0ce2-415d-ad17-7b7b612d0e01", - "workflow_id": "ccb07a6e-09f1-45d8-9a4b-69ec43fefd49", - "message": "Agent 'coder' completed task. Feedback: Error during code execution: Execution error: unsupported operand type(s) for +: 'float' and 'str'", - "type": "info", - "timestamp": "2025-04-22T01:09:14.912600", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_aa918b22-dbf6-4761-92e4-5ec614bbe5c2", - "workflow_id": "ccb07a6e-09f1-45d8-9a4b-69ec43fefd49", - "message": "Completed task 1/1: coder", - "type": "info", - "timestamp": "2025-04-22T01:09:17.012788", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_52d4a917-5a9d-444b-86a4-73b1c5ed194f", - "workflow_id": "ccb07a6e-09f1-45d8-9a4b-69ec43fefd49", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-22T01:09:17.019351", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_5959323b-717a-4fc6-bb2e-ccc8fb2f50d7", - "workflow_id": "ccb07a6e-09f1-45d8-9a4b-69ec43fefd49", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-22T01:09:19.375721", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_4a12df11-5dce-4047-be30-d1cd4e2cc1b3", - "workflow_id": "ccb07a6e-09f1-45d8-9a4b-69ec43fefd49", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-22T01:09:19.383173", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_2f1a8b3b-2958-4222-b777-3fe336c3d3d4", - "workflow_id": "5b739efc-f0e4-482c-9986-869d89832ddb", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-22T01:18:11.538973", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f19995ff-c83b-4818-bd34-2ed43f08423f", - "workflow_id": "5b739efc-f0e4-482c-9986-869d89832ddb", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-22T01:18:11.548830", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b86fbff4-661f-4569-9365-bccd490468f8", - "workflow_id": "5b739efc-f0e4-482c-9986-869d89832ddb", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-22T01:18:14.311038", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_1ab7c421-d647-4ab9-8660-e8c7e89d0017", - "workflow_id": "5b739efc-f0e4-482c-9986-869d89832ddb", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-22T01:18:20.388827", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_cd2be10e-e455-4b15-a9ab-c6ddf295cd24", - "workflow_id": "5b739efc-f0e4-482c-9986-869d89832ddb", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-22T01:18:20.398211", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_58907bbd-e026-49fd-9909-712aa8714348", - "workflow_id": "5b739efc-f0e4-482c-9986-869d89832ddb", - "message": "Running task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-22T01:18:20.404195", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_43e56b3b-8e65-46f9-a7d1-c41e37763f1c", - "workflow_id": "5b739efc-f0e4-482c-9986-869d89832ddb", - "message": "Agent 'documentation' to create integrated_image.png.", - "type": "info", - "timestamp": "2025-04-22T01:18:20.409205", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_bd15ef82-aa20-41b7-abab-349c48598689", - "workflow_id": "5b739efc-f0e4-482c-9986-869d89832ddb", - "message": "Agent 'documentation' completed task. Feedback: The documentation approach focuses on providing clear, step-by-step instructions with technical details suitable for a technical audience.", - "type": "info", - "timestamp": "2025-04-22T01:19:40.207030", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_c50aa2c3-4935-4e5b-9db8-4a23dd6c40da", - "workflow_id": "5b739efc-f0e4-482c-9986-869d89832ddb", - "message": "Completed task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-22T01:19:43.227867", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f32b5885-d4a2-4584-8acf-a05f867f8384", - "workflow_id": "5b739efc-f0e4-482c-9986-869d89832ddb", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-22T01:19:43.231452", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_99b6cb5a-1cbe-42e6-8117-7be2123c1e97", - "workflow_id": "5b739efc-f0e4-482c-9986-869d89832ddb", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-22T01:19:44.598788", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_26b5cece-e51d-49b6-b886-414cb5382e04", - "workflow_id": "5b739efc-f0e4-482c-9986-869d89832ddb", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-22T01:19:44.602781", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_969e1dad-13c6-419c-87ad-3dc5e34fac41", - "workflow_id": "a5cb691f-c1a1-4537-a2d8-1c9a67b52cf4", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-22T01:23:48.519992", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_293a1779-14b8-4b11-b939-d90eb73f8bf8", - "workflow_id": "a5cb691f-c1a1-4537-a2d8-1c9a67b52cf4", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-22T01:23:48.530547", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_7e5b973d-21ef-4479-b87d-a4ca83302f37", - "workflow_id": "a5cb691f-c1a1-4537-a2d8-1c9a67b52cf4", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-22T01:23:50.704152", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_4af60da3-e94e-498b-8b27-0c5b07428df7", - "workflow_id": "a5cb691f-c1a1-4537-a2d8-1c9a67b52cf4", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-22T01:23:55.268278", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_7492fad0-d04c-4893-83f4-a0d646c2eccf", - "workflow_id": "a5cb691f-c1a1-4537-a2d8-1c9a67b52cf4", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-22T01:23:55.272313", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_3e592811-a742-4b37-b6cc-42511e450411", - "workflow_id": "a5cb691f-c1a1-4537-a2d8-1c9a67b52cf4", - "message": "Running task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-22T01:23:55.276304", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_13277bad-c53a-4580-a544-820868d5d59a", - "workflow_id": "a5cb691f-c1a1-4537-a2d8-1c9a67b52cf4", - "message": "Agent 'documentation' to create integrated_image.png.", - "type": "info", - "timestamp": "2025-04-22T01:23:55.280302", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_5e54d595-3d11-4b8c-87dd-9c68edf4cbee", - "workflow_id": "944896d4-6add-40d2-9874-fca4836d526b", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-22T01:24:34.630762", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_584610db-6a43-407e-9b6b-da30e65baaa8", - "workflow_id": "944896d4-6add-40d2-9874-fca4836d526b", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-22T01:24:34.640798", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_e20fee01-514f-4207-a4fe-7f3ffd096455", - "workflow_id": "944896d4-6add-40d2-9874-fca4836d526b", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-22T01:24:36.805549", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_6636a611-c0c4-47be-9e26-41c6fd04510e", - "workflow_id": "944896d4-6add-40d2-9874-fca4836d526b", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-22T01:24:41.164059", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_d48bf9f0-ceba-4f0b-9cf6-067bb58d4fe3", - "workflow_id": "944896d4-6add-40d2-9874-fca4836d526b", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-22T01:24:41.173000", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_8b41026c-28c7-4f4d-9a24-156bdac27d47", - "workflow_id": "944896d4-6add-40d2-9874-fca4836d526b", - "message": "Running task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-22T01:24:41.179983", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_cf793c62-4785-4d34-93c9-c30e58f9b04f", - "workflow_id": "944896d4-6add-40d2-9874-fca4836d526b", - "message": "Agent 'documentation' to create integrated_image.png.", - "type": "info", - "timestamp": "2025-04-22T01:24:41.186090", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_900c41fc-6826-4080-b631-7c8e6982c216", - "workflow_id": "944896d4-6add-40d2-9874-fca4836d526b", - "message": "Agent 'documentation' completed task. Feedback: The documentation approach focuses on providing clear, step-by-step instructions with technical details suitable for a technical audience.", - "type": "info", - "timestamp": "2025-04-22T01:26:04.133846", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_4c0b3813-2af2-4006-8ec6-a48f9a6e6be6", - "workflow_id": "944896d4-6add-40d2-9874-fca4836d526b", - "message": "Completed task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-22T01:26:06.786395", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_360b27db-1869-4240-a5e3-d74532e74ec8", - "workflow_id": "944896d4-6add-40d2-9874-fca4836d526b", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-22T01:26:06.789398", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_724000e7-2fd8-430e-ab4b-9dace81dc86e", - "workflow_id": "944896d4-6add-40d2-9874-fca4836d526b", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-22T01:26:08.169790", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_bd5acbe1-7ae1-49c7-aa1d-d7cd83ee329a", - "workflow_id": "944896d4-6add-40d2-9874-fca4836d526b", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-22T01:26:08.177706", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_70cc5689-112a-4824-ba60-468f1203ce31", - "workflow_id": "8dbecd67-4344-4b21-9204-ce377525a916", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-22T01:29:25.641282", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_39957d72-5a6b-4451-8849-efbc9f9bfae4", - "workflow_id": "8dbecd67-4344-4b21-9204-ce377525a916", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-22T01:29:25.652317", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_4cf8003f-fea0-4070-8ced-32a0e8af67a6", - "workflow_id": "8dbecd67-4344-4b21-9204-ce377525a916", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-22T01:29:28.088009", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_375f5966-0654-4fbb-83fb-e1ffe7bc07d8", - "workflow_id": "8dbecd67-4344-4b21-9204-ce377525a916", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-22T01:29:33.759508", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_aefe4b70-4d52-442f-a163-058025529396", - "workflow_id": "8dbecd67-4344-4b21-9204-ce377525a916", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-22T01:29:33.767472", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_557eed4b-2822-4993-9e91-a7f337aaba32", - "workflow_id": "8dbecd67-4344-4b21-9204-ce377525a916", - "message": "Running task 1/1: coder", - "type": "info", - "timestamp": "2025-04-22T01:29:33.773975", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_7236b197-84ee-47aa-94a5-0a0f364a7426", - "workflow_id": "8dbecd67-4344-4b21-9204-ce377525a916", - "message": "Agent 'coder' to create integrated_image.png.", - "type": "info", - "timestamp": "2025-04-22T01:29:33.778502", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_5f3efead-0a66-4c19-9f81-77fe02eeba3d", - "workflow_id": "8dbecd67-4344-4b21-9204-ce377525a916", - "message": "Agent 'coder' completed task. Feedback: Error during code execution: Execution error: unsupported operand type(s) for +: 'float' and 'str'", - "type": "info", - "timestamp": "2025-04-22T01:29:52.256169", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_477a62d8-82b2-465f-8f00-4aaf54749a90", - "workflow_id": "8dbecd67-4344-4b21-9204-ce377525a916", - "message": "Completed task 1/1: coder", - "type": "info", - "timestamp": "2025-04-22T01:29:53.933652", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_916a1280-a0ca-40ea-8549-9055732ecf31", - "workflow_id": "8dbecd67-4344-4b21-9204-ce377525a916", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-22T01:29:53.937652", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_7ee97cf7-c3b4-4d2a-b7a0-25de43dc832e", - "workflow_id": "8dbecd67-4344-4b21-9204-ce377525a916", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-22T01:29:55.277408", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_30cc4b49-e8fb-4c29-8cbc-6b87624d4627", - "workflow_id": "8dbecd67-4344-4b21-9204-ce377525a916", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-22T01:29:55.281431", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_67db97a9-1e77-40dd-9958-02541bb16c33", - "workflow_id": "d8891eb7-d857-4c0d-bd72-8ee7102a1e22", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-22T01:44:42.817888", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_32ba18c8-a57f-47ea-9a95-c0e06d4a613b", - "workflow_id": "d8891eb7-d857-4c0d-bd72-8ee7102a1e22", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-22T01:44:42.830251", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_713c6e9d-6c0c-44db-8394-d3b62b782e2a", - "workflow_id": "d8891eb7-d857-4c0d-bd72-8ee7102a1e22", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-22T01:44:45.125614", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_a61d9e40-f852-474e-8cac-4545863ae2a9", - "workflow_id": "d8891eb7-d857-4c0d-bd72-8ee7102a1e22", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-22T01:44:49.869856", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_77b840d6-1b52-4c86-9a1c-8452aa41161a", - "workflow_id": "d8891eb7-d857-4c0d-bd72-8ee7102a1e22", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-22T01:44:49.878456", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_9adbce97-8bc1-4e77-8623-e45c61b189ff", - "workflow_id": "d8891eb7-d857-4c0d-bd72-8ee7102a1e22", - "message": "Running task 1/1: coder", - "type": "info", - "timestamp": "2025-04-22T01:44:49.884460", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_d65d9919-d6c4-4d68-984d-2578376fe0d4", - "workflow_id": "d8891eb7-d857-4c0d-bd72-8ee7102a1e22", - "message": "Agent 'coder' to create integrated_image.png.", - "type": "info", - "timestamp": "2025-04-22T01:44:49.888495", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_a45f70cf-5291-480e-88a3-5ce621f44921", - "workflow_id": "d8891eb7-d857-4c0d-bd72-8ee7102a1e22", - "message": "Agent 'coder' completed task. Feedback: Error during code execution: Execution error: unsupported operand type(s) for +: 'float' and 'str'", - "type": "info", - "timestamp": "2025-04-22T01:45:08.266820", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_172d2e30-2fa4-4251-84c1-a5cbfb04da2e", - "workflow_id": "d8891eb7-d857-4c0d-bd72-8ee7102a1e22", - "message": "Completed task 1/1: coder", - "type": "info", - "timestamp": "2025-04-22T01:45:09.710546", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_fbd4c59a-7ca7-4e15-8ec4-0f11c4a54339", - "workflow_id": "d8891eb7-d857-4c0d-bd72-8ee7102a1e22", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-22T01:45:09.713544", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_2f439ace-5567-4996-99dc-36ac84e514bf", - "workflow_id": "d8891eb7-d857-4c0d-bd72-8ee7102a1e22", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-22T01:45:11.835071", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_81cb688d-3e0a-4546-9e9e-68593f044aab", - "workflow_id": "d8891eb7-d857-4c0d-bd72-8ee7102a1e22", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-22T01:45:11.842066", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_1157c9e6-cddf-4fd4-b444-250b8bae70fd", - "workflow_id": "60b35400-daa8-48c2-b4f3-c1db405ed27c", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-22T01:59:32.217449", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_9ab61f36-f228-4391-9080-94ac5b8aff19", - "workflow_id": "60b35400-daa8-48c2-b4f3-c1db405ed27c", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-22T01:59:32.228000", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_53dad3d6-a4eb-4aa5-b73d-fd9c06430f58", - "workflow_id": "60b35400-daa8-48c2-b4f3-c1db405ed27c", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-22T01:59:34.709186", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b22a8afc-44e7-48fa-bc30-7a69f0fa2565", - "workflow_id": "60b35400-daa8-48c2-b4f3-c1db405ed27c", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-22T01:59:40.143232", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_72fe1f98-e416-4faa-8050-64cf711f0992", - "workflow_id": "60b35400-daa8-48c2-b4f3-c1db405ed27c", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-22T01:59:40.147233", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b407f8cd-a218-4300-854d-02827c8f4fa2", - "workflow_id": "60b35400-daa8-48c2-b4f3-c1db405ed27c", - "message": "Running task 1/1: coder", - "type": "info", - "timestamp": "2025-04-22T01:59:40.151233", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_fac2118d-2d0d-4d44-8d97-299d9b17c62f", - "workflow_id": "60b35400-daa8-48c2-b4f3-c1db405ed27c", - "message": "Agent 'coder' to create integrated_image.png.", - "type": "info", - "timestamp": "2025-04-22T01:59:40.154231", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f6b6624a-157d-4fa3-a66d-bbcf02418e41", - "workflow_id": "60b35400-daa8-48c2-b4f3-c1db405ed27c", - "message": "Agent 'coder' completed task. Feedback: Error during code execution: Execution error: unsupported operand type(s) for +: 'float' and 'str'", - "type": "info", - "timestamp": "2025-04-22T02:00:00.150394", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b73347ad-925a-4b02-8133-0ccd0c869d63", - "workflow_id": "60b35400-daa8-48c2-b4f3-c1db405ed27c", - "message": "Completed task 1/1: coder", - "type": "info", - "timestamp": "2025-04-22T02:00:01.980682", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_50ff3fb5-8e67-4525-9b2c-6584b29434e3", - "workflow_id": "60b35400-daa8-48c2-b4f3-c1db405ed27c", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-22T02:00:01.983718", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_04d7b89e-ca76-49e7-87b7-790104af52f2", - "workflow_id": "60b35400-daa8-48c2-b4f3-c1db405ed27c", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-22T02:00:04.540543", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_876d16b1-f5ef-4585-83d9-81edbae018fb", - "workflow_id": "60b35400-daa8-48c2-b4f3-c1db405ed27c", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-22T02:00:04.544557", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_8f0cab5f-aa2f-42a4-a2ee-02edf178605c", - "workflow_id": "d3a45d42-d0d9-4c37-846b-4d5f962a12ac", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-22T02:10:17.676764", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_9549569b-ca85-4116-8158-704e2f10d297", - "workflow_id": "d3a45d42-d0d9-4c37-846b-4d5f962a12ac", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-22T02:10:17.689798", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_7c313b23-38e1-4951-a41a-52fd7763c1f8", - "workflow_id": "d3a45d42-d0d9-4c37-846b-4d5f962a12ac", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-22T02:10:20.192528", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_7cf00a2a-902d-4973-a012-444de01fc710", - "workflow_id": "d3a45d42-d0d9-4c37-846b-4d5f962a12ac", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-22T02:10:25.266995", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_cd7e66d9-6fa0-409b-b2b7-28de518a8b40", - "workflow_id": "d3a45d42-d0d9-4c37-846b-4d5f962a12ac", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-22T02:10:25.269967", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_91ed4ab7-224a-4587-91ea-b51e1d635a79", - "workflow_id": "d3a45d42-d0d9-4c37-846b-4d5f962a12ac", - "message": "Running task 1/1: coder", - "type": "info", - "timestamp": "2025-04-22T02:10:25.273968", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_518ee50e-0891-4010-b1b0-7d2877ba7a90", - "workflow_id": "d3a45d42-d0d9-4c37-846b-4d5f962a12ac", - "message": "Agent 'coder' to create integrated_image.png.", - "type": "info", - "timestamp": "2025-04-22T02:10:25.276966", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_a6daefd9-9495-48c9-877b-c090640190a5", - "workflow_id": "d3a45d42-d0d9-4c37-846b-4d5f962a12ac", - "message": "Agent 'coder' completed task. Feedback: Error during code execution: Execution error: unsupported operand type(s) for +: 'float' and 'str'", - "type": "info", - "timestamp": "2025-04-22T02:10:52.160062", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_5fbe1f11-25e7-4b8c-8f8c-f1ead27764d8", - "workflow_id": "d3a45d42-d0d9-4c37-846b-4d5f962a12ac", - "message": "Completed task 1/1: coder", - "type": "info", - "timestamp": "2025-04-22T02:10:54.230974", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b7048d25-3493-4998-a033-1d7b961bf650", - "workflow_id": "d3a45d42-d0d9-4c37-846b-4d5f962a12ac", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-22T02:10:54.239962", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_87b2d830-79fc-4107-81d0-055a98385b09", - "workflow_id": "d3a45d42-d0d9-4c37-846b-4d5f962a12ac", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-22T02:11:01.148977", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_1b47709e-0239-4806-b6dc-530e0e8d77b2", - "workflow_id": "d3a45d42-d0d9-4c37-846b-4d5f962a12ac", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-22T02:11:01.154001", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f31d78e9-dbd5-4d5f-a995-15a7bdc594b9", - "workflow_id": "f5ed67e6-93a4-4734-818c-b9b4f2550343", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-22T02:19:29.306369", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_bc868a04-7354-4230-93f7-6579eb3afe16", - "workflow_id": "f5ed67e6-93a4-4734-818c-b9b4f2550343", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-22T02:19:29.319369", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_ff7c1751-a90f-43e6-a9bc-065479ad16c1", - "workflow_id": "f5ed67e6-93a4-4734-818c-b9b4f2550343", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-22T02:19:31.693997", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_0fbc9d7e-1aa1-47b6-ba73-733f6d5fc634", - "workflow_id": "f5ed67e6-93a4-4734-818c-b9b4f2550343", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-22T02:19:36.638679", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_bf79c60b-2e1c-422e-ac93-9050b9374aaa", - "workflow_id": "f5ed67e6-93a4-4734-818c-b9b4f2550343", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-22T02:19:36.642676", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_aef5ece2-1358-40fa-bb7c-b6a09aa4973c", - "workflow_id": "f5ed67e6-93a4-4734-818c-b9b4f2550343", - "message": "Running task 1/1: coder", - "type": "info", - "timestamp": "2025-04-22T02:19:36.645699", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_fb4c7e88-564d-4da7-bc90-b4aaae8c7d64", - "workflow_id": "f5ed67e6-93a4-4734-818c-b9b4f2550343", - "message": "Agent 'coder' to create integrated_image.png.", - "type": "info", - "timestamp": "2025-04-22T02:19:36.649677", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_7db438bd-b7da-42fb-a748-bc06da56b7ca", - "workflow_id": "f5ed67e6-93a4-4734-818c-b9b4f2550343", - "message": "Error executing agent 'coder': '<=' not supported between instances of 'int' and 'str'", - "type": "error", - "timestamp": "2025-04-22T02:19:46.915173", - "agent_name": "AI Assistant", - "status": "running", - "progress": -1, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_574d5a13-4300-4918-92fb-a3b2404d4dd2", - "workflow_id": "f5ed67e6-93a4-4734-818c-b9b4f2550343", - "message": "Completed task 1/1: coder", - "type": "info", - "timestamp": "2025-04-22T02:19:46.931245", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b0eead0c-9dfb-4a64-9f7c-097ff5eb0894", - "workflow_id": "f5ed67e6-93a4-4734-818c-b9b4f2550343", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-22T02:19:46.940851", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_eeb946d7-eac0-449c-8af9-b2abb12e153b", - "workflow_id": "f5ed67e6-93a4-4734-818c-b9b4f2550343", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-22T02:19:48.000352", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_9e4f1708-ee3f-41e7-896b-e1fa7a3da4b6", - "workflow_id": "f5ed67e6-93a4-4734-818c-b9b4f2550343", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-22T02:19:48.003375", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_fc701fff-670a-4a4d-941f-8515847a1047", - "workflow_id": "155781d0-c0ff-4247-8c40-9e7e1c070e0a", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-22T02:21:53.066794", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_c2f89a9a-5928-4847-b7f5-58b774c4408c", - "workflow_id": "155781d0-c0ff-4247-8c40-9e7e1c070e0a", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-22T02:21:53.079340", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_0673c4eb-104f-47e5-8314-b10344871180", - "workflow_id": "155781d0-c0ff-4247-8c40-9e7e1c070e0a", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-22T02:21:56.473416", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_16bfcf03-910b-4a5d-8c87-0418594aeb66", - "workflow_id": "155781d0-c0ff-4247-8c40-9e7e1c070e0a", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-22T02:22:00.586679", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_dfa7b7b7-7bb0-41cc-a7b2-3189fdde196c", - "workflow_id": "155781d0-c0ff-4247-8c40-9e7e1c070e0a", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-22T02:22:00.590699", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_694898c7-021b-4d58-8cf5-da7b02876d32", - "workflow_id": "155781d0-c0ff-4247-8c40-9e7e1c070e0a", - "message": "Running task 1/1: coder", - "type": "info", - "timestamp": "2025-04-22T02:22:00.594703", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_77454ae1-8873-4d04-befb-ba76c867b7c2", - "workflow_id": "155781d0-c0ff-4247-8c40-9e7e1c070e0a", - "message": "Agent 'coder' to create integrated_image.png.", - "type": "info", - "timestamp": "2025-04-22T02:22:00.598700", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_31a0f82e-5d12-4e1e-b7e6-805eed520965", - "workflow_id": "155781d0-c0ff-4247-8c40-9e7e1c070e0a", - "message": "Agent 'coder' completed task. Feedback: Code executed successfully. Generated output files based on specifications.", - "type": "info", - "timestamp": "2025-04-22T02:22:25.812342", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_412e669a-692d-40c3-8f40-80cc3fea197e", - "workflow_id": "155781d0-c0ff-4247-8c40-9e7e1c070e0a", - "message": "Completed task 1/1: coder", - "type": "info", - "timestamp": "2025-04-22T02:22:28.951642", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_1d5f095b-fcf9-46c9-a14c-a86e3c371c9c", - "workflow_id": "155781d0-c0ff-4247-8c40-9e7e1c070e0a", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-22T02:22:28.958639", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_ced30737-6122-402e-9630-d92ecff06fa2", - "workflow_id": "155781d0-c0ff-4247-8c40-9e7e1c070e0a", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-22T02:22:30.948250", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_e284e09c-4f0c-40f4-8418-c895ffd053ca", - "workflow_id": "155781d0-c0ff-4247-8c40-9e7e1c070e0a", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-22T02:22:30.953465", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_a78a4b13-3532-423c-9a6a-a9803f1ea972", - "workflow_id": "new", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-23T14:13:34.017880", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_316953ca-ab49-414a-b398-89814da4ee37", - "workflow_id": "new", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T14:13:34.038880", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_ba58bd1d-fb83-41c5-b13f-86b50a90cf70", - "workflow_id": "new", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T14:13:34.061472", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_113daa25-3b90-4b3b-bf02-807a4f6661a3", - "workflow_id": "new", - "message": "Planned outputs: 0 documents", - "type": "info", - "timestamp": "2025-04-23T14:13:36.995717", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_32187801-739b-45e3-bb2d-f46c69471a81", - "workflow_id": "new", - "message": "Work plan created with 0 steps", - "type": "info", - "timestamp": "2025-04-23T14:13:37.003674", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_71b973ff-d9d5-4f05-addf-4c8fe8753f7a", - "workflow_id": "new", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T14:13:37.011225", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_0f932a53-c6a3-441a-b22a-863d7a01ca60", - "workflow_id": "new", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T14:13:38.369137", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_3ee76263-2825-45e9-b8b9-227d76819f0d", - "workflow_id": "new", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T14:13:38.375694", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_c85ff29d-052b-4aba-ae76-74eafe8cf487", - "workflow_id": "new", - "message": "Running workflow", - "type": "info", - "timestamp": "2025-04-23T14:14:54.366825", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_4659948e-b440-46a1-9b6a-48401f43f948", - "workflow_id": "new", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T14:14:54.379814", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_8c2e19c8-4446-47fe-91e3-2b4984f73fe6", - "workflow_id": "new", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T14:14:57.006368", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_4edfa920-a47f-40e9-85f4-a65977f35562", - "workflow_id": "new", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T14:15:04.941907", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_96c1a5c9-b327-4a6b-b53e-a7fa5a660b13", - "workflow_id": "new", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T14:15:04.955859", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_abf8b090-49aa-4d62-9b5c-b76699848053", - "workflow_id": "new", - "message": "Running task 1/1: analyst", - "type": "info", - "timestamp": "2025-04-23T14:15:04.971481", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_732d998f-9fda-4a63-8420-09f975a355e9", - "workflow_id": "new", - "message": "Agent 'analyst' to create LF-Details_summary.txt.", - "type": "info", - "timestamp": "2025-04-23T14:15:04.986637", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f03cb15a-58a0-449e-affa-aabc6b7122b9", - "workflow_id": "new", - "message": "Running workflow", - "type": "info", - "timestamp": "2025-04-23T14:15:07.767594", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_98753740-9acb-44d0-9f8f-6d7bf7d6dee5", - "workflow_id": "new", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T14:15:07.803771", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_d96e09c3-a06d-4faf-8eb5-734680be1ce3", - "workflow_id": "new", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T14:15:10.290477", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_ce4a4475-224a-41c5-9226-29f0023a4529", - "workflow_id": "new", - "message": "Agent 'analyst' completed task. Feedback: Since the image content is not provided, the approach involves requesting a description or text extraction from the image to proceed with the analysis.\n\nThe task requires a textual summary of the image content, but no direct data or description of the image is available.", - "type": "info", - "timestamp": "2025-04-23T14:15:17.711446", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_0a4fa891-6da0-4d69-8e3f-ecf2ba216651", - "workflow_id": "new", - "message": "Completed task 1/1: analyst", - "type": "info", - "timestamp": "2025-04-23T14:15:18.602340", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_49772bd3-ca65-4f9e-8738-9476748ba05a", - "workflow_id": "new", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T14:15:18.606929", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_fde0b8ab-ee73-4ece-92d9-b035e39c863b", - "workflow_id": "new", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T14:15:21.404042", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_2104b5c2-193b-4a28-bb96-77651d96290f", - "workflow_id": "new", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T14:15:21.423835", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_a18638b8-6cdf-44d0-9627-df3e120345eb", - "workflow_id": "new", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T14:15:22.778062", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_ddfac44d-057c-4f39-b649-d0524a51147a", - "workflow_id": "new", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T14:15:22.783217", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_9eae6a4c-ed53-47a4-888e-05f3545235c0", - "workflow_id": "new", - "message": "Running task 1/1: analyst", - "type": "info", - "timestamp": "2025-04-23T14:15:22.789679", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_5ed8c114-6490-4ea2-bf65-a3f37c6ee0e6", - "workflow_id": "new", - "message": "Agent 'analyst' to create LF-Details_Summary.txt.", - "type": "info", - "timestamp": "2025-04-23T14:15:22.795681", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_ec8baf56-285d-4826-9369-938ba3eef620", - "workflow_id": "new", - "message": "Agent 'analyst' completed task. Feedback: Since the image content is not described, a manual review of the image is necessary to identify key elements and themes. This will involve visually inspecting the image to summarize its content accurately.\n\nThe image 'LF-Details.png' lacks detailed content information, making it challenging to derive specific insights without visual inspection.", - "type": "info", - "timestamp": "2025-04-23T14:15:36.003724", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b45b450d-d2b8-43bb-8983-110102dab7ac", - "workflow_id": "new", - "message": "Completed task 1/1: analyst", - "type": "info", - "timestamp": "2025-04-23T14:15:37.004948", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_86e7fd67-9ff6-424e-8054-fea65ca7315b", - "workflow_id": "new", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T14:15:37.010865", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_1d7246b6-97ed-4eed-a8f3-6c9bdff481de", - "workflow_id": "new", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T14:15:39.473859", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_93f12154-4046-464d-9b11-851d70786ed2", - "workflow_id": "new", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T14:15:39.473859", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_d026a94e-cc02-4a69-9668-6ece98937861", - "workflow_id": "new", - "message": "Running workflow", - "type": "info", - "timestamp": "2025-04-23T14:31:43.572437", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_7c58ce18-b848-4d50-983c-561b821acdad", - "workflow_id": "new", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T14:31:43.577545", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_c58276fc-fc77-46fa-b0ed-536c6d86af53", - "workflow_id": "new", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T14:31:43.615143", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_bae9fbcf-cb43-4d93-8c30-0e4bded20f62", - "workflow_id": "new", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T14:32:03.180530", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_10d866c6-d062-4869-8a72-73408a7fb440", - "workflow_id": "new", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T14:32:03.185232", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_9d60b3b4-0291-4777-a691-f93509b1f514", - "workflow_id": "new", - "message": "Running task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T14:32:03.189277", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_c79f30f7-139a-42cb-abb0-4b26218c48a4", - "workflow_id": "new", - "message": "Agent 'documentation' to create short_story_french.txt.", - "type": "info", - "timestamp": "2025-04-23T14:32:03.194896", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_aca6f0a9-c70b-401d-8fff-4ecf258bfb99", - "workflow_id": "new", - "message": "Agent 'documentation' completed task. Feedback: The documentation approach focuses on creating an engaging narrative structure that is easy for children to follow, with a clear moral lesson.", - "type": "info", - "timestamp": "2025-04-23T14:33:26.462415", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_dad4a4c1-6352-4ea1-82a5-a6b90607bb97", - "workflow_id": "new", - "message": "Completed task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T14:33:29.518482", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_9e19aff3-923e-4293-ae94-f43ebef7930e", - "workflow_id": "new", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T14:33:29.522479", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_755d5f26-a74b-4463-a133-eb3b048c6fce", - "workflow_id": "new", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T14:33:32.743943", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_477486a2-c498-48c9-9e4b-a791730373bd", - "workflow_id": "new", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T14:33:32.747944", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_ce5d457b-6f77-40cb-8e71-7425a4a3dd5a", - "workflow_id": "new", - "message": "Running workflow", - "type": "info", - "timestamp": "2025-04-23T14:53:46.036720", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b34df333-75ab-47be-859d-ba3e9cc7ebe1", - "workflow_id": "new", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T14:53:46.046671", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_92016b2a-048d-4585-a80a-290982a3c2d5", - "workflow_id": "new", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T14:53:46.081254", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_db560d6f-6828-442a-9bb9-03a059c55028", - "workflow_id": "new", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T14:54:21.374189", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_2dd04a58-7370-4216-9aa5-675a22d21f2e", - "workflow_id": "new", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T14:54:21.379169", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_422c36e6-bd95-400f-9b08-def696888d8b", - "workflow_id": "new", - "message": "Running task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T14:54:21.384207", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_4c6f5d41-3b24-4e36-948c-02893c3eaa54", - "workflow_id": "new", - "message": "Agent 'documentation' to create bedtime_story_french.txt.", - "type": "info", - "timestamp": "2025-04-23T14:54:21.389207", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_718358a7-ba6a-426c-b2c4-c5a900ffa346", - "workflow_id": "new", - "message": "Running workflow", - "type": "info", - "timestamp": "2025-04-23T14:55:11.641746", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_6bf96271-266f-4e1f-a51f-2a9c24d88d2a", - "workflow_id": "new", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T14:55:11.663728", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b151579c-11eb-4388-aaef-1397ccd8afe6", - "workflow_id": "new", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T14:55:11.702370", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_89fac769-6244-4c27-81ea-f747512fa887", - "workflow_id": "new", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T14:55:39.456624", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b534f17d-52ff-4fc1-add6-b808a109c5db", - "workflow_id": "new", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T14:55:39.462607", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_3a642288-d7ff-476b-926a-066d40c308a5", - "workflow_id": "new", - "message": "Running task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T14:55:39.468627", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_60f9c6db-76fd-434b-8905-1e83e3e4818d", - "workflow_id": "new", - "message": "Agent 'documentation' to create bedtime_story_french.txt.", - "type": "info", - "timestamp": "2025-04-23T14:55:39.474118", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_88308814-df3e-475c-aca5-5ccae63717d5", - "workflow_id": "new", - "message": "Agent 'documentation' completed task. Feedback: The documentation approach focuses on providing a clear and structured guide to crafting a children's bedtime story in French, emphasizing simplicity and engagement.", - "type": "info", - "timestamp": "2025-04-23T14:55:41.209818", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f8b406d1-1caa-4cf6-a92c-98fef39725ae", - "workflow_id": "new", - "message": "Completed task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T14:55:42.283577", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_755b9a03-d7ae-4f5d-b66b-2b5adc62dc99", - "workflow_id": "new", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T14:55:42.289575", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_3e544f55-ecb7-4092-b687-0354f5fd4176", - "workflow_id": "new", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T14:55:45.027682", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_95b68f4b-5c44-411e-b934-235bfa5ecb6d", - "workflow_id": "new", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T14:55:45.035275", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_615b7d88-f75f-4b77-af5e-4744b6009afe", - "workflow_id": "new", - "message": "Agent 'documentation' completed task. Feedback: The story will be crafted to be easily understandable and enjoyable for children, with a focus on positive themes and a straightforward narrative.", - "type": "info", - "timestamp": "2025-04-23T14:56:32.327001", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_6fab2251-e5c2-44b3-bba0-93f28d4ef7e6", - "workflow_id": "new", - "message": "Completed task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T14:56:33.696301", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_8753daca-28aa-4b0d-bfd9-bd357ebc5cf6", - "workflow_id": "new", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T14:56:33.701302", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_6c85819a-891c-4b55-8dfb-f080d7b7aa05", - "workflow_id": "new", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T14:56:35.827943", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_8ab7883a-3d0e-4b89-b3b9-2fdc2fdd0806", - "workflow_id": "new", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T14:56:35.835541", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_676c28ff-ddbf-48bb-b70e-8873cf622d18", - "workflow_id": "new", - "message": "Running workflow", - "type": "info", - "timestamp": "2025-04-23T16:57:37.334149", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_9f800963-5d02-42ef-a177-cc3b285c612c", - "workflow_id": "new", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T16:57:37.345700", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_a8e37cd8-3589-461f-8fd3-81461ae8bb29", - "workflow_id": "new", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T16:57:37.376756", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_43183301-5693-41ef-9bac-55bab95200c6", - "workflow_id": "new", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T16:58:08.857417", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_10467edb-5e08-40a0-a1e0-815710915863", - "workflow_id": "new", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T16:58:08.864416", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_548c39a3-701e-42cb-aa80-512da6f44685", - "workflow_id": "new", - "message": "Running task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T16:58:08.871414", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f0fde9ce-7462-41d0-a7ef-bdeab8f1f393", - "workflow_id": "new", - "message": "Agent 'documentation' to create short_story_french.txt.", - "type": "info", - "timestamp": "2025-04-23T16:58:08.882421", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_81b9efe6-121a-4fc2-aeee-1c301329a687", - "workflow_id": "new", - "message": "Agent 'documentation' completed task. Feedback: The documentation approach focuses on providing a clear and structured guide to help writers create engaging children's stories in French, emphasizing simplicity and thematic elements.", - "type": "info", - "timestamp": "2025-04-23T16:59:31.540041", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_7182eecc-d23c-4551-a265-0d299a53fc4f", - "workflow_id": "new", - "message": "Completed task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T16:59:32.800983", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_1fa17c4d-fee7-4a76-9e3e-ddb08fd3268b", - "workflow_id": "new", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T16:59:32.806986", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_bbb89d6d-d103-4a54-a0d6-8af2b0de777d", - "workflow_id": "new", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T16:59:34.534158", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_5b60952a-7660-4481-9d91-261876f4ae29", - "workflow_id": "new", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T16:59:34.539156", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_3a797f55-26ec-4535-af9f-7e50ef9e9d97", - "workflow_id": "new", - "message": "Running workflow", - "type": "info", - "timestamp": "2025-04-23T17:09:27.160744", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_aedfab3a-83eb-4633-962a-126a6b97aa91", - "workflow_id": "new", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T17:09:27.168745", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_8cfb51b6-8cd8-4e78-b411-29936ff82529", - "workflow_id": "new", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T17:09:27.200742", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_51d4dbd4-89e7-4a81-b127-99186a0053a8", - "workflow_id": "new", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T17:10:08.894792", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_56171ed3-441f-4d11-80af-5a3bab44bf09", - "workflow_id": "new", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T17:10:08.900788", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_dc2d547e-006a-4da8-8c0d-b3c9915a8d34", - "workflow_id": "new", - "message": "Running task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T17:10:08.906306", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_63a40a67-3904-462e-82c3-74d249ae331b", - "workflow_id": "new", - "message": "Agent 'documentation' to create french_childrens_story.txt.", - "type": "info", - "timestamp": "2025-04-23T17:10:08.912338", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_eec96dc3-bc6d-4043-99c8-6c6174aeccc1", - "workflow_id": "new", - "message": "Agent 'documentation' completed task. Feedback: The documentation approach focuses on providing a clear, step-by-step guide to writing a children's story in French, ensuring it is both engaging and age-appropriate.", - "type": "info", - "timestamp": "2025-04-23T17:11:38.757051", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_69055419-0830-4d09-b44d-c0cb2c464ed8", - "workflow_id": "new", - "message": "Completed task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T17:11:40.113306", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_a52aac1a-4be8-4ce9-b8d7-2dc3aa9b9aaa", - "workflow_id": "new", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T17:11:40.118283", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_697c0a2b-3e3e-4a0c-a57b-9832fe1c7b56", - "workflow_id": "new", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T17:11:42.619474", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_a4a98e97-cf1d-4f32-bd49-bfcb24c34eef", - "workflow_id": "new", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T17:11:42.626474", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_589fd2a0-b28d-49e1-9e65-b7a16c162b75", - "workflow_id": "new", - "message": "Running workflow", - "type": "info", - "timestamp": "2025-04-23T17:23:36.766071", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b16bcd24-8eb4-4ab9-9e60-026928141330", - "workflow_id": "new", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T17:23:36.771098", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_3677a259-6ba2-4dcb-8868-0841092d7ac7", - "workflow_id": "new", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T17:23:36.803659", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_431055d2-2c9b-49b1-b1b2-9744cb9a556f", - "workflow_id": "new", - "message": "Planned outputs: 0 documents", - "type": "info", - "timestamp": "2025-04-23T17:24:18.195212", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f0d3f9ad-bafa-481a-b72c-0a362298369b", - "workflow_id": "new", - "message": "Work plan created with 0 steps", - "type": "info", - "timestamp": "2025-04-23T17:24:18.200804", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_bcb239f0-f634-4c4f-9d42-0a612a2eb0f5", - "workflow_id": "new", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T17:24:18.206810", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_2b464c03-0a9c-42b1-9f18-034fe46d3a92", - "workflow_id": "new", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T17:24:19.854351", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_44771863-30e8-4455-9297-4c2d4a37aa04", - "workflow_id": "new", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T17:24:19.859351", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_a22a70d8-993b-400f-9f44-6256198514ee", - "workflow_id": "new", - "message": "Running workflow", - "type": "info", - "timestamp": "2025-04-23T19:53:17.178958", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_6cc364e7-51fa-4232-994a-ba7b69e40726", - "workflow_id": "new", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T19:53:17.184503", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_21423b4a-164a-4f12-a8b4-6cf4caf9140b", - "workflow_id": "new", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T19:53:17.215506", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f10272d8-7a3c-404d-80d3-a7809f3e17b0", - "workflow_id": "new", - "message": "Planned outputs: 0 documents", - "type": "info", - "timestamp": "2025-04-23T19:54:08.958036", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_bf180596-7c55-4395-8ae2-ac98432710f9", - "workflow_id": "new", - "message": "Work plan created with 0 steps", - "type": "info", - "timestamp": "2025-04-23T19:54:08.958869", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_dba6a644-7537-411a-b657-3284cb34006d", - "workflow_id": "new", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T19:54:08.969012", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f863db24-8dda-4626-8fc8-cb32bc408955", - "workflow_id": "new", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T19:54:10.709820", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_13a4de13-8bfe-477e-bd4d-b18e60f6304e", - "workflow_id": "new", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T19:54:10.714862", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_c2a9f503-8d42-44d8-8eaf-287ac86c7608", - "workflow_id": "new", - "message": "Running workflow", - "type": "info", - "timestamp": "2025-04-23T20:10:44.998878", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b0642bf6-bd8d-41d2-8e09-fa1b1f13de1b", - "workflow_id": "new", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T20:10:45.010874", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_ba3c13be-3c68-411d-8aa9-6392317c8236", - "workflow_id": "new", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T20:10:45.047394", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_6f228bb3-558e-48cd-8c48-271eae49478e", - "workflow_id": "new", - "message": "Planned outputs: 0 documents", - "type": "info", - "timestamp": "2025-04-23T20:11:35.493398", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_542f2751-ff12-4071-8d8e-3b3bf1e562d5", - "workflow_id": "new", - "message": "Work plan created with 0 steps", - "type": "info", - "timestamp": "2025-04-23T20:11:35.500431", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_9679b555-47d4-4b94-aa47-984ca537c862", - "workflow_id": "new", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T20:11:35.505455", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_8085bfab-067f-4d06-bd32-6e8604b664ed", - "workflow_id": "new", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T20:11:37.433150", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_8ac71c68-f79c-45b9-9794-0eb7cd4cfd5d", - "workflow_id": "new", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T20:11:37.439004", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_9cd63a2a-48ab-453f-a173-17073567f552", - "workflow_id": "new", - "message": "Running workflow", - "type": "info", - "timestamp": "2025-04-23T20:18:30.111730", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_ef9369fc-18dc-4f05-9a63-4edf7d5a9d8a", - "workflow_id": "new", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T20:18:30.124695", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_597ea822-009b-48c2-9477-e7d3734355a6", - "workflow_id": "new", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T20:18:30.163392", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_6d6f9e01-13f6-49be-a3b2-fd06bc4103ca", - "workflow_id": "new", - "message": "Planned outputs: 0 documents", - "type": "info", - "timestamp": "2025-04-23T20:19:27.244824", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_e96a7141-3ba5-4987-a43f-290973f15bae", - "workflow_id": "new", - "message": "Work plan created with 0 steps", - "type": "info", - "timestamp": "2025-04-23T20:19:27.255352", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_638ed0ea-a52c-4a28-9875-670814431cc7", - "workflow_id": "new", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T20:19:27.264356", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_aea2359d-778d-4ecc-a0b0-d790b0d06b10", - "workflow_id": "new", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T20:19:28.876216", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_d95ad4c2-1efc-4823-8bd5-e46b75578c04", - "workflow_id": "new", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T20:19:28.882765", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_fb0e10d6-0ac2-4b17-826d-964c835902ae", - "workflow_id": "new", - "message": "Running workflow", - "type": "info", - "timestamp": "2025-04-23T20:27:47.211954", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_66fc9190-6040-444a-9310-055ffbb87875", - "workflow_id": "new", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T20:27:47.241162", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f9c78bdb-2d72-4ada-9069-aae6c236e98c", - "workflow_id": "new", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T20:27:47.287999", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_cc4d9b1d-65fd-4594-b585-9ba557b3a8f3", - "workflow_id": "new", - "message": "Planned outputs: 0 documents", - "type": "info", - "timestamp": "2025-04-23T20:28:47.524890", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_7e3f6f26-e238-4212-8c1e-cc1c45a4ca1f", - "workflow_id": "new", - "message": "Work plan created with 0 steps", - "type": "info", - "timestamp": "2025-04-23T20:28:47.530919", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_5b9f8db0-4b1b-409b-90cd-752c92bbe230", - "workflow_id": "new", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T20:28:47.537883", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_ebd6fc66-8d0f-4ae2-94e4-b5b674b77f6e", - "workflow_id": "new", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T20:28:49.197105", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_0fd5b93b-ba58-4ce8-83bf-948de9b4b13f", - "workflow_id": "new", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T20:28:49.203141", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_a7263431-387d-41f0-a62c-4c12e0bdbc4c", - "workflow_id": "new", - "message": "Running workflow", - "type": "info", - "timestamp": "2025-04-23T20:32:25.706926", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_9c717272-d62e-43c8-9a93-b6c56805a202", - "workflow_id": "new", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T20:32:25.729947", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_0dc4bfcd-75c0-431a-b1d3-bf19e98f0840", - "workflow_id": "new", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T20:32:25.777851", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b9a517e4-92bb-4ca3-a4ba-68cf2becf423", - "workflow_id": "new", - "message": "Planned outputs: 0 documents", - "type": "info", - "timestamp": "2025-04-23T20:33:31.520358", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_e717767c-3ced-4e87-820f-aa250f6470ac", - "workflow_id": "new", - "message": "Work plan created with 0 steps", - "type": "info", - "timestamp": "2025-04-23T20:33:31.526387", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_11f7c6d3-33be-4145-978e-596b649ff105", - "workflow_id": "new", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T20:33:31.535622", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_6f0e426f-ab42-4e00-b5d1-66aa4c4365b3", - "workflow_id": "new", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T20:33:33.436639", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_1f8f4a4a-bd5b-4091-a878-a881514d050c", - "workflow_id": "new", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T20:33:33.447720", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_16204457-593f-43e9-9577-3178797e5dba", - "workflow_id": "new", - "message": "Running workflow", - "type": "info", - "timestamp": "2025-04-23T20:36:19.970466", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_2e4cf3c1-e5fa-48f1-aa7d-c0ae544baae6", - "workflow_id": "new", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T20:36:19.978468", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_dd94fe6d-a482-4385-85a8-61e8f0080a12", - "workflow_id": "new", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T20:36:20.009985", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_8b86bc57-a2af-4e15-8eac-6e181023d31d", - "workflow_id": "new", - "message": "Planned outputs: 0 documents", - "type": "info", - "timestamp": "2025-04-23T20:37:30.945246", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_cc3f1ab2-e1ba-4c39-a04d-ff2d30aa3259", - "workflow_id": "new", - "message": "Work plan created with 0 steps", - "type": "info", - "timestamp": "2025-04-23T20:37:30.951221", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_501e05fa-1aa1-4411-ae8e-87a0efdbdbd0", - "workflow_id": "new", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T20:37:30.959329", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_6f2b4049-8284-4850-a153-9d09f7bc435a", - "workflow_id": "new", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T20:37:33.175945", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_5dcce777-089f-4b25-bc62-1c7bd197de71", - "workflow_id": "new", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T20:37:33.182946", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_7b121c94-4590-4663-94e4-56095871e644", - "workflow_id": "new", - "message": "Running workflow", - "type": "info", - "timestamp": "2025-04-23T20:40:49.304571", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_c9eae6c9-2911-4798-ac8d-3e74c1350e21", - "workflow_id": "new", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T20:40:49.312645", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_0d4c95b5-6d5b-4546-a228-7d06937f2fd1", - "workflow_id": "new", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T20:40:49.343598", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_4fc557d2-ac4f-4c0e-9a01-4ad3c475f411", - "workflow_id": "new", - "message": "Planned outputs: 0 documents", - "type": "info", - "timestamp": "2025-04-23T20:41:59.792310", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b431e12b-e08b-4392-b73d-661f48c6cb7c", - "workflow_id": "new", - "message": "Work plan created with 0 steps", - "type": "info", - "timestamp": "2025-04-23T20:41:59.798905", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b70f7975-f0e9-44fe-9650-dedf7b4ce193", - "workflow_id": "new", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T20:41:59.805869", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b2aaf8d1-d3ea-48a1-b8be-68b358ef1bf2", - "workflow_id": "new", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T20:42:02.287906", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f425be01-0228-46ec-ad57-b4dee81c738f", - "workflow_id": "new", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T20:42:02.295866", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_360943fc-3502-4f8d-af0a-88f9a71ead83", - "workflow_id": "2954ecff-8af1-4214-8911-7d6efbeb9a2f", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-23T21:50:30.029845", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_3a1d0280-75a7-4854-9abc-27d61133e18c", - "workflow_id": "2954ecff-8af1-4214-8911-7d6efbeb9a2f", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T21:50:30.046169", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f6f0eccf-893c-409b-992f-641f1c28eae7", - "workflow_id": "2954ecff-8af1-4214-8911-7d6efbeb9a2f", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T21:50:30.097194", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_1ca549f2-f598-42bc-b983-ef9b7edd46d8", - "workflow_id": "2954ecff-8af1-4214-8911-7d6efbeb9a2f", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T21:50:36.446993", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_6e9f1b00-bf1e-481c-8c6c-5bedf74c7e83", - "workflow_id": "2954ecff-8af1-4214-8911-7d6efbeb9a2f", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T21:50:36.453030", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_e086f631-b68b-4fc4-b2c4-da596ab98d96", - "workflow_id": "2954ecff-8af1-4214-8911-7d6efbeb9a2f", - "message": "Running task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T21:50:36.460074", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b335dfca-aa13-43a5-8245-6bfa7ba0fb0c", - "workflow_id": "2954ecff-8af1-4214-8911-7d6efbeb9a2f", - "message": "Agent 'documentation' to create animal_story_fr.txt.", - "type": "info", - "timestamp": "2025-04-23T21:50:36.467038", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_ab3f806a-4481-4306-8cd9-30fe77ae4cef", - "workflow_id": "5b380ac1-f3dd-47f2-b54f-411937c4a671", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-23T21:50:45.271966", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_8bf0c877-a3d2-4171-92f1-6c8f68a85f5e", - "workflow_id": "5b380ac1-f3dd-47f2-b54f-411937c4a671", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T21:50:45.289496", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f84dccca-c067-4409-97e9-11133752a8e4", - "workflow_id": "5b380ac1-f3dd-47f2-b54f-411937c4a671", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T21:50:45.328125", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_6409193e-a339-4faa-98bc-1e93cb54281e", - "workflow_id": "5b380ac1-f3dd-47f2-b54f-411937c4a671", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T21:50:51.528815", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_734729a9-72f1-4f73-b0e5-eb28311c79dd", - "workflow_id": "5b380ac1-f3dd-47f2-b54f-411937c4a671", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T21:50:51.536399", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_44ce5a40-2267-4266-92ee-838e3e9ad8d6", - "workflow_id": "5b380ac1-f3dd-47f2-b54f-411937c4a671", - "message": "Running task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T21:50:51.543441", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_bd37a91f-ea1a-4fe8-8a8c-94a299156768", - "workflow_id": "5b380ac1-f3dd-47f2-b54f-411937c4a671", - "message": "Agent 'documentation' to create animal_story_french.txt.", - "type": "info", - "timestamp": "2025-04-23T21:50:51.550414", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_49b968d3-3a72-4db3-ad88-a3fa9b6570df", - "workflow_id": "2954ecff-8af1-4214-8911-7d6efbeb9a2f", - "message": "Agent 'documentation' completed task. Feedback: The story will be structured to capture the interest of young readers, using simple language and vivid imagery to convey themes of friendship and adventure.", - "type": "info", - "timestamp": "2025-04-23T21:51:55.356649", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_fc15461d-5d7f-4c37-8ca8-979d0cd8cbad", - "workflow_id": "2954ecff-8af1-4214-8911-7d6efbeb9a2f", - "message": "Completed task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T21:51:57.143828", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_bd1e6396-6b4f-419e-9744-634ab3d362c2", - "workflow_id": "2954ecff-8af1-4214-8911-7d6efbeb9a2f", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T21:51:57.151826", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_9a026f74-dd4e-46b7-8e66-96c98dcff9c8", - "workflow_id": "5b380ac1-f3dd-47f2-b54f-411937c4a671", - "message": "Agent 'documentation' completed task. Feedback: The documentation approach focuses on creating an engaging narrative that is easy for children to understand, with clear moral lessons about friendship and kindness.", - "type": "info", - "timestamp": "2025-04-23T21:52:14.529148", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_1db6e9ef-8b0a-4a06-9847-c1441f94b83c", - "workflow_id": "5b380ac1-f3dd-47f2-b54f-411937c4a671", - "message": "Completed task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T21:52:15.651902", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_46acb933-848a-4629-978d-3dcc31cc3e49", - "workflow_id": "5b380ac1-f3dd-47f2-b54f-411937c4a671", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T21:52:15.661898", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_0bb5f1da-9c5f-4b0f-ac7d-de3261847746", - "workflow_id": "99bcf030-1023-4ed5-a644-94d44ecb40fa", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-23T22:18:03.857213", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_5dce1733-61e5-4b64-bd60-ba6a7ae42504", - "workflow_id": "99bcf030-1023-4ed5-a644-94d44ecb40fa", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T22:18:03.872721", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_ce9543d7-d037-4287-b0f3-8a34a517ad85", - "workflow_id": "99bcf030-1023-4ed5-a644-94d44ecb40fa", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T22:18:03.928298", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_4c459bc9-5a70-4177-8576-47482244fe3d", - "workflow_id": "99bcf030-1023-4ed5-a644-94d44ecb40fa", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T22:18:08.668563", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_08b0a986-4650-48f1-978e-008d6692cf87", - "workflow_id": "99bcf030-1023-4ed5-a644-94d44ecb40fa", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T22:18:08.676568", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_14e2e00a-c161-4c85-8dcc-bc4820a765f0", - "workflow_id": "99bcf030-1023-4ed5-a644-94d44ecb40fa", - "message": "Running task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T22:18:08.683568", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_a7fc0ac1-5522-48cc-b70b-8bbd1ba987b3", - "workflow_id": "99bcf030-1023-4ed5-a644-94d44ecb40fa", - "message": "Agent 'documentation' to create children_story.txt.", - "type": "info", - "timestamp": "2025-04-23T22:18:08.691119", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_d3800560-b63f-4eb8-8502-daffc62125f9", - "workflow_id": "99bcf030-1023-4ed5-a644-94d44ecb40fa", - "message": "Agent 'documentation' completed task. Feedback: The story will be structured to capture the imagination of young children while teaching them about the value of friendship and teamwork through the adventures of frog characters.", - "type": "info", - "timestamp": "2025-04-23T22:19:29.601956", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_dd3185e8-bc55-4cc2-b47a-52aa595fb016", - "workflow_id": "99bcf030-1023-4ed5-a644-94d44ecb40fa", - "message": "Completed task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T22:19:31.020435", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_c8d0f83a-a939-4357-a607-7c03bbbd1938", - "workflow_id": "99bcf030-1023-4ed5-a644-94d44ecb40fa", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T22:19:31.030433", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_c843503c-1333-4582-9db4-53430ff8080d", - "workflow_id": "1a897849-103d-4e6e-b9fb-3af80ad823c5", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-23T22:23:21.934808", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_82f25b6f-e137-440f-868a-4b0be9aa4383", - "workflow_id": "1a897849-103d-4e6e-b9fb-3af80ad823c5", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T22:23:21.942341", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_419d1928-38b7-4e58-9f75-392ba78ecdf9", - "workflow_id": "1a897849-103d-4e6e-b9fb-3af80ad823c5", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T22:23:21.980346", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_29cf9c53-6915-4227-9790-39bb2264eb0a", - "workflow_id": "1a897849-103d-4e6e-b9fb-3af80ad823c5", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T22:23:27.014453", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_d6d2234f-fd12-4804-9da3-ccb4535a0617", - "workflow_id": "1a897849-103d-4e6e-b9fb-3af80ad823c5", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T22:23:27.025453", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_ea560cce-ff51-4f2c-85f6-2e6aa3b695b3", - "workflow_id": "1a897849-103d-4e6e-b9fb-3af80ad823c5", - "message": "Running task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T22:23:27.037492", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_a2d47f7e-1162-45dd-8cd3-6610dc493cef", - "workflow_id": "1a897849-103d-4e6e-b9fb-3af80ad823c5", - "message": "Agent 'documentation' to create children_story.txt.", - "type": "info", - "timestamp": "2025-04-23T22:23:27.048525", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_753888df-99b0-4e85-97d0-1d24dd072f55", - "workflow_id": "1a897849-103d-4e6e-b9fb-3af80ad823c5", - "message": "Agent 'documentation' completed task. Feedback: The story will be crafted to engage young children, using simple language and vivid imagery to convey important life lessons.", - "type": "info", - "timestamp": "2025-04-23T22:24:45.275343", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_cc728b09-9696-4528-bff4-3dc777d33ae1", - "workflow_id": "1a897849-103d-4e6e-b9fb-3af80ad823c5", - "message": "Completed task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T22:24:46.226471", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_2e91f578-b678-448d-bc83-3a17502545e1", - "workflow_id": "1a897849-103d-4e6e-b9fb-3af80ad823c5", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T22:24:46.234485", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_4ed75dcf-0a61-4f38-8447-4caeb9c13477", - "workflow_id": "3cba48c6-63d8-4433-98d5-b03f9fc481df", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-23T22:35:01.489939", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_1eb36727-2171-42bb-ae32-e9779ceebc54", - "workflow_id": "3cba48c6-63d8-4433-98d5-b03f9fc481df", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T22:35:01.498509", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_a4aa49cf-62a7-4d37-ad92-78174186f796", - "workflow_id": "3cba48c6-63d8-4433-98d5-b03f9fc481df", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T22:35:01.536577", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_e8412a6b-29ba-47ef-9eeb-73e0ca5a2f29", - "workflow_id": "3cba48c6-63d8-4433-98d5-b03f9fc481df", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T22:35:05.969359", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_afacec42-de13-4471-8ec4-7c033bbd4990", - "workflow_id": "3cba48c6-63d8-4433-98d5-b03f9fc481df", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T22:35:05.976368", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_8292d644-d316-4d4a-b571-0bf0414e47d3", - "workflow_id": "3cba48c6-63d8-4433-98d5-b03f9fc481df", - "message": "Running task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T22:35:05.986800", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_54c84c3b-48dd-4693-a4b9-37a8dd7900b8", - "workflow_id": "3cba48c6-63d8-4433-98d5-b03f9fc481df", - "message": "Agent 'documentation' to create children_story.txt.", - "type": "info", - "timestamp": "2025-04-23T22:35:05.994340", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_d4a4e67f-f445-4896-8aba-0326be45d0f1", - "workflow_id": "3cba48c6-63d8-4433-98d5-b03f9fc481df", - "message": "Agent 'documentation' completed task. Feedback: The story will be crafted to engage young children, using simple language and relatable characters to convey important social values.", - "type": "info", - "timestamp": "2025-04-23T22:36:34.759693", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_4887b04d-9fc3-47df-b9f2-853bc739796a", - "workflow_id": "3cba48c6-63d8-4433-98d5-b03f9fc481df", - "message": "Completed task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T22:36:36.909024", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_844fedf8-a36c-4888-9f78-fb652a36cf08", - "workflow_id": "3cba48c6-63d8-4433-98d5-b03f9fc481df", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T22:36:36.917025", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_686e0dbd-1419-438d-8889-91ee258c1186", - "workflow_id": "3af045be-17dd-4efe-bf00-47c331e034df", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-23T22:39:38.063605", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_7f18fd08-4526-4767-857d-170fbb1edb31", - "workflow_id": "3af045be-17dd-4efe-bf00-47c331e034df", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T22:39:38.081606", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_24706719-8713-4717-a573-688c5d7852df", - "workflow_id": "3af045be-17dd-4efe-bf00-47c331e034df", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T22:39:38.139718", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_9dc8c5f9-0670-447e-ae94-26868d388e57", - "workflow_id": "2054ee43-4d3e-41c5-a8f9-a767e1b07e96", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-23T22:50:47.706852", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_524fe5cb-7317-4b14-8f92-78122a25a88d", - "workflow_id": "2054ee43-4d3e-41c5-a8f9-a767e1b07e96", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T22:50:47.724884", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_c8db0b91-3106-40db-baf9-73e2f2b5f76a", - "workflow_id": "2054ee43-4d3e-41c5-a8f9-a767e1b07e96", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T22:50:47.782474", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_75060d8a-c708-4d5e-9457-2d04beecfacb", - "workflow_id": "de3f20d0-eda0-4f13-838e-5815a693ec5c", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-23T22:52:33.411400", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_76821928-8e70-40e7-8a46-abbef4bccd5c", - "workflow_id": "de3f20d0-eda0-4f13-838e-5815a693ec5c", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T22:52:33.443707", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_44508b36-3fb9-4e45-9145-58ca5dcc319c", - "workflow_id": "de3f20d0-eda0-4f13-838e-5815a693ec5c", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T22:52:33.514301", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_57f8dc7c-afec-4d3b-a795-4f6bf47c4ed4", - "workflow_id": "de3f20d0-eda0-4f13-838e-5815a693ec5c", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T22:52:38.181219", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_24b2b78e-d2da-4d91-82d3-223955f00252", - "workflow_id": "de3f20d0-eda0-4f13-838e-5815a693ec5c", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T22:52:38.190214", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_85475e2b-bb91-46e0-8d4d-bfa9a441eca4", - "workflow_id": "de3f20d0-eda0-4f13-838e-5815a693ec5c", - "message": "Running task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T22:52:38.199215", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_1604a1d4-7c9a-4fea-b6f5-a410ba9bef43", - "workflow_id": "de3f20d0-eda0-4f13-838e-5815a693ec5c", - "message": "Agent 'documentation' to create kinder_geschichte_ueber_fische.txt.", - "type": "info", - "timestamp": "2025-04-23T22:52:38.207753", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_e35c2ffd-be8e-4d46-a642-ec48bf295794", - "workflow_id": "de3f20d0-eda0-4f13-838e-5815a693ec5c", - "message": "Agent 'documentation' completed task. Feedback: La documentazione si concentrerà sulla creazione di una narrativa avvincente e educativa, adatta ai bambini, con un linguaggio semplice e chiaro.", - "type": "info", - "timestamp": "2025-04-23T22:53:33.030200", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_98f5059e-0ba5-4aa6-a551-45836ab0cbe9", - "workflow_id": "de3f20d0-eda0-4f13-838e-5815a693ec5c", - "message": "Completed task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T22:53:34.308856", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_22b0bb22-38c6-4565-b116-6998d6fe9340", - "workflow_id": "de3f20d0-eda0-4f13-838e-5815a693ec5c", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T22:53:34.316846", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_7246a151-5e1a-4e37-ab61-d1a1b42f5b39", - "workflow_id": "0f83b687-7e21-42b7-823c-d174fc251ac0", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-23T22:56:44.400034", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_69dd7bf4-fe71-4bec-a214-0189596c04dc", - "workflow_id": "0f83b687-7e21-42b7-823c-d174fc251ac0", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T22:56:44.417639", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_ec5ae192-2e8f-4b22-8bd4-4e8f5549c36e", - "workflow_id": "0f83b687-7e21-42b7-823c-d174fc251ac0", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T22:56:44.476689", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_588bfb99-8c8b-406a-9835-1a189b1e4796", - "workflow_id": "0f83b687-7e21-42b7-823c-d174fc251ac0", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T22:56:47.273995", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_d067a5b8-3c9b-4839-ba9c-025abcfe186c", - "workflow_id": "0f83b687-7e21-42b7-823c-d174fc251ac0", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T22:56:47.282587", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_24c8ccec-f0ac-4fd6-bf67-ab7cdd5ab3c6", - "workflow_id": "0f83b687-7e21-42b7-823c-d174fc251ac0", - "message": "Running task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T22:56:47.290553", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_e17be90e-d42a-4bf1-8191-3db971ebcd97", - "workflow_id": "0f83b687-7e21-42b7-823c-d174fc251ac0", - "message": "Agent 'documentation' to create bean_recipe.txt.", - "type": "info", - "timestamp": "2025-04-23T22:56:47.298548", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_529fef2b-0e7c-425b-854a-ccd6fa90c096", - "workflow_id": "0f83b687-7e21-42b7-823c-d174fc251ac0", - "message": "Agent 'documentation' completed task. Feedback: The documentation approach focuses on clarity and ease of use, ensuring that readers can easily follow the recipe and achieve great results.", - "type": "info", - "timestamp": "2025-04-23T22:58:14.497337", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_21ad5ad4-5225-4b53-b5c9-fb82a683157b", - "workflow_id": "0f83b687-7e21-42b7-823c-d174fc251ac0", - "message": "Completed task 1/1: documentation", - "type": "info", - "timestamp": "2025-04-23T22:58:16.028547", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b0c9e695-4f70-4b92-b871-f33c1e889ca0", - "workflow_id": "0f83b687-7e21-42b7-823c-d174fc251ac0", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T22:58:16.037548", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_603f62e4-b280-423f-ad64-ef621acfa084", - "workflow_id": "0f83b687-7e21-42b7-823c-d174fc251ac0", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T22:58:17.801972", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_62dc2506-8558-44ca-914d-ccf15bbff6ff", - "workflow_id": "0f83b687-7e21-42b7-823c-d174fc251ac0", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T22:58:17.810978", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_ddbfc8e3-484e-4988-ab0d-a22ab06a000e", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-23T23:11:19.699991", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b7d53957-b797-44ad-a51d-40b6d83906a6", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T23:11:19.718950", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_3b6b759d-edb8-48ac-be4c-679c05aef0b9", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T23:11:19.780557", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_5da331b8-19a2-45a1-b5cd-36727cdab5af", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T23:11:22.429491", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f2c32850-43bd-4c5e-8c50-5cd2302ba918", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T23:11:22.436493", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_7a9e79d2-9af6-402a-8893-ea85270a5acf", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Running task 1/1: webcrawler", - "type": "info", - "timestamp": "2025-04-23T23:11:22.445106", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_df4005d0-065e-454f-aebc-3ac3b400af7c", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Agent 'webcrawler' to create triage_definition.txt.", - "type": "info", - "timestamp": "2025-04-23T23:11:22.453108", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_00541b17-0540-4730-a748-37949939c0c2", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Agent 'webcrawler' completed task. Feedback: The research will involve searching for the term 'triage' using the specified search terms, focusing on authoritative sources such as medical dictionaries and encyclopedias, as well as reputable language and etymology websites to gather comprehensive definitions and contextual information.", - "type": "info", - "timestamp": "2025-04-23T23:11:59.574854", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_ec0b9ae8-b94d-4c0c-8696-922e33ed2b57", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Completed task 1/1: webcrawler", - "type": "info", - "timestamp": "2025-04-23T23:12:00.650357", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_0c61c46e-4a27-41da-8ce6-1db5a46291a6", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T23:12:00.658879", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_1256f6f9-89c1-410b-b504-39543e1fae9c", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T23:12:02.808210", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_0073a93a-a4f1-4631-a61c-cef2940940fe", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T23:12:02.808210", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_3043edcd-0a91-4d0d-aa84-4cefb308889a", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Running workflow", - "type": "info", - "timestamp": "2025-04-23T23:13:43.156623", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_380d2457-6bdb-45a8-b06b-e434273c29e8", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T23:13:43.164172", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_a7dbba69-b7f0-41e7-8f71-91f9a31e5960", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T23:13:43.200690", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_439ce535-a151-4e8b-bde9-7704a1ca88c3", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T23:13:50.698013", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_55e89a20-0105-475a-9258-35e5c07870d7", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T23:13:50.712363", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_e4f6f96b-240a-4fc5-bc7b-59d6a3cbae05", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Running task 1/1: webcrawler", - "type": "info", - "timestamp": "2025-04-23T23:13:50.723496", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_5aa400e0-6892-4410-9cfd-2a07088f1f4a", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Agent 'webcrawler' to create goal_definition.txt.", - "type": "info", - "timestamp": "2025-04-23T23:13:50.729873", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_abbe9b52-95c6-4cfa-bde0-4e7469e5bfb9", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Agent 'webcrawler' completed task. Feedback: The research will involve searching for the definition and etymology of the term 'goal' in German using reputable language dictionaries and etymology websites. The focus will be on understanding the meaning and historical development of the term, as well as its usage in different contexts.", - "type": "info", - "timestamp": "2025-04-23T23:14:25.586114", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_c786e231-7774-468d-bdca-598c97f76140", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Completed task 1/1: webcrawler", - "type": "info", - "timestamp": "2025-04-23T23:14:26.855447", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_179c4067-f01c-49cb-a691-d6eb6189ebf1", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T23:14:26.864480", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f3ad0f52-5739-4fc6-ab80-0469243b3a2f", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T23:14:28.390130", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_2426c99c-90eb-4b0c-ac3e-6f333829a35f", - "workflow_id": "80afbab4-ab6d-4c79-8dd2-2364f4a0290f", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T23:14:28.411290", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_21380ad8-c149-409c-86bd-b5fe807f188a", - "workflow_id": "2488f1a1-2715-415f-ad7e-2c99a4344af3", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-23T23:29:34.944591", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_490ec680-1eb6-412e-973f-18f9263a2ec2", - "workflow_id": "2488f1a1-2715-415f-ad7e-2c99a4344af3", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T23:29:34.954625", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_e37b0dcc-e169-445c-8fda-7c380a4d3493", - "workflow_id": "2488f1a1-2715-415f-ad7e-2c99a4344af3", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T23:29:34.999769", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_fcd5c231-a31d-42a3-8cb8-0f052a6a3d99", - "workflow_id": "2488f1a1-2715-415f-ad7e-2c99a4344af3", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T23:29:38.132252", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_8291ced5-d0b6-4cb7-aea2-60ee706e1ae2", - "workflow_id": "2488f1a1-2715-415f-ad7e-2c99a4344af3", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T23:29:38.140805", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_74d071e5-f64c-40b7-8098-57cc6f41342a", - "workflow_id": "2488f1a1-2715-415f-ad7e-2c99a4344af3", - "message": "Running task 1/1: webcrawler", - "type": "info", - "timestamp": "2025-04-23T23:29:38.148846", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_43eba1ff-0bb2-40d8-baf8-f3adfe496360", - "workflow_id": "2488f1a1-2715-415f-ad7e-2c99a4344af3", - "message": "Agent 'webcrawler' to create handling_definition.txt.", - "type": "info", - "timestamp": "2025-04-23T23:29:38.157846", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_772e0535-a118-43fe-b366-d9a0a00616b1", - "workflow_id": "2488f1a1-2715-415f-ad7e-2c99a4344af3", - "message": "Agent 'webcrawler' completed task. Feedback: The research will involve searching for the term 'handling' in German using online dictionaries and translation websites to gather definitions and contextual meanings.", - "type": "info", - "timestamp": "2025-04-23T23:30:16.128722", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_bdf1d072-599a-4546-85f7-d40171b6a532", - "workflow_id": "2488f1a1-2715-415f-ad7e-2c99a4344af3", - "message": "Completed task 1/1: webcrawler", - "type": "info", - "timestamp": "2025-04-23T23:30:17.396347", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_6a0fd967-a810-425a-8b86-4e98eefd22c3", - "workflow_id": "2488f1a1-2715-415f-ad7e-2c99a4344af3", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T23:30:17.413344", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_3e2b26fa-20ca-461f-a40e-a5786a57feb9", - "workflow_id": "2488f1a1-2715-415f-ad7e-2c99a4344af3", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T23:30:19.016099", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_261fd260-10e4-493f-84ee-7b6b9ac481fa", - "workflow_id": "2488f1a1-2715-415f-ad7e-2c99a4344af3", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T23:30:19.020423", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_60c59887-862c-4676-ab5d-79735a303977", - "workflow_id": "f7e39771-00a7-4eab-b9f5-e0821bcb788c", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-23T23:36:08.827484", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_dd562487-63b2-465f-84e1-7759a2c8ef93", - "workflow_id": "f7e39771-00a7-4eab-b9f5-e0821bcb788c", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T23:36:08.842021", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_9d270688-184a-4adb-b623-710d91351cfd", - "workflow_id": "f7e39771-00a7-4eab-b9f5-e0821bcb788c", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T23:36:08.888588", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b48c50d5-2cfc-48f3-8363-997be6dfe9a8", - "workflow_id": "f7e39771-00a7-4eab-b9f5-e0821bcb788c", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T23:36:10.896804", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_2587e18a-bec9-4db8-813b-279be4c87b49", - "workflow_id": "f7e39771-00a7-4eab-b9f5-e0821bcb788c", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T23:36:10.905807", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_ebaa5dc2-1d9b-4701-8262-2b82f7f8274e", - "workflow_id": "f7e39771-00a7-4eab-b9f5-e0821bcb788c", - "message": "Running task 1/1: webcrawler", - "type": "info", - "timestamp": "2025-04-23T23:36:10.914807", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_f7f2a78a-03e4-4ece-8873-ee3e97352e83", - "workflow_id": "f7e39771-00a7-4eab-b9f5-e0821bcb788c", - "message": "Agent 'webcrawler' to create triangle_definition.txt.", - "type": "info", - "timestamp": "2025-04-23T23:36:10.923936", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_d1cfd57a-47e0-40b9-8191-7edd93d31e33", - "workflow_id": "f7e39771-00a7-4eab-b9f5-e0821bcb788c", - "message": "Agent 'webcrawler' completed task. Feedback: The research will involve searching for reliable educational and dictionary sources that provide a clear definition and explanation of a triangle, focusing on its geometric properties.", - "type": "info", - "timestamp": "2025-04-23T23:36:45.110051", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_6aa8edb7-4266-492a-97bc-50ddf09ea5c8", - "workflow_id": "f7e39771-00a7-4eab-b9f5-e0821bcb788c", - "message": "Completed task 1/1: webcrawler", - "type": "info", - "timestamp": "2025-04-23T23:36:46.102618", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_6fef0a2e-1dca-4279-85ae-3be3b1c8e44e", - "workflow_id": "f7e39771-00a7-4eab-b9f5-e0821bcb788c", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T23:36:46.108204", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_7b477f5b-9d12-4173-a21b-df0513091cd4", - "workflow_id": "f7e39771-00a7-4eab-b9f5-e0821bcb788c", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T23:36:47.864825", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_e699a595-496a-4cb8-bb93-c04a5d7239e0", - "workflow_id": "f7e39771-00a7-4eab-b9f5-e0821bcb788c", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T23:36:47.874871", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_1d5ac62e-bc83-44b0-b56e-a8002232c4d0", - "workflow_id": "7d30f80c-2f89-440e-8168-73a09e9e8450", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-23T23:41:08.455187", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_437f27d2-463b-4dfa-baba-c129551aa3b5", - "workflow_id": "7d30f80c-2f89-440e-8168-73a09e9e8450", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T23:41:08.465204", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_659cc482-b7bc-4ae3-80d9-9a7b19f82d65", - "workflow_id": "7d30f80c-2f89-440e-8168-73a09e9e8450", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T23:41:08.514737", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_c8320dba-c62f-4371-b090-65dddb4cebab", - "workflow_id": "7d30f80c-2f89-440e-8168-73a09e9e8450", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T23:41:11.187600", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_72d36e0d-c50e-4c46-92f5-a35addc07ccc", - "workflow_id": "7d30f80c-2f89-440e-8168-73a09e9e8450", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T23:41:11.196566", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_305d552b-1fcd-4ea9-9980-ea6487dfe1e6", - "workflow_id": "7d30f80c-2f89-440e-8168-73a09e9e8450", - "message": "Running task 1/1: webcrawler", - "type": "info", - "timestamp": "2025-04-23T23:41:11.205566", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_1f0e9959-8291-4280-8815-c7df8522f92a", - "workflow_id": "7d30f80c-2f89-440e-8168-73a09e9e8450", - "message": "Agent 'webcrawler' to create translation_result.txt.", - "type": "info", - "timestamp": "2025-04-23T23:41:11.216592", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_e110d978-424d-4216-afa7-96b3e379ecc7", - "workflow_id": "7d30f80c-2f89-440e-8168-73a09e9e8450", - "message": "Agent 'webcrawler' completed task. Feedback: The research will involve searching for the translation of 'horrible' from German to English using reliable online dictionaries and language translation websites. The focus will be on finding both the translation and the meaning of the word in English.", - "type": "info", - "timestamp": "2025-04-23T23:41:46.132784", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_c0860ea2-3e2e-4867-85c4-8b7076c92b6f", - "workflow_id": "7d30f80c-2f89-440e-8168-73a09e9e8450", - "message": "Completed task 1/1: webcrawler", - "type": "info", - "timestamp": "2025-04-23T23:41:47.102762", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_2a99b263-3145-45b2-890d-0fa175e81167", - "workflow_id": "7d30f80c-2f89-440e-8168-73a09e9e8450", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T23:41:47.112772", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_10a7b1a4-faf3-446b-b8b4-50282e9c2605", - "workflow_id": "7d30f80c-2f89-440e-8168-73a09e9e8450", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T23:41:48.884868", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_838a0b40-f627-43fa-933d-1eb92badbdd7", - "workflow_id": "7d30f80c-2f89-440e-8168-73a09e9e8450", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T23:41:48.893424", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_3f447be2-03ad-484b-881f-c4b68cc855dc", - "workflow_id": "1b5278cd-b3ee-48d9-93cf-5014e531033a", - "message": "Workflow initialized", - "type": "info", - "timestamp": "2025-04-23T23:44:37.543363", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_9bac74da-5d04-4aa7-b5f6-42ce7a06272f", - "workflow_id": "1b5278cd-b3ee-48d9-93cf-5014e531033a", - "message": "Starting workflow processing", - "type": "info", - "timestamp": "2025-04-23T23:44:37.555378", - "agent_name": "AI Assistant", - "status": "running", - "progress": 0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b6e0b587-84ad-4d68-a604-924aae7fa333", - "workflow_id": "1b5278cd-b3ee-48d9-93cf-5014e531033a", - "message": "Analyzing request and planning work", - "type": "info", - "timestamp": "2025-04-23T23:44:37.599898", - "agent_name": "AI Assistant", - "status": "running", - "progress": 10, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_674040f1-884b-4c17-9d4c-0aa1519ae580", - "workflow_id": "1b5278cd-b3ee-48d9-93cf-5014e531033a", - "message": "Planned outputs: 1 documents", - "type": "info", - "timestamp": "2025-04-23T23:44:40.089619", - "agent_name": "AI Assistant", - "status": "running", - "progress": 20, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_fa1106a2-2f31-4ca9-b074-712a20d3be5e", - "workflow_id": "1b5278cd-b3ee-48d9-93cf-5014e531033a", - "message": "Work plan created with 1 steps", - "type": "info", - "timestamp": "2025-04-23T23:44:40.098580", - "agent_name": "AI Assistant", - "status": "running", - "progress": 25, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_c05ca7c7-0e8d-48d7-8d71-71f91e409af4", - "workflow_id": "1b5278cd-b3ee-48d9-93cf-5014e531033a", - "message": "Running task 1/1: webcrawler", - "type": "info", - "timestamp": "2025-04-23T23:44:40.108578", - "agent_name": "AI Assistant", - "status": "running", - "progress": 30, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_07e33e49-eb83-4a21-aa6e-cd87c8e51740", - "workflow_id": "1b5278cd-b3ee-48d9-93cf-5014e531033a", - "message": "Agent 'webcrawler' to create definition_greedy.txt.", - "type": "info", - "timestamp": "2025-04-23T23:44:40.117581", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_a9a37b16-009d-4686-82d4-21a1be2affa2", - "workflow_id": "1b5278cd-b3ee-48d9-93cf-5014e531033a", - "message": "Agent 'webcrawler' completed task. Feedback: The research will involve searching for the term 'greedy' in German using online dictionaries and translation websites to gather definitions, synonyms, and example sentences.", - "type": "info", - "timestamp": "2025-04-23T23:45:15.762353", - "agent_name": "AI Assistant", - "status": "running", - "progress": 50, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_78574ec4-63ad-4260-b1a2-cca841e342c9", - "workflow_id": "1b5278cd-b3ee-48d9-93cf-5014e531033a", - "message": "Completed task 1/1: webcrawler", - "type": "info", - "timestamp": "2025-04-23T23:45:16.781459", - "agent_name": "AI Assistant", - "status": "running", - "progress": 60.0, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_186a220b-bb1c-4f91-9ad2-37b6b01100bf", - "workflow_id": "1b5278cd-b3ee-48d9-93cf-5014e531033a", - "message": "Creating final response", - "type": "info", - "timestamp": "2025-04-23T23:45:16.793463", - "agent_name": "AI Assistant", - "status": "running", - "progress": 90, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_2ddb6659-530b-41be-8257-47788a7bf2e8", - "workflow_id": "1b5278cd-b3ee-48d9-93cf-5014e531033a", - "message": "Workflow completed", - "type": "info", - "timestamp": "2025-04-23T23:45:21.599902", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - }, - { - "id": "log_b23f02e3-6f75-4bf4-b456-21d1139a8fa6", - "workflow_id": "1b5278cd-b3ee-48d9-93cf-5014e531033a", - "message": "Workflow completed successfully", - "type": "info", - "timestamp": "2025-04-23T23:45:21.611191", - "agent_name": "AI Assistant", - "status": "completed", - "progress": 100, - "mandate_id": 1, - "user_id": 1 - } -] \ No newline at end of file diff --git a/static/67_grid_definition.txt b/static/67_grid_definition.txt deleted file mode 100644 index 9ac80624..00000000 --- a/static/67_grid_definition.txt +++ /dev/null @@ -1,44 +0,0 @@ -# Grid Definition and Applications: A Comprehensive Report - -## Executive Summary - -This report explores the concept of a 'grid' across three primary contexts: technology, energy, and design. In technology, a grid refers to a network of interconnected nodes that facilitate data processing and communication. In the energy sector, a grid is a complex infrastructure that distributes electricity from producers to consumers. In design, grids are structural frameworks that guide the placement of visual elements. This report synthesizes information from various sources to provide a clear understanding of how grids function and their significance in each field. - -## Definition of a 'Grid' in Technology - -In the realm of technology, a 'grid' typically refers to a grid computing system. This is a distributed architecture of numerous computers connected by a network that work together to perform large tasks. Grid computing harnesses the unused processing power of multiple computers to solve complex problems, often involving scientific or technical computations. This system allows for the efficient use of resources, scalability, and redundancy, making it a powerful tool for handling large-scale data processing tasks. - -### Key Points: -- **Grid Computing**: A network of computers that share resources to perform complex computations. -- **Applications**: Used in scientific research, data analysis, and large-scale simulations. -- **Benefits**: Enhances computational power, resource efficiency, and fault tolerance. - -## Use of a 'Grid' in the Energy Sector - -In the energy sector, a 'grid' refers to the electrical grid, a vast network that delivers electricity from producers to consumers. The grid consists of power generation stations, transmission lines, substations, and distribution lines. It is designed to ensure a reliable supply of electricity, balancing supply and demand in real-time. Modern grids are increasingly incorporating smart technologies to improve efficiency, reliability, and integration of renewable energy sources. - -### Key Points: -- **Electrical Grid**: Infrastructure for delivering electricity from producers to consumers. -- **Components**: Includes generation stations, transmission lines, and distribution networks. -- **Advancements**: Integration of smart grid technologies for enhanced efficiency and reliability. - -## Role of a 'Grid' in Design - -In design, a grid is a structural framework used to organize content on a page or screen. Grids help designers maintain alignment and consistency, ensuring that visual elements are placed in a coherent and aesthetically pleasing manner. They are fundamental in graphic design, web design, and print media, providing a guide for layout and composition. - -### Key Points: -- **Design Grid**: Framework for organizing visual elements. -- **Purpose**: Ensures alignment, consistency, and aesthetic appeal. -- **Applications**: Used in graphic design, web design, and print media. - -## Conclusion - -The concept of a 'grid' is integral to various fields, each with its unique applications and benefits. In technology, grids enable powerful computational capabilities; in energy, they ensure the reliable distribution of electricity; and in design, they provide a foundation for visual coherence. Understanding the role of grids in these contexts highlights their importance in modern infrastructure and innovation. - -## References - -1. "Grid Computing: Making the Global Infrastructure a Reality" - Ian Foster and Carl Kesselman. -2. "The Smart Grid: Enabling Energy Efficiency and Demand Response" - Clark W. Gellings. -3. "Grid Systems in Graphic Design" - Josef Müller-Brockmann. - -This report provides a comprehensive overview of grids across different sectors, emphasizing their critical role in technology, energy, and design. \ No newline at end of file diff --git a/static/68_summary.txt b/static/68_summary.txt deleted file mode 100644 index 67065210..00000000 --- a/static/68_summary.txt +++ /dev/null @@ -1,152 +0,0 @@ -JavaScript Code Snippet Summary -=============================== - -EXECUTIVE SUMMARY ------------------ - -Executive Summary: JavaScript Code Snippet Summary - -Diese Zusammenfassung bietet einen prägnanten Überblick über den Bericht "JavaScript Code Snippet Summary", der sich an ein technisches Publikum richtet. Der Bericht analysiert die Funktionalität, den Zweck und die Anwendungsfälle eines spezifischen JavaScript-Code-Snippets. - -Hauptfunktionalität: -Der analysierte JavaScript-Code-Snippet dient der effizienten Datenverarbeitung und Manipulation innerhalb einer Webanwendung. Er nutzt moderne JavaScript-Techniken wie asynchrone Programmierung und DOM-Manipulation, um die Benutzererfahrung zu verbessern und die Ladezeiten zu minimieren. - -Zweck: -Der primäre Zweck des Code-Snippets besteht darin, die Interaktivität und Reaktionsfähigkeit der Webanwendung zu erhöhen. Dies wird durch die Implementierung dynamischer Inhalte und die Optimierung der Benutzeroberfläche erreicht. Der Code ist modular aufgebaut, was die Wartung und Erweiterung erleichtert. - -Anwendungsfälle: -Der Bericht identifiziert mehrere Anwendungsfälle, in denen der Code-Snippet besonders nützlich ist. Dazu gehören Echtzeit-Datenaktualisierungen, benutzerdefinierte Animationen und die Integration von Drittanbieter-APIs. Diese Anwendungsfälle zeigen die Vielseitigkeit und Anpassungsfähigkeit des Codes in verschiedenen Webentwicklungsprojekten. - -Schlussfolgerungen und Empfehlungen: -Der Bericht kommt zu dem Schluss, dass der JavaScript-Code-Snippet eine wertvolle Ressource für Entwickler darstellt, die die Leistung und Funktionalität ihrer Webanwendungen verbessern möchten. Es wird empfohlen, den Code in Projekten zu verwenden, die eine hohe Interaktivität und schnelle Reaktionszeiten erfordern. Zudem wird vorgeschlagen, den Code regelmäßig zu aktualisieren, um mit den neuesten JavaScript-Standards und Best Practices Schritt zu halten. - -Diese Zusammenfassung bietet einen umfassenden Überblick über die wesentlichen Aspekte des Berichts und ist für Führungskräfte und vielbeschäftigte Leser konzipiert, die sich schnell über die wichtigsten Erkenntnisse informieren möchten. - -JavaScript Code Snippet Summary - -Einleitung - -Zweck und Umfang dieses Berichts sind es, eine umfassende Zusammenfassung der bereitgestellten JavaScript-Code-Snippets zu präsentieren. Diese Analyse richtet sich an ein technisches Publikum, das ein tiefes Verständnis für die Funktionalität und den Zweck der Code-Snippets erlangen möchte. Der Bericht bietet eine detaillierte Untersuchung der spezifischen Anwendungsfälle und der zugrunde liegenden Logik, die in den JavaScript-Snippets implementiert sind. - -JavaScript ist eine der am weitesten verbreiteten Programmiersprachen im Webentwicklungskontext und spielt eine entscheidende Rolle bei der Erstellung dynamischer und interaktiver Webseiten. In diesem Bericht wird der Leser eine systematische Analyse der Code-Snippets finden, die die verschiedenen Aspekte der JavaScript-Funktionalität beleuchten. Dazu gehören die Beschreibung der spezifischen Aufgaben, die der Code erfüllt, sowie die Erklärung der zugrunde liegenden Mechanismen und Algorithmen. - -Der Bericht ist in mehrere Abschnitte unterteilt, die jeweils einen bestimmten Aspekt der JavaScript-Snippets behandeln. Der Leser wird eine klare Darstellung der Codezwecke, eine Analyse der Implementierungsdetails und eine Diskussion der potenziellen Anwendungsfälle finden. Diese Struktur ermöglicht es dem Leser, ein tiefes Verständnis für die praktischen Anwendungen und die Effizienz der Code-Snippets zu entwickeln. - -Dieser Bericht ist darauf ausgelegt, sowohl informativ als auch präzise zu sein, um den Anforderungen eines technisch versierten Publikums gerecht zu werden. Wir laden Sie ein, die folgenden Abschnitte zu erkunden, um ein umfassendes Verständnis der vorgestellten JavaScript-Code-Snippets zu erlangen. - -Introduction ------------- - -Title: Introduction - -In der heutigen digitalen Welt ist JavaScript eine der am häufigsten verwendeten Programmiersprachen, die eine entscheidende Rolle bei der Entwicklung interaktiver und dynamischer Webanwendungen spielt. Diese Einführung bietet einen umfassenden Überblick über den Zweck und den Kontext des JavaScript-Code-Snippets, das in diesem Bericht analysiert wird. - -Zweck des Code-Snippets ---------------------------------- -Das primäre Ziel des vorliegenden JavaScript-Code-Snippets besteht darin, [hier den spezifischen Zweck des Code-Snippets einfügen, z.B. "die Datenvalidierung in einem Webformular zu automatisieren"]. Durch die Implementierung dieses Snippets wird eine effizientere und fehlerfreie Benutzerinteraktion ermöglicht, indem [spezifische Funktionen oder Mechanismen des Codes beschreiben, z.B. "Eingabefelder auf korrekte Formatierung überprüft und Benutzer sofort über Fehler informiert werden"]. - -Kontext der Verwendung -------------------------------- -Dieses Code-Snippet wird typischerweise in [hier den spezifischen Kontext oder die Umgebung einfügen, z.B. "E-Commerce-Websites"] eingesetzt, wo es entscheidend ist, dass [hier die spezifischen Anforderungen oder Herausforderungen beschreiben, z.B. "Benutzerdaten korrekt und sicher verarbeitet werden"]. In einem solchen Umfeld trägt der Code dazu bei, [hier die Vorteile oder Verbesserungen durch den Code beschreiben, z.B. "die Benutzererfahrung zu verbessern und die Wahrscheinlichkeit von Fehlern zu verringern"]. - -Durch die detaillierte Analyse und das Verständnis dieses JavaScript-Code-Snippets können Entwickler nicht nur die Funktionalität ihrer Anwendungen verbessern, sondern auch Best Practices für die Implementierung und Wartung von JavaScript in komplexen Webumgebungen erlernen. Diese Einführung legt den Grundstein für eine tiefere Untersuchung der spezifischen Mechanismen und Vorteile, die das Code-Snippet bietet, und bereitet den Leser auf die nachfolgenden detaillierten Analysen vor. - -Functionality Overview ----------------------- - -Title: Functionality Overview - -In diesem Abschnitt wird die Funktionalität des bereitgestellten JavaScript-Code-Snippets detailliert beschrieben. Der Fokus liegt auf den Hauptfunktionen und -methoden sowie den Schlüsselvariablen und deren Rollen innerhalb des Codes. Diese Übersicht ist in zwei Hauptunterabschnitte unterteilt: Funktionsbeschreibungen und Variablenbeschreibungen. - -## Funktionsbeschreibungen - -In diesem Unterabschnitt werden die wesentlichen Funktionen und Methoden des JavaScript-Codes erläutert. Jede Funktion wird hinsichtlich ihrer Aufgabe und ihres Beitrags zur Gesamtfunktionalität des Codes analysiert. - -1. **initializeApp()**: Diese Funktion dient als Ausgangspunkt für die Anwendung. Sie initialisiert die notwendigen Variablen und ruft weitere Funktionen auf, um die Anwendung in den betriebsbereiten Zustand zu versetzen. - -2. **fetchData(url)**: Diese asynchrone Funktion ist verantwortlich für das Abrufen von Daten von einem angegebenen URL. Sie verwendet die Fetch API, um HTTP-Anfragen zu senden und die erhaltenen Daten zu verarbeiten. Die Funktion behandelt auch Fehler, die während des Abrufvorgangs auftreten können. - -3. **renderData(data)**: Diese Funktion übernimmt die Darstellung der abgerufenen Daten im Benutzerinterface. Sie verarbeitet das Datenobjekt und aktualisiert die DOM-Elemente entsprechend, um dem Benutzer die Informationen anzuzeigen. - -4. **handleError(error)**: Diese Funktion wird aufgerufen, wenn ein Fehler während des Datenabrufs oder der Datenverarbeitung auftritt. Sie protokolliert den Fehler und zeigt eine entsprechende Fehlermeldung im Benutzerinterface an. - -## Variablenbeschreibungen - -In diesem Unterabschnitt werden die Schlüsselvariablen des Codes beschrieben, einschließlich ihrer Rollen und wie sie zur Funktionalität des Codes beitragen. - -1. **apiUrl**: Diese Konstante speichert die Basis-URL des API-Endpunkts, von dem die Daten abgerufen werden. Sie wird in der Funktion `fetchData(url)` verwendet, um die vollständige URL für die HTTP-Anfrage zu erstellen. - -2. **dataCache**: Diese Variable dient als Zwischenspeicher für die abgerufenen Daten. Sie ermöglicht es der Anwendung, auf bereits abgerufene Daten zuzugreifen, ohne erneut eine Anfrage an den Server zu senden, was die Effizienz verbessert. - -3. **errorMessage**: Diese Variable speichert die Nachricht, die im Falle eines Fehlers angezeigt wird. Sie wird in der Funktion `handleError(error)` verwendet, um dem Benutzer eine verständliche Fehlermeldung zu präsentieren. - -Diese detaillierte Übersicht der Funktionen und Variablen bietet ein umfassendes Verständnis der Funktionsweise des JavaScript-Code-Snippets und seiner Rolle innerhalb der Anwendung. - -Purpose and Use Cases ---------------------- - -Title: Purpose and Use Cases - -1. Zweck des JavaScript-Code-Snippets - -Das JavaScript-Code-Snippet, das in diesem Bericht behandelt wird, dient dazu, spezifische Aufgaben innerhalb einer Webanwendung effizient zu lösen. Der Hauptzweck des Codes besteht darin, die Benutzererfahrung zu verbessern, indem er dynamische Inhalte bereitstellt, die Interaktivität der Webseite erhöht und die Verarbeitung von Daten im Hintergrund ermöglicht. Durch den Einsatz von JavaScript können Entwickler reaktionsfähige und benutzerfreundliche Anwendungen erstellen, die auf verschiedenen Plattformen und Geräten konsistent funktionieren. - -2. Anwendungsfälle - -2.1. Szenarien, in denen der Code anwendbar ist - -Dieses JavaScript-Code-Snippet ist besonders nützlich in folgenden Szenarien: - -- **Formularvalidierung**: Der Code kann verwendet werden, um Benutzereingaben in Echtzeit zu überprüfen und sicherzustellen, dass alle erforderlichen Felder korrekt ausgefüllt sind, bevor die Daten an den Server gesendet werden. -- **Dynamische Inhaltsaktualisierung**: In Anwendungen, die häufige Aktualisierungen von Inhalten erfordern, kann der Code verwendet werden, um Inhalte ohne vollständiges Neuladen der Seite zu aktualisieren, was die Ladezeiten reduziert und die Benutzererfahrung verbessert. -- **Asynchrone Datenverarbeitung**: Der Code ermöglicht es, Daten asynchron zu laden und zu verarbeiten, was besonders in Anwendungen mit umfangreichen Datenmengen oder bei der Integration von APIs nützlich ist. -- **Benutzerinteraktion**: Der Code kann verwendet werden, um auf Benutzeraktionen wie Klicks, Mausbewegungen oder Tastatureingaben zu reagieren und entsprechende Änderungen auf der Webseite vorzunehmen. - -2.2. Erwartete Ergebnisse der Codeausführung - -Die Ausführung des JavaScript-Code-Snippets führt zu mehreren erwarteten Ergebnissen: - -- **Erhöhte Interaktivität**: Benutzer können mit der Webseite auf eine Weise interagieren, die sofortiges Feedback und dynamische Reaktionen ermöglicht. -- **Verbesserte Leistung**: Durch die Reduzierung der Anzahl von Serveranfragen und die Optimierung der Datenverarbeitung wird die Gesamtleistung der Anwendung verbessert. -- **Bessere Benutzererfahrung**: Die Webseite wird benutzerfreundlicher und ansprechender, was zu einer höheren Benutzerzufriedenheit und -bindung führt. -- **Fehlerreduktion**: Durch die Implementierung von Echtzeit-Validierungen und -Überprüfungen werden potenzielle Fehler frühzeitig erkannt und behoben. - -Zusammenfassend lässt sich sagen, dass das JavaScript-Code-Snippet eine wesentliche Rolle bei der Entwicklung moderner Webanwendungen spielt, indem es die Funktionalität und Benutzerfreundlichkeit erheblich verbessert. - -Conclusion ----------- - -Title: Conclusion - -In this concluding section, we will encapsulate the impact of the JavaScript code snippet discussed in the report, as well as explore potential improvements or alternatives that could enhance its functionality and efficiency. - -**Summary of the Code's Impact** - -The JavaScript code snippet analyzed in this report serves a crucial role in [specific functionality, e.g., data manipulation, user interface enhancement, etc.]. Its implementation has demonstrated significant improvements in [specific outcomes, e.g., performance, user engagement, etc.], thereby underscoring its value in [specific context, e.g., web development, application performance, etc.]. By leveraging [specific JavaScript features or libraries], the code achieves [specific results, e.g., faster processing times, improved user experience, etc.], which are essential for [specific goals, e.g., maintaining competitive advantage, ensuring seamless user interaction, etc.]. - -**Potential Improvements or Alternatives** - -While the current implementation of the JavaScript code snippet is effective, there are several areas where enhancements could be made to further optimize its performance: - -1. **Optimization of Algorithms**: By refining the algorithms used within the code, it is possible to reduce computational overhead and improve execution speed. This could involve adopting more efficient data structures or leveraging advanced JavaScript features such as asynchronous programming. - -2. **Code Modularity**: Increasing the modularity of the code can enhance maintainability and scalability. By breaking down the code into smaller, reusable components, developers can more easily update and expand the functionality without affecting the entire system. - -3. **Utilization of Modern Frameworks**: Exploring modern JavaScript frameworks such as React, Angular, or Vue.js could provide additional benefits in terms of performance and ease of integration. These frameworks offer robust ecosystems and tools that can streamline development processes and improve code quality. - -4. **Enhanced Error Handling**: Implementing comprehensive error handling mechanisms can improve the robustness of the code. By anticipating potential issues and providing clear error messages, the code can become more resilient and user-friendly. - -In conclusion, the JavaScript code snippet provides a solid foundation for achieving [specific objectives]. However, by considering the potential improvements outlined above, it is possible to further enhance its effectiveness and adaptability in a rapidly evolving technological landscape. This proactive approach will ensure that the code remains relevant and continues to deliver value in the long term. - -CONCLUSION ----------- - -JavaScript Code Snippet Summary - Abschlussbericht - -In diesem Bericht haben wir die wesentlichen Aspekte eines spezifischen JavaScript-Code-Snippets untersucht, wobei der Schwerpunkt auf dessen Funktionalität und Zweck lag. Der Bericht richtete sich an ein technisches Publikum und behandelte die Hauptthemen JavaScript-Funktionalität, den Zweck des Codes und mögliche Anwendungsfälle. - -Zusammenfassend lässt sich sagen, dass das analysierte JavaScript-Code-Snippet eine effiziente Lösung für [spezifische Funktionalität] bietet. Es wurde entwickelt, um [Zweck des Codes] zu erfüllen und zeigt sich besonders nützlich in [Anwendungsfälle]. Die Implementierung des Codes demonstriert die Vielseitigkeit und Leistungsfähigkeit von JavaScript in modernen Webanwendungen. - -Um die im Bericht behandelten Themen abzuschließen, empfehlen wir, den Code in realen Projekten zu testen, um seine Effizienz und Zuverlässigkeit weiter zu validieren. Darüber hinaus könnte eine Erweiterung des Codes in Betracht gezogen werden, um zusätzliche Funktionalitäten zu integrieren, die den spezifischen Anforderungen eines Projekts entsprechen. - -Abschließend ist die Bedeutung dieses Berichts darin zu sehen, dass er nicht nur die Funktionalität und den Zweck des JavaScript-Code-Snippets verdeutlicht, sondern auch wertvolle Einblicke in dessen praktische Anwendungen bietet. Dies sollte den Lesern helfen, fundierte Entscheidungen über die Implementierung und Anpassung von JavaScript in ihren eigenen Projekten zu treffen. diff --git a/static/69_nacht_gedicht.txt b/static/69_nacht_gedicht.txt deleted file mode 100644 index 955e1acb..00000000 --- a/static/69_nacht_gedicht.txt +++ /dev/null @@ -1,228 +0,0 @@ -Creating a Poem about the Night in German -========================================= - -Titel: Einführung in den Leitfaden "Ein Gedicht über die Nacht auf Deutsch schreiben" - -Willkommen zu unserem Leitfaden "Ein Gedicht über die Nacht auf Deutsch schreiben". Dieser Leitfaden ist für alle gedacht, die sich von der geheimnisvollen und faszinierenden Welt der Nacht inspirieren lassen möchten, um ihre Gedanken und Gefühle in Form eines Gedichts auszudrücken. Egal, ob Sie ein erfahrener Dichter sind oder gerade erst anfangen, Ihre poetische Reise zu erkunden – dieser Leitfaden bietet Ihnen wertvolle Einblicke und praktische Tipps. - -In diesem Dokument werden wir uns mit der Kunst des Nachtgedichts befassen, indem wir die deutsche Sprache als unser kreatives Werkzeug nutzen. Wir werden die Struktur eines Gedichts untersuchen, die Bedeutung von Bildsprache und Symbolik hervorheben und Ihnen helfen, Ihre eigenen nächtlichen Visionen in Worte zu fassen. Die Nacht, mit all ihren Geheimnissen und ihrer Schönheit, bietet eine reiche Quelle der Inspiration, die wir gemeinsam erkunden werden. - -Sie werden in diesem Leitfaden Folgendes finden: -- Eine Einführung in die Grundlagen der Poesie und wie sie auf die Nacht angewendet werden können. -- Tipps zur Verwendung der deutschen Sprache, um Ihre nächtlichen Eindrücke lebendig und ausdrucksstark zu gestalten. -- Beispiele für poetische Strukturen und Techniken, die Ihnen helfen, Ihre Gedanken zu organisieren und zu präsentieren. -- Anregungen zur Verwendung von Bildsprache und Symbolik, um die Tiefe und Emotionen der Nacht einzufangen. - -Unser Ziel ist es, Ihnen nicht nur die Werkzeuge an die Hand zu geben, um ein Gedicht über die Nacht zu schreiben, sondern auch Ihre Kreativität zu fördern und Ihre Liebe zur Poesie zu vertiefen. Lassen Sie uns gemeinsam in die Welt der Nacht eintauchen und die Magie der Worte entdecken. - -Introduction to Night Poetry ----------------------------- - -Title: Einführung in die Nachtpoesie - -Willkommen zu unserer Reise in die faszinierende Welt der Nachtpoesie. In dieser Einführung werden wir die Definition der Nachtpoesie erkunden und ihre kulturelle Bedeutung in der Literatur beleuchten. Lassen Sie uns gemeinsam entdecken, wie die Dunkelheit der Nacht die Fantasie von Dichtern und Schriftstellern beflügelt hat. - -## Was ist Nachtpoesie? - -Nachtpoesie ist eine spezielle Form der Dichtung, die sich mit den Themen und Stimmungen der Nacht auseinandersetzt. Sie umfasst Gedichte, die die Dunkelheit, Stille und Geheimnisse der Nacht einfangen. Diese Art von Poesie nutzt oft die Nacht als Metapher für innere Reflexion, Träume und das Unbewusste. Die Nacht wird in der Poesie häufig als eine Zeit der Introspektion und des emotionalen Ausdrucks dargestellt, in der die Grenzen zwischen Realität und Fantasie verschwimmen. - -Ein Beispiel für Nachtpoesie ist das Gedicht "Abendlied" von Matthias Claudius, das die Ruhe und den Frieden der Nacht beschreibt und gleichzeitig eine tiefere, spirituelle Ebene anspricht. - -## Historischer Kontext - -Die Nacht hat in der Literaturgeschichte schon immer eine bedeutende Rolle gespielt. Bereits in der Antike wurde die Nacht in Gedichten und Geschichten als eine Zeit der Magie und des Mysteriums dargestellt. In der Romantik erlebte die Nachtpoesie eine Blütezeit, da Dichter wie Novalis und Joseph von Eichendorff die Nacht als Symbol für das Unbekannte und das Unbewusste nutzten. Diese Epoche betonte die emotionale Tiefe und die spirituelle Suche, die mit der Dunkelheit verbunden sind. - -Im 20. Jahrhundert setzten Dichter wie Rainer Maria Rilke und Georg Trakl die Tradition der Nachtpoesie fort, indem sie die Nacht als eine Zeit der Einsamkeit und des Nachdenkens darstellten. Ihre Werke reflektieren die komplexen Gefühle und Gedanken, die die Nacht hervorrufen kann. - -Die kulturelle Bedeutung der Nacht in der Literatur zeigt sich auch in der Vielfalt der Themen, die sie inspiriert hat – von der Melancholie und Sehnsucht bis hin zur Hoffnung und Erneuerung. Nachtpoesie bietet eine reiche Leinwand für kreative Ausdrucksformen und lädt dazu ein, die tiefsten Ecken der menschlichen Seele zu erkunden. - -In dieser Einführung haben wir die Grundlagen der Nachtpoesie und ihre historische Entwicklung betrachtet. Lassen Sie uns nun tiefer in die Kunst des Dichtens eintauchen und entdecken, wie Sie Ihre eigenen poetischen Werke über die Nacht schaffen können. - -Elements of a Night Poem ------------------------- - -Title: Elemente eines Nachtgedichts - -Ein Gedicht über die Nacht zu schreiben, kann eine faszinierende Reise in die Dunkelheit und ihre Geheimnisse sein. In diesem Abschnitt werden wir die wesentlichen Elemente eines Nachtgedichts untersuchen, um Ihnen zu helfen, Ihre eigenen poetischen Werke zu gestalten. - -**Themen in der Nachtpoesie** - -Die Nacht ist ein reichhaltiges Thema in der Poesie, das zahlreiche Interpretationen und Emotionen hervorrufen kann. Hier sind einige der häufigsten Themen, die in Nachtgedichten behandelt werden: - -1. **Ruhe und Stille**: Die Nacht wird oft als eine Zeit der Ruhe und des Friedens dargestellt. Dichter nutzen diese Themen, um eine Atmosphäre der Gelassenheit zu schaffen, die den Leser in eine Welt der Entspannung und Kontemplation entführt. - -2. **Geheimnisse und Unbekanntes**: Die Dunkelheit der Nacht kann auch das Unbekannte symbolisieren. Gedichte, die sich mit diesem Thema befassen, erforschen oft das Gefühl des Mysteriums und der Entdeckung, das die Nacht mit sich bringt. - -3. **Träume und Fantasie**: Die Nacht ist die Zeit der Träume. Viele Dichter nutzen die Nacht als Metapher für die Welt der Fantasie und der unendlichen Möglichkeiten, die in unseren Träumen verborgen liegen. - -4. **Einsamkeit und Melancholie**: Die Nacht kann auch Gefühle der Einsamkeit und Melancholie hervorrufen. Diese Themen werden oft verwendet, um tiefere emotionale Zustände zu erkunden und eine Verbindung zum Leser herzustellen. - -**Symbolik der Nacht** - -Die Nacht ist reich an Symbolik und bietet eine Vielzahl von Bildern, die in Gedichten verwendet werden können, um tiefere Bedeutungen zu vermitteln: - -1. **Mond und Sterne**: Diese Himmelskörper sind häufige Symbole in der Nachtpoesie. Der Mond kann für Veränderung, Zyklen und das Unbewusste stehen, während Sterne oft Hoffnung und Orientierung symbolisieren. - -2. **Schatten und Dunkelheit**: Schatten können Geheimnisse und das Verborgene darstellen. Die Dunkelheit selbst kann sowohl Schutz als auch Bedrohung symbolisieren, je nach Kontext des Gedichts. - -3. **Nachtvögel und Tiere**: Eulen, Fledermäuse und andere nachtaktive Tiere werden oft als Symbole für Weisheit, Geheimnis und das Unbekannte verwendet. - -4. **Stille und Geräusche der Nacht**: Die Abwesenheit von Lärm kann Frieden symbolisieren, während die subtilen Geräusche der Nacht, wie das Zirpen von Grillen, eine lebendige Atmosphäre schaffen können. - -**Beispiele und Anwendung** - -Um diese Elemente in Ihrem Gedicht zu verwenden, könnten Sie beispielsweise die Stille der Nacht beschreiben, indem Sie die sanften Geräusche der Natur einfangen oder die geheimnisvolle Aura des Mondlichts nutzen, um eine Szene zu malen. Ein Gedicht könnte so beginnen: - -_"In der stillen Nacht, wo der Mond leise wacht, -flüstern die Sterne von Träumen, die erwacht."_ - -Durch die Einbeziehung dieser Themen und Symbole können Sie ein tiefgründiges und eindrucksvolles Nachtgedicht schaffen, das die Leser in die faszinierende Welt der Dunkelheit entführt. - -Writing a Poem in German ------------------------- - -Title: Writing a Poem in German - -Willkommen zu unserem Leitfaden zum Schreiben eines Gedichts über die Nacht auf Deutsch! In diesem Abschnitt werden wir die Grundlagen der deutschen Poesie erkunden und Ihnen nützliche Vokabeln an die Hand geben, um Ihre poetischen Gedanken in der deutschen Sprache auszudrücken. Lassen Sie uns gemeinsam in die Welt der deutschen Poesie eintauchen. - -**German Poetic Structure** - -Beim Schreiben eines Gedichts auf Deutsch ist es wichtig, die grundlegende Struktur der deutschen Poesie zu verstehen. Traditionell sind deutsche Gedichte oft in Strophen unterteilt, die aus mehreren Versen bestehen. Hier sind einige wichtige Aspekte, die Sie beachten sollten: - -1. **Reimschema**: Deutsche Gedichte verwenden häufig Reimschemata wie Paarreim (AABB), Kreuzreim (ABAB) oder umarmender Reim (ABBA). Diese Strukturen helfen, einen rhythmischen Fluss zu erzeugen. - -2. **Metrum**: Das Metrum bezieht sich auf das rhythmische Muster eines Gedichts. In der deutschen Poesie sind Jambus (kurz-lang) und Trochäus (lang-kurz) weit verbreitet. Ein regelmäßiges Metrum kann Ihrem Gedicht eine musikalische Qualität verleihen. - -3. **Strophenform**: Eine Strophe kann aus zwei bis acht oder mehr Versen bestehen. Die Anzahl der Verse und die Wahl des Reimschemas beeinflussen den Gesamteindruck des Gedichts. - -4. **Bildsprache**: Deutsche Gedichte nutzen oft Metaphern, Vergleiche und Symbole, um tiefere Bedeutungen zu vermitteln. Diese sprachlichen Mittel bereichern den Text und regen die Vorstellungskraft des Lesers an. - -**Useful Vocabulary** - -Um ein Gedicht über die Nacht zu schreiben, ist es hilfreich, einige spezifische Vokabeln und Phrasen zu kennen, die Ihnen helfen, die Atmosphäre und Stimmung der Nacht einzufangen. Hier sind einige nützliche Wörter und Ausdrücke: - -- **Nacht** (f) – night -- **Sterne** (pl) – stars -- **Mond** (m) – moon -- **Dunkelheit** (f) – darkness -- **Stille** (f) – silence -- **Traum** (m) – dream -- **Schatten** (m) – shadow -- **Schlaf** (m) – sleep -- **Zwielicht** (n) – twilight -- **Geheimnisvoll** – mysterious -- **Leuchten** – to shine -- **Flüstern** – to whisper - -**Beispielsätze:** - -- "Die Sterne leuchten hell in der stillen Nacht." -- "Der Mond wirft geheimnisvolle Schatten auf die Erde." -- "In der Dunkelheit flüstert der Wind leise." - -Mit diesen Grundlagen und Vokabeln sind Sie bestens gerüstet, um Ihr eigenes Gedicht über die Nacht auf Deutsch zu verfassen. Lassen Sie Ihrer Kreativität freien Lauf und experimentieren Sie mit verschiedenen Strukturen und Bildern. Viel Spaß beim Dichten! - -Examples of Night Poems ------------------------ - -Title: Beispiele für Nachtgedichte - -In dieser Sektion werden wir einige berühmte Nachtgedichte analysieren und Inspirationen für das Schreiben eigener Gedichte über die Nacht bieten. Die Nacht, mit ihrer geheimnisvollen und oft beruhigenden Atmosphäre, hat viele Dichter inspiriert, ihre Gedanken und Gefühle in Worte zu fassen. Lassen Sie uns eintauchen in die Welt der Nachtpoesie. - -## Berühmte Nachtgedichte - -### "Abendlied" von Matthias Claudius -Dieses Gedicht ist eines der bekanntesten deutschen Nachtgedichte. Claudius beschreibt die Ruhe und den Frieden der Nacht und wie sie die Welt in einen sanften Schlaf hüllt. Die Zeilen „Der Mond ist aufgegangen, die goldnen Sternlein prangen“ sind vielen bekannt und vermitteln ein Gefühl von Geborgenheit und Stille. Claudius nutzt einfache, aber eindrucksvolle Bilder, um die Schönheit der Nacht zu schildern. - -### "Nachtgedanken" von Heinrich Heine -Heines "Nachtgedanken" sind ein Beispiel dafür, wie die Nacht als Metapher für tiefere emotionale und politische Themen genutzt werden kann. In diesem Gedicht reflektiert Heine über seine Heimat und die Sehnsucht nach Freiheit. Die Nacht wird hier zum Symbol für Trauer und Hoffnung zugleich, was dem Gedicht eine besondere Tiefe verleiht. - -### "Mondnacht" von Joseph von Eichendorff -Eichendorffs "Mondnacht" ist ein weiteres Meisterwerk der deutschen Nachtpoesie. In diesem Gedicht wird die Nacht als eine Zeit der Verbindung zwischen Himmel und Erde beschrieben. Die Natur wird lebendig und spiegelt die inneren Gefühle des lyrischen Ichs wider. Eichendorff schafft es, mit seinen Worten eine fast magische Atmosphäre zu erzeugen. - -## Inspiration und Analyse - -### Inspiration für das Schreiben -Die Nacht bietet unzählige Möglichkeiten für poetische Inspiration. Sie kann als Symbol für Ruhe, Geheimnis, Angst oder Hoffnung dienen. Wenn Sie ein Gedicht über die Nacht schreiben möchten, überlegen Sie, welche Emotionen oder Bilder die Nacht in Ihnen hervorruft. Ist es die Stille, die Sie inspiriert, oder vielleicht die Dunkelheit und das Unbekannte? - -### Analyse von Nachtgedichten -Bei der Analyse von Nachtgedichten ist es wichtig, auf die verwendeten Bilder und Symbole zu achten. Wie nutzen Dichter die Nacht, um ihre Botschaften zu vermitteln? Welche Emotionen werden durch die Nacht hervorgerufen? Indem Sie diese Fragen stellen, können Sie ein tieferes Verständnis für die Poesie der Nacht entwickeln und Ihre eigenen Gedichte bereichern. - -### Praktische Tipps -- Beginnen Sie mit einer Beobachtung: Was sehen, hören oder fühlen Sie in der Nacht? -- Nutzen Sie Metaphern und Vergleiche, um die Nacht lebendig zu machen. -- Experimentieren Sie mit verschiedenen Stimmungen: von beruhigend bis unheimlich. -- Lassen Sie sich von der Natur inspirieren: der Mond, die Sterne, die Dunkelheit. - -Die Nacht ist ein faszinierendes Thema für Gedichte, das sowohl Anfänger als auch erfahrene Dichter inspiriert. Nutzen Sie die Beispiele und Analysen in dieser Sektion, um Ihre eigene poetische Reise in die Welt der Nacht zu beginnen. - -Creating Your Own Night Poem ----------------------------- - -Title: Creating Your Own Night Poem - -Willkommen zu unserem Leitfaden, wie Sie Ihr eigenes Gedicht über die Nacht auf Deutsch verfassen können. In diesem Abschnitt führen wir Sie Schritt für Schritt durch den Prozess und geben Ihnen kreative Tipps, um Ihre poetische Reise zu inspirieren. Lassen Sie uns beginnen! - -**Step-by-Step Guide** - -1. **Thema und Stimmung festlegen** - Beginnen Sie damit, sich zu überlegen, welche Aspekte der Nacht Sie in Ihrem Gedicht einfangen möchten. Ist es die Ruhe und Stille, die Dunkelheit oder vielleicht das geheimnisvolle Gefühl, das die Nacht mit sich bringt? Entscheiden Sie sich für eine Stimmung, die Ihr Gedicht durchziehen soll. - -2. **Wortschatz sammeln** - Sammeln Sie Wörter und Ausdrücke, die mit der Nacht in Verbindung stehen. Denken Sie an Begriffe wie „Sterne“, „Mondschein“, „Schatten“ oder „Stille“. Notieren Sie sich auch Synonyme und Metaphern, die Ihre Vorstellungskraft anregen. - -3. **Struktur wählen** - Überlegen Sie, welche Form Ihr Gedicht haben soll. Möchten Sie ein traditionelles Sonett, ein freies Versmaß oder vielleicht ein Haiku schreiben? Die Struktur kann Ihrem Gedicht einen Rahmen geben und hilft Ihnen, Ihre Gedanken zu ordnen. - -4. **Erster Entwurf** - Schreiben Sie einen ersten Entwurf Ihres Gedichts. Lassen Sie Ihre Gedanken frei fließen und machen Sie sich keine Sorgen um Perfektion. Konzentrieren Sie sich darauf, Ihre Emotionen und Eindrücke der Nacht auf Papier zu bringen. - -5. **Überarbeitung** - Lesen Sie Ihren Entwurf laut vor. Achten Sie auf den Rhythmus und den Klang der Wörter. Überarbeiten Sie Stellen, die holprig klingen oder nicht zur gewählten Stimmung passen. Scheuen Sie sich nicht, ganze Passagen zu ändern oder zu entfernen. - -6. **Feinschliff** - Fügen Sie Ihrem Gedicht abschließend stilistische Feinheiten hinzu. Achten Sie auf Reime, Alliterationen oder andere poetische Mittel, die Ihrem Werk Tiefe verleihen können. Überprüfen Sie auch die Grammatik und Rechtschreibung. - -**Creative Tips** - -- **Inspiration suchen** - Lassen Sie sich von der Natur inspirieren. Machen Sie einen Spaziergang in der Nacht und achten Sie auf die Geräusche und Bilder um Sie herum. Notieren Sie Ihre Eindrücke und verwenden Sie sie als Grundlage für Ihr Gedicht. - -- **Emotionen einfließen lassen** - Denken Sie darüber nach, welche Emotionen die Nacht in Ihnen hervorruft. Ist es Frieden, Angst oder vielleicht Sehnsucht? Lassen Sie diese Gefühle in Ihre Worte einfließen, um Ihrem Gedicht Authentizität zu verleihen. - -- **Experimentieren Sie mit Perspektiven** - Schreiben Sie aus verschiedenen Perspektiven. Wie würde ein Nachtvogel die Dunkelheit beschreiben? Oder ein Kind, das zum ersten Mal die Sterne sieht? Diese Perspektivwechsel können Ihrem Gedicht eine neue Dimension verleihen. - -- **Lesen Sie andere Gedichte** - Lesen Sie Gedichte anderer Autoren über die Nacht. Lassen Sie sich von deren Stil und Themen inspirieren, aber achten Sie darauf, Ihre eigene Stimme zu bewahren. - -Mit diesen Schritten und Tipps sind Sie bestens gerüstet, um Ihr eigenes Gedicht über die Nacht zu verfassen. Lassen Sie Ihrer Kreativität freien Lauf und genießen Sie den Prozess des Schreibens. Viel Spaß beim Dichten! - -Conclusion ----------- - -# Conclusion - -## Summary - -In diesem Leitfaden haben wir uns intensiv mit dem Thema befasst, wie man ein Gedicht über die Nacht auf Deutsch verfasst. Wir haben die Bedeutung der Nacht als Inspirationsquelle erkundet und verschiedene poetische Techniken besprochen, die Ihnen helfen können, Ihre Gedanken und Gefühle in Worte zu fassen. Von der Auswahl der richtigen Metaphern und Symbole bis hin zur Strukturierung Ihrer Verse – all diese Elemente tragen dazu bei, die Magie der Nacht in Ihrem Gedicht einzufangen. Wir haben auch Beispiele und Anregungen gegeben, um Ihre Kreativität zu fördern und Ihnen den Einstieg zu erleichtern. - -## Final Thoughts - -Das Schreiben eines Gedichts über die Nacht ist eine wunderbare Möglichkeit, die stille Schönheit und die geheimnisvolle Atmosphäre dieser Tageszeit zu würdigen. Lassen Sie sich von der Dunkelheit, den Sternen und der Ruhe inspirieren, um Ihre eigenen einzigartigen Gedanken und Emotionen auszudrücken. Denken Sie daran, dass es beim Dichten keine festen Regeln gibt – es geht darum, Ihre eigene Stimme zu finden und Ihre persönliche Sichtweise zu teilen. Also, nehmen Sie sich die Zeit, die Nacht zu beobachten, und lassen Sie Ihre Fantasie freien Lauf. Wir ermutigen Sie, Ihre Gedichte zu schreiben und vielleicht sogar mit anderen zu teilen. Wer weiß, vielleicht inspirieren Sie jemanden mit Ihren Worten, die Schönheit der Nacht auf eine neue Weise zu sehen. Viel Spaß beim Schreiben! - -CONCLUSION ----------- - -Abschluss: "Ein Gedicht über die Nacht auf Deutsch verfassen" - -In diesem Leitfaden haben wir die wesentlichen Aspekte des Verfassens eines Gedichts über die Nacht in deutscher Sprache behandelt. Wir begannen mit der Erkundung der Bedeutung der Nacht in der Poesie und ihrer Rolle als Quelle der Inspiration. Die Nacht bietet eine reiche Palette an Bildern und Symbolen, die in Gedichten verwendet werden können, um Emotionen und Stimmungen auszudrücken. - -Ein zentraler Punkt war die Struktur eines Gedichts, die in der deutschen Sprache sowohl traditionell als auch modern gestaltet werden kann. Wir haben verschiedene poetische Formen und deren Anwendung auf das Thema Nacht untersucht. Dabei wurde betont, wie wichtig es ist, die richtige Balance zwischen Form und Inhalt zu finden, um die gewünschte Wirkung zu erzielen. - -Ein weiterer Schwerpunkt lag auf der Verwendung von Bildsprache und Symbolik. Diese Elemente sind entscheidend, um die Tiefe und Vielschichtigkeit der Nacht in einem Gedicht zu erfassen. Wir haben Techniken vorgestellt, wie man durch Metaphern, Vergleiche und andere stilistische Mittel lebendige und eindrucksvolle Bilder schaffen kann. - -Zum Abschluss möchten wir die Leser ermutigen, ihre eigenen Gedichte über die Nacht zu verfassen und dabei die im Leitfaden besprochenen Techniken anzuwenden. Experimentieren Sie mit verschiedenen Formen und Stilen, um Ihre persönliche Sichtweise auf die Nacht auszudrücken. Nutzen Sie die Nacht als Leinwand für Ihre Kreativität und lassen Sie sich von ihrer geheimnisvollen und faszinierenden Natur inspirieren. - -Dieser Leitfaden soll Ihnen nicht nur helfen, ein Gedicht über die Nacht zu schreiben, sondern auch Ihre Fähigkeiten als Dichter im Allgemeinen zu erweitern. Die Nacht bietet unendliche Möglichkeiten zur Erkundung und Interpretation, und wir hoffen, dass Sie durch diesen Leitfaden motiviert werden, Ihre poetische Reise fortzusetzen. diff --git a/static/6_sales_trends_analysis.txt b/static/6_sales_trends_analysis.txt new file mode 100644 index 00000000..f9ab6e20 --- /dev/null +++ b/static/6_sales_trends_analysis.txt @@ -0,0 +1,71 @@ +``` +Filename: sales_trends_analysis.txt + +--- + +# Q1 2023 Sales Trends Analysis + +## Introduction + +This report provides a detailed analysis of the sales figures and trends observed in the first quarter of 2023. The analysis focuses on identifying key sales trends, growth patterns, and potential opportunities for improvement. The insights are derived from the Q1 sales data and visualizations, including bar and pie charts, to provide a comprehensive understanding of the sales performance. + +## Monthly Sales Trends + +### Overview + +The sales data for Q1 2023 shows a consistent upward trend in monthly revenue, with significant growth observed from January to March. The monthly sales figures are as follows: + +- **January:** $1,500,000 +- **February:** $1,650,000 +- **March:** $1,800,000 + +### Growth Analysis + +- **January:** 5.2% growth +- **February:** 10.0% growth +- **March:** 9.1% growth + +The data indicates a steady increase in sales, with February experiencing the highest growth rate. This suggests effective sales strategies and market conditions during this period. + +## Regional Sales Contributions + +### Regional Breakdown + +- **North:** 35% of total sales +- **South:** 25% of total sales +- **East:** 20% of total sales +- **West:** 20% of total sales + +The North region is the leading contributor to the sales growth, accounting for the largest share of total sales. This highlights the region's strong market presence and potential for further expansion. + +## Product Revenue Contributions + +### Top Products + +- **Product A:** 40% of revenue +- **Product B:** 30% of revenue +- **Product C:** 20% of revenue +- **Others:** 10% of revenue + +Product A is the top-performing product, contributing significantly to the overall revenue. This indicates a strong market demand and suggests opportunities for increased focus and investment in Product A. + +## Key Insights and Opportunities + +### Insights + +1. **Consistent Growth:** The sales data shows a consistent growth trend across the first quarter, with February achieving the highest growth rate. +2. **Regional Strength:** The North region is a key driver of sales, suggesting potential for further market penetration and expansion. +3. **Product Focus:** Product A's substantial contribution to revenue highlights its importance and potential for increased marketing and sales efforts. + +### Opportunities for Improvement + +1. **Enhance Regional Strategies:** Explore strategies to boost sales in the South, East, and West regions to balance regional contributions. +2. **Diversify Product Portfolio:** Consider expanding the product range or enhancing the features of existing products to capture a larger market share. +3. **Optimize Marketing Efforts:** Leverage the success of Product A by increasing marketing efforts and exploring cross-selling opportunities with other products. + +## Conclusion + +The Q1 2023 sales analysis reveals a positive growth trajectory with significant contributions from the North region and Product A. By focusing on regional expansion and product diversification, there are ample opportunities to enhance sales performance and achieve sustained growth in the upcoming quarters. + +--- End of Report --- +``` \ No newline at end of file diff --git a/static/70_generated_code.py b/static/70_generated_code.py deleted file mode 100644 index dfdd1c0f..00000000 --- a/static/70_generated_code.py +++ /dev/null @@ -1,33 +0,0 @@ -input_files = [] # DO NOT CHANGE THIS LINE - -# REQUIREMENTS: - -def is_prime(n: int) -> bool: - if n <= 1: - return False - if n <= 3: - return True - if n % 2 == 0 or n % 3 == 0: - return False - i = 5 - while i * i <= n: - if n % i == 0 or n % (i + 2) == 0: - return False - i += 6 - return True - -def generate_primes(limit: int) -> list: - primes = [] - num = 2 - while len(primes) < limit: - if is_prime(num): - primes.append(num) - num += 1 - return primes - -try: - prime_numbers = generate_primes(1000) - prime_numbers_str = "\n".join(map(str, prime_numbers)) - result = {"primes.txt": prime_numbers_str} -except Exception as e: - result = {"error.txt": str(e)} \ No newline at end of file diff --git a/static/71_execution_history.json b/static/71_execution_history.json deleted file mode 100644 index 32f860dc..00000000 --- a/static/71_execution_history.json +++ /dev/null @@ -1,13 +0,0 @@ -[ - { - "attempt": 1, - "code": "input_files = [] # DO NOT CHANGE THIS LINE\n\n# REQUIREMENTS: \n\ndef is_prime(n: int) -> bool:\n if n <= 1:\n return False\n if n <= 3:\n return True\n if n % 2 == 0 or n % 3 == 0:\n return False\n i = 5\n while i * i <= n:\n if n % i == 0 or n % (i + 2) == 0:\n return False\n i += 6\n return True\n\ndef generate_primes(limit: int) -> list:\n primes = []\n num = 2\n while len(primes) < limit:\n if is_prime(num):\n primes.append(num)\n num += 1\n return primes\n\ntry:\n prime_numbers = generate_primes(1000)\n prime_numbers_str = \"\\n\".join(map(str, prime_numbers))\n result = {\"primes.txt\": prime_numbers_str}\nexcept Exception as e:\n result = {\"error.txt\": str(e)}", - "result": { - "success": true, - "output": "", - "error": "", - "result": null, - "exit_code": 0 - } - } -] \ No newline at end of file diff --git a/static/72_generated_code.py b/static/72_generated_code.py deleted file mode 100644 index 7669de7c..00000000 --- a/static/72_generated_code.py +++ /dev/null @@ -1,39 +0,0 @@ -input_files = [] # DO NOT CHANGE THIS LINE - -# REQUIREMENTS: - -import json - -def is_prime(n: int) -> bool: - if n <= 1: - return False - if n <= 3: - return True - if n % 2 == 0 or n % 3 == 0: - return False - i = 5 - while i * i <= n: - if n % i == 0 or n % (i + 2) == 0: - return False - i += 6 - return True - -def generate_primes(limit: int) -> list: - primes = [] - num = 2 - while len(primes) < limit: - if is_prime(num): - primes.append(num) - num += 1 - return primes - -def main(): - try: - primes = generate_primes(1000) - primes_str = "\n".join(map(str, primes)) - result = {"primes.txt": primes_str} - except Exception as e: - result = {"error.txt": str(e)} - return result - -result = main() \ No newline at end of file diff --git a/static/73_execution_history.json b/static/73_execution_history.json deleted file mode 100644 index 886a4eb8..00000000 --- a/static/73_execution_history.json +++ /dev/null @@ -1,13 +0,0 @@ -[ - { - "attempt": 1, - "code": "input_files = [] # DO NOT CHANGE THIS LINE\n\n# REQUIREMENTS: \n\nimport json\n\ndef is_prime(n: int) -> bool:\n if n <= 1:\n return False\n if n <= 3:\n return True\n if n % 2 == 0 or n % 3 == 0:\n return False\n i = 5\n while i * i <= n:\n if n % i == 0 or n % (i + 2) == 0:\n return False\n i += 6\n return True\n\ndef generate_primes(limit: int) -> list:\n primes = []\n num = 2\n while len(primes) < limit:\n if is_prime(num):\n primes.append(num)\n num += 1\n return primes\n\ndef main():\n try:\n primes = generate_primes(1000)\n primes_str = \"\\n\".join(map(str, primes))\n result = {\"primes.txt\": primes_str}\n except Exception as e:\n result = {\"error.txt\": str(e)}\n return result\n\nresult = main()", - "result": { - "success": true, - "output": "", - "error": "", - "result": null, - "exit_code": 0 - } - } -] \ No newline at end of file diff --git a/static/74_generated_code.py b/static/74_generated_code.py deleted file mode 100644 index 4384c398..00000000 --- a/static/74_generated_code.py +++ /dev/null @@ -1,33 +0,0 @@ -input_files = [] # DO NOT CHANGE THIS LINE - -# REQUIREMENTS: - -def is_prime(n: int) -> bool: - if n <= 1: - return False - if n <= 3: - return True - if n % 2 == 0 or n % 3 == 0: - return False - i = 5 - while i * i <= n: - if n % i == 0 or n % (i + 2) == 0: - return False - i += 6 - return True - -def generate_primes(limit: int) -> list: - primes = [] - num = 2 - while len(primes) < limit: - if is_prime(num): - primes.append(num) - num += 1 - return primes - -try: - prime_numbers = generate_primes(1000) - prime_numbers_str = "\n".join(map(str, prime_numbers)) - result = {"output.txt": prime_numbers_str} -except Exception as e: - result = {"output.txt": f"An error occurred: {str(e)}"} \ No newline at end of file diff --git a/static/75_execution_history.json b/static/75_execution_history.json deleted file mode 100644 index 55e9e50b..00000000 --- a/static/75_execution_history.json +++ /dev/null @@ -1,13 +0,0 @@ -[ - { - "attempt": 1, - "code": "input_files = [] # DO NOT CHANGE THIS LINE\n\n# REQUIREMENTS: \n\ndef is_prime(n: int) -> bool:\n if n <= 1:\n return False\n if n <= 3:\n return True\n if n % 2 == 0 or n % 3 == 0:\n return False\n i = 5\n while i * i <= n:\n if n % i == 0 or n % (i + 2) == 0:\n return False\n i += 6\n return True\n\ndef generate_primes(limit: int) -> list:\n primes = []\n num = 2\n while len(primes) < limit:\n if is_prime(num):\n primes.append(num)\n num += 1\n return primes\n\ntry:\n prime_numbers = generate_primes(1000)\n prime_numbers_str = \"\\n\".join(map(str, prime_numbers))\n result = {\"output.txt\": prime_numbers_str}\nexcept Exception as e:\n result = {\"output.txt\": f\"An error occurred: {str(e)}\"}", - "result": { - "success": true, - "output": "", - "error": "", - "result": null, - "exit_code": 0 - } - } -] \ No newline at end of file diff --git a/static/76_generated_code.py b/static/76_generated_code.py deleted file mode 100644 index 2c75d068..00000000 --- a/static/76_generated_code.py +++ /dev/null @@ -1,42 +0,0 @@ -input_files = [] # DO NOT CHANGE THIS LINE - -# REQUIREMENTS: - -def is_prime(n: int) -> bool: - if n <= 1: - return False - if n <= 3: - return True - if n % 2 == 0 or n % 3 == 0: - return False - i = 5 - while i * i <= n: - if n % i == 0 or n % (i + 2) == 0: - return False - i += 6 - return True - -def generate_primes(limit: int) -> list: - primes = [] - num = 2 - while len(primes) < limit: - if is_prime(num): - primes.append(num) - num += 1 - return primes - -def save_primes_to_file(primes: list, filename: str) -> None: - try: - with open(filename, 'w') as f: - for prime in primes: - f.write(f"{prime}\n") - except IOError as e: - print(f"An error occurred while writing to the file: {e}") - -def main(): - primes = generate_primes(1000) - save_primes_to_file(primes, "primes.txt") - result = {"primes.txt": "\n".join(map(str, primes))} - return result - -result = main() \ No newline at end of file diff --git a/static/77_execution_history.json b/static/77_execution_history.json deleted file mode 100644 index d057f1c7..00000000 --- a/static/77_execution_history.json +++ /dev/null @@ -1,13 +0,0 @@ -[ - { - "attempt": 1, - "code": "input_files = [] # DO NOT CHANGE THIS LINE\n\n# REQUIREMENTS: \n\ndef is_prime(n: int) -> bool:\n if n <= 1:\n return False\n if n <= 3:\n return True\n if n % 2 == 0 or n % 3 == 0:\n return False\n i = 5\n while i * i <= n:\n if n % i == 0 or n % (i + 2) == 0:\n return False\n i += 6\n return True\n\ndef generate_primes(limit: int) -> list:\n primes = []\n num = 2\n while len(primes) < limit:\n if is_prime(num):\n primes.append(num)\n num += 1\n return primes\n\ndef save_primes_to_file(primes: list, filename: str) -> None:\n try:\n with open(filename, 'w') as f:\n for prime in primes:\n f.write(f\"{prime}\\n\")\n except IOError as e:\n print(f\"An error occurred while writing to the file: {e}\")\n\ndef main():\n primes = generate_primes(1000)\n save_primes_to_file(primes, \"primes.txt\")\n result = {\"primes.txt\": \"\\n\".join(map(str, primes))}\n return result\n\nresult = main()", - "result": { - "success": true, - "output": "", - "error": "", - "result": null, - "exit_code": 0 - } - } -] \ No newline at end of file diff --git a/static/78_generated_code.py b/static/78_generated_code.py deleted file mode 100644 index f951e6ff..00000000 --- a/static/78_generated_code.py +++ /dev/null @@ -1,39 +0,0 @@ -input_files = [] # DO NOT CHANGE THIS LINE - -# REQUIREMENTS: - -import json - -def is_prime(n: int) -> bool: - if n <= 1: - return False - if n <= 3: - return True - if n % 2 == 0 or n % 3 == 0: - return False - i = 5 - while i * i <= n: - if n % i == 0 or n % (i + 2) == 0: - return False - i += 6 - return True - -def generate_primes(count: int) -> list: - primes = [] - num = 2 - while len(primes) < count: - if is_prime(num): - primes.append(num) - num += 1 - return primes - -def main(): - try: - primes = generate_primes(1000) - primes_str = "\n".join(map(str, primes)) - result = {"primes.txt": primes_str} - except Exception as e: - result = {"error.txt": str(e)} - return result - -result = main() \ No newline at end of file diff --git a/static/79_execution_history.json b/static/79_execution_history.json deleted file mode 100644 index 68b2f467..00000000 --- a/static/79_execution_history.json +++ /dev/null @@ -1,13 +0,0 @@ -[ - { - "attempt": 1, - "code": "input_files = [] # DO NOT CHANGE THIS LINE\n\n# REQUIREMENTS: \n\nimport json\n\ndef is_prime(n: int) -> bool:\n if n <= 1:\n return False\n if n <= 3:\n return True\n if n % 2 == 0 or n % 3 == 0:\n return False\n i = 5\n while i * i <= n:\n if n % i == 0 or n % (i + 2) == 0:\n return False\n i += 6\n return True\n\ndef generate_primes(count: int) -> list:\n primes = []\n num = 2\n while len(primes) < count:\n if is_prime(num):\n primes.append(num)\n num += 1\n return primes\n\ndef main():\n try:\n primes = generate_primes(1000)\n primes_str = \"\\n\".join(map(str, primes))\n result = {\"primes.txt\": primes_str}\n except Exception as e:\n result = {\"error.txt\": str(e)}\n return result\n\nresult = main()", - "result": { - "success": true, - "output": "", - "error": "", - "result": null, - "exit_code": 0 - } - } -] \ No newline at end of file diff --git a/static/7_q2_forecast.svg b/static/7_q2_forecast.svg new file mode 100644 index 00000000..70c8a06e --- /dev/null +++ b/static/7_q2_forecast.svg @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/static/8_forecast_apr_jun.svg b/static/8_forecast_apr_jun.svg new file mode 100644 index 00000000..6ec91ed5 --- /dev/null +++ b/static/8_forecast_apr_jun.svg @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/test_workflow1.py b/test_workflow1.py deleted file mode 100644 index 43431e8f..00000000 --- a/test_workflow1.py +++ /dev/null @@ -1,230 +0,0 @@ -""" -Test script for ChatManager workflow with simulated file uploads. -Demonstrates the complete workflow from file upload to chat execution. -""" - -import asyncio -import base64 -import logging -import os -import sys -from typing import Dict, Any, List, Tuple -from datetime import datetime - -# Configure logging -logging.basicConfig( - level=logging.INFO, - format='%(asctime)s - %(levelname)s - %(name)s - %(message)s', - handlers=[logging.StreamHandler()] -) -logger = logging.getLogger("test_workflow") - -# Add project directory to path -sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) - -# Import modules -from modules.lucydom_interface import get_lucydom_interface -from modules.chat import get_chat_manager - -async def create_test_files(mandate_id: int, user_id: int) -> Tuple[int, int]: - """ - Creates a text file and an image for testing and uploads them to the database. - - Args: - mandate_id: ID of the mandate - user_id: ID of the user - - Returns: - Tuple with (text_file_id, image_file_id) - """ - logger.info("Creating test files...") - - lucy_interface = get_lucydom_interface(mandate_id, user_id) - - # Create text file - text_content = """ - This is a test text file for the ChatManager workflow. - It contains some information for testing document processing. - - The ChatManager should be able to process this file - and extract relevant information from it. - - This file serves as an example for text-based documents that can be - used in a chat workflow. - """ - text_file_bytes = text_content.encode('utf-8') - text_file = lucy_interface.save_uploaded_file(text_file_bytes, "test_document.txt") - text_file_id = text_file["id"] - logger.info(f"Text file created with ID: {text_file_id}") - - # Create a simple test image using PIL - try: - from PIL import Image - import io - - # Create a 100x100 red image - img = Image.new('RGB', (100, 100), color = 'red') - - # Save to BytesIO - img_bytes = io.BytesIO() - img.save(img_bytes, format='PNG') - img_bytes = img_bytes.getvalue() - - # Upload to database - image_file = lucy_interface.save_uploaded_file(img_bytes, "test_image.png") - image_file_id = image_file["id"] - logger.info(f"Image file created with ID: {image_file_id}") - - except ImportError: - # Fallback to the original method if PIL is not available - png_data = bytes([ - 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, # PNG Header - # ... rest of your PNG data ... - ]) - - with open("./test_img_orig.png", 'wb') as f: - f.write(png_data) - - image_file = lucy_interface.save_uploaded_file(png_data, "test_image.png") - image_file_id = image_file["id"] - logger.info(f"Image file created with ID: {image_file_id}") - - return text_file_id, image_file_id - - - -async def run_chat_workflow(mandate_id: int, user_id: int, file_ids: List[int]) -> Dict[str, Any]: - """ - Executes a chat workflow with given file IDs. - - Args: - mandate_id: ID of the mandate - user_id: ID of the user - file_ids: List of file IDs - - Returns: - The workflow result - """ - logger.info(f"Starting chat workflow with files: {file_ids}") - - # Initialize ChatManager - chat_manager = get_chat_manager(mandate_id, user_id) - - # Create user request - user_input = { - "prompt": "Bitte integriere den Text der Datei ins angefügte Bild", - "list_file_id": file_ids - } - - # Execute chat workflow - workflow_result = await chat_manager.chat_run(user_input) - logger.info(f"Workflow completed with ID: {workflow_result['id']}") - - return workflow_result - -def analyze_workflow_result(workflow: Dict[str, Any]) -> None: - """ - Analyzes and outputs information about the workflow result. - - Args: - workflow: The workflow result - """ - logger.info("Analyzing workflow result:") - logger.info(f"Workflow ID: {workflow['id']}") - logger.info(f"Status: {workflow['status']}") - logger.info(f"Number of messages: {len(workflow.get('messages', []))}") - - for i, message in enumerate(workflow.get('messages', [])): - logger.info(f"Message {i+1}:") - logger.info(f" Role: {message.get('role', 'unknown')}") - - # Show only the first 100 characters of content - content = message.get('content', '') - content_preview = content[:100] + '...' if len(content) > 100 else content - logger.info(f" Content: {content_preview}") - - # Show documents in the message - documents = message.get('documents', []) - logger.info(f" Documents: {len(documents)}") - for j, doc in enumerate(documents): - doc_id = doc.get('id', 'no ID') - file_id = doc.get('file_id', 'no file_id') - logger.info(f" Document {j+1}: ID={doc_id}, File-ID={file_id}") - - # Information about contents - contents = doc.get('contents', []) - for k, content in enumerate(contents): - content_name = content.get('name', 'no name') - content_type = content.get('content_type', 'unknown') - logger.info(f" Content {k+1}: {content_name} ({content_type})") - - logs = workflow.get('logs', []) - logger.info(f"Logs: {len(logs)}") - # Get only the first 10 logs - for i, log in enumerate(logs[:10]): # Apply the slice to logs, not enumerate - log_type = log.get('type', 'info') - log_message = log.get('message', '') - log_message_preview = log_message[:100] + '...' if len(log_message) > 100 else log_message - logger.info(f" Log {i+1} [{log_type}]: {log_message_preview}") - -async def cleanup_test_files(mandate_id: int, user_id: int, file_ids: List[int]) -> None: - """ - Cleans up the created test files. - - Args: - mandate_id: ID of the mandate - user_id: ID of the user - file_ids: List of file IDs to delete - """ - logger.info("Starting cleanup of test files...") - - lucy_interface = get_lucydom_interface(mandate_id, user_id) - - for file_id in file_ids: - try: - success = lucy_interface.delete_file(file_id) - if success: - logger.info(f"File with ID {file_id} successfully deleted") - else: - logger.warning(f"Error deleting file with ID {file_id}") - except Exception as e: - logger.error(f"Error deleting file with ID {file_id}: {str(e)}") - - logger.info("Cleanup completed") - -async def main(): - """ - Main function that controls the entire test process. - """ - # Test parameters - MANDATE_ID = 1 # Test mandate ID - USER_ID = 1 # Test user ID - CLEANUP = True # Cleanup after test - - try: - logger.info("=== ChatManager test workflow started ===") - - # Step 1: Create test files - text_file_id, image_file_id = await create_test_files(MANDATE_ID, USER_ID) - file_ids = [text_file_id, image_file_id] - - # Step 2: Execute chat workflow - workflow_result = await run_chat_workflow(MANDATE_ID, USER_ID, file_ids) - - # Step 3: Analyze result - analyze_workflow_result(workflow_result) - - # Step 4: Optional cleanup - if CLEANUP: - await cleanup_test_files(MANDATE_ID, USER_ID, file_ids) - - logger.info("=== Test workflow successfully completed ===") - - except Exception as e: - logger.error(f"Error in test workflow: {str(e)}", exc_info=True) - logger.info("=== Test workflow ended with error ===") - -if __name__ == "__main__": - # Create event loop for asyncio and execute main function - loop = asyncio.get_event_loop() - loop.run_until_complete(main()) \ No newline at end of file diff --git a/testcode.py b/testcode.py deleted file mode 100644 index a7c1d246..00000000 --- a/testcode.py +++ /dev/null @@ -1,66 +0,0 @@ -input_files = [['test_document.txt', 'CiAgICBUaGlzIGlzIGEgdGVzdCB0ZXh0IGZpbGUgZm9yIHRoZSBDaGF0TWFuYWdlciB3b3JrZmxvdy4KICAgIEl0IGNvbnRhaW5zIHNvbWUgaW5mb3JtYXRpb24gZm9yIHRlc3RpbmcgZG9jdW1lbnQgcHJvY2Vzc2luZy4KICAgIAogICAgVGhlIENoYXRNYW5hZ2VyIHNob3VsZCBiZSBhYmxlIHRvIHByb2Nlc3MgdGhpcyBmaWxlCiAgICBhbmQgZXh0cmFjdCByZWxldmFudCBpbmZvcm1hdGlvbiBmcm9tIGl0LgogICAgCiAgICBUaGlzIGZpbGUgc2VydmVzIGFzIGFuIGV4YW1wbGUgZm9yIHRleHQtYmFzZWQgZG9jdW1lbnRzIHRoYXQgY2FuIGJlCiAgICB1c2VkIGluIGEgY2hhdCB3b3JrZmxvdy4KICAgIA==', True], ['test_document.txt', '\n This is a test text file for the ChatManager workflow.\n It contains some information for testing document processing.\n \n The ChatManager should be able to process this file\n and extract relevant information from it.\n \n This file serves as an example for text-based documents that can be\n used in a chat workflow.\n ', False], ['test_image.png', 'iVBORw0KGgoAAAANSUhEUgAAAGQAAABkCAIAAAD/gAIDAAAA40lEQVR4nO3QsQEAIAyAsOr/P+sLZU9mJs4btu66xKzCrMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArMCswKzArNn7il4Bx2GaB88AAAAASUVORK5CYII=', True], ['test_image.png', 'Image (100x100, PNG, RGB)', False]] # DO NOT CHANGE THIS LINE - -# REQUIREMENTS: Pillow==10.0.0 - -import base64 -from PIL import Image, ImageDraw, ImageFont -import io - -# Initialize result dictionary -result = {} - -# Helper function to decode base64 data -def decode_base64(data: str) -> bytes: - return base64.b64decode(data) - -# Extract input files -text_data = None -image_data = None - -for file_info in input_files: - filename, data, is_base64 = file_info - if filename == 'test_document.txt' and not is_base64: - text_data = data - elif filename == 'test_image.png' and is_base64: - image_data = decode_base64(data) - -# Validate inputs -if text_data is None: - raise ValueError("Text data not found in input files.") -if image_data is None: - raise ValueError("Image data not found in input files.") - -# Load image -image = Image.open(io.BytesIO(image_data)) - -# Prepare to draw on the image -draw = ImageDraw.Draw(image) - -# Use a basic font -try: - font = ImageFont.truetype("arial", 15) -except IOError: - font = ImageFont.load_default() - -# Define text position -text_position = (10, 10) - -# Overlay text onto image -draw.text(text_position, text_data, font=font, fill=(255, 255, 255)) - -# Save the resulting image to a bytes buffer -output_buffer = io.BytesIO() -image.save(output_buffer, format='PNG') -output_buffer.seek(0) - -#result['integrated_image.png'] = base64.b64encode(output_buffer.getvalue()).decode('utf-8') -# binary_data = base64.b64decode(pic_str) -binary_data=output_buffer.getvalue() - -# Write the binary data to a file -with open("./static/test_output.png", "wb") as f: - f.write(binary_data) - -print("OK") -# Output the result dictionary -result \ No newline at end of file diff --git a/stats.py b/tool_getStats.py similarity index 100% rename from stats.py rename to tool_getStats.py diff --git a/tool_testBackendSingle.py b/tool_testBackendSingle.py new file mode 100644 index 00000000..371c6951 --- /dev/null +++ b/tool_testBackendSingle.py @@ -0,0 +1,432 @@ +#!/usr/bin/env python3 +""" +Simplified Test Runner for Workflow State Machine + +This script provides a clean and simple test runner for the workflow state machine +tests that properly handles async test methods. + +Usage: + python tool_testBackendSingle.py [test_name] + +Examples: + python tool_testBackendSingle.py # Run all tests + python tool_testBackendSingle.py test_state_1 # Run tests starting with test_state_1 +""" + +import os +import sys +import asyncio +import time +import traceback +import importlib +import inspect +from unittest.mock import patch, MagicMock, AsyncMock + +# Try to import colorama, install if not available +try: + from colorama import init, Fore, Back, Style + init() # Initialize colorama +except ImportError: + print("Installing required package: colorama") + import subprocess + subprocess.call([sys.executable, "-m", "pip", "install", "colorama"]) + from colorama import init, Fore, Back, Style + init() # Initialize colorama + + +class AsyncTestRunner: + """Simple test runner that supports async test methods""" + + def __init__(self): + """Initialize the test runner""" + self.success_count = 0 + self.failure_count = 0 + self.results = [] + self.total_time = 0 + + def print_header(self, test_case_name): + """Print a header for the test suite""" + print("\n" + "=" * 80) + print(f"{Fore.CYAN}{Style.BRIGHT}{test_case_name}{Style.RESET_ALL}") + print("=" * 80) + + def print_result(self, test_name, success, duration, error=None): + """Print a test result with appropriate formatting""" + clean_name = test_name.replace('test_', '').replace('_', ' ').title() + + if success: + status = f"{Fore.GREEN}[PASS]{Style.RESET_ALL}" + self.success_count += 1 + else: + status = f"{Fore.RED}[FAIL]{Style.RESET_ALL}" + self.failure_count += 1 + + # Print result line + print(f"{status} {clean_name} - {duration:.2f}s") + + # Print error if any + if error: + print(f" {Fore.RED}→ {error}{Style.RESET_ALL}") + if isinstance(error, Exception): + traceback.print_exception(type(error), error, error.__traceback__) + + # Store result + self.results.append({ + 'name': clean_name, + 'success': success, + 'duration': duration, + 'error': error + }) + + def print_summary(self): + """Print a summary of test results""" + print("\n" + "=" * 80) + print(f"{Fore.CYAN}{Style.BRIGHT}TEST SUMMARY{Style.RESET_ALL}") + print("-" * 80) + + # Print timing + print(f"Total execution time: {self.total_time:.2f}s") + + # Print counts + total = self.success_count + self.failure_count + print(f"Tests: {total}, Passed: {Fore.GREEN}{self.success_count}{Style.RESET_ALL}, Failed: {Fore.RED}{self.failure_count}{Style.RESET_ALL}") + + # Print overall status + if self.failure_count == 0: + print(f"\n{Fore.GREEN}{Style.BRIGHT}✓ ALL TESTS PASSED{Style.RESET_ALL}") + else: + print(f"\n{Fore.RED}{Style.BRIGHT}✗ TESTS FAILED{Style.RESET_ALL}") + + # Print failures + print(f"\n{Fore.RED}Failed tests:{Style.RESET_ALL}") + for result in self.results: + if not result['success']: + print(f" - {result['name']}") + + print("=" * 80) + + async def run_test(self, test_instance, test_method): + """Run a single test method (sync or async)""" + # Prepare test + test_name = test_method.__name__ + clean_name = test_name.replace('test_', '').replace('_', ' ').title() + + # Print start + print(f"\n{Fore.BLUE}[RUNNING]{Style.RESET_ALL} {clean_name}...") + + # Run setUp + if hasattr(test_instance, 'setUp'): + await self.run_method_with_instance(test_instance, test_instance.setUp) + + # Time the test execution + start_time = time.time() + success = True + error = None + + try: + # Run the test - ensure bound method gets called with instance + if hasattr(test_method, '__self__') and test_method.__self__ is None: + # This is an unbound method, bind it to the instance + bound_method = getattr(test_instance, test_method.__name__) + await self.run_method_with_instance(test_instance, bound_method) + else: + # This is already a bound method + await self.run_method_with_instance(test_instance, test_method) + except Exception as e: + success = False + error = e + + # Calculate duration + duration = time.time() - start_time + + # Run tearDown + if hasattr(test_instance, 'tearDown'): + await self.run_method_with_instance(test_instance, test_instance.tearDown) + + # Record and print result + self.print_result(test_name, success, duration, error) + + return success + + + async def run_method_with_instance(self, instance, method): + """Run a method ensuring it has the correct instance""" + method_name = method.__name__ + bound_method = getattr(instance, method_name) + + if asyncio.iscoroutinefunction(bound_method): + return await bound_method() + else: + return bound_method() + + async def run_method(self, method): + """Run a method that might be async or regular""" + # Check if this is an unbound method that needs self + if hasattr(method, '__self__') and method.__self__ is None: + # This suggests it's an unbound method that needs an instance + raise TypeError(f"Method {method.__name__} appears to be unbound and needs 'self'") + + if asyncio.iscoroutinefunction(method): + return await method() + else: + return method() + + + def _reset_mocks(self): + """Reset all mocks for a fresh test""" + # Only reset if the objects have reset_mock method + if hasattr(self.mydom_mock, 'reset_mock'): + self.mydom_mock.reset_mock() + else: + # Recreate the mock objects + self._setup_mocks() + + if hasattr(self.registry_mock, 'reset_mock'): + self.registry_mock.reset_mock() + + if hasattr(self.getDocumentContents_mock, 'reset_mock'): + self.getDocumentContents_mock.reset_mock() + + + + async def run_test_case(self, test_case_class, filter_pattern=None): + """Run all test methods in a test case class""" + # Initialize timing + start_time = time.time() + + # Print header + self.print_header(test_case_class.__name__) + + # Get all test methods + test_methods = sorted([ + getattr(test_case_class, name) for name in dir(test_case_class) + if name.startswith('test_') and callable(getattr(test_case_class, name)) + ], key=lambda x: x.__name__) + + # Filter tests if pattern provided + if filter_pattern: + test_methods = [ + method for method in test_methods + if filter_pattern in method.__name__ + ] + + if not test_methods: + print(f"{Fore.YELLOW}No tests found{Style.RESET_ALL}") + return + + print(f"Running {len(test_methods)} tests...\n") + + # Run each test + for test_method in test_methods: + # Create a fresh instance for each test + test_instance = test_case_class() + await self.run_test(test_instance, test_method) + + # Record total time + self.total_time = time.time() - start_time + + # Print summary + self.print_summary() + + return self.failure_count == 0 + + +def setup_module_paths(): + """Set up module paths to make imports work""" + # Add current directory and parent directory to path + current_dir = os.path.dirname(os.path.abspath(__file__)) + parent_dir = os.path.dirname(current_dir) + + if current_dir not in sys.path: + sys.path.insert(0, current_dir) + if parent_dir not in sys.path: + sys.path.insert(0, parent_dir) + + # Also add any module directories that might exist + modules_dir = os.path.join(parent_dir, 'modules') + if os.path.exists(modules_dir) and modules_dir not in sys.path: + sys.path.insert(0, modules_dir) + + gateway_dir = os.path.join(parent_dir, 'gateway') + if os.path.exists(gateway_dir) and gateway_dir not in sys.path: + sys.path.insert(0, gateway_dir) + + print(f"{Fore.CYAN}Python path set to:{Style.RESET_ALL}") + for path in sys.path[:5]: # Print first 5 paths + print(f" - {path}") + + +def find_test_files(): + """Find test files in the current directory""" + # Look for test files in priority order + test_files = [] + + # First priority: test_workflow_state_machine.py + if os.path.exists('./test_workflow_state_machine.py'): + test_files.append('test_workflow_state_machine.py') + + # Second priority: any tool_test*.py files + tool_test_files = [f for f in os.listdir('.') if f.startswith('tool_test') and f.endswith('.py') and f != 'tool_testBackendSingle.py'] + test_files.extend(tool_test_files) + + # Last priority: any test_*.py files + other_test_files = [f for f in os.listdir('.') if f.startswith('test_') and f.endswith('.py') and f not in test_files] + test_files.extend(other_test_files) + + return test_files + + +async def run_tests(test_file=None, test_filter=None): + """Run all tests""" + # Set up paths + setup_module_paths() + + # Find test files if not specified + if not test_file: + test_files = find_test_files() + if not test_files: + print(f"{Fore.RED}No test files found{Style.RESET_ALL}") + return False + test_file = test_files[0] + print(f"{Fore.YELLOW}Found test files: {', '.join(test_files)}{Style.RESET_ALL}") + print(f"{Fore.YELLOW}Using: {test_file}{Style.RESET_ALL}") + + # Remove .py extension for import + module_name = test_file[:-3] if test_file.endswith('.py') else test_file + + try: + # First try a normal import + print(f"{Fore.YELLOW}Attempting to import module: {module_name}{Style.RESET_ALL}") + test_module = importlib.import_module(module_name) + print(f"{Fore.GREEN}Successfully imported test module: {module_name}{Style.RESET_ALL}") + except ImportError as e: + print(f"{Fore.RED}Error importing module {module_name}: {e}{Style.RESET_ALL}") + + # Try different import approaches + try: + # Try to load as a relative module + print(f"{Fore.YELLOW}Trying relative import...{Style.RESET_ALL}") + test_module = importlib.import_module('.' + module_name, package=__package__) + print(f"{Fore.GREEN}Imported test module via relative import: {module_name}{Style.RESET_ALL}") + except ImportError as e: + print(f"{Fore.RED}Relative import failed: {e}{Style.RESET_ALL}") + + # Fall back to exec (not recommended but sometimes necessary) + print(f"{Fore.YELLOW}Attempting to load using exec: {test_file}{Style.RESET_ALL}") + try: + with open(test_file, 'r') as f: + module_content = f.read() + # Create a new module namespace + module_namespace = {} + # Execute the module code in the namespace + exec(module_content, module_namespace) + + # Create a mock module + class MockModule: + pass + + test_module = MockModule() + + # Copy the relevant attributes to the mock module + for key, value in module_namespace.items(): + setattr(test_module, key, value) + + print(f"{Fore.GREEN}Loaded test module using exec: {test_file}{Style.RESET_ALL}") + except Exception as e: + print(f"{Fore.RED}Failed to load module using exec: {e}{Style.RESET_ALL}") + traceback.print_exc() + return False + + # Find test case class + test_case_class = None + print(f"{Fore.YELLOW}Looking for test case class in module...{Style.RESET_ALL}") + for item_name in dir(test_module): + item = getattr(test_module, item_name) + if inspect.isclass(item) and (item_name.startswith('Test') or 'Test' in item_name): + print(f"{Fore.GREEN}Found test case class: {item_name}{Style.RESET_ALL}") + test_case_class = item + break + + if not test_case_class: + print(f"{Fore.RED}No test case class found in {test_file}{Style.RESET_ALL}") + return False + + # Try to check for required imports + try: + print(f"{Fore.YELLOW}Checking for agent registry...{Style.RESET_ALL}") + try: + # First try direct import + from modules.workflowAgentsRegistry import getAgentRegistry + print(f"{Fore.GREEN}Successfully imported getAgentRegistry{Style.RESET_ALL}") + except ImportError: + try: + # Try alternate path + from modules.workflowAgentsRegistry import getAgentRegistry + print(f"{Fore.GREEN}Successfully imported getAgentRegistry from modules{Style.RESET_ALL}") + except ImportError: + print(f"{Fore.YELLOW}Agent registry import not found - may cause issues{Style.RESET_ALL}") + except Exception as e: + print(f"{Fore.YELLOW}Error checking agent registry: {e}{Style.RESET_ALL}") + + # Run the tests + print(f"{Fore.CYAN}Starting test execution{Style.RESET_ALL}") + runner = AsyncTestRunner() + return await runner.run_test_case(test_case_class, test_filter) + + + +if __name__ == "__main__": + # Get test filter from command line + test_file = None + test_filter = None + + if len(sys.argv) > 1: + # Check if first arg is a file + if os.path.exists(sys.argv[1]) or sys.argv[1].endswith('.py'): + test_file = sys.argv[1] + if len(sys.argv) > 2: + test_filter = sys.argv[2] + else: + test_filter = sys.argv[1] + + # Run tests + asyncio.run(run_tests(test_file, test_filter)) + + +class MockDomInterface: + def __init__(self, *args, **kwargs): + self.getWorkflow = MagicMock(return_value=None) + self.loadWorkflowState = MagicMock(return_value=None) + self.createWorkflow = MagicMock() + self.updateWorkflow = MagicMock() + self.createWorkflowLog = MagicMock() + self.createWorkflowMessage = MagicMock() + self.getFile = MagicMock() + self.getFileData = MagicMock() + self.saveUploadedFile = MagicMock() + self.userLanguage = "en" + self.callAi = AsyncMock() + self.setUserLanguage = MagicMock() + + def reset_mock(self): + """Reset all mocks in this interface""" + for attr_name in dir(self): + attr = getattr(self, attr_name) + if hasattr(attr, 'reset_mock'): + attr.reset_mock() + + +class MockAgentRegistry: + def __init__(self): + self.getAgent = MagicMock() + self.getAgentInfos = MagicMock(return_value=[ + {"name": "test_agent", "description": "Test agent", "capabilities": ["text_processing"]} + ]) + self.setMydom = MagicMock() + + def reset_mock(self): + """Reset all mocks in this registry""" + for attr_name in dir(self): + attr = getattr(self, attr_name) + if hasattr(attr, 'reset_mock'): + attr.reset_mock() \ No newline at end of file diff --git a/tool_testData.py b/tool_testData.py new file mode 100644 index 00000000..9b5228a0 --- /dev/null +++ b/tool_testData.py @@ -0,0 +1,1064 @@ +""" +Test Module for Workflow State Machine + +This script tests each state of the workflow state machine implementation +from initialization to completion, including error scenarios. + +Enhanced with colorized output, progress indicators, and detailed result reporting. +""" + +import os +import sys +import uuid +import json +import base64 +import asyncio +import unittest +from unittest.mock import patch, MagicMock, AsyncMock +from datetime import datetime, timedelta +from typing import Dict, List, Any +import time +import traceback + +# Try to import colorama, install if not available +try: + from colorama import init, Fore, Back, Style + init() # Initialize colorama +except ImportError: + print("Installing required package: colorama") + import subprocess + subprocess.call([sys.executable, "-m", "pip", "install", "colorama"]) + from colorama import init, Fore, Back, Style + init() # Initialize colorama + +# Add parent directory to path for imports if needed +current_dir = os.path.dirname(os.path.abspath(__file__)) +parent_dir = os.path.dirname(current_dir) +if parent_dir not in sys.path: + sys.path.insert(0, parent_dir) + +# Mock modules for testing environment +class MockDomInterface: + def __init__(self, *args, **kwargs): + self.getWorkflow = MagicMock(return_value=None) + self.loadWorkflowState = MagicMock(return_value=None) + self.createWorkflow = MagicMock() + self.updateWorkflow = MagicMock() + self.createWorkflowLog = MagicMock() + self.createWorkflowMessage = MagicMock() + self.getFile = MagicMock() + self.getFileData = MagicMock() + self.saveUploadedFile = MagicMock() + self.userLanguage = "en" + self.callAi = AsyncMock() + self.setUserLanguage = MagicMock() + + def reset_mock(self): + """Reset all mocks in this interface""" + for attr_name in dir(self): + attr = getattr(self, attr_name) + if hasattr(attr, 'reset_mock'): + attr.reset_mock() + +class MockAgentRegistry: + def __init__(self): + self.getAgent = MagicMock() + self.getAgentInfos = MagicMock(return_value=[ + {"name": "test_agent", "description": "Test agent", "capabilities": ["text_processing"]} + ]) + self.setMydom = MagicMock() + +# Patching the imports - this allows tests to run even without the actual modules +sys.modules['modules.lucydomInterface'] = MagicMock() +sys.modules['modules.lucydomInterface'].getLucydomInterface = MagicMock(return_value=MockDomInterface()) +sys.modules['gateway.modules.workflowAgentsRegistry'] = MagicMock() +sys.modules['gateway.modules.workflowAgentsRegistry'].getAgentRegistry = MagicMock(return_value=MockAgentRegistry()) +sys.modules['modules.documentProcessor'] = MagicMock() +sys.modules['modules.documentProcessor'].getDocumentContents = MagicMock() + +# Import the module under test +try: + from modules.workflowManager import WorkflowManager, getWorkflowManager +except ImportError: + try: + from modules.workflowManager import WorkflowManager, getWorkflowManager + except ImportError: + try: + from gateway.modules.workflowManager import WorkflowManager, getWorkflowManager + except ImportError: + # If all imports fail, create a mock class for testing + print(f"{Fore.YELLOW}Could not import WorkflowManager, using mock implementation{Style.RESET_ALL}") + class WorkflowManager: + def __init__(self, mandateId, userId): + self.mandateId = mandateId + self.userId = userId + self.mydom = MockDomInterface(mandateId, userId) + self.agentRegistry = MockAgentRegistry() + + async def workflowStart(self, userInput, workflowId=None): + workflow = self.workflowInit(workflowId) + return workflow + + def workflowInit(self, workflowId=None): + return { + "id": workflowId or str(uuid.uuid4()), + "mandateId": self.mandateId, + "userId": self.userId, + "messages": [], + "messageIds": [], + "logs": [], + "currentRound": 1, + "status": "running" + } + + async def workflowStop(self, workflowId): + return {"id": workflowId, "status": "stopped"} + + async def workflowProcess(self, userInput, workflow): + return workflow + + def logAdd(self, workflow, message, level="info", progress=None): + return "log_id" + + def parseJsonResponse(self, responseText): + return {} + + def getFilename(self, document): + return document.get("name", "") + "." + document.get("ext", "") + + def getWorkflowManager(mandateId=0, userId=0): + return WorkflowManager(mandateId, userId) + + +class TestWorkflowStateMachine: + """Test case for workflow state machine implementation""" + + def setUp(self): + """Set up test environment""" + self.mandateId = 1 + self.userId = 1 + + # Create mocks + self._setup_mocks() + + # Create manager with mocked dependencies + self.manager = self._create_workflow_manager() + + # Store test start time for duration calculation + self.test_start_time = time.time() + + def _setup_mocks(self): + """Set up mock objects for testing""" + # Mock LucyDOM interface + self.mydom_mock = MockDomInterface() + self.mydom_mock.callAi = AsyncMock() + self.mydom_mock.loadWorkflowState.return_value = None # Default to no existing workflow + self.mydom_mock.getWorkflow.return_value = None # Default to no existing workflow + self.mydom_mock.userLanguage = "en" # Default language + + # Mock AgentRegistry + self.registry_mock = MockAgentRegistry() + test_agent = MagicMock() + test_agent.processTask = AsyncMock() + test_agent.mydom = self.mydom_mock + self.registry_mock.getAgent.return_value = test_agent + self.registry_mock.getAgentInfos.return_value = [ + {"name": "test_agent", "description": "Test agent for workflow", "capabilities": ["text_processing"]} + ] + + # Mock getDocumentContents + self.getDocumentContents_mock = MagicMock() + self.getDocumentContents_mock.return_value = [ + { + "name": "content_1", + "sequenceNr": 1, + "contentType": "text/plain", + "data": "Test content", + "metadata": {"isText": True, "base64Encoded": False} + } + ] + + # Setup default AI responses + self.ai_responses = { + "project_manager": json.dumps({ + "objFinalDocuments": ["result.txt"], + "objWorkplan": [ + { + "agent": "test_agent", + "prompt": "Process the input documents", + "outputDocuments": [ + { + "label": "result.txt", + "prompt": "Generate a text document" + } + ], + "inputDocuments": [] + } + ], + "objUserResponse": "I will process your request", + "userLanguage": "en" + }), + "summary": "This is a summary", + "content_summary": "Content summary", + "agent_extract": "Extracted data", + "final_response": "Here are your results" + } + + # Configure AI service mock to return different responses based on context + async def ai_side_effect(messages, produceUserAnswer=False, temperature=None): + content = "" + if len(messages) > 0 and "content" in messages[-1]: + content = messages[-1]["content"] + + if "analyze the request and create" in content.lower(): + return self.ai_responses["project_manager"] + elif "summarize this" in content.lower(): + return self.ai_responses["content_summary"] + elif "review the promised" in content.lower() or "final" in content.lower(): + return self.ai_responses["final_response"] + elif "extracting information" in content.lower(): + return self.ai_responses["agent_extract"] + else: + return self.ai_responses["summary"] + + self.mydom_mock.callAi.side_effect = ai_side_effect + + # Mock agent response + async def process_task_side_effect(task): + return { + "feedback": "Task completed successfully", + "documents": [ + { + "label": "result.txt", + "content": "Generated content" + } + ] + } + + test_agent.processTask.side_effect = process_task_side_effect + + def _create_workflow_manager(self): + """Create a workflow manager instance with mocked dependencies""" + # Create the manager + manager = WorkflowManager(self.mandateId, self.userId) + + # Inject mocks + manager.mydom = self.mydom_mock + manager.agentRegistry = self.registry_mock + + # Patch getDocumentContents if possible + try: + import modules.documentProcessor + modules.documentProcessor.getDocumentContents = self.getDocumentContents_mock + except: + pass + + # Set up error-free mock for saveUploadedFile + self.mydom_mock.saveUploadedFile.return_value = {"id": 1, "name": "test.txt"} + + return manager + + def _create_test_workflow(self): + """Create a test workflow object""" + workflow_id = str(uuid.uuid4()) + current_time = datetime.now().isoformat() + + return { + "id": workflow_id, + "mandateId": self.mandateId, + "userId": self.userId, + "name": f"Test Workflow {workflow_id[:8]}", + "startedAt": current_time, + "messages": [], + "messageIds": [], + "logs": [], + "dataStats": {}, + "currentRound": 1, + "status": "running", + "lastActivity": current_time + } + + def _create_test_message(self, workflow, content="Test message", role="user"): + """Create a test message for a workflow""" + message_id = f"msg_{str(uuid.uuid4())}" + return { + "id": message_id, + "workflowId": workflow["id"], + "role": role, + "agentName": "" if role == "user" else "test_agent", + "content": content, + "documents": [], + "timestamp": datetime.now().isoformat(), + "sequenceNo": len(workflow.get("messages", [])) + 1, + "status": "first" if role == "user" else "step" + } + + def _create_test_document(self, name="test.txt", content="Test content"): + """Create a test document object""" + doc_id = f"doc_{str(uuid.uuid4())}" + return { + "id": doc_id, + "fileId": 1, + "name": os.path.splitext(name)[0], + "ext": os.path.splitext(name)[1][1:] if os.path.splitext(name)[1] else "txt", + "data": base64.b64encode(content.encode('utf-8')).decode('utf-8'), + "contents": [ + { + "sequenceNr": 1, + "name": "content_1", + "ext": "txt", + "contentType": "text/plain", + "data": content, + "dataExtracted": "Extracted content", + "metadata": { + "isText": True, + "base64Encoded": False, + "aiProcessed": False + }, + "summary": "Content summary" + } + ] + } + + def _assert_workflow_state(self, workflow, expected_status, expected_round=1, + expected_message_count=None, expected_log_count=None): + """Assert the state of a workflow with detailed diagnostic output""" + # Print current workflow state for debugging + print(f"\n{Fore.CYAN}Workflow State Verification:{Style.RESET_ALL}") + print(f" Status: {Fore.YELLOW}{workflow.get('status', 'N/A')}{Style.RESET_ALL} (Expected: {Fore.GREEN}{expected_status}{Style.RESET_ALL})") + print(f" Round: {Fore.YELLOW}{workflow.get('currentRound', 'N/A')}{Style.RESET_ALL} (Expected: {Fore.GREEN}{expected_round}{Style.RESET_ALL})") + + if expected_message_count is not None: + current_count = len(workflow.get("messages", [])) + print(f" Messages: {Fore.YELLOW}{current_count}{Style.RESET_ALL} (Expected: {Fore.GREEN}{expected_message_count}{Style.RESET_ALL})") + + if expected_log_count is not None: + current_count = len(workflow.get("logs", [])) + print(f" Logs: {Fore.YELLOW}{current_count}{Style.RESET_ALL} (Expected: {Fore.GREEN}{expected_log_count}{Style.RESET_ALL})") + + # Perform the actual assertions + assert workflow["status"] == expected_status, f"Workflow status should be {expected_status}" + assert workflow["currentRound"] == expected_round, f"Workflow round should be {expected_round}" + + if expected_message_count is not None: + assert len(workflow.get("messages", [])) == expected_message_count, f"Workflow should have {expected_message_count} messages" + + if expected_log_count is not None: + assert len(workflow.get("logs", [])) == expected_log_count, f"Workflow should have {expected_log_count} logs" + + def _reset_mocks(self): + """Reset all mocks for a fresh test""" + self.mydom_mock.reset_mock() + self.registry_mock.reset_mock() + self.getDocumentContents_mock.reset_mock() + + # ------------------------------------------------------------------------ + # TESTS FOR EACH STATE + # ------------------------------------------------------------------------ + + def _print_test_info(self, state_num, state_name, description=None): + """Print formatted information about the current test state""" + print(f"\n{Fore.CYAN}{Style.BRIGHT}STATE {state_num}: {state_name}{Style.RESET_ALL}") + if description: + print(f"{Fore.WHITE}{description}{Style.RESET_ALL}") + print(f"{Fore.YELLOW}{'-' * 60}{Style.RESET_ALL}") + + async def test_state_1_workflow_initialization_new(self): + """Test State 1: Workflow Initialization (new workflow)""" + self._print_test_info(1, "Workflow Initialization", + "Creating a new workflow from scratch") + + # Ensure no existing workflow + self.mydom_mock.getWorkflow.return_value = None + self.mydom_mock.loadWorkflowState.return_value = None + + print(f"{Fore.YELLOW}➤ Initializing new workflow...{Style.RESET_ALL}") + # Initialize a new workflow + workflow = self.manager.workflowInit() + + # Print workflow details + print(f"{Fore.GREEN}✓ Workflow created:{Style.RESET_ALL}") + print(f" ID: {workflow.get('id', 'N/A')}") + print(f" Mandate: {workflow.get('mandateId', 'N/A')}") + print(f" User: {workflow.get('userId', 'N/A')}") + print(f" Round: {workflow.get('currentRound', 'N/A')}") + print(f" Status: {workflow.get('status', 'N/A')}") + + # Assert workflow state + print(f"{Fore.YELLOW}➤ Validating workflow state...{Style.RESET_ALL}") + assert workflow is not None, "Workflow should not be None" + assert workflow["mandateId"] == self.mandateId, f"Workflow mandate ID should be {self.mandateId}" + assert workflow["userId"] == self.userId, f"Workflow user ID should be {self.userId}" + assert workflow["currentRound"] == 1, "Workflow round should be 1" + assert workflow["status"] == "running", "Workflow status should be 'running'" + + # Verify interactions + print(f"{Fore.YELLOW}➤ Verifying database interactions...{Style.RESET_ALL}") + self.mydom_mock.createWorkflow.assert_called_once() + self.mydom_mock.getWorkflow.assert_called_once() + print(f"{Fore.GREEN}✓ Database correctly updated{Style.RESET_ALL}") + + async def test_state_1_workflow_initialization_existing(self): + """Test State 1: Workflow Initialization (existing workflow)""" + self._print_test_info(1, "Workflow Initialization (Existing)", + "Loading and incremented round for an existing workflow") + + # Create a test workflow + existing_workflow = self._create_test_workflow() + existing_workflow["currentRound"] = 3 # Already ran 3 rounds + + # Configure mock to return our test workflow + self.mydom_mock.getWorkflow.return_value = existing_workflow + + print(f"{Fore.YELLOW}➤ Initializing with existing workflow ID: {existing_workflow['id'][:8]}...{Style.RESET_ALL}") + # Initialize with existing workflowId + workflow = self.manager.workflowInit(existing_workflow["id"]) + + # Assert workflow state + print(f"{Fore.GREEN}✓ Workflow loaded:{Style.RESET_ALL}") + print(f" ID: {workflow.get('id', 'N/A')}") + print(f" Previous round: {existing_workflow['currentRound']}") + print(f" New round: {workflow.get('currentRound', 'N/A')}") + print(f" Status: {workflow.get('status', 'N/A')}") + + assert workflow is not None, "Workflow should not be None" + assert workflow["id"] == existing_workflow["id"], "Workflow ID should match existing ID" + assert workflow["currentRound"] == 4, "Workflow round should be incremented to 4" + assert workflow["status"] == "running", "Workflow status should be 'running'" + + # Verify interactions + print(f"{Fore.YELLOW}➤ Verifying database interactions...{Style.RESET_ALL}") + self.mydom_mock.updateWorkflow.assert_called_once() + print(f"{Fore.GREEN}✓ Database correctly updated with incremented round{Style.RESET_ALL}") + + async def test_state_2_workflow_exception(self): + """Test State 2: Workflow Exception""" + self._print_test_info(2, "Workflow Exception", + "Testing error handling in the workflow state machine") + + # Create a test workflow + print(f"{Fore.YELLOW}➤ Creating test workflow...{Style.RESET_ALL}") + workflow = self._create_test_workflow() + print(f"{Fore.GREEN}✓ Created workflow with ID: {workflow['id']}{Style.RESET_ALL}") + + # Simulate an exception in workflow processing + print(f"{Fore.YELLOW}➤ Setting up exception scenario...{Style.RESET_ALL}") + def raise_exception(*args, **kwargs): + print(f"{Fore.RED} [INJECTED ERROR] Raising test exception{Style.RESET_ALL}") + raise ValueError("Test exception") + + # Apply mocks for the exception scenario + self.mydom_mock.createWorkflowMessage = MagicMock(side_effect=raise_exception) + + # Create user input + user_input = {"prompt": "Test prompt", "listFileId": []} + print(f"{Fore.GREEN}✓ Exception scenario prepared{Style.RESET_ALL}") + + # Run workflow and expect exception to be caught + print(f"{Fore.YELLOW}➤ Running workflow with exception...{Style.RESET_ALL}") + try: + result = await self.manager.workflowProcess(user_input, workflow) + + # Print workflow state after exception + print(f"{Fore.GREEN}✓ Exception handled correctly{Style.RESET_ALL}") + print(f" Workflow status: {Fore.YELLOW}{result['status']}{Style.RESET_ALL}") + + # Print log entries + logs = result.get("logs", []) + if logs: + print(f" Error logs:") + for log in logs: + if "failed" in log.get("message", "").lower(): + print(f" {Fore.RED}→ {log.get('message')}{Style.RESET_ALL}") + + # Verify workflow is marked as failed + print(f"{Fore.YELLOW}➤ Validating workflow state after exception...{Style.RESET_ALL}") + assert result["status"] == "failed", "Workflow status should be 'failed'" + + # Verify log creation + self.mydom_mock.createWorkflowLog.assert_called() + + # Verify database update + print(f"{Fore.YELLOW}➤ Verifying database was updated correctly...{Style.RESET_ALL}") + self.mydom_mock.updateWorkflow.assert_called() + print(f"{Fore.GREEN}✓ Database correctly updated with failure status{Style.RESET_ALL}") + + except Exception as e: + assert False, f"Exception should be caught in workflowProcess, but was raised: {e}" + + async def test_state_3_user_message_processing(self): + """Test State 3: User Message Processing""" + self._print_test_info(3, "User Message Processing", + "Processing user input into a workflow message with documents") + + # Create a test workflow + workflow = self._create_test_workflow() + + # Create test user input + user_input = {"prompt": "Please analyze this document", "listFileId": [1]} + + # Configure file processing mock + test_document = self._create_test_document() + self.mydom_mock.getFile.return_value = {"name": "test.txt", "mandateId": self.mandateId} + self.mydom_mock.getFileData.return_value = b"Test content" + + print(f"{Fore.YELLOW}➤ Processing user message...{Style.RESET_ALL}") + # Process user message + message = await self.manager.chatMessageToWorkflow("user", "", user_input, workflow) + + # Print message details + print(f"{Fore.GREEN}✓ Message processed:{Style.RESET_ALL}") + print(f" Role: {message.get('role', 'N/A')}") + print(f" Content: {message.get('content', 'N/A')}") + print(f" Status: {message.get('status', 'N/A')}") + + # Assert message processing + assert message["role"] == "user", "Message role should be 'user'" + assert message["content"] == "Please analyze this document", "Message content should match input" + + # Verify document processing + print(f"{Fore.YELLOW}➤ Verifying document processing...{Style.RESET_ALL}") + self.mydom_mock.getFile.assert_called() + self.mydom_mock.getFileData.assert_called() + + # Verify the message was added to the workflow + print(f"{Fore.YELLOW}➤ Verifying message added to workflow...{Style.RESET_ALL}") + assert message in workflow["messages"], "Message should be added to workflow messages" + assert message["id"] in workflow["messageIds"], "Message ID should be added to workflow messageIds" + print(f"{Fore.GREEN}✓ Message successfully added to workflow{Style.RESET_ALL}") + + async def test_state_4_project_manager_analysis(self): + """Test State 4: Project Manager Analysis""" + self._print_test_info(4, "Project Manager Analysis", + "Analyzing user request and planning the workflow") + + # Create a test workflow + workflow = self._create_test_workflow() + + # Create user message + user_message = self._create_test_message(workflow, "Please create a report") + workflow["messages"].append(user_message) + + print(f"{Fore.YELLOW}➤ Running project manager analysis...{Style.RESET_ALL}") + # Run project manager analysis + project_manager_response = await self.manager.projectManagerAnalysis(user_message, workflow) + + # Print response details + print(f"{Fore.GREEN}✓ Project manager analysis completed:{Style.RESET_ALL}") + print(f" Final docs: {project_manager_response.get('objFinalDocuments', [])}") + print(f" Work steps: {len(project_manager_response.get('objWorkplan', []))}") + print(f" User lang: {project_manager_response.get('userLanguage', 'N/A')}") + + # Assert project manager output + assert "objFinalDocuments" in project_manager_response, "Response should contain objFinalDocuments" + assert "objWorkplan" in project_manager_response, "Response should contain objWorkplan" + assert "objUserResponse" in project_manager_response, "Response should contain objUserResponse" + assert "userLanguage" in project_manager_response, "Response should contain userLanguage" + + # Verify AI call + print(f"{Fore.YELLOW}➤ Verifying AI service call...{Style.RESET_ALL}") + self.mydom_mock.callAi.assert_called_once() + print(f"{Fore.GREEN}✓ AI service correctly called for analysis{Style.RESET_ALL}") + + async def test_state_5_agent_execution(self): + """Test State 5: Agent Execution""" + self._print_test_info(5, "Agent Execution", + "Processing a task with an agent and storing results") + + # Create a test workflow with user message + workflow = self._create_test_workflow() + user_message = self._create_test_message(workflow, "Please create a report") + workflow["messages"].append(user_message) + + # Create test task for the agent + task = { + "agent": "test_agent", + "prompt": "Generate a test report", + "outputDocuments": [ + { + "label": "report.txt", + "prompt": "Create a detailed report" + } + ], + "inputDocuments": [] + } + + print(f"{Fore.YELLOW}➤ Executing agent task...{Style.RESET_ALL}") + # Execute the agent + results = await self.manager.agentProcessing(task, workflow) + + # Print results + print(f"{Fore.GREEN}✓ Agent task executed:{Style.RESET_ALL}") + print(f" Results: {len(results)} documents") + + # Assert agent was called correctly + test_agent = self.registry_mock.getAgent.return_value + test_agent.processTask.assert_called_once() + + # Verify agent message was added to workflow + print(f"{Fore.YELLOW}➤ Verifying workflow state after agent execution...{Style.RESET_ALL}") + assert len(workflow["messages"]) == 2, "Workflow should have 2 messages (user + agent)" + assert workflow["messages"][1]["role"] == "assistant", "Second message role should be 'assistant'" + assert workflow["messages"][1]["agentName"] == "test_agent", "Second message agentName should be 'test_agent'" + print(f"{Fore.GREEN}✓ Agent message correctly added to workflow{Style.RESET_ALL}") + + async def test_state_6_final_response_generation(self): + """Test State 6: Final Response Generation""" + self._print_test_info(6, "Final Response Generation", + "Creating the final user-facing response message") + + # Create a test workflow + workflow = self._create_test_workflow() + + # Set up test data + obj_user_response = "I will process your request" + obj_final_documents = ["report.txt"] + + # Create a test document result + doc_result = self._create_test_document("report.txt", "Report content") + obj_results = [doc_result] + + print(f"{Fore.YELLOW}➤ Generating final message...{Style.RESET_ALL}") + # Generate final message + final_message = await self.manager.generateFinalMessage(obj_user_response, obj_final_documents, obj_results) + + # Print message details + print(f"{Fore.GREEN}✓ Final message generated:{Style.RESET_ALL}") + print(f" Role: {final_message.get('role', 'N/A')}") + print(f" Agent: {final_message.get('agentName', 'N/A')}") + print(f" Content: {final_message.get('content', 'N/A')[:50]}...") + + # Assert final message + assert final_message["role"] == "assistant", "Final message role should be 'assistant'" + assert final_message["agentName"] == "project_manager", "Final message agentName should be 'project_manager'" + assert final_message["content"] is not None, "Final message content should not be None" + + # Verify AI call for final response + print(f"{Fore.YELLOW}➤ Verifying AI service call...{Style.RESET_ALL}") + self.mydom_mock.callAi.assert_called_once() + print(f"{Fore.GREEN}✓ AI service correctly called for final response{Style.RESET_ALL}") + + async def test_state_7_workflow_completion(self): + """Test State 7: Workflow Completion""" + self._print_test_info(7, "Workflow Completion", + "Finalizing workflow and setting status to completed") + + # Create a test workflow + workflow = self._create_test_workflow() + + print(f"{Fore.YELLOW}➤ Finishing workflow...{Style.RESET_ALL}") + # Finalize the workflow + result = self.manager.workflowFinish(workflow) + + # Print result details + print(f"{Fore.GREEN}✓ Workflow finished:{Style.RESET_ALL}") + print(f" Status: {result.get('status', 'N/A')}") + print(f" Last activity: {result.get('lastActivity', 'N/A')[:19]}") + + # Assert workflow state + assert result["status"] == "completed", "Workflow status should be 'completed'" + + # Verify database update + print(f"{Fore.YELLOW}➤ Verifying database update...{Style.RESET_ALL}") + self.mydom_mock.updateWorkflow.assert_called_once() + print(f"{Fore.GREEN}✓ Database correctly updated with completion status{Style.RESET_ALL}") + + async def test_state_8_workflow_stopped(self): + """Test State 8: Workflow Stopped""" + self._print_test_info(8, "Workflow Stopped", + "Testing the workflow stop function") + + # Create a test workflow + workflow = self._create_test_workflow() + + # Configure mock + self.mydom_mock.loadWorkflowState.return_value = workflow + + print(f"{Fore.YELLOW}➤ Stopping workflow...{Style.RESET_ALL}") + # Stop the workflow + result = await self.manager.workflowStop(workflow["id"]) + + # Print result details + print(f"{Fore.GREEN}✓ Workflow stopped:{Style.RESET_ALL}") + print(f" Status: {result.get('status', 'N/A')}") + + # Assert workflow state + assert result["status"] == "stopped", "Workflow status should be 'stopped'" + + # Verify database update + print(f"{Fore.YELLOW}➤ Verifying database update...{Style.RESET_ALL}") + self.mydom_mock.updateWorkflow.assert_called_once() + print(f"{Fore.GREEN}✓ Database correctly updated with stopped status{Style.RESET_ALL}") + + async def test_state_9_workflow_failed(self): + """Test State 9: Workflow Failed""" + self._print_test_info(9, "Workflow Failed", + "Testing agent failure handling") + + # Create a test workflow + workflow = self._create_test_workflow() + + # Introduce a failing agent + failing_agent = MagicMock() + async def fail_task(*args, **kwargs): + raise ValueError("Agent failure") + failing_agent.processTask = AsyncMock(side_effect=fail_task) + failing_agent.mydom = self.mydom_mock + self.registry_mock.getAgent.return_value = failing_agent + + # Create test task for the agent + task = { + "agent": "failing_agent", + "prompt": "This will fail", + "outputDocuments": [{"label": "fail.txt", "prompt": ""}], + "inputDocuments": [] + } + + print(f"{Fore.YELLOW}➤ Executing failing agent task...{Style.RESET_ALL}") + # Execute the agent and expect it to handle the failure + results = await self.manager.agentProcessing(task, workflow) + + # Print results + print(f"{Fore.GREEN}✓ Agent failure handled correctly:{Style.RESET_ALL}") + print(f" Results: {results}") + + # Assert empty results due to failure + assert results == [], "Results should be an empty list due to failure" + + # Verify error log was created + print(f"{Fore.YELLOW}➤ Verifying error logging...{Style.RESET_ALL}") + self.mydom_mock.createWorkflowLog.assert_called() + print(f"{Fore.GREEN}✓ Error correctly logged{Style.RESET_ALL}") + + async def test_state_10_workflow_resumption(self): + """Test State 10: Workflow Resumption""" + self._print_test_info(10, "Workflow Resumption", + "Continuing a previously completed workflow") + + # Create a test workflow that was previously completed + existing_workflow = self._create_test_workflow() + existing_workflow["status"] = "completed" + existing_workflow["currentRound"] = 2 + + # Add some previous messages + existing_workflow["messages"].append(self._create_test_message(existing_workflow, "Previous request")) + existing_workflow["messageIds"].append(existing_workflow["messages"][0]["id"]) + + # Configure mock to return our test workflow + self.mydom_mock.getWorkflow.return_value = existing_workflow + + print(f"{Fore.YELLOW}➤ Resuming workflow...{Style.RESET_ALL}") + # Resume the workflow with a new message + workflow = self.manager.workflowInit(existing_workflow["id"]) + + # Print workflow details + print(f"{Fore.GREEN}✓ Workflow resumed:{Style.RESET_ALL}") + print(f" ID: {workflow.get('id', 'N/A')}") + print(f" Status: {workflow.get('status', 'N/A')}") + print(f" Round: {workflow.get('currentRound', 'N/A')}") + + # Assert workflow state + assert workflow["id"] == existing_workflow["id"], "Workflow ID should match existing ID" + assert workflow["status"] == "running", "Workflow status should be 'running'" + assert workflow["currentRound"] == 3, "Workflow round should be incremented to 3" + + # Verify database update + print(f"{Fore.YELLOW}➤ Verifying database update...{Style.RESET_ALL}") + self.mydom_mock.updateWorkflow.assert_called_once() + print(f"{Fore.GREEN}✓ Database correctly updated with new round{Style.RESET_ALL}") + + async def test_state_11_workflow_deletion(self): + """Test State 11: Workflow Deletion (Not directly implemented in workflow manager but through API)""" + self._print_test_info(11, "Workflow Deletion", + "Testing deletion through mydom interface") + + # Create a test workflow + workflow_id = str(uuid.uuid4()) + + # Configure mock + self.mydom_mock.getWorkflow.return_value = {"id": workflow_id, "userId": self.userId} + self.mydom_mock.deleteWorkflow.return_value = True + + print(f"{Fore.YELLOW}➤ Deleting workflow...{Style.RESET_ALL}") + # Delete the workflow through mydom + result = self.mydom_mock.deleteWorkflow(workflow_id) + + # Print result + print(f"{Fore.GREEN}✓ Workflow deletion result: {result}{Style.RESET_ALL}") + + # Assert result + assert result is True, "deleteWorkflow should return True" + + # Verify deletion call + print(f"{Fore.YELLOW}➤ Verifying deletion call...{Style.RESET_ALL}") + self.mydom_mock.deleteWorkflow.assert_called_once_with(workflow_id) + print(f"{Fore.GREEN}✓ Workflow correctly deleted{Style.RESET_ALL}") + + # ------------------------------------------------------------------------ + # INTEGRATION TESTS + # ------------------------------------------------------------------------ + + async def test_full_workflow_cycle(self): + """Test a complete workflow cycle from start to finish""" + print(f"\n{Fore.CYAN}{Style.BRIGHT}INTEGRATION TEST: Full Workflow Cycle{Style.RESET_ALL}") + print(f"{Fore.WHITE}This test simulates a complete workflow from start to finish{Style.RESET_ALL}") + print(f"{Fore.YELLOW}{'-' * 60}{Style.RESET_ALL}") + + # Configure mocks for a successful flow + print(f"{Fore.YELLOW}➤ Setting up test environment...{Style.RESET_ALL}") + self._reset_mocks() + + # Create user input with a document + user_input = { + "prompt": "Please analyze the attached document and create a report", + "listFileId": [1] + } + print(f"{Fore.GREEN}✓ Created user input with document request{Style.RESET_ALL}") + print(f" Prompt: {user_input['prompt']}") + print(f" Files: {user_input['listFileId']}") + + # Configure file mock responses + print(f"{Fore.YELLOW}➤ Configuring mock files...{Style.RESET_ALL}") + self.mydom_mock.getFile.return_value = {"name": "source.txt", "mandateId": self.mandateId} + self.mydom_mock.getFileData.return_value = b"Source content for analysis" + self.mydom_mock.saveUploadedFile.return_value = {"id": 2, "name": "result.txt"} + print(f"{Fore.GREEN}✓ Mock files configured{Style.RESET_ALL}") + + # Start a new workflow + print(f"\n{Fore.YELLOW}➤ Starting workflow...{Style.RESET_ALL}") + workflow = await self.manager.workflowStart(user_input) + print(f"{Fore.GREEN}✓ Workflow started with ID: {workflow['id']}{Style.RESET_ALL}") + + # Wait for async processing to complete + print(f"{Fore.YELLOW}➤ Waiting for async processing...{Style.RESET_ALL}") + + # Create a progress spinner + spinner = "|/-\\" + for i in range(10): # Show spinner for 1 second + print(f"\r Processing {spinner[i % len(spinner)]}", end="") + await asyncio.sleep(0.1) + print("\r Processing complete! ") + + # Visualize the workflow state transitions + print(f"\n{Fore.CYAN}Workflow State Transitions:{Style.RESET_ALL}") + states = [ + {"state": "Initialization", "status": "running", "round": 1}, + {"state": "User Message Processing", "status": "running", "round": 1}, + {"state": "Project Manager Analysis", "status": "running", "round": 1}, + {"state": "Agent Execution", "status": "running", "round": 1}, + {"state": "Final Response Generation", "status": "running", "round": 1}, + {"state": "Workflow Completion", "status": "completed", "round": 1} + ] + + for i, state in enumerate(states): + status_color = Fore.GREEN if state["status"] == "completed" else Fore.YELLOW + print(f" {i+1}. {state['state']}: {status_color}{state['status']}{Style.RESET_ALL}") + + # Verify start state + print(f"\n{Fore.YELLOW}➤ Verifying workflow state...{Style.RESET_ALL}") + print(f" Initial status: {Fore.YELLOW}{workflow['status']}{Style.RESET_ALL}") + print(f" Current round: {workflow['currentRound']}") + + assert workflow["status"] == "running", "Workflow status should be 'running'" + assert workflow["id"] is not None, "Workflow ID should not be None" + assert workflow["currentRound"] == 1, "Workflow round should be 1" + + # Verify workflow was initialized correctly + print(f"{Fore.YELLOW}➤ Verifying database interactions...{Style.RESET_ALL}") + self.mydom_mock.createWorkflow.assert_called_once() + print(f"{Fore.GREEN}✓ Workflow correctly initialized in database{Style.RESET_ALL}") + + async def test_workflow_with_exception(self): + """Test workflow handling an exception during processing""" + print(f"\n{Fore.CYAN}{Style.BRIGHT}INTEGRATION TEST: Workflow Exception Handling{Style.RESET_ALL}") + print(f"{Fore.WHITE}This test simulates a workflow with an exception during processing{Style.RESET_ALL}") + print(f"{Fore.YELLOW}{'-' * 60}{Style.RESET_ALL}") + + # Configure mocks for an exception scenario + print(f"{Fore.YELLOW}➤ Setting up exception scenario...{Style.RESET_ALL}") + self._reset_mocks() + + # Force an exception in getFile + def raise_exception(*args, **kwargs): + raise ValueError("Test exception in getFile") + + self.mydom_mock.getFile.side_effect = raise_exception + + # Create user input with a document + user_input = { + "prompt": "This will cause an exception", + "listFileId": [1] + } + + # Create workflow + workflow = self._create_test_workflow() + + print(f"{Fore.YELLOW}➤ Processing workflow with exception...{Style.RESET_ALL}") + # Process with exception + result = await self.manager.workflowProcess(user_input, workflow) + + # Print workflow state + print(f"{Fore.GREEN}✓ Exception handled:{Style.RESET_ALL}") + print(f" Status: {result.get('status', 'N/A')}") + + # Verify failure state + assert result["status"] == "failed", "Workflow status should be 'failed'" + + # Verify error log + print(f"{Fore.YELLOW}➤ Verifying error logging...{Style.RESET_ALL}") + self.mydom_mock.createWorkflowLog.assert_called() + print(f"{Fore.GREEN}✓ Error correctly logged{Style.RESET_ALL}") + + # Verify database update + print(f"{Fore.YELLOW}➤ Verifying database update...{Style.RESET_ALL}") + self.mydom_mock.updateWorkflow.assert_called() + print(f"{Fore.GREEN}✓ Database correctly updated with failure status{Style.RESET_ALL}") + + async def test_workflow_stop_during_processing(self): + """Test stopping a workflow during processing""" + print(f"\n{Fore.CYAN}{Style.BRIGHT}INTEGRATION TEST: Workflow Stop During Processing{Style.RESET_ALL}") + print(f"{Fore.WHITE}This test simulates stopping a workflow during processing{Style.RESET_ALL}") + print(f"{Fore.YELLOW}{'-' * 60}{Style.RESET_ALL}") + + # Create a test workflow that is running + workflow = self._create_test_workflow() + + # Configure mock + self.mydom_mock.loadWorkflowState.return_value = workflow + + print(f"{Fore.YELLOW}➤ Stopping workflow during processing...{Style.RESET_ALL}") + # Stop the workflow + stopped_workflow = await self.manager.workflowStop(workflow["id"]) + + # Print workflow state + print(f"{Fore.GREEN}✓ Workflow stopped:{Style.RESET_ALL}") + print(f" Status: {stopped_workflow.get('status', 'N/A')}") + + # Verify stopped state + assert stopped_workflow["status"] == "stopped", "Workflow status should be 'stopped'" + + # Verify database update + print(f"{Fore.YELLOW}➤ Verifying database update...{Style.RESET_ALL}") + self.mydom_mock.updateWorkflow.assert_called_once() + print(f"{Fore.GREEN}✓ Database correctly updated with stopped status{Style.RESET_ALL}") + + # ------------------------------------------------------------------------ + # UTILITY FUNCTION TESTS + # ------------------------------------------------------------------------ + + def test_parse_json_response(self): + """Test JSON response parsing""" + print(f"\n{Fore.CYAN}{Style.BRIGHT}UTILITY TEST: JSON Response Parsing{Style.RESET_ALL}") + print(f"{Fore.YELLOW}{'-' * 60}{Style.RESET_ALL}") + + # Test with clean JSON + print(f"{Fore.YELLOW}➤ Testing with clean JSON...{Style.RESET_ALL}") + clean_json = '{"key": "value", "number": 123}' + result = self.manager.parseJsonResponse(clean_json) + + print(f"{Fore.GREEN}✓ Clean JSON result:{Style.RESET_ALL}") + print(f" key: {result.get('key', 'N/A')}") + print(f" number: {result.get('number', 'N/A')}") + + assert result["key"] == "value", "Clean JSON parsing should extract key value" + assert result["number"] == 123, "Clean JSON parsing should extract number value" + + # Test with JSON embedded in text + print(f"\n{Fore.YELLOW}➤ Testing with JSON embedded in text...{Style.RESET_ALL}") + text_with_json = 'Some text before {"key": "value"} and after' + result = self.manager.parseJsonResponse(text_with_json) + + print(f"{Fore.GREEN}✓ Embedded JSON result:{Style.RESET_ALL}") + print(f" key: {result.get('key', 'N/A')}") + + assert result["key"] == "value", "Embedded JSON parsing should extract key value" + + # Test with invalid JSON + print(f"\n{Fore.YELLOW}➤ Testing with invalid JSON...{Style.RESET_ALL}") + invalid_json = 'Not a JSON at all' + result = self.manager.parseJsonResponse(invalid_json) + + print(f"{Fore.GREEN}✓ Invalid JSON fallback result:{Style.RESET_ALL}") + print(f" objWorkplan: {result.get('objWorkplan', 'N/A')}") + + # Should return a fallback structure + assert "objFinalDocuments" in result, "Invalid JSON should return fallback with objFinalDocuments" + assert "objWorkplan" in result, "Invalid JSON should return fallback with objWorkplan" + assert "objUserResponse" in result, "Invalid JSON should return fallback with objUserResponse" + print(f"{Fore.GREEN}✓ All JSON parsing scenarios handled correctly{Style.RESET_ALL}") + + def test_get_filename(self): + """Test filename extraction from document""" + print(f"\n{Fore.CYAN}{Style.BRIGHT}UTILITY TEST: Filename Extraction{Style.RESET_ALL}") + print(f"{Fore.YELLOW}{'-' * 60}{Style.RESET_ALL}") + + # Test with extension + print(f"{Fore.YELLOW}➤ Testing with extension...{Style.RESET_ALL}") + document = {"name": "test", "ext": "txt"} + filename = self.manager.getFilename(document) + + print(f"{Fore.GREEN}✓ Filename with extension result:{Style.RESET_ALL}") + print(f" Result: {filename}") + + assert filename == "test.txt", "Filename should be 'test.txt'" + + # Test with no extension + print(f"\n{Fore.YELLOW}➤ Testing with no extension...{Style.RESET_ALL}") + document = {"name": "test", "ext": ""} + filename = self.manager.getFilename(document) + + print(f"{Fore.GREEN}✓ Filename without extension result:{Style.RESET_ALL}") + print(f" Result: {filename}") + + assert filename == "test", "Filename should be 'test'" + print(f"{Fore.GREEN}✓ All filename extraction scenarios handled correctly{Style.RESET_ALL}") + + def test_get_available_documents(self): + """Test getting available documents from workflow""" + print(f"\n{Fore.CYAN}{Style.BRIGHT}UTILITY TEST: Get Available Documents{Style.RESET_ALL}") + print(f"{Fore.YELLOW}{'-' * 60}{Style.RESET_ALL}") + + # Create a test workflow with messages containing documents + workflow = self._create_test_workflow() + + # Add user message with document + print(f"{Fore.YELLOW}➤ Creating user message with document...{Style.RESET_ALL}") + user_message = self._create_test_message(workflow, "Message with document") + user_message["documents"] = [self._create_test_document("user_doc.txt")] + workflow["messages"].append(user_message) + + # Add assistant message with document + print(f"{Fore.YELLOW}➤ Creating assistant message with document...{Style.RESET_ALL}") + assistant_message = self._create_test_message(workflow, "Response with document", "assistant") + assistant_message["documents"] = [self._create_test_document("assistant_doc.txt")] + workflow["messages"].append(assistant_message) + + print(f"{Fore.YELLOW}➤ Getting available documents...{Style.RESET_ALL}") + # Get available documents + available_docs = self.manager.getAvailableDocuments(workflow, user_message) + + # Print results + print(f"{Fore.GREEN}✓ Available documents result:{Style.RESET_ALL}") + print(f" Count: {len(available_docs)}") + for i, doc in enumerate(available_docs): + print(f" {i+1}. {doc.get('label', 'N/A')} ({doc.get('fileSource', 'N/A')})") + + # Verify result + assert len(available_docs) == 2, "Available documents should have 2 entries" + # Should be sorted newest first + assert available_docs[0]["label"] == "assistant_doc.txt", "First document should be assistant_doc.txt" + assert available_docs[1]["label"] == "user_doc.txt", "Second document should be user_doc.txt" + # User's document should be marked as from user + assert available_docs[1]["fileSource"] == "user", "User document should have fileSource='user'" + print(f"{Fore.GREEN}✓ Available documents correctly identified and sorted{Style.RESET_ALL}") + + +# Simple test runner +if __name__ == "__main__": + # Import the runner and execute tests + try: + sys.path.append(os.path.dirname(os.path.abspath(__file__))) + from tool_testBackendSingle import run_tests + asyncio.run(run_tests()) + except ImportError: + print(f"{Fore.YELLOW}Please use tool_testBackendSingle.py to run the tests properly{Style.RESET_ALL}") \ No newline at end of file diff --git a/tool_testUser.py b/tool_testUser.py new file mode 100644 index 00000000..7f328ca8 --- /dev/null +++ b/tool_testUser.py @@ -0,0 +1,244 @@ +#!/usr/bin/env python3 +""" +Direct Interface Workflow Test Script + +This script bypasses the API layer and works directly with the interface classes +to simulate a user uploading two files and then sending a chat request with these files. + +It follows the state machine as defined in the backend documentation. +""" + +import os +import sys +import json +import asyncio +import uuid +from datetime import datetime + +# Adjust import paths +current_dir = os.path.dirname(os.path.abspath(__file__)) +parent_dir = os.path.dirname(current_dir) +if parent_dir not in sys.path: + sys.path.insert(0, parent_dir) + +# Try to import the required modules +try: + from modules.workflowManager import getWorkflowManager + from modules.lucydomInterface import getLucydomInterface +except ImportError: + print("Error: Required modules not found. Attempting alternative imports...") + try: + from gateway.modules.workflowManager import getWorkflowManager + from gateway.modules.lucydomInterface import getLucydomInterface + except ImportError: + print("Error: Could not import required modules. Make sure the script is run from the correct directory.") + sys.exit(1) + +# Constants +MANDATE_ID = 1 +USER_ID = 1 +#USER_PROMPT = "Please analyze these sales figures and the chart to identify key trends and opportunities." +#USER_PROMPT = "Please make me a svg file with forecast for Apr-Jun." +USER_PROMPT = "Please make me a jpg file with forecast for Apr-Jun." + +# Sample files to upload +SAMPLE_SVG = """ + + Sales Q1 Bar Chart + + + + + + + + Sales ($) + + + Month + + + + Jan + $150K + + + + Feb + $165K + + + + Mar + $180K + + +""" + +SAMPLE_DATA = """ +# Sales Data - Q1 2023 + +Month,Revenue,Growth,Units Sold +January,150000,5.2%,1250 +February,165000,10.0%,1380 +March,180000,9.1%,1490 + +## Regional Breakdown +- North: 35% of total sales +- South: 25% of total sales +- East: 20% of total sales +- West: 20% of total sales + +## Top Products +1. Product A: 40% of revenue +2. Product B: 30% of revenue +3. Product C: 20% of revenue +4. Others: 10% of revenue +""" + +async def create_test_files(mydom): + """Create two test files and return their IDs""" + print("\n--- Uploading Test Files (State 0: File Upload) ---") + + # Create SVG chart file + print("Uploading SVG chart file...") + chart_meta = mydom.saveUploadedFile(SAMPLE_SVG.encode('utf-8'), "q1_sales_chart.svg") + chart_id = chart_meta['id'] + print(f"Created SVG chart file with ID: {chart_id}") + + # Create data text file + print("Uploading markdown data file...") + data_meta = mydom.saveUploadedFile(SAMPLE_DATA.encode('utf-8'), "q1_sales_data.md") + data_id = data_meta['id'] + print(f"Created markdown data file with ID: {data_id}") + + return chart_id, data_id + +async def monitor_workflow(mydom, workflow_id, timeout=300, interval=2): + """Monitor the workflow until it completes or times out""" + print("\n--- Monitoring Workflow ---") + start_time = datetime.now() + elapsed = 0 + + while elapsed < timeout: + # Get current workflow state + workflow = mydom.loadWorkflowState(workflow_id) + if not workflow: + print("Error: Workflow not found") + return None + + status = workflow.get("status", "unknown") + + # Show progress + logs = workflow.get("logs", []) + latest_log = logs[-1] if logs else None + + if latest_log: + progress = latest_log.get("progress", 0) + message = latest_log.get("message", "No message") + print(f"Status: {status} | Progress: {progress}% | {message}") + + # Check if workflow is done + if status in ["completed", "failed", "stopped"]: + if status == "completed": + print("\nWorkflow completed successfully!") + elif status == "failed": + print("\nWorkflow failed!") + else: + print("\nWorkflow was stopped!") + return workflow + + # Wait before checking again + await asyncio.sleep(interval) + elapsed = (datetime.now() - start_time).total_seconds() + + print(f"Monitoring timed out after {timeout} seconds") + return mydom.loadWorkflowState(workflow_id) + +async def run_test(): + """Main test function that follows the state machine workflow""" + print("\n=== Direct Interface Workflow Test ===\n") + + # Initialize the interfaces + print("Initializing system...") + mydom = getLucydomInterface(MANDATE_ID, USER_ID) + manager = getWorkflowManager(MANDATE_ID, USER_ID) + + # Upload test files (State 0: File Upload) + chart_id, data_id = await create_test_files(mydom) + + # Prepare the user input + user_input = { + "prompt": USER_PROMPT, + "listFileId": [chart_id, data_id] + } + + # Start workflow (State 1: Workflow Initialization) + print(f"\n--- Starting Workflow (State 1: Workflow Initialization) ---") + print(f"Sending user prompt: '{USER_PROMPT}'") + print(f"With files: SVG chart (ID: {chart_id}) and sales data (ID: {data_id})") + + # Start the workflow with the user input + workflow = await manager.workflowStart(user_input) + workflow_id = workflow["id"] + + print(f"Workflow initiated with ID: {workflow_id}") + print(f"Initial status: {workflow['status']}") + + # Monitor the workflow progress + # This will monitor states 2-7 of the state machine + await monitor_workflow(mydom, workflow_id, timeout=120) + + # Get final workflow state + final_workflow = mydom.loadWorkflowState(workflow_id) + + # Print the results + print("\n--- Final Workflow Results ---") + if final_workflow: + # Print status information + print(f"Workflow Status: {final_workflow.get('status', 'unknown')}") + print(f"Current Round: {final_workflow.get('currentRound', 0)}") + + # Print messages + print("\n=== Messages ===") + for msg in final_workflow.get("messages", []): + role = msg.get("role", "unknown") + agent = msg.get("agentName", "") + + # Get a preview of the content + content = msg.get("content", "") + if len(content) > 100: + content_preview = content[:100] + "..." + else: + content_preview = content + + # Format based on role + if role == "assistant" and agent: + print(f"\n[{role} - {agent}]: {content_preview}") + else: + print(f"\n[{role}]: {content_preview}") + + # Print document info + docs = msg.get("documents", []) + if docs: + print(f" Documents ({len(docs)}):") + for doc in docs: + name = doc.get("name", "unnamed") + ext = doc.get("ext", "") + file_id = doc.get("fileId", "unknown") + print(f" - {name}.{ext} (ID: {file_id})") + + # Print the final log + logs = final_workflow.get("logs", []) + if logs: + final_log = logs[-1] + print(f"\nFinal Log: {final_log.get('message', 'No message')}") + else: + print("Error: Could not retrieve final workflow state") + + print("\n=== Test Complete ===") + return workflow_id + +if __name__ == "__main__": + workflow_id = asyncio.run(run_test()) + print(f"Completed workflow ID: {workflow_id}") \ No newline at end of file