language models updated

ApiLayers/AllConfigs/Redis/configs.py

@@ -17,6 +17,16 @@ class WagRedis:
         )
 
 
+# VALIDATION_USER: str = "VALIDATION_USER"
+class RedisValidationKeys:
+    ENDPOINTS: str = "ENDPOINTS"
+    VALIDATIONS: str = "VALIDATIONS"
+    HEADERS: str = "HEADERS"
+    ERRORCODES: str = "ERRORCODES"
+    RESPONSES: str = "RESPONSES"
+    LANGUAGE_MODELS: str = "LANGUAGE_MODELS"
+
+
 class RedisAuthKeys:
     AUTH: str = "AUTH"
     OCCUPANT: str = "OCCUPANT"
@@ -26,8 +36,6 @@ class RedisAuthKeys:
 class RedisCategoryKeys:
     REBUILD: str = "REBUILD"
     ENDPOINT2CLASS: str = "ENDPOINT2CLASS"
-    LANGUAGE_MODELS: str = "LANGUAGE_MODELS"
-    VALIDATION_USER: str = "VALIDATION_USER"
     CLUSTER_INDEX: str = "CLUSTER_INDEX"
     CLUSTER_FUNCTION_CODES: str = "CLUSTER_FUNCTION_CODES"
     METHOD_FUNCTION_CODES: str = "METHOD_FUNCTION_CODES"

ApiLayers/ApiServices/Login/user_login_handler.py

@@ -10,6 +10,7 @@ class UserLoginModule:
 
     def __init__(self, request: "Request"):
         self.request = request
+        self.user = None
 
     @staticmethod
     def check_user_exists(access_key: str):
@@ -38,9 +39,9 @@ class UserLoginModule:
         from ApiLayers.ApiServices.Token.token_handler import TokenService
         from ApiLayers.Schemas import Users
 
-        """Login user via credentials."""
         # Get the actual data from the BaseRequestModel if needed
         found_user: Users = self.check_user_exists(access_key=access_data.access_key)
+        self.user = found_user
         if len(found_user.hash_password) < 5:
             raise HTTPExceptionApi(
                 error_code="HTTP_400_BAD_REQUEST",

ApiLayers/ApiValidations/Response/default_response.py

@@ -1,153 +1,118 @@
-from ast import Dict
-from typing import Any, Optional
+from typing import Optional
 from fastapi import status
 from fastapi.responses import JSONResponse
 
 
 class BaseEndpointResponse:
 
-    def __init__(self, code: str, lang: str):
-        self.code = code
+    def __init__(self, lang: str, code: str):
         self.lang = lang
+        self.code = code
 
-    def retrieve_message(self):
-        messages = {}
-        return messages[self.code][self.lang]
+    @property
+    def response(self) -> Optional[dict]:
+        from Services.Redis import RedisActions
+        from ApiLayers.AllConfigs.Redis.configs import RedisValidationKeys
+
+        language_model_key = f"{RedisValidationKeys.LANGUAGE_MODELS}:{RedisValidationKeys.RESPONSES}"
+        language_model = RedisActions.get_json(list_keys=[language_model_key, self.code , self.lang])
+        if language_model.status:
+            return language_model.first.as_dict
+        raise ValueError("Language model not found")
 
 
-# 1. 200 OK
-class EndpointSuccessResponse(BaseEndpointResponse):
+class EndpointSuccessResponse(BaseEndpointResponse):            # 1. 200 OK
 
-    def as_dict(self, data: Optional[Dict[str, Any]] = None):
+    def as_dict(self, data: Optional[dict] = None):
         return JSONResponse(
             status_code=status.HTTP_200_OK,
-            content=dict(
-                completed=True,
-                message=self.retrieve_message(),
-                lang=self.lang,
-                data=data,
-            ),
+            content=dict(completed=True, lang=self.lang, data=data, **self.response)
         )
 
 
-# 2. 201 Created
-class EndpointCreatedResponse(BaseEndpointResponse):
+class EndpointCreatedResponse(BaseEndpointResponse):            # 2. 201 Created
 
-    def as_dict(self, data: Optional[Dict[str, Any]] = None):
+    def as_dict(self, data: Optional[dict] = None):
         return JSONResponse(
             status_code=status.HTTP_201_CREATED,
-            content=dict(
-                completed=True,
-                message=self.retrieve_message(),
-                lang=self.lang,
-                data=data,
-            ),
+            content=dict(completed=True, lang=self.lang, data=data, **self.response)
         )
 
 
-# 3. 202 Accepted
-class EndpointAcceptedResponse(BaseEndpointResponse):
+class EndpointAcceptedResponse(BaseEndpointResponse):           # 3. 202 Accepted
 
-    def as_dict(self, data: Optional[Dict[str, Any]] = None):
+    def as_dict(self, data: Optional[dict] = None):
         return JSONResponse(
             status_code=status.HTTP_202_ACCEPTED,
-            content=dict(
-                completed=True,
-                message=self.retrieve_message(),
-                lang=self.lang,
-                data=data,
-            ),
+            content=dict(completed=True, lang=self.lang, data=data, **self.response)
         )
 
 
-# 4. 400 Bad Request
-class EndpointBadRequestResponse(BaseEndpointResponse):
+class EndpointBadRequestResponse(BaseEndpointResponse):         # 4. 400 Bad Request
 
-    def as_dict(self, data: Optional[Dict[str, Any]] = None):
+    def as_dict(self, data: Optional[dict] = None):
         return JSONResponse(
             status_code=status.HTTP_400_BAD_REQUEST,
-            content=dict(
-                completed=False,
-                message=self.retrieve_message(),
-                lang=self.lang,
-                data=data,
-            ),
+            content=dict(completed=False, lang=self.lang, data=data, **self.response)
         )
 
 
-# 5. 401 Unauthorized
-class EndpointUnauthorizedResponse(BaseEndpointResponse):
+class EndpointUnauthorizedResponse(BaseEndpointResponse):       # 5. 401 Unauthorized
 
     def as_dict(self):
         return JSONResponse(
             status_code=status.HTTP_401_UNAUTHORIZED,
-            content=dict(
-                completed=False, message=self.retrieve_message(), lang=self.lang
-            ),
+            content=dict(completed=False, lang=self.lang, **self.response)
         )
 
 
-# 6. 404 Not Found
-class EndpointNotFoundResponse(BaseEndpointResponse):
+class EndpointNotFoundResponse(BaseEndpointResponse):            # 6. 404 Not Found
 
     def as_dict(self):
         return JSONResponse(
             status_code=status.HTTP_404_NOT_FOUND,
-            content=dict(
-                completed=False, message=self.retrieve_message(), lang=self.lang
-            ),
+            content=dict(completed=False, lang=self.lang, **self.response)
         )
 
 
-# 3. 403 Forbidden
-class EndpointForbiddenResponse(BaseEndpointResponse):
+class EndpointForbiddenResponse(BaseEndpointResponse):           # 3. 403 Forbidden
 
     def as_dict(self):
         return JSONResponse(
             status_code=status.HTTP_403_FORBIDDEN,
-            content=dict(
-                completed=False, message=self.retrieve_message(), lang=self.lang
-            ),
+            content=dict(completed=False, lang=self.lang, **self.response)
         )
 
 
-# 6. 409 Conflict
-class EndpointConflictResponse(BaseEndpointResponse):
+class EndpointConflictResponse(BaseEndpointResponse):             # 6. 409 Conflict
 
     def as_dict(self):
         return JSONResponse(
             status_code=status.HTTP_409_CONFLICT,
-            content=dict(
-                completed=False, message=self.retrieve_message(), lang=self.lang
-            ),
+            content=dict(completed=False, lang=self.lang, **self.response)
         )
 
 
-# 7. 429 Too Many Requests
-class EndpointTooManyRequestsResponse(BaseEndpointResponse):
+class EndpointTooManyRequestsResponse(BaseEndpointResponse):     # 7. 429 Too Many Requests
 
-    def __init__(self, retry_after: int):
+    def __init__(self, retry_after: int, lang: str, code: str):
+        super().__init__(lang=lang, code=code)
         self.retry_after = retry_after
 
     def as_dict(self):
         return JSONResponse(
             status_code=status.HTTP_429_TOO_MANY_REQUESTS,
             headers={"Retry-After": str(self.retry_after)},
-            content=dict(
-                completed=False, message=self.retrieve_message(), lang=self.lang
-            ),
+            content=dict(completed=False, lang=self.lang, **self.response)
         )
 
 
-# 7. 500 Internal Server Error
-class EndpointInternalErrorResponse(BaseEndpointResponse):
+class EndpointInternalErrorResponse(BaseEndpointResponse):      # 7. 500 Internal Server Error
 
     def as_dict(self):
         return JSONResponse(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            content=dict(
-                completed=False, message=self.retrieve_message(), lang=self.lang
-            ),
+            content=dict(completed=False, lang=self.lang, **self.response)
         )
 
 
@@ -156,7 +121,5 @@ class EndpointErrorResponse(BaseEndpointResponse):
     def as_dict(self):
         return JSONResponse(
             status_code=status.HTTP_304_NOT_MODIFIED,
-            content=dict(
-                completed=False, message=self.retrieve_message(), lang=self.lang
-            ),
+            content=dict(completed=False, lang=self.lang, **self.response)
         )

ApiLayers/ErrorHandlers/Exceptions/api_exc.py

@@ -1,3 +1,6 @@
+from Services.Redis.Actions.actions import RedisActions
+
+
 class HTTPExceptionApi(Exception):
 
     def __init__(self, error_code: str, lang: str, loc: str = "", sys_msg: str = ""):
@@ -5,3 +8,11 @@ class HTTPExceptionApi(Exception):
         self.lang = lang
         self.loc = loc
         self.sys_msg = sys_msg
+
+    def retrieve_error_message_by_code_at_redis(self):
+        """
+        Retrieve the error message from the redis by the error code.
+        """
+        error_msg = RedisActions.get_json(list_keys=["LANGUAGE_MODELS", "ERRORCODES", self.lang])
+        if error_msg.status:
+            return error_msg.first