nsj-rest-lib2 0.0.35__py3-none-any.whl → 0.0.37__py3-none-any.whl

nsj_rest_lib2/compiler/compiler.py

@@ -28,6 +28,7 @@ from nsj_rest_lib2.compiler.util.type_naming_util import (
     compile_entity_class_name,
     compile_namespace_keys,
 )
+from nsj_rest_lib2.compiler.response_dto_compiler import ResponseDTOCompiler
 from nsj_rest_lib2.compiler.util.relation_ref import RelationRefParser
 
 from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
@@ -169,9 +170,12 @@ class EDLCompiler:
         get_function_name = None
         list_function_name = None
         delete_function_name = None
+        handlers: dict[str, Any] = {}
+        post_handler = None
+        put_handler = None
+        patch_handler = None
 
         if isinstance(entity_model, EntityModel) and entity_model.api:
-            handlers = {}
             if entity_model.api.handlers:
                 handlers = {
                     (verb or "").lower(): handler
@@ -179,16 +183,20 @@ class EDLCompiler:
                     if handler
                 }
 
+            post_handler = handlers.get("post")
+            put_handler = handlers.get("put")
+            patch_handler = handlers.get("patch")
+
             insert_output = self._function_compiler.compile_insert(
                 entity_model,
                 properties_structure,
-                handlers.get("post"),
+                post_handler,
                 prefx_class_name,
             )
             update_output = self._function_compiler.compile_update(
                 entity_model,
                 properties_structure,
-                handlers.get("put"),
+                put_handler,
                 prefx_class_name,
             )
             get_handler = handlers.get("get")
@@ -354,6 +362,16 @@ class EDLCompiler:
         # Adicionando as dependências das relações
         relations_dependencies_complete.extend(relations_dependencies)
 
+        response_dto_compiler = ResponseDTOCompiler(
+            dto_compiler=self._dto_compiler,
+            entity_model=entity_model,
+            prefx_class_name=prefx_class_name,
+            ast_dto_attributes=ast_dto_attributes,
+            aux_classes=aux_classes,
+            related_imports=related_imports,
+            fixed_filters=fixed_filters,
+        )
+
         # Adicionando as dependências da extensão parcial
         if partial_metadata and partial_base_model:
             relation_dependency = RelationDependency()
@@ -367,6 +385,68 @@ class EDLCompiler:
             relation_dependency.grupo_empresarial = partial_base_model.grupo_empresarial
             relations_dependencies_complete.append(relation_dependency)
 
+        post_expected = "empty"
+        put_expected = "empty"
+        patch_expected = "empty"
+        get_expected = "empty"
+        list_expected = "empty"
+        delete_expected = "empty"
+        post_properties = None
+        put_properties = None
+        patch_properties = None
+        if isinstance(entity_model, EntityModel) and entity_model.api:
+            post_expected, post_properties = (
+                response_dto_compiler.handler_result_details(post_handler)
+            )
+            put_expected, put_properties = (
+                response_dto_compiler.handler_result_details(put_handler)
+            )
+            patch_expected, patch_properties = (
+                response_dto_compiler.handler_result_details(patch_handler)
+            )
+            get_expected, _ = response_dto_compiler.handler_result_details(
+                get_handler
+            )
+            list_expected, _ = response_dto_compiler.handler_result_details(
+                list_handler
+            )
+            delete_expected, _ = response_dto_compiler.handler_result_details(
+                delete_handler
+            )
+
+        if post_expected == "partial_row":
+            post_class_name, post_code = (
+                response_dto_compiler.compile_partial_response_dto(
+                    "post", post_properties or []
+                )
+            )
+            compiler_result_post_class = post_class_name
+            dto_code += "\n\n" + post_code
+        else:
+            compiler_result_post_class = None
+
+        if put_expected == "partial_row":
+            put_class_name, put_code = (
+                response_dto_compiler.compile_partial_response_dto(
+                    "put", put_properties or []
+                )
+            )
+            compiler_result_put_class = put_class_name
+            dto_code += "\n\n" + put_code
+        else:
+            compiler_result_put_class = None
+
+        if patch_expected == "partial_row":
+            patch_class_name, patch_code = (
+                response_dto_compiler.compile_partial_response_dto(
+                    "patch", patch_properties or []
+                )
+            )
+            compiler_result_patch_class = patch_class_name
+            dto_code += "\n\n" + patch_code
+        else:
+            compiler_result_patch_class = None
+
         # Construindo o resultado
         compiler_result = CompilerResult()
         compiler_result.entity_class_name = entity_class_name
@@ -389,6 +469,34 @@ class EDLCompiler:
         compiler_result.source_delete_function_type = (
             delete_function_code.strip() or None
         )
+        compiler_result.retrieve_after_insert = post_expected == "entity_row"
+        compiler_result.retrieve_after_update = put_expected == "entity_row"
+        compiler_result.retrieve_after_partial_update = (
+            patch_expected == "entity_row"
+        )
+        compiler_result.post_response_dto_class_name = compiler_result_post_class
+        compiler_result.put_response_dto_class_name = compiler_result_put_class
+        compiler_result.patch_response_dto_class_name = (
+            compiler_result_patch_class
+        )
+        compiler_result.custom_json_post_response = (
+            post_expected == "custom_json"
+        )
+        compiler_result.custom_json_put_response = (
+            put_expected == "custom_json"
+        )
+        compiler_result.custom_json_patch_response = (
+            patch_expected == "custom_json"
+        )
+        compiler_result.custom_json_get_response = (
+            get_expected == "custom_json"
+        )
+        compiler_result.custom_json_list_response = (
+            list_expected == "custom_json"
+        )
+        compiler_result.custom_json_delete_response = (
+            delete_expected == "custom_json"
+        )
 
         insert_code_compiled = insert_function_code.strip()
         update_code_compiled = update_function_code.strip()

nsj_rest_lib2/compiler/dto_compiler.py

@@ -1,4 +1,5 @@
 import ast
+from typing import Optional
 
 import black
 
@@ -21,6 +22,7 @@ class DTOCompiler:
         fixed_filters: list[tuple[str, BasicTypes]],
         prefx_class_name: str,
         partial_metadata: dict[str, str] | None,
+        class_name_override: Optional[str] = None,
     ) -> tuple[str, str]:
         """
         Compila o código do DTO a partir do AST e retorna o código compilado.
@@ -158,7 +160,9 @@ class DTOCompiler:
             )
 
         # Criando o ast da classe
-        class_name = compile_dto_class_name(entity_model.id, prefx_class_name)
+        class_name = class_name_override or compile_dto_class_name(
+            entity_model.id, prefx_class_name
+        )
         ast_class = ast.ClassDef(
             name=class_name,
             bases=[ast.Name(id="DTOBase", ctx=ast.Load())],

nsj_rest_lib2/compiler/edl_model/api_model.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Dict, List, Literal, Optional
 
-from pydantic import AliasChoices, BaseModel, Field
+from pydantic import AliasChoices, BaseModel, Field, model_validator
 
 APIVerbs = Literal["GET", "POST", "PUT", "DELETE", "PATCH"]
 
@@ -46,10 +46,22 @@ class HandlerCall(BaseModel):
 
 
 class HandlerResult(BaseModel):
-    expected: Literal["empty", "entity_row"] = Field(
+    expected: Literal["empty", "entity_row", "custom_json", "partial_row"] = Field(
         default="empty",
         description="Define o formato esperado do retorno da função.",
     )
+    properties: Optional[List[str]] = Field(
+        default=None,
+        description="Lista de propriedades a serem retornadas quando o resultado esperado for 'partial_row'.",
+    )
+
+    @model_validator(mode="after")
+    def validate_partial_row(self):
+        if self.expected == "partial_row" and not self.properties:
+            raise ValueError(
+                "result.properties é obrigatório quando result.expected for 'partial_row'."
+            )
+        return self
 
 
 class HandlerError(BaseModel):
@@ -68,12 +80,12 @@ class HandlerError(BaseModel):
 
 
 class HandlerConfig(BaseModel):
-    impl: Literal["pg_function"] = Field(
-        ...,
+    impl: Optional[Literal["pg_function"]] = Field(
+        default=None,
         description="Somente funções PostgreSQL (pg_function) são suportadas neste estágio.",
     )
-    function_ref: str = Field(
-        ...,
+    function_ref: Optional[str] = Field(
+        default=None,
         description="Referência qualificada para a função no banco (ex.: schema.fn_nome).",
     )
     call: Optional[HandlerCall] = Field(

nsj_rest_lib2/compiler/model.py

@@ -59,3 +59,15 @@ class CompilerResult:
         self.source_get_function_type: str | None = None
         self.source_list_function_type: str | None = None
         self.source_delete_function_type: str | None = None
+        self.retrieve_after_insert: bool | None = None
+        self.retrieve_after_update: bool | None = None
+        self.retrieve_after_partial_update: bool | None = None
+        self.post_response_dto_class_name: str | None = None
+        self.put_response_dto_class_name: str | None = None
+        self.patch_response_dto_class_name: str | None = None
+        self.custom_json_post_response: bool | None = None
+        self.custom_json_put_response: bool | None = None
+        self.custom_json_patch_response: bool | None = None
+        self.custom_json_get_response: bool | None = None
+        self.custom_json_list_response: bool | None = None
+        self.custom_json_delete_response: bool | None = None

nsj_rest_lib2/compiler/response_dto_compiler.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import ast
+from typing import Any, Optional
+
+from nsj_rest_lib2.compiler.dto_compiler import DTOCompiler
+from nsj_rest_lib2.compiler.edl_model.entity_model_base import EntityModelBase
+from nsj_rest_lib2.compiler.edl_model.primitives import BasicTypes
+from nsj_rest_lib2.compiler.util.str_util import CompilerStrUtil
+from nsj_rest_lib2.compiler.util.type_naming_util import (
+    compile_response_dto_class_name,
+)
+
+
+class ResponseDTOCompiler:
+    def __init__(
+        self,
+        dto_compiler: DTOCompiler,
+        entity_model: EntityModelBase,
+        prefx_class_name: str,
+        ast_dto_attributes: list[ast.stmt],
+        aux_classes: list[ast.stmt],
+        related_imports: list[tuple[str, str, str]],
+        fixed_filters: list[tuple[str, BasicTypes]],
+    ) -> None:
+        self._dto_compiler = dto_compiler
+        self._entity_model = entity_model
+        self._prefx_class_name = prefx_class_name
+        self._aux_classes = aux_classes
+        self._related_imports = related_imports
+        self._fixed_filters = fixed_filters
+        self._dto_attr_map = self._build_attr_map(ast_dto_attributes)
+
+    @staticmethod
+    def handler_result_details(handler: Any) -> tuple[str, list[str] | None]:
+        expected = "empty"
+        properties = None
+        if handler and getattr(handler, "result", None):
+            expected = handler.result.expected or "empty"
+            properties = handler.result.properties
+        return (expected, properties)
+
+    def compile_partial_response_dto(
+        self, verb: str, properties: list[str]
+    ) -> tuple[str, str]:
+        if not properties:
+            raise Exception(
+                f"result.properties não pode ser vazio para '{verb}' na entidade '{self._entity_model.id}'."
+            )
+
+        normalized = [
+            CompilerStrUtil.to_snake_case(prop) for prop in properties
+        ]
+        missing = [
+            properties[idx]
+            for idx, norm in enumerate(normalized)
+            if norm not in self._dto_attr_map
+        ]
+        if missing:
+            raise Exception(
+                f"As propriedades {missing} não foram encontradas na entidade '{self._entity_model.id}'."
+            )
+
+        filtered_attrs = [self._dto_attr_map[name] for name in normalized]
+        filtered_fixed_filters = [
+            item for item in self._fixed_filters if item[0] in normalized
+        ]
+
+        class_name = compile_response_dto_class_name(
+            self._entity_model.id,
+            self._prefx_class_name,
+            verb,
+        )
+
+        return self._dto_compiler.compile(
+            self._entity_model,
+            filtered_attrs,
+            self._aux_classes,
+            self._related_imports,
+            filtered_fixed_filters,
+            self._prefx_class_name,
+            None,
+            class_name_override=class_name,
+        )
+
+    @staticmethod
+    def _extract_attr_name(stmt: ast.stmt) -> Optional[str]:
+        if isinstance(stmt, ast.AnnAssign) and isinstance(stmt.target, ast.Name):
+            return stmt.target.id
+        if isinstance(stmt, ast.Assign) and stmt.targets:
+            target = stmt.targets[0]
+            if isinstance(target, ast.Name):
+                return target.id
+        return None
+
+    def _build_attr_map(
+        self, ast_dto_attributes: list[ast.stmt]
+    ) -> dict[str, ast.stmt]:
+        dto_attr_map: dict[str, ast.stmt] = {}
+        for stmt in ast_dto_attributes:
+            name = self._extract_attr_name(stmt)
+            if name:
+                dto_attr_map[name] = stmt
+        return dto_attr_map

nsj_rest_lib2/compiler/util/type_naming_util.py

@@ -1,6 +1,8 @@
+import hashlib
 import uuid
-from typing import Iterable
+from typing import Iterable, Iterator, Optional
 
+from nsj_rest_lib2.compiler.model import CompilerResult
 from nsj_rest_lib2.compiler.util.str_util import CompilerStrUtil
 
 
@@ -14,10 +16,90 @@ def compile_namespace_keys(
     return (grupo_key, tenant_key, default_key)
 
 
+def resolve_namespace_key(
+    tenant: str | int | None, grupo_empresarial: str | uuid.UUID | None
+) -> str:
+    grupo_key, tenant_key, default_key = compile_namespace_keys(
+        tenant,
+        grupo_empresarial,
+    )
+
+    if (
+        tenant
+        and tenant != 0
+        and grupo_empresarial
+        and str(grupo_empresarial) != "00000000-0000-0000-0000-000000000000"
+    ):
+        return grupo_key
+    if tenant and tenant != 0:
+        return tenant_key
+    return default_key
+
+
+def build_entity_hash(compiler_result: CompilerResult) -> str:
+    hasher = hashlib.sha256()
+
+    for content in _iter_hash_chunks(
+        compiler_result.dto_code,
+        compiler_result.entity_code,
+        compiler_result.insert_function_name,
+        compiler_result.update_function_name,
+        compiler_result.get_function_name,
+        compiler_result.list_function_name,
+        compiler_result.delete_function_name,
+        compiler_result.source_insert_function,
+        compiler_result.source_update_function,
+        compiler_result.source_get_function_type,
+        compiler_result.source_list_function_type,
+        compiler_result.source_delete_function_type,
+        compiler_result.post_response_dto_class_name,
+        compiler_result.put_response_dto_class_name,
+        compiler_result.patch_response_dto_class_name,
+        str(compiler_result.retrieve_after_insert),
+        str(compiler_result.retrieve_after_update),
+        str(compiler_result.retrieve_after_partial_update),
+        str(compiler_result.custom_json_post_response),
+        str(compiler_result.custom_json_put_response),
+        str(compiler_result.custom_json_patch_response),
+        str(compiler_result.custom_json_get_response),
+        str(compiler_result.custom_json_list_response),
+        str(compiler_result.custom_json_delete_response),
+        compiler_result.service_account,
+    ):
+        hasher.update(content)
+
+    return hasher.hexdigest()
+
+
+def _iter_hash_chunks(*chunks: Optional[str]) -> Iterator[bytes]:
+    for chunk in chunks:
+        if chunk:
+            yield chunk.encode("utf-8")
+
+
 def compile_dto_class_name(entity_id: str, prefx_class_name: str = "") -> str:
     return f"{CompilerStrUtil.to_pascal_case(prefx_class_name)}{CompilerStrUtil.to_pascal_case(entity_id)}DTO"
 
 
+def compile_response_dto_class_name(
+    entity_id: str, prefx_class_name: str, verb: str
+) -> str:
+    verb = (verb or "").lower()
+    suffix_map = {
+        "post": "PostResponseDTO",
+        "put": "PutResponseDTO",
+        "patch": "PatchResponseDTO",
+    }
+    suffix = suffix_map.get(
+        verb, f"{CompilerStrUtil.to_pascal_case(verb)}ResponseDTO"
+    )
+    return (
+        f"{CompilerStrUtil.to_pascal_case(prefx_class_name)}"
+        f"{CompilerStrUtil.to_pascal_case(entity_id)}"
+        f"{suffix}"
+    )
+
+
 def compile_entity_class_name(entity_id: str, prefx_class_name: str = "") -> str:
     return f"{CompilerStrUtil.to_pascal_case(prefx_class_name)}{CompilerStrUtil.to_pascal_case(entity_id)}Entity"
 

nsj_rest_lib2/controller/dynamic_controller.py

@@ -11,12 +11,12 @@ from nsj_gcf_utils.rest_error_util import format_json_error
 from nsj_multi_database_lib.decorator.multi_database import multi_database
 
 from nsj_rest_lib.controller.controller_util import DEFAULT_RESP_HEADERS
-from nsj_rest_lib.controller.list_route import ListRoute
+from nsj_rest_lib.controller.delete_route import DeleteRoute
 from nsj_rest_lib.controller.get_route import GetRoute
+from nsj_rest_lib.controller.list_route import ListRoute
+from nsj_rest_lib.controller.patch_route import PatchRoute
 from nsj_rest_lib.controller.post_route import PostRoute
 from nsj_rest_lib.controller.put_route import PutRoute
-from nsj_rest_lib.controller.patch_route import PatchRoute
-from nsj_rest_lib.controller.delete_route import DeleteRoute
 
 from nsj_rest_lib2.exception import MissingEntityConfigException
 from nsj_rest_lib2.service.entity_loader import EntityLoader
@@ -55,6 +55,7 @@ def setup_dynamic_routes(
     dynamic_root_path: str = "edl1",
     injector_factory: Any = None,
     escopo_in_url: bool = False,
+    edls_path: str | None = None,
 ) -> None:
 
     if not escopo_in_url:
@@ -68,6 +69,8 @@ def setup_dynamic_routes(
             f"/{APP_NAME}/{dynamic_root_path}/<entity_escopo>/<entity_resource>/<id>"
         )
 
+    entity_loader = EntityLoader(edls_path=edls_path)
+
     def _dynamic_route_wrapper(
         route_builder: Callable[[tuple[Any, ...]], Callable[..., Any]],
         endpoint_suffix: str | None = None,
@@ -83,7 +86,6 @@ def setup_dynamic_routes(
             tenant, grupo_empresarial, force_reload = _get_query_args()
 
             try:
-                entity_loader = EntityLoader()
                 entity_config = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,
@@ -133,6 +135,10 @@ def setup_dynamic_routes(
             _get_function_type_class_name,
             list_function_type_class_name,
             _delete_function_type_class_name,
+            *_,
+            _custom_json_get_response,
+            custom_json_list_response,
+            _custom_json_delete_response,
         ) = entity_config
 
         def list_dynamic(*args: Any, **kwargs: Any) -> Any:
@@ -149,6 +155,7 @@ def setup_dynamic_routes(
                 list_function_type_class=etities_dict.get(
                     list_function_type_class_name
                 ),
+                custom_json_response=bool(custom_json_list_response),
             )
 
             return route.handle_request(*args, **kwargs)
@@ -173,6 +180,10 @@ def setup_dynamic_routes(
             get_function_type_class_name,
             _list_function_type_class_name,
             _delete_function_type_class_name,
+            *_,
+            custom_json_get_response,
+            _custom_json_list_response,
+            _custom_json_delete_response,
         ) = entity_config
 
         def get_dynamic(*args: Any, **kwargs: Any) -> Any:
@@ -187,6 +198,7 @@ def setup_dynamic_routes(
                 injector_factory=injector_factory,
                 get_function_name=get_function_name,
                 get_function_type_class=etities_dict.get(get_function_type_class_name),
+                custom_json_response=bool(custom_json_get_response),
             )
 
             return route.handle_request(*args, **kwargs)
@@ -211,6 +223,18 @@ def setup_dynamic_routes(
             _get_function_type_class_name,
             _list_function_type_class_name,
             _delete_function_type_class_name,
+            retrieve_after_insert,
+            _retrieve_after_update,
+            _retrieve_after_partial_update,
+            post_response_dto_class_name,
+            _put_response_dto_class_name,
+            _patch_response_dto_class_name,
+            custom_json_post_response,
+            _custom_json_put_response,
+            _custom_json_patch_response,
+            _custom_json_get_response,
+            _custom_json_list_response,
+            _custom_json_delete_response,
         ) = entity_config
 
         def post_dynamic(*args: Any, **kwargs: Any) -> Any:
@@ -223,6 +247,12 @@ def setup_dynamic_routes(
                 else None
             )
 
+            dto_response_class = (
+                etities_dict.get(post_response_dto_class_name)
+                if post_response_dto_class_name
+                else None
+            )
+
             route = PostRoute(
                 url=COLLECTION_DYNAMIC_ROUTE,
                 http_method="POST",
@@ -231,6 +261,9 @@ def setup_dynamic_routes(
                 injector_factory=injector_factory,
                 insert_function_type_class=insert_function_type_class,
                 insert_function_name=insert_function_name,
+                dto_response_class=dto_response_class,
+                retrieve_after_insert=retrieve_after_insert,
+                custom_json_response=bool(custom_json_post_response),
             )
 
             return route.handle_request(*args, **kwargs)
@@ -255,8 +288,26 @@ def setup_dynamic_routes(
             _get_function_type_class_name,
             _list_function_type_class_name,
             _delete_function_type_class_name,
+            _retrieve_after_insert,
+            retrieve_after_update,
+            _retrieve_after_partial_update,
+            _post_response_dto_class_name,
+            put_response_dto_class_name,
+            _patch_response_dto_class_name,
+            _custom_json_post_response,
+            custom_json_put_response,
+            _custom_json_patch_response,
+            _custom_json_get_response,
+            _custom_json_list_response,
+            _custom_json_delete_response,
         ) = entity_config
 
+        dto_response_class = (
+            etities_dict.get(put_response_dto_class_name)
+            if put_response_dto_class_name
+            else None
+        )
+
         def put_dynamic(*args: Any, **kwargs: Any) -> Any:
             if not api_expose or "PUT" not in api_verbs:
                 return ("", 405, {})
@@ -275,6 +326,9 @@ def setup_dynamic_routes(
                 injector_factory=injector_factory,
                 update_function_type_class=update_function_type_class,
                 update_function_name=update_function_name,
+                dto_response_class=dto_response_class,
+                retrieve_after_update=retrieve_after_update,
+                custom_json_response=bool(custom_json_put_response),
             )
 
             return route.handle_request(*args, **kwargs)
@@ -296,19 +350,42 @@ def setup_dynamic_routes(
             _get_function_name,
             _list_function_name,
             _delete_function_name,
-            *_,
+            _get_function_type_class_name,
+            _list_function_type_class_name,
+            _delete_function_type_class_name,
+            _retrieve_after_insert,
+            _retrieve_after_update,
+            retrieve_after_partial_update,
+            _post_response_dto_class_name,
+            _put_response_dto_class_name,
+            patch_response_dto_class_name,
+            _custom_json_post_response,
+            _custom_json_put_response,
+            custom_json_patch_response,
+            _custom_json_get_response,
+            _custom_json_list_response,
+            _custom_json_delete_response,
         ) = entity_config
 
         def patch_dynamic(*args: Any, **kwargs: Any) -> Any:
             if not api_expose or "PATCH" not in api_verbs:
                 return ("", 405, {})
 
+            dto_response_class = (
+                etities_dict.get(patch_response_dto_class_name)
+                if patch_response_dto_class_name
+                else None
+            )
+
             route = PatchRoute(
                 url=ONE_DYNAMIC_ROUTE,
                 http_method="PATCH",
                 dto_class=etities_dict[dto_class_name],
                 entity_class=etities_dict[entity_class_name],
                 injector_factory=injector_factory,
+                dto_response_class=dto_response_class,
+                retrieve_after_partial_update=retrieve_after_partial_update,
+                custom_json_response=bool(custom_json_patch_response),
             )
 
             return route.handle_request(*args, **kwargs)
@@ -333,6 +410,10 @@ def setup_dynamic_routes(
             _get_function_type_class_name,
             _list_function_type_class_name,
             delete_function_type_class_name,
+            *_,
+            _custom_json_get_response,
+            _custom_json_list_response,
+            custom_json_delete_response,
         ) = entity_config
 
         def delete_dynamic(*args: Any, **kwargs: Any) -> Any:
@@ -349,6 +430,7 @@ def setup_dynamic_routes(
                 delete_function_type_class=etities_dict.get(
                     delete_function_type_class_name
                 ),
+                custom_json_response=bool(custom_json_delete_response),
             )
 
             return route.handle_request(*args, **kwargs)