nlbone 0.7.32__py3-none-any.whl → 0.8.0__py3-none-any.whl

nlbone/adapters/i18n/engine.py

@@ -1,9 +1,11 @@
+import logging
 from typing import Dict, Optional
 
+from nlbone.adapters.i18n.loaders import BaseLoader
+
 from nlbone.core.ports.translation import TranslationPort
-from nlbone.utils.context import get_locale
 
-from .loaders import BaseLoader
+logger = logging.getLogger(__name__)
 
 
 class I18nAdapter(TranslationPort):
@@ -17,19 +19,22 @@ class I18nAdapter(TranslationPort):
             self._translations = self.loader.load()
 
     def translate(self, key: str, locale: Optional[str] = None, **kwargs) -> str:
-        self._ensure_loaded()
-
         target_locale = locale or self.default_locale
-
-        locale_data = self._translations.get(target_locale, {})
-        text = locale_data.get(key)
-
-        if text is None:
-            text = self._translations.get(self.default_locale, {}).get(key, key)
-
-        if kwargs:
-            try:
-                return text.format(**kwargs)
-            except KeyError:
-                pass
-        return text
+        try:
+            self._ensure_loaded()
+
+            locale_data = self._translations.get(target_locale, {})
+            text = locale_data.get(key)
+
+            if text is None:
+                text = self._translations.get(self.default_locale, {}).get(key, key)
+
+            if kwargs:
+                try:
+                    return text.format(**kwargs)
+                except KeyError:
+                    pass
+            return text
+        except:
+            logger.exception("Failed to translate key '{}' to locale '{}'".format(key, target_locale))
+            return key

nlbone/interfaces/api/exception_handlers.py

@@ -1,19 +1,23 @@
 from __future__ import annotations
 
-from typing import Any, Mapping, Optional
+from typing import Any, Mapping, Optional, List
 from uuid import uuid4
 
 from fastapi import FastAPI, Request
 from fastapi import HTTPException as FastAPIHTTPException
 from fastapi.exceptions import RequestValidationError
 from fastapi.responses import JSONResponse
-from pydantic import ValidationError
+from pydantic import BaseModel, ValidationError
 from starlette.exceptions import HTTPException as StarletteHTTPException
-
-from .exceptions import BaseHttpException
+from starlette.status import HTTP_500_INTERNAL_SERVER_ERROR, HTTP_422_UNPROCESSABLE_ENTITY
 
 from nlbone.adapters.i18n import translator as _
-# ---- Helpers ---------------------------------------------------------------
+from .exceptions import BaseHttpException, ErrorDetail, UnprocessableEntityException
+
+
+class ErrorResponse(BaseModel):
+    message: str
+    errors: List[ErrorDetail]
 
 
 def _ensure_trace_id(request: Request) -> str:
@@ -22,93 +26,141 @@ def _ensure_trace_id(request: Request) -> str:
 
 
 def _json_response(
-    request: Request,
-    status_code: int,
-    *,
-    detail: Any,
-    headers: Optional[Mapping[str, str]] = None,
-    trace_id: Optional[str] = None,
-    extra: Optional[Mapping[str, Any]] = None,
+        request: Request,
+        status_code: int,
+        content: Any,
+        trace_id: Optional[str] = None,
+        headers: Optional[Mapping[str, str]] = None,
 ) -> JSONResponse:
-    payload: dict[str, Any] = {"detail": detail}
-    if extra:
-        payload.update(extra)
     tid = trace_id or _ensure_trace_id(request)
 
-    payload.setdefault("trace_id", tid)
+    if isinstance(content, dict):
+        payload = content
+    else:
+        payload = content.model_dump(exclude_none=True) if hasattr(content, "model_dump") else content
+
+    payload["trace_id"] = tid
 
     base_headers = {"X-Trace-Id": tid}
     if headers:
         base_headers.update(headers)
 
-    return JSONResponse(status_code=status_code, content=payload, headers=base_headers)
-
-
-# ---- Public Installer ------------------------------------------------------
+    return JSONResponse(
+        status_code=status_code,
+        content=payload,
+        headers=base_headers
+    )
 
 
 def install_exception_handlers(
-    app: FastAPI,
-    *,
-    logger: Any = None,
-    expose_server_errors: bool = False,
+        app: FastAPI,
+        *,
+        logger: Any = None,
+        expose_server_errors: bool = False,
 ) -> None:
+    async def _log_exception(
+            request: Request,
+            exc: Exception,
+            level: str = "warning",
+            extra: Optional[dict] = None
+    ):
+        if not logger:
+            return
+
+        log_payload = {
+            "path": request.url.path,
+            "method": request.method,
+            **extra
+        } if extra else {"path": request.url.path}
+
+        log_method = getattr(logger, level, logger.warning)
+        log_method(str(exc), extra=log_payload)
+
     @app.exception_handler(BaseHttpException)
     async def _handle_base_http_exception(request: Request, exc: BaseHttpException):
-        if logger:
-            logger.warning(
-                "http_error",
-                extra={"status": exc.status_code, "detail": exc.detail, "path": request.url.path},
-            )
-        locale = locale = getattr(request.state, "locale", None)
-        return _json_response(request, exc.status_code, detail=_(exc.detail, locale=locale))
-
-    @app.exception_handler(FastAPIHTTPException)
-    async def _handle_fastapi_http_exception(request: Request, exc: FastAPIHTTPException):
-        if logger:
-            logger.warning(
-                "fastapi_http_error",
-                extra={"status": exc.status_code, "detail": exc.detail, "path": request.url.path},
-            )
-        locale = locale = getattr(request.state, "locale", None)
-        return _json_response(request, exc.status_code, detail=_(exc.detail, locale=locale))
+        await _log_exception(request, exc, extra={"status": exc.status_code, "detail": exc.message})
+
+        locale = getattr(request.state, "locale", None)
+
+        main_message = _(exc.message, locale=locale)
+
+        translated_errors = []
+        if exc.errors:
+            for err in exc.errors:
+                err_copy = err.model_copy()
+                if err_copy.message:
+                    err_copy.message = _(err_copy.message, locale=locale)
+                translated_errors.append(err_copy)
+
+        response_model = ErrorResponse(
+            message=main_message,
+            errors=translated_errors
+        )
+
+        return _json_response(request, exc.status_code, content=response_model)
 
-    @app.exception_handler(StarletteHTTPException)
-    async def _handle_starlette_http_exception(request: Request, exc: StarletteHTTPException):
-        if logger:
-            logger.warning(
-                "starlette_http_error",
-                extra={"status": exc.status_code, "detail": exc.detail, "path": request.url.path},
-            )
-        locale = locale = getattr(request.state, "locale", None)
-        return _json_response(request, exc.status_code, detail=_(exc.detail, locale=locale))
-
-    # 3) خطاهای اعتبارسنجی FastAPI (request body/query/path)
     @app.exception_handler(RequestValidationError)
     async def _handle_request_validation_error(request: Request, exc: RequestValidationError):
-        errors = exc.errors()
-        if logger:
-            logger.info(
-                "request_validation_error",
-                extra={"errors": errors, "path": request.url.path},
-            )
-        return _json_response(request, 422, detail=errors)
+        await _log_exception(request, exc, level="info", extra={"errors": exc.errors()})
+
+        normalized_exception = UnprocessableEntityException(
+            detail="Validation Error",
+            validation_errors=exc.errors()
+        )
+        return await _handle_base_http_exception(request, normalized_exception)
 
     @app.exception_handler(ValidationError)
     async def _handle_pydantic_validation_error(request: Request, exc: ValidationError):
-        errors = exc.errors()
-        if logger:
-            logger.info(
-                "pydantic_validation_error",
-                extra={"errors": errors, "path": request.url.path},
-            )
-        return _json_response(request, 422, detail=errors)
+        await _log_exception(request, exc, level="info", extra={"errors": exc.errors()})
+
+        normalized_exception = UnprocessableEntityException(
+            detail="Validation Error",
+            validation_errors=exc.errors()
+        )
+        return await _handle_base_http_exception(request, normalized_exception)
+
+    @app.exception_handler(StarletteHTTPException)
+    async def _handle_starlette_http_exception(request: Request, exc: StarletteHTTPException):
+        await _log_exception(request, exc, extra={"status": exc.status_code})
+
+        locale = getattr(request.state, "locale", None)
+        message_str = str(exc.detail) if exc.detail else "HTTP Error"
+        translated_message = _(message_str, locale=locale)
+
+        error_detail = ErrorDetail(
+            code=exc.status_code,
+            message=translated_message
+        )
+
+        response_model = ErrorResponse(
+            message=translated_message,
+            errors=[error_detail]
+        )
+
+        return _json_response(request, exc.status_code, content=response_model)
 
     @app.exception_handler(Exception)
     async def _handle_unexpected_exception(request: Request, exc: Exception):
         tid = _ensure_trace_id(request)
-        if logger:
-            logger.exception("unhandled_exception", extra={"trace_id": tid, "path": request.url.path})
-        detail = str(exc) if expose_server_errors else "internal server error"
-        locale = locale = getattr(request.state, "locale", None)
-        return _json_response(request, 500, detail=_(detail, locale=locale), trace_id=tid)
+        await _log_exception(request, exc, level="exception", extra={"trace_id": tid})
+
+        raw_detail = str(exc) if expose_server_errors else "Internal Server Error"
+        locale = getattr(request.state, "locale", None)
+        translated_detail = _(raw_detail, locale=locale)
+
+        error_detail = ErrorDetail(
+            code=HTTP_500_INTERNAL_SERVER_ERROR,
+            message=translated_detail
+        )
+
+        response_model = ErrorResponse(
+            message=translated_detail,
+            errors=[error_detail]
+        )
+
+        return _json_response(
+            request,
+            HTTP_500_INTERNAL_SERVER_ERROR,
+            content=response_model,
+            trace_id=tid
+        )

nlbone/interfaces/api/exceptions.py

@@ -1,108 +1,153 @@
-from typing import Any, Iterable, Dict, List
+from http import HTTPStatus
+from typing import Any, Dict, List, Optional, Union
 
-from fastapi import HTTPException, status
+from fastapi import HTTPException
+from pydantic import BaseModel, Field
 
 
-def _error_entry(loc: Iterable[Any] | None, detail: str, type_: str) -> dict:
-    return {
-        "loc": list(loc) if loc else [],
-        "msg": detail,
-        "type": type_,
-    }
+class ErrorDetail(BaseModel):
+    code: int | str = 0
+    message: Optional[str] = None
+    fields: Optional[Union[List[Union[str, int]], str]] = None
+    data: Optional[Union[List[Dict], Dict]] = None
 
 
-def _errors(loc: Iterable[Any] | None, detail: str, type_: str) -> list[dict]:
-    return [_error_entry(loc, detail, type_)]
+class BaseHttpException(HTTPException):
+    def __init__(
+            self,
+            status_code: int,
+            detail: Optional[str] = None,
+            errors: Optional[List[ErrorDetail]] = None,
+            fields: Optional[Union[List[Union[str, int]], str]] = None,
+            data: Optional[Dict] = None,
+            code: Optional[str] = None,
+    ):
+        if errors is None:
+            message = detail or HTTPStatus(status_code).phrase
+
+            if not code:
+                code = HTTPStatus(status_code).phrase.lower().replace(" ", "_")
+
+            errors = [
+                ErrorDetail(
+                    code=code,
+                    message=message,
+                    fields=fields,
+                    data=data
+                )
+            ]
 
+        self.errors = errors
+        super().__init__(status_code=status_code, detail=self.message)
 
-class BaseHttpException(HTTPException):
-    pass
+    @property
+    def message(self) -> str:
+        if self.errors and self.errors[0].message:
+            return self.errors[0].message
+        return HTTPStatus(self.status_code).phrase
 
 
-class BadRequestException(BaseHttpException):
-    def __init__(self, detail: str):
+class UnprocessableEntityException(BaseHttpException):
+    def __init__(
+            self,
+            detail: str = None,
+            fields: Optional[Union[List[Union[str, int]], str]] = None,
+            validation_errors: Optional[List[Dict[str, Any]]] = None
+    ):
+        errors = None
+
+        if validation_errors:
+            errors = []
+            for error in validation_errors:
+                err_type = error.get("type")
+                loc = error.get("loc")
+                msg = error.get("msg")
+                inp = error.get("input")
+
+                if err_type == "json_invalid":
+                    loc = ["body"]
+                    msg = "Invalid JSON format. Please check your syntax (e.g., convert '۱' to '1')."
+
+                elif isinstance(loc, tuple):
+                    loc = list(loc)
+
+                error_data = {}
+                if inp is not None and not (isinstance(inp, dict) and not inp):
+                    error_data["input"] = inp
+
+                errors.append(
+                    ErrorDetail(
+                        code=err_type or "validation_error",
+                        message=msg,
+                        fields=loc,
+                        data=error_data if error_data else None
+                    )
+                )
+
         super().__init__(
-            status_code=status.HTTP_400_BAD_REQUEST,
+            status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
             detail=detail,
+            fields=fields,
+            errors=errors
         )
 
 
+class BadRequestException(BaseHttpException):
+    def __init__(self, detail: str = None, code: int = 0):
+        super().__init__(status_code=HTTPStatus.BAD_REQUEST, detail=detail, code=code)
+
+
 class UnauthorizedException(BaseHttpException):
-    def __init__(self, detail: str = "unauthorized"):
-        super().__init__(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail=detail,
-        )
+    def __init__(self, detail: str = None):
+        super().__init__(status_code=HTTPStatus.UNAUTHORIZED, detail=detail)
 
 
 class ForbiddenException(BaseHttpException):
-    def __init__(self, detail: str = "forbidden"):
-        super().__init__(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail=detail,
-        )
+    def __init__(self, detail: str = None):
+        super().__init__(status_code=HTTPStatus.FORBIDDEN, detail=detail)
 
 
 class NotFoundException(BaseHttpException):
-    def __init__(self, detail: str = "not found"):
-        super().__init__(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=detail,
-        )
+    def __init__(self, detail: str = None):
+        super().__init__(status_code=HTTPStatus.NOT_FOUND, detail=detail)
 
 
 class ConflictException(BaseHttpException):
-    def __init__(self, detail: str = "conflict"):
-        super().__init__(
-            status_code=status.HTTP_409_CONFLICT,
-            detail=detail,
-        )
+    def __init__(self, detail: str = None, data: Optional[Union[List[Dict], Dict]] = None):
+        super().__init__(status_code=HTTPStatus.CONFLICT, detail=detail, data=data)
 
 
 class NotSupportedException(BaseHttpException):
-    def __init__(self, detail: str = "NotSupported"):
-        super().__init__(
-            status_code=status.HTTP_501_NOT_IMPLEMENTED,
-            detail=detail,
-        )
+    def __init__(self, detail: str = None):
+        super().__init__(status_code=HTTPStatus.NOT_IMPLEMENTED, detail=detail)
 
 
 class InternalServerException(BaseHttpException):
-    def __init__(self, detail: str = "internal_server_error"):
-        super().__init__(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=detail,
-        )
+    def __init__(self, detail: str = None):
+        super().__init__(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=detail)
 
 
-class UnprocessableEntityException(BaseHttpException):
-    def __init__(self, detail: str, loc: Iterable[Any] | None = None, type_: str = "unprocessable_entity"):
+class LogicalValidationException(UnprocessableEntityException):
+    def __init__(self, detail: str = None,
+                 fields: Optional[Union[List[str], str]] = None,
+                 validation_errors: Optional[List[Dict[str, Any]]] = None):
         super().__init__(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=_errors(loc, detail, type_),
+            detail=detail,
+            fields=fields,
+            validation_errors=validation_errors
         )
 
 
-class LogicalValidationException(HTTPException):
-    def __init__(self, detail: str = None, loc: Iterable[Any] | None = None, type_: str = "logical_error",
-                 errors: List[Dict[str, Any]] = None):
-        self.errors = errors
-        if errors:
-            super().__init__(detail=errors, status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,)
-        else:
-            super().__init__(detail=_errors(loc, detail, type_), status_code=status.HTTP_422_UNPROCESSABLE_ENTITY)
-
-
 class GoneException(BaseHttpException):
-    def __init__(self, detail: str = "Gone"):
-        super().__init__(
-            status_code=status.HTTP_410_GONE,
-            detail=detail,
-        )
+    def __init__(self, detail: str = None):
+        super().__init__(status_code=HTTPStatus.GONE, detail=detail)
+
 
 class TooManyRequestsException(BaseHttpException):
-    def __init__(self, detail: str = "TooManyRequests"):
-        super().__init__(
-            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
-            detail=detail,
-        )
+    def __init__(self, detail: str = None):
+        super().__init__(status_code=HTTPStatus.TOO_MANY_REQUESTS, detail=detail)
+
+
+class NotAcceptableException(BaseHttpException):
+    def __init__(self, detail: str = None):
+        super().__init__(status_code=HTTPStatus.NOT_ACCEPTABLE, detail=detail)

nlbone/utils/flatten_dict.py

@@ -0,0 +1,9 @@
+def flatten_dict(d, parent_key='', sep='.'):
+    items = {}
+    for k, v in d.items():
+        new_key = f"{parent_key}{sep}{k}" if parent_key else k
+        if isinstance(v, dict):
+            items.update(flatten_dict(v, new_key, sep))
+        else:
+            items[new_key] = v
+    return items

{nlbone-0.7.32.dist-info → nlbone-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nlbone
-Version: 0.7.32
+Version: 0.8.0
 Summary: Backbone package for interfaces and infrastructure in Python projects
 Author-email: Amir Hosein Kahkbazzadeh <a.khakbazzadeh@gmail.com>
 License: MIT

{nlbone-0.7.32.dist-info → nlbone-0.8.0.dist-info}/RECORD

@@ -31,7 +31,7 @@ nlbone/adapters/http_clients/uploadchi/__init__.py,sha256=uBzEOuVtY22teWW2b36Pit
 nlbone/adapters/http_clients/uploadchi/uploadchi.py,sha256=erpjOees25FW0nuK1PkYS-oU0h8MeRV9Rhs1cf3gaEs,4881
 nlbone/adapters/http_clients/uploadchi/uploadchi_async.py,sha256=PQbVNeaYde5CmgT3vcnQoI1PGeSs9AxHlPFuB8biOmU,4717
 nlbone/adapters/i18n/__init__.py,sha256=fS97TR7HEc7fiDC2ufQKoFOxXDNkGA4njAFIB3EmhLk,426
-nlbone/adapters/i18n/engine.py,sha256=55DbbVPPHG64o640BzWDsjaxRfu6GykZzVBqME03iDE,1078
+nlbone/adapters/i18n/engine.py,sha256=yH_b614oJQ2PgM8qpQ5_Prroi4Jjqb-xPguHCCJm0_0,1305
 nlbone/adapters/i18n/loaders.py,sha256=7td0Cmn0ehjDO2S2qeH31zwl8UyWI7quzedP9PnPhWk,2381
 nlbone/adapters/i18n/locales/fa-IR.json,sha256=Sc711S0_HexhSCJ6eVgr2HjoSDmSz4uODZmNn9O9Pec,88
 nlbone/adapters/messaging/__init__.py,sha256=o6ZiMihm_MhRXfcEpcjHBB3JGQovQbg3pxe0qS6516c,41
@@ -70,8 +70,8 @@ nlbone/core/ports/translation.py,sha256=pnqbxhdRCR7eprm8UI8ZKKx7VDUPntvBtlytrnTG
 nlbone/core/ports/uow.py,sha256=VhqSc-Ryt9m-rlNMiXTzD3dPGz6mM_JxND8D0UJGRu4,962
 nlbone/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/interfaces/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/interfaces/api/exception_handlers.py,sha256=jH2VAgx63auFSat1H3uQ0Z9JrJ6YYN57dFuqwKzT7EU,4431
-nlbone/interfaces/api/exceptions.py,sha256=06S677YplJgODjVaa3fP00dPy9i-bNIlDWg1t5Q8EZc,3194
+nlbone/interfaces/api/exception_handlers.py,sha256=2wJp0HZcsSNVsmjFXma3FQ994iga7m3zm9o1E4MIncw,5582
+nlbone/interfaces/api/exceptions.py,sha256=IggZxV9q6l4jqw-G7SWEmuyXnWgbNXJJT-rmnirRIK4,5057
 nlbone/interfaces/api/routers.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/interfaces/api/schemas.py,sha256=34Tz2EeXyf12rFL9iyYWaB2ftuaXUebQQQxSO9ouV94,133
 nlbone/interfaces/api/additional_filed/__init__.py,sha256=BWemliLSQV9iq1vdUaF733q0FOSipSWBOQk9eYj732Q,318
@@ -109,13 +109,14 @@ nlbone/utils/cache_keys.py,sha256=Y2YSellHTbUOcoaNbl1jaD4r485VU_e4KXsfBWhYTBo,10
 nlbone/utils/cache_registry.py,sha256=3FWYyhujW8oPBiVUPzk1CqJ3jJfxs9729Sbb1pQ5Fag,707
 nlbone/utils/context.py,sha256=Wq3QLYsMzo_xUiVAHLgEPQUG6LhgJTmFn8MO5Qa7S8w,1837
 nlbone/utils/crypto.py,sha256=PX0Tlf2nqXcGbuv16J26MoUPzo2c4xcD4sZBXxhBXgQ,746
+nlbone/utils/flatten_dict.py,sha256=nkx8gAcJkjCKG3I5y9clqtjGMZCWyUWRhgD2R8zGEqM,299
 nlbone/utils/flatten_sqlalchemy_result.py,sha256=JGwQEauoJVjhzvXrOtqabj3wQ7zp2-OPwhuh44sUdUE,625
 nlbone/utils/http.py,sha256=0yeI34j5FfelqvX3PJnKknSXji1jl15VYbVIIvrSbXg,997
 nlbone/utils/normalize_mobile.py,sha256=sGH4tV9gX-6eVKozviNWJhm1DN1J28Nj-ERldCYkS_E,732
 nlbone/utils/redactor.py,sha256=-V4HrHmHwPi3Kez587Ek1uJlgK35qGSrwBOvcbw8Jas,1279
 nlbone/utils/time.py,sha256=DjjyQ9GLsfXoT6NK8RDW2rOlJg3e6sF04Jw6PBUrSvg,1268
-nlbone-0.7.32.dist-info/METADATA,sha256=m6ntviUXuOCKo5ZV_f08VeicMw2HvO3PG8sNw2qUEyU,2295
-nlbone-0.7.32.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-nlbone-0.7.32.dist-info/entry_points.txt,sha256=CpIL45t5nbhl1dGQPhfIIDfqqak3teK0SxPGBBr7YCk,59
-nlbone-0.7.32.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone-0.7.32.dist-info/RECORD,,
+nlbone-0.8.0.dist-info/METADATA,sha256=Joe3SppJPlbtJ5q5vdB1jSKCTAgOodLaLdkI4BWg7K4,2294
+nlbone-0.8.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+nlbone-0.8.0.dist-info/entry_points.txt,sha256=CpIL45t5nbhl1dGQPhfIIDfqqak3teK0SxPGBBr7YCk,59
+nlbone-0.8.0.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlbone-0.8.0.dist-info/RECORD,,