From eaaf650e961f205255a3abd0c371f10d8d0e9a9d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Maria=20=C3=96hrman?= Date: Mon, 29 Jan 2024 08:57:20 +0100 Subject: [PATCH] fix format and lint errors --- .../src/karp/auth_infrastructure/__init__.py | 2 +- .../src/karp/cliapp/subapps/entries_subapp.py | 10 ++-- .../karp/cliapp/subapps/entry_repo_subapp.py | 2 +- .../src/karp/cliapp/subapps/query_subapp.py | 4 +- .../karp/cliapp/subapps/resource_subapp.py | 12 +++-- karp-backend/src/karp/foundation/entity.py | 8 +-- karp-backend/src/karp/foundation/errors.py | 5 +- karp-backend/src/karp/foundation/events.py | 4 +- .../src/karp/karp_v6_api/contrib/matomo.py | 4 +- .../karp_v6_api/dependencies/auth_deps.py | 8 +-- .../karp/karp_v6_api/dependencies/lex_deps.py | 5 +- karp-backend/src/karp/karp_v6_api/main.py | 4 +- .../karp/karp_v6_api/routes/entries_api.py | 4 +- karp-backend/src/karp/karp_v6_api/schemas.py | 2 +- karp-backend/src/karp/lex/__init__.py | 4 +- .../lex/application/repositories/resources.py | 4 +- .../application/use_cases/entry_handlers.py | 4 +- .../use_cases/resource_handlers.py | 4 +- .../src/karp/lex/domain/entities/entry.py | 2 +- .../src/karp/lex/domain/entities/resource.py | 14 +++--- karp-backend/src/karp/lex/domain/errors.py | 15 ++++-- .../lex/domain/value_objects/entry_schema.py | 5 +- .../src/karp/lex_infrastructure/__init__.py | 6 +-- .../queries/generic_entries.py | 29 +++++------ .../lex_infrastructure/queries/resources.py | 3 +- .../repositories/sql_entries.py | 23 +++++---- .../repositories/sql_resources.py | 12 +---- .../karp/lex_infrastructure/sql/sql_models.py | 8 +-- karp-backend/src/karp/main/__init__.py | 4 +- karp-backend/src/karp/main/errors.py | 2 +- karp-backend/src/karp/main/migrations/env.py | 12 ++--- .../versions/5bb29472d33f_init_db.py | 4 +- karp-backend/src/karp/main/modules.py | 4 +- .../src/karp/search/application/use_cases.py | 14 ++++-- karp-backend/src/karp/search/domain/query.py | 8 +-- .../elasticsearch6/es_mapping_repo.py | 30 +++--------- .../queries/es6_search_service.py | 49 +++++++------------ .../repositories/es6_indicies.py | 8 +-- .../transformers/generic_entry_transformer.py | 28 +++-------- .../transformers/generic_pre_processor.py | 12 ++--- .../src/karp/lex_core/alias_generators.py | 4 +- tests/common_data.py | 4 +- tests/e2e/conftest.py | 5 +- tests/e2e/test_entries_api.py | 5 +- tests/e2e/test_history_api.py | 4 +- tests/integration/test_sql_entries_uow.py | 5 +- .../test_sql_resource_repository.py | 4 +- tests/integration/test_sql_uow.py | 4 +- tests/unit/auth/adapters.py | 1 - tests/unit/lex/adapters.py | 16 +++--- tests/unit/lex/test_resource.py | 8 +-- tests/unit/lex/test_resource_handlers.py | 3 +- tests/unit/lex_core/entry_dto_unit_test.py | 4 +- tests/unit/search/adapters.py | 5 +- tests/unit/search/test_search_handlers.py | 16 ++---- .../test_es6_es_query.py | 8 +-- .../test_es6_mappings.py | 8 +-- .../test_es6_query_parser.py | 16 ++---- 58 files changed, 177 insertions(+), 325 deletions(-) diff --git a/karp-backend/src/karp/auth_infrastructure/__init__.py b/karp-backend/src/karp/auth_infrastructure/__init__.py index 0f210cff..96956b3c 100644 --- a/karp-backend/src/karp/auth_infrastructure/__init__.py +++ b/karp-backend/src/karp/auth_infrastructure/__init__.py @@ -39,7 +39,7 @@ def jwt_auth_service_config(self) -> JWTAuthServiceConfig: # noqa: D102 @injector.provider def jwt_auth_service( # noqa: D102 self, is_resource_protected: LexIsResourceProtected - ) -> JWTAuthService: + ) -> JWTAuthService: return JWTAuthService( pubkey_path=self.pubkey_path, is_resource_protected=is_resource_protected ) diff --git a/karp-backend/src/karp/cliapp/subapps/entries_subapp.py b/karp-backend/src/karp/cliapp/subapps/entries_subapp.py index 42537c17..c8dda17f 100644 --- a/karp-backend/src/karp/cliapp/subapps/entries_subapp.py +++ b/karp-backend/src/karp/cliapp/subapps/entries_subapp.py @@ -184,9 +184,7 @@ def validate_entries( # noqa: ANN201, D103 ), resource_id_raw: Optional[str] = typer.Option(None, "--resource_id"), as_import: bool = typer.Option(False, "--as-import"), - output: Optional[Path] = typer.Option( - None, "--output", "-o", help="file to write to" - ), + output: Optional[Path] = typer.Option(None, "--output", "-o", help="file to write to"), ): """Validate entries without adding or importing them. @@ -221,13 +219,11 @@ def validate_entries( # noqa: ANN201, D103 raise typer.Exit(code=300) allow_additional_properties = config.get("additionalProperties", True) - schema = entry_schema.create_entry_json_schema(config["fields"],allow_additional_properties) + schema = entry_schema.create_entry_json_schema(config["fields"], allow_additional_properties) error_code = 0 - entries: Iterable[dict] = json_streams.load_from_file( - path, use_stdin_as_default=True - ) + entries: Iterable[dict] = json_streams.load_from_file(path, use_stdin_as_default=True) if as_import: entries = (import_entry["entry"] for import_entry in entries) with json_streams.sink_from_file( diff --git a/karp-backend/src/karp/cliapp/subapps/entry_repo_subapp.py b/karp-backend/src/karp/cliapp/subapps/entry_repo_subapp.py index c59d91f3..5379e9b3 100644 --- a/karp-backend/src/karp/cliapp/subapps/entry_repo_subapp.py +++ b/karp-backend/src/karp/cliapp/subapps/entry_repo_subapp.py @@ -19,7 +19,7 @@ def create(infile: typer.FileBinaryRead, ctx: typer.Context): # noqa: ANN201, D try: data = json.load(infile) except Exception as err: # noqa: BLE001 - typer.echo(f"Error reading file '{infile.name}': {str(err)}") + typer.echo(f"Error reading file '{infile.name}': {err!s}") raise typer.Exit(123) from err create_entry_repo = CreateEntryRepository.from_dict( data, diff --git a/karp-backend/src/karp/cliapp/subapps/query_subapp.py b/karp-backend/src/karp/cliapp/subapps/query_subapp.py index b634b235..feac784b 100644 --- a/karp-backend/src/karp/cliapp/subapps/query_subapp.py +++ b/karp-backend/src/karp/cliapp/subapps/query_subapp.py @@ -16,9 +16,7 @@ def resource( # noqa: ANN201, D103 ctx: typer.Context, resource_id: str, - output: Optional[Path] = typer.Option( - None, help="Path to write to. Defaults to stdout." - ), + output: Optional[Path] = typer.Option(None, help="Path to write to. Defaults to stdout."), ): search_service = inject_from_ctx(Es6SearchService, ctx) query_request = search.QueryRequest(resource_ids=[resource_id]) diff --git a/karp-backend/src/karp/cliapp/subapps/resource_subapp.py b/karp-backend/src/karp/cliapp/subapps/resource_subapp.py index 70e60034..09e3fefa 100644 --- a/karp-backend/src/karp/cliapp/subapps/resource_subapp.py +++ b/karp-backend/src/karp/cliapp/subapps/resource_subapp.py @@ -9,8 +9,12 @@ from karp.command_bus import CommandBus from karp.lex_core.value_objects import UniqueIdStr, unique_id from karp.lex_core import commands as lex_commands -from karp.lex_infrastructure import SqlGetPublishedResources, SqlGetResources, SqlReadOnlyResourceRepository, \ - SqlListEntryRepos +from karp.lex_infrastructure import ( + SqlGetPublishedResources, + SqlGetResources, + SqlReadOnlyResourceRepository, + SqlListEntryRepos, +) from karp.search import commands as search_commands from karp.cliapp.utility import cli_error_handler, cli_timer @@ -179,9 +183,7 @@ def show( # noqa: ANN201, D103 resource = repo.get_by_resource_id(resource_id, version=version) if not resource: version_str = version or "latest" - typer.echo( - f"Can't find resource '{resource_id}', version '{version_str}'", err=True - ) + typer.echo(f"Can't find resource '{resource_id}', version '{version_str}'", err=True) raise typer.Exit(3) typer.echo(tabulate(((key, value) for key, value in resource.dict().items()))) diff --git a/karp-backend/src/karp/foundation/entity.py b/karp-backend/src/karp/foundation/entity.py index 2675728a..26e76d55 100644 --- a/karp-backend/src/karp/foundation/entity.py +++ b/karp-backend/src/karp/foundation/entity.py @@ -75,9 +75,7 @@ def _increment_version(self): # noqa: ANN202 def _validate_version(self, version: int) -> None: if version != self.version: - raise ConsistencyError( - f"Entity version mismatch: {version} != {self.version}" - ) + raise ConsistencyError(f"Entity version mismatch: {version} != {self.version}") class TimestampedEntity(Entity): # noqa: D101 @@ -90,9 +88,7 @@ def __init__( # noqa: D107 ) -> None: super().__init__(id=id, discarded=discarded) self._last_modified = self._ensure_timestamp(last_modified) - self._last_modified_by = ( - "Unknown user" if last_modified_by is None else last_modified_by - ) + self._last_modified_by = "Unknown user" if last_modified_by is None else last_modified_by @property def last_modified(self): # noqa: ANN201 diff --git a/karp-backend/src/karp/foundation/errors.py b/karp-backend/src/karp/foundation/errors.py index fa010dfa..06cd8963 100644 --- a/karp-backend/src/karp/foundation/errors.py +++ b/karp-backend/src/karp/foundation/errors.py @@ -4,7 +4,10 @@ class NotFoundError(Exception): # noqa: D100 entity_name: str = "Generic entity" def __init__( # noqa: D107 - self, entity_id, *args, msg: str | None = None # noqa: ANN002 + self, + entity_id, + *args, + msg: str | None = None, # noqa: ANN002 ) -> None: msg = msg or f"{self.entity_name} not found. Id: {entity_id}" super().__init__(msg, *args) diff --git a/karp-backend/src/karp/foundation/events.py b/karp-backend/src/karp/foundation/events.py index e71de8be..14ca11c5 100644 --- a/karp-backend/src/karp/foundation/events.py +++ b/karp-backend/src/karp/foundation/events.py @@ -74,7 +74,5 @@ def post(self, event: Event) -> None: # noqa: D102 try: evt_handler(event) except Exception as err: # noqa: F841 - logger.exception( - "Exception handling event", extra={"karp_event": event} - ) + logger.exception("Exception handling event", extra={"karp_event": event}) raise diff --git a/karp-backend/src/karp/karp_v6_api/contrib/matomo.py b/karp-backend/src/karp/karp_v6_api/contrib/matomo.py index 9c601fdb..044018b8 100644 --- a/karp-backend/src/karp/karp_v6_api/contrib/matomo.py +++ b/karp-backend/src/karp/karp_v6_api/contrib/matomo.py @@ -98,9 +98,7 @@ async def dispatch( # noqa: D102 try: logger.debug("Making tracking call", extra={"url": tracking_url}) r = http.request("GET", tracking_url) - logger.debug( - "tracking call", extra={"status_code": r.status, "data": r.data} - ) + logger.debug("tracking call", extra={"status_code": r.status, "data": r.data}) except urllib3.exceptions.HTTPError: logger.exception("Error tracking view") return response diff --git a/karp-backend/src/karp/karp_v6_api/dependencies/auth_deps.py b/karp-backend/src/karp/karp_v6_api/dependencies/auth_deps.py index 61d7db12..0fa522b7 100644 --- a/karp-backend/src/karp/karp_v6_api/dependencies/auth_deps.py +++ b/karp-backend/src/karp/karp_v6_api/dependencies/auth_deps.py @@ -92,7 +92,7 @@ def get_user( # noqa: D103 extra={"credentials": credentials}, ) return auth_service.authenticate(credentials.scheme, credentials.credentials) - except KarpError: - raise credentials_exception - except TokenError: - raise credentials_exception + except KarpError as err: + raise credentials_exception from err + except TokenError as err: + raise credentials_exception from err diff --git a/karp-backend/src/karp/karp_v6_api/dependencies/lex_deps.py b/karp-backend/src/karp/karp_v6_api/dependencies/lex_deps.py index 6d69a1b8..98bf85a9 100644 --- a/karp-backend/src/karp/karp_v6_api/dependencies/lex_deps.py +++ b/karp-backend/src/karp/karp_v6_api/dependencies/lex_deps.py @@ -31,6 +31,7 @@ from karp.lex.application.repositories import EntryUnitOfWorkCreator + def get_resource_unit_of_work( # noqa: D103 db_session: Session = Depends(get_session), event_bus: EventBus = Depends(event_deps.get_eventbus), @@ -43,9 +44,7 @@ def get_resource_unit_of_work( # noqa: D103 def get_entry_repo_uow( # noqa: D103 db_session: Session = Depends(get_session), - entry_uow_factory: EntryUnitOfWorkCreator = Depends( - inject_from_req(EntryUnitOfWorkCreator) - ), + entry_uow_factory: EntryUnitOfWorkCreator = Depends(inject_from_req(EntryUnitOfWorkCreator)), event_bus: EventBus = Depends(event_deps.get_eventbus), ) -> EntryUowRepositoryUnitOfWork: return SqlEntryUowRepositoryUnitOfWork( diff --git a/karp-backend/src/karp/karp_v6_api/main.py b/karp-backend/src/karp/karp_v6_api/main.py index 6c86b4d9..74ac5296 100644 --- a/karp-backend/src/karp/karp_v6_api/main.py +++ b/karp-backend/src/karp/karp_v6_api/main.py @@ -230,9 +230,7 @@ async def _logging_middleware(request: Request, call_next) -> Response: access_token=app_context.settings["tracking.matomo.token"], ) else: - logger.warning( - "Tracking to Matomo is not enabled, please set TRACKING_MATOMO_URL." - ) + logger.warning("Tracking to Matomo is not enabled, please set TRACKING_MATOMO_URL.") app.add_middleware(CorrelationIdMiddleware) return app diff --git a/karp-backend/src/karp/karp_v6_api/routes/entries_api.py b/karp-backend/src/karp/karp_v6_api/routes/entries_api.py index 59ba3501..9a4028f8 100644 --- a/karp-backend/src/karp/karp_v6_api/routes/entries_api.py +++ b/karp-backend/src/karp/karp_v6_api/routes/entries_api.py @@ -37,9 +37,7 @@ logger = logging.getLogger(__name__) -@router.get( - "/{resource_id}/{entry_id}/{version}", response_model=EntryDto, tags=["History"] -) +@router.get("/{resource_id}/{entry_id}/{version}", response_model=EntryDto, tags=["History"]) @router.get("/{resource_id}/{entry_id}", response_model=EntryDto, tags=["History"]) def get_history_for_entry( # noqa: ANN201, D103 resource_id: str, diff --git a/karp-backend/src/karp/karp_v6_api/schemas.py b/karp-backend/src/karp/karp_v6_api/schemas.py index 576cd062..59d879c2 100644 --- a/karp-backend/src/karp/karp_v6_api/schemas.py +++ b/karp-backend/src/karp/karp_v6_api/schemas.py @@ -14,7 +14,7 @@ class BaseModel(pydantic.BaseModel): class Config: # noqa: D106 alias_generator = alias_generators.to_lower_camel - json_encoders = {ulid.ULID: lambda u: u.str} + json_encoders: typing.ClassVar = {ulid.ULID: lambda u: u.str} def serialize(self) -> dict: """Serialize model to dict.""" diff --git a/karp-backend/src/karp/lex/__init__.py b/karp-backend/src/karp/lex/__init__.py index 38968a6a..c8964020 100644 --- a/karp-backend/src/karp/lex/__init__.py +++ b/karp-backend/src/karp/lex/__init__.py @@ -155,9 +155,7 @@ def import_entries( # noqa: D102 resource_uow: ResourceUnitOfWork, entry_repo_uow: EntryUowRepositoryUnitOfWork, ) -> CommandHandler[commands.ImportEntries]: - return ImportingEntries( - resource_uow=resource_uow, entry_repo_uow=entry_repo_uow - ) + return ImportingEntries(resource_uow=resource_uow, entry_repo_uow=entry_repo_uow) @injector.provider def importing_entries_in_chunks( # noqa: D102 diff --git a/karp-backend/src/karp/lex/application/repositories/resources.py b/karp-backend/src/karp/lex/application/repositories/resources.py index b8216326..0a2e8cb5 100644 --- a/karp-backend/src/karp/lex/application/repositories/resources.py +++ b/karp-backend/src/karp/lex/application/repositories/resources.py @@ -25,9 +25,7 @@ def get_by_resource_id( # noqa: D102 if resource := self.get_by_resource_id_optional(resource_id, version=version): return resource else: - raise self.EntityNotFound( - f"Entity with resource_id='{resource_id}' can't be found." - ) + raise self.EntityNotFound(f"Entity with resource_id='{resource_id}' can't be found.") def get_by_resource_id_optional( # noqa: D102 self, resource_id: str, *, version: Optional[int] = None diff --git a/karp-backend/src/karp/lex/application/use_cases/entry_handlers.py b/karp-backend/src/karp/lex/application/use_cases/entry_handlers.py index 0f335db6..418cfb61 100644 --- a/karp-backend/src/karp/lex/application/use_cases/entry_handlers.py +++ b/karp-backend/src/karp/lex/application/use_cases/entry_handlers.py @@ -233,9 +233,7 @@ def execute(self, command: commands.DeleteEntry) -> None: # noqa: D102 uw.commit() -class ExecutingBatchOfEntryCommands( - CommandHandler[commands.ExecuteBatchOfEntryCommands] -): +class ExecutingBatchOfEntryCommands(CommandHandler[commands.ExecuteBatchOfEntryCommands]): def __init__(self, command_bus: CommandBus) -> None: self.command_bus = command_bus diff --git a/karp-backend/src/karp/lex/application/use_cases/resource_handlers.py b/karp-backend/src/karp/lex/application/use_cases/resource_handlers.py index 1d4bbfe1..f4db7779 100644 --- a/karp-backend/src/karp/lex/application/use_cases/resource_handlers.py +++ b/karp-backend/src/karp/lex/application/use_cases/resource_handlers.py @@ -38,9 +38,7 @@ def execute(self, command: commands.CreateResource) -> ResourceDto: # noqa: D10 ) with self.resource_uow as uow: - existing_resource = uow.repo.get_by_resource_id_optional( - command.resource_id - ) + existing_resource = uow.repo.get_by_resource_id_optional(command.resource_id) if ( existing_resource and not existing_resource.discarded diff --git a/karp-backend/src/karp/lex/domain/entities/entry.py b/karp-backend/src/karp/lex/domain/entities/entry.py index 6456e872..28012968 100644 --- a/karp-backend/src/karp/lex/domain/entities/entry.py +++ b/karp-backend/src/karp/lex/domain/entities/entry.py @@ -161,7 +161,7 @@ def create_entry( # noqa: D103 *, id: unique_id.UniqueId, # noqa: A002 repo_id: unique_id.UniqueId, - last_modified_by: str = None, + last_modified_by: Optional[str] = None, message: Optional[str] = None, last_modified: typing.Optional[float] = None, ) -> Tuple[Entry, list[events.Event]]: diff --git a/karp-backend/src/karp/lex/domain/entities/resource.py b/karp-backend/src/karp/lex/domain/entities/resource.py index f639c6b5..cb4d1755 100644 --- a/karp-backend/src/karp/lex/domain/entities/resource.py +++ b/karp-backend/src/karp/lex/domain/entities/resource.py @@ -83,7 +83,7 @@ def publish( # noqa: D102 user: str, message: str, version: int, - timestamp: float = None, + timestamp: Optional[float] = None, ) -> list[events.Event]: self._update_metadata(timestamp, user, message or "Published", version) self.is_published = True @@ -137,9 +137,7 @@ def set_resource_id( # noqa: D102 timestamp: Optional[float] = None, message: Optional[str] = None, ) -> list[events.Event]: - self._update_metadata( - timestamp, user, message or "setting resource_id", version - ) + self._update_metadata(timestamp, user, message or "setting resource_id", version) self._resource_id = resource_id return [ events.ResourceUpdated( @@ -227,7 +225,7 @@ def release_with_name(self, name: str): # noqa: ANN201, D102 raise NotImplementedError() def discard( # noqa: D102 - self, *, user: str, message: str, timestamp: float = None + self, *, user: str, message: str, timestamp: Optional[float] = None ) -> list[events.Event]: self._op = ResourceOp.DELETED self._message = message or "Entry deleted." @@ -382,9 +380,9 @@ def description(self) -> str: def create_resource( # noqa: D103 config: dict[str, Any], entry_repo_id: unique_id.UniqueId, - created_by: str = None, - user: str = None, - created_at: float = None, + created_by: Optional[str] = None, + user: Optional[str] = None, + created_at: Optional[float] = None, id: unique_id.UniqueId = None, # noqa: A002 resource_id: typing.Optional[str] = None, message: typing.Optional[str] = None, diff --git a/karp-backend/src/karp/lex/domain/errors.py b/karp-backend/src/karp/lex/domain/errors.py index c4ccaffb..4b2ec539 100644 --- a/karp-backend/src/karp/lex/domain/errors.py +++ b/karp-backend/src/karp/lex/domain/errors.py @@ -22,7 +22,10 @@ class EntryNotFound(NotFoundError, LexDomainError): # noqa: D101 entity_name = "Entry" def __init__( # noqa: D107 - self, *args, entity_id=None, **kwargs # noqa: ANN002, ANN003 + self, + *args, + entity_id=None, + **kwargs, # noqa: ANN002, ANN003 ) -> None: NotFoundError.__init__(self, entity_id, *args) LexDomainError.__init__(self, **kwargs) @@ -33,7 +36,10 @@ class EntryRepoNotFound(NotFoundError, LexDomainError): # noqa: D101 entity_name = "EntryRepository" def __init__( # noqa: D107 - self, entity_id, *args, **kwargs # noqa: ANN002, ANN003 + self, + entity_id, + *args, + **kwargs, # noqa: ANN002, ANN003 ) -> None: NotFoundError.__init__(self, entity_id, *args) LexDomainError.__init__(self, entity_id, *args, **kwargs) @@ -43,7 +49,10 @@ class ResourceNotFound(NotFoundError, LexDomainError): # noqa: D101 entity_name = "Resource" def __init__( # noqa: D107 - self, entity_id, *args, **kwargs # noqa: ANN002, ANN003 + self, + entity_id, + *args, + **kwargs, # noqa: ANN002, ANN003 ) -> None: NotFoundError.__init__(self, entity_id, *args) LexDomainError.__init__(self, entity_id, *args, **kwargs) diff --git a/karp-backend/src/karp/lex/domain/value_objects/entry_schema.py b/karp-backend/src/karp/lex/domain/value_objects/entry_schema.py index 2b86bef3..93d9214d 100644 --- a/karp-backend/src/karp/lex/domain/value_objects/entry_schema.py +++ b/karp-backend/src/karp/lex/domain/value_objects/entry_schema.py @@ -23,9 +23,7 @@ def validate_entry(self, json_obj: dict[str, Any]) -> dict[str, Any]: try: self._compiled_schema(json_obj) except fastjsonschema.JsonSchemaException as e: - logger.warning( - "Entry not valid", extra={"entry": json_obj, "error_message": str(e)} - ) + logger.warning("Entry not valid", extra={"entry": json_obj, "error_message": str(e)}) raise errors.InvalidEntry() from e return json_obj @@ -74,7 +72,6 @@ def recursive_field( parent_field_name: str, parent_field_def: dict[str, Any], ) -> None: - if parent_field_def["type"] != "object": # TODO this will not work when we have user defined types, s.a. saldoid schema_type = json_schema_type(parent_field_def["type"]) diff --git a/karp-backend/src/karp/lex_infrastructure/__init__.py b/karp-backend/src/karp/lex_infrastructure/__init__.py index 3de9fb99..65dc7a22 100644 --- a/karp-backend/src/karp/lex_infrastructure/__init__.py +++ b/karp-backend/src/karp/lex_infrastructure/__init__.py @@ -89,11 +89,9 @@ def resources_uow( # noqa: D102 @injector.provider def entry_uow_creator( # noqa: D102 - self, - session_factory: sessionmaker, - event_bus: EventBus + self, session_factory: sessionmaker, event_bus: EventBus ) -> EntryUnitOfWorkCreator: # noqa: D102 - return SqlEntryUowCreator(session = session_factory(), event_bus = event_bus) + return SqlEntryUowCreator(session=session_factory(), event_bus=event_bus) class GenericLexInfrastructure(injector.Module): # noqa: D101 diff --git a/karp-backend/src/karp/lex_infrastructure/queries/generic_entries.py b/karp-backend/src/karp/lex_infrastructure/queries/generic_entries.py index 1e277d5c..d66290cb 100644 --- a/karp-backend/src/karp/lex_infrastructure/queries/generic_entries.py +++ b/karp-backend/src/karp/lex_infrastructure/queries/generic_entries.py @@ -44,18 +44,20 @@ def __init__( # noqa: D107 self.entry_repo_uow = entry_repo_uow def get_by_id( # noqa: D102 - self, resource_id: str, id: UniqueIdStr # noqa: A002 + self, + resource_id: str, + id: UniqueIdStr, # noqa: A002 ) -> EntryDto: entry_repo_id = self.get_entry_repo_id.query(resource_id) with self.entry_repo_uow as uw: entry_uow = uw.repo.get_by_id(entry_repo_id) with entry_uow as uw: - return self._entry_to_entry_dto( - uw.repo.by_id(UniqueId.validate(id)), resource_id - ) + return self._entry_to_entry_dto(uw.repo.by_id(UniqueId.validate(id)), resource_id) def get_by_id_optional( # noqa: D102 - self, resource_id: str, id: UniqueIdStr # noqa: A002 + self, + resource_id: str, + id: UniqueIdStr, # noqa: A002 ) -> typing.Optional[EntryDto]: entry_repo_id = self.get_entry_repo_id.query(resource_id) with self.entry_repo_uow as uw: @@ -70,10 +72,7 @@ def all_entries(self, resource_id: str) -> typing.Iterable[EntryDto]: # noqa: D with self.entry_repo_uow as uw: entry_uow = uw.repo.get_by_id(entry_repo_id) with entry_uow as uw: - return ( - _entry_to_entry_dto(entry, resource_id) - for entry in uw.repo.all_entries() - ) + return (_entry_to_entry_dto(entry, resource_id) for entry in uw.repo.all_entries()) class GenericEntryQuery: # noqa: D101 @@ -98,9 +97,7 @@ def query( # noqa: D102 version: typing.Optional[int], ) -> EntryDto: entry_repo_id = self.get_entry_repo_id(resource_id) - with self.entry_repo_uow, self.entry_repo_uow.repo.get_by_id( - entry_repo_id - ) as uw: + with self.entry_repo_uow, self.entry_repo_uow.repo.get_by_id(entry_repo_id) as uw: result = uw.repo.by_id(UniqueId.validate(id), version=version) return EntryDto( @@ -121,9 +118,7 @@ def query( # noqa: D102 ) -> GetHistoryDto: logger.info("querying history", extra={"request": request}) entry_repo_id = self.get_entry_repo_id(request.resource_id) - with self.entry_repo_uow, self.entry_repo_uow.repo.get_by_id( - entry_repo_id - ) as uw: + with self.entry_repo_uow, self.entry_repo_uow.repo.get_by_id(entry_repo_id) as uw: paged_query, total = uw.repo.get_history( entry_id=request.entry_id, user_id=request.user_id, @@ -171,9 +166,7 @@ def query( # noqa: D102 request: EntryDiffRequest, ) -> EntryDiffDto: entry_repo_id = self.get_entry_repo_id(request.resource_id) - with self.entry_repo_uow, self.entry_repo_uow.repo.get_by_id( - entry_repo_id - ) as uw: + with self.entry_repo_uow, self.entry_repo_uow.repo.get_by_id(entry_repo_id) as uw: db_entry = uw.repo.by_id(request.id) if request.from_version: diff --git a/karp-backend/src/karp/lex_infrastructure/queries/resources.py b/karp-backend/src/karp/lex_infrastructure/queries/resources.py index 3d0bfde7..ea74a0a3 100644 --- a/karp-backend/src/karp/lex_infrastructure/queries/resources.py +++ b/karp-backend/src/karp/lex_infrastructure/queries/resources.py @@ -54,7 +54,6 @@ def query(self) -> Iterable[ResourceDto]: # noqa: D102 class SqlReadOnlyResourceRepository(SqlQuery): - def get_by_resource_id( # noqa: D102 self, resource_id: str, version: Optional[int] = None ) -> Optional[ResourceDto]: @@ -77,7 +76,7 @@ def get_by_id( # noqa: D102 .filter_by(**filters) .order_by(ResourceModel.last_modified.desc()) ) - print(f"stmt={str(stmt)}") + print(f"stmt={stmt!s}") row = self._conn.execute(stmt).first() return _row_to_dto(row) if row else None diff --git a/karp-backend/src/karp/lex_infrastructure/repositories/sql_entries.py b/karp-backend/src/karp/lex_infrastructure/repositories/sql_entries.py index 6c0b920b..ea185af6 100644 --- a/karp-backend/src/karp/lex_infrastructure/repositories/sql_entries.py +++ b/karp-backend/src/karp/lex_infrastructure/repositories/sql_entries.py @@ -136,13 +136,13 @@ def _by_id( if version: query = query.filter_by(version=version) elif after_date is not None: - query = query.filter( - self.history_model.last_modified >= after_date - ).order_by(self.history_model.last_modified) + query = query.filter(self.history_model.last_modified >= after_date).order_by( + self.history_model.last_modified + ) elif before_date: - query = query.filter( - self.history_model.last_modified <= before_date - ).order_by(self.history_model.last_modified.desc()) + query = query.filter(self.history_model.last_modified <= before_date).order_by( + self.history_model.last_modified.desc() + ) elif oldest_first: query = query.order_by(self.history_model.last_modified) else: @@ -219,9 +219,7 @@ def get_history( # noqa: ANN201, D102 total = query.count() return [self._history_row_to_entry(row) for row in paged_query.all()], total - def _entry_to_history_dict( - self, entry: Entry, history_id: Optional[int] = None - ) -> Dict: + def _entry_to_history_dict(self, entry: Entry, history_id: Optional[int] = None) -> Dict: return { "history_id": history_id, "entity_id": entry.id, @@ -290,7 +288,10 @@ def repo(self) -> SqlEntryRepository: # noqa: D102 @classmethod def from_dict( # noqa: ANN206, D102 - cls, settings: typing.Dict, resource_config, **kwargs # noqa: ANN003 + cls, + settings: typing.Dict, + resource_config, + **kwargs, # noqa: ANN003 ): return cls(repo_settings=settings, resource_config=resource_config, **kwargs) @@ -335,5 +336,3 @@ def create( # noqa: D102 event_bus=self.event_bus, ) return self.cache[id], [] - - diff --git a/karp-backend/src/karp/lex_infrastructure/repositories/sql_resources.py b/karp-backend/src/karp/lex_infrastructure/repositories/sql_resources.py index 19a43a99..f5489ffe 100644 --- a/karp-backend/src/karp/lex_infrastructure/repositories/sql_resources.py +++ b/karp-backend/src/karp/lex_infrastructure/repositories/sql_resources.py @@ -120,11 +120,7 @@ def _get_published_resources(self) -> typing.List[entities.Resource]: ), ) - return [ - resource_dto.to_entity() - for resource_dto in query - if resource_dto is not None - ] + return [resource_dto.to_entity() for resource_dto in query if resource_dto is not None] def _get_all_resources(self) -> typing.List[entities.Resource]: self._check_has_session() @@ -144,11 +140,7 @@ def _get_all_resources(self) -> typing.List[entities.Resource]: ), ) - return [ - resource_dto.to_entity() - for resource_dto in query - if resource_dto is not None - ] + return [resource_dto.to_entity() for resource_dto in query if resource_dto is not None] class SqlResourceUnitOfWork( # noqa: D101 diff --git a/karp-backend/src/karp/lex_infrastructure/sql/sql_models.py b/karp-backend/src/karp/lex_infrastructure/sql/sql_models.py index 0c0ad020..8278874d 100644 --- a/karp-backend/src/karp/lex_infrastructure/sql/sql_models.py +++ b/karp-backend/src/karp/lex_infrastructure/sql/sql_models.py @@ -46,9 +46,7 @@ class ResourceModel(db.Base): # noqa: D101 op = Column(Enum(ResourceOp), nullable=False) discarded = Column(Boolean, default=False) __table_args__ = ( - UniqueConstraint( - "entity_id", "version", name="entity_id_version_unique_constraint" - ), + UniqueConstraint("entity_id", "version", name="entity_id_version_unique_constraint"), # TODO only one resource can be active, but several can be inactive # here is how to do it in MariaDB, unclear whether this is possible using SQLAlchemy # `virtual_column` char(0) as (if(active,'', NULL)) persistent @@ -175,9 +173,7 @@ class BaseHistoryEntry: # noqa: D101 @classmethod @declared_attr def __table_args__(cls): # noqa: ANN206, D105 - return UniqueConstraint( - "entity_id", "version", name="id_version_unique_constraint" - ) + return UniqueConstraint("entity_id", "version", name="id_version_unique_constraint") @classmethod def from_entity(cls, entry: entities.Entry): # noqa: ANN206, D102 diff --git a/karp-backend/src/karp/main/__init__.py b/karp-backend/src/karp/main/__init__.py index be26c6fc..db94cd62 100644 --- a/karp-backend/src/karp/main/__init__.py +++ b/karp-backend/src/karp/main/__init__.py @@ -92,9 +92,7 @@ def _setup_dependency_injection( def _setup_search_context(container: injector.Injector, settings: dict) -> None: - container.binder.install( - Es6SearchIndexMod(index_prefix=settings.get("es.index_prefix")) - ) + container.binder.install(Es6SearchIndexMod(index_prefix=settings.get("es.index_prefix"))) def configure_logging(settings: dict[str, str]) -> None: # noqa: D103 diff --git a/karp-backend/src/karp/main/errors.py b/karp-backend/src/karp/main/errors.py index 117632f9..9a8a988f 100644 --- a/karp-backend/src/karp/main/errors.py +++ b/karp-backend/src/karp/main/errors.py @@ -15,7 +15,7 @@ class ClientErrorCodes(enum.IntEnum): # noqa: D101 class KarpError(Exception): # noqa: D101 def __init__( # noqa: D107 - self, message: str, code: int = None, http_return_code: int = 400 + self, message: str, code: Optional[int] = None, http_return_code: int = 400 ) -> None: super().__init__(message) self.message = message diff --git a/karp-backend/src/karp/main/migrations/env.py b/karp-backend/src/karp/main/migrations/env.py index 84c7cc34..57c9ac17 100644 --- a/karp-backend/src/karp/main/migrations/env.py +++ b/karp-backend/src/karp/main/migrations/env.py @@ -46,14 +46,10 @@ def run_migrations_online(): # noqa: ANN201 # drop testing db if it exists and create a fresh one with default_engine.connect() as default_conn: logger.warning("dropping database: %s", karp_config.DATABASE_NAME) - default_conn.execute( - f"DROP DATABASE IF EXISTS {karp_config.DATABASE_NAME}" - ) + default_conn.execute(f"DROP DATABASE IF EXISTS {karp_config.DATABASE_NAME}") logger.warning("creating database: %s", karp_config.DATABASE_NAME) - result = default_conn.execute( - f"CREATE DATABASE {karp_config.DATABASE_NAME}" - ) + result = default_conn.execute(f"CREATE DATABASE {karp_config.DATABASE_NAME}") logger.warning("db response: %s", result) logger.info("migrating url: %s", karp_config.DATABASE_URL) @@ -84,9 +80,7 @@ def run_migrations_offline() -> None: """ # noqa: D202, D200, D212 if os.environ.get("TESTING"): - raise RuntimeError( - "Running testing migrations offline currently not permitted." - ) + raise RuntimeError("Running testing migrations offline currently not permitted.") alembic.context.configure(url=str(karp_config.DATABASE_URL)) with alembic.context.begin_transaction(): diff --git a/karp-backend/src/karp/main/migrations/versions/5bb29472d33f_init_db.py b/karp-backend/src/karp/main/migrations/versions/5bb29472d33f_init_db.py index 407c99aa..f376914c 100644 --- a/karp-backend/src/karp/main/migrations/versions/5bb29472d33f_init_db.py +++ b/karp-backend/src/karp/main/migrations/versions/5bb29472d33f_init_db.py @@ -35,9 +35,7 @@ def create_resources(): # noqa: ANN201, D103 sa.Column("op", sa.Enum("ADDED", "UPDATED", "DELETED"), nullable=False), sa.Column("discarded", sa.Boolean(), nullable=True), sa.PrimaryKeyConstraint("history_id"), - sa.UniqueConstraint( - "entity_id", "version", name="entity_id_version_unique_constraint" - ), + sa.UniqueConstraint("entity_id", "version", name="entity_id_version_unique_constraint"), ) diff --git a/karp-backend/src/karp/main/modules.py b/karp-backend/src/karp/main/modules.py index 518e24e8..052cbc81 100644 --- a/karp-backend/src/karp/main/modules.py +++ b/karp-backend/src/karp/main/modules.py @@ -118,9 +118,7 @@ def install_auth_service( # noqa: ANN201, D103 container: injector.Injector, settings: Dict[str, str] ): container.binder.install(AuthInfrastructure()) - container.binder.install( - JwtAuthInfrastructure(Path(settings["auth.jwt.pubkey.path"])) - ) + container.binder.install(JwtAuthInfrastructure(Path(settings["auth.jwt.pubkey.path"]))) def request_configuration(conn: Connection, session: Session): # noqa: ANN201, D103 diff --git a/karp-backend/src/karp/search/application/use_cases.py b/karp-backend/src/karp/search/application/use_cases.py index d8cab4dc..daff2ccc 100644 --- a/karp-backend/src/karp/search/application/use_cases.py +++ b/karp-backend/src/karp/search/application/use_cases.py @@ -13,7 +13,9 @@ from karp.search.domain import commands from karp.search.generic_resources import GenericResourceViews from karp.search_infrastructure.transformers.generic_pre_processor import GenericPreProcessor -from karp.search_infrastructure.transformers.generic_entry_transformer import GenericEntryTransformer +from karp.search_infrastructure.transformers.generic_entry_transformer import ( + GenericEntryTransformer, +) logger = logging.getLogger(__name__) @@ -72,7 +74,10 @@ def __init__(self, index_uow: IndexUnitOfWork): # noqa: D107, ANN204 self.index_uow = index_uow def __call__( # noqa: D102, ANN204 - self, event: events.ResourceCreated, *args, **kwargs # noqa: ANN002, ANN003 + self, + event: events.ResourceCreated, + *args, + **kwargs, # noqa: ANN002, ANN003 ): print(f"{event.resource_id=}") with self.index_uow as uw: @@ -87,7 +92,10 @@ def __init__(self, index_uow: IndexUnitOfWork): # noqa: D107, ANN204 self.index_uow = index_uow def __call__( # noqa: D102, ANN204 - self, event: events.ResourceDiscarded, *args, **kwargs # noqa: ANN002, ANN003 + self, + event: events.ResourceDiscarded, + *args, + **kwargs, # noqa: ANN002, ANN003 ): print(f"{event.resource_id=}") diff --git a/karp-backend/src/karp/search/domain/query.py b/karp-backend/src/karp/search/domain/query.py index df516b2c..62c8481c 100644 --- a/karp-backend/src/karp/search/domain/query.py +++ b/karp-backend/src/karp/search/domain/query.py @@ -14,13 +14,9 @@ class Query(pydantic.BaseModel): # noqa: D101 include_fields: typing.Optional[list[str]] = None exclude_fields: typing.Optional[list[str]] = None q: typing.Optional[str] = None - sort_dict: typing.Optional[dict[str, list[str]]] = pydantic.Field( - default_factory=dict - ) + sort_dict: typing.Optional[dict[str, list[str]]] = pydantic.Field(default_factory=dict) - @pydantic.validator( - "resources", "include_fields", "exclude_fields", "sort", pre=True - ) + @pydantic.validator("resources", "include_fields", "exclude_fields", "sort", pre=True) def split_str(cls, v): # noqa: ANN206, D102 return v.split(",") if isinstance(v, str) else v diff --git a/karp-backend/src/karp/search_infrastructure/elasticsearch6/es_mapping_repo.py b/karp-backend/src/karp/search_infrastructure/elasticsearch6/es_mapping_repo.py index 87e20fec..90b839e6 100644 --- a/karp-backend/src/karp/search_infrastructure/elasticsearch6/es_mapping_repo.py +++ b/karp-backend/src/karp/search_infrastructure/elasticsearch6/es_mapping_repo.py @@ -105,9 +105,7 @@ def get_index_name(self, resource_id: str) -> str: # noqa: D102 index=self._config_index, id=resource_id, doc_type=KARP_CONFIGINDEX_TYPE ) except es_exceptions.NotFoundError as err: - logger.info( - "didn't find index_name for resource '%s' details: %s", resource_id, err - ) + logger.info("didn't find index_name for resource '%s' details: %s", resource_id, err) return self._update_config(resource_id)["index_name"] return res["_source"]["index_name"] @@ -117,15 +115,13 @@ def get_alias_name(self, resource_id: str) -> str: # noqa: D102 index=self._config_index, id=resource_id, doc_type=KARP_CONFIGINDEX_TYPE ) except es_exceptions.NotFoundError as err: - logger.info( - "didn't find alias_name for resource '%s' details: %s", resource_id, err - ) + logger.info("didn't find alias_name for resource '%s' details: %s", resource_id, err) return self._update_config(resource_id)["alias_name"] return res["_source"]["alias_name"] @staticmethod def get_analyzed_fields_from_mapping( # noqa: D102 - properties: Dict[str, Dict[str, Dict[str, Any]]] + properties: Dict[str, Dict[str, Dict[str, Any]]], ) -> List[str]: analyzed_fields = [] @@ -151,23 +147,17 @@ def _init_field_mapping( field_mapping: Dict[str, List[str]] = {} sortable_fields = {} aliases = self._get_all_aliases() - mapping: Dict[ - str, Dict[str, Dict[str, Dict[str, Dict]]] - ] = self.es.indices.get_mapping() + mapping: Dict[str, Dict[str, Dict[str, Dict[str, Dict]]]] = self.es.indices.get_mapping() for alias, index in aliases: if ( "mappings" in mapping[index] and "entry" in mapping[index]["mappings"] and "properties" in mapping[index]["mappings"]["entry"] ): - field_mapping[ - alias - ] = Es6MappingRepository.get_analyzed_fields_from_mapping( + field_mapping[alias] = Es6MappingRepository.get_analyzed_fields_from_mapping( mapping[index]["mappings"]["entry"]["properties"] ) - sortable_fields[ - alias - ] = Es6MappingRepository.create_sortable_map_from_mapping( + sortable_fields[alias] = Es6MappingRepository.create_sortable_map_from_mapping( mapping[index]["mappings"]["entry"]["properties"] ) return field_mapping, sortable_fields @@ -217,14 +207,10 @@ def translate_sort_fields( translated_sort_fields.extend( ( {field: {"order": sort_order}} - for field in self.translate_sort_field( - resource_id, sort_value - ) + for field in self.translate_sort_field(resource_id, sort_value) ) ) - translated_sort_fields.extend( - self.translate_sort_field(resource_id, sort_value) - ) + translated_sort_fields.extend(self.translate_sort_field(resource_id, sort_value)) return translated_sort_fields diff --git a/karp-backend/src/karp/search_infrastructure/queries/es6_search_service.py b/karp-backend/src/karp/search_infrastructure/queries/es6_search_service.py index f698df38..d3e6888b 100644 --- a/karp-backend/src/karp/search_infrastructure/queries/es6_search_service.py +++ b/karp-backend/src/karp/search_infrastructure/queries/es6_search_service.py @@ -39,9 +39,7 @@ def walk__and(self, node): # noqa: ANN201, D102 return result def walk__contains(self, node): # noqa: ANN201, D102 - return es_dsl.Q( - "regexp", **{self.walk(node.field): f".*{self.walk(node.arg)}.*"} - ) + return es_dsl.Q("regexp", **{self.walk(node.field): f".*{self.walk(node.arg)}.*"}) def walk__endswith(self, node): # noqa: ANN201, D102 return es_dsl.Q("regexp", **{self.walk(node.field): f".*{self.walk(node.arg)}"}) @@ -49,9 +47,7 @@ def walk__endswith(self, node): # noqa: ANN201, D102 def walk__equals(self, node): # noqa: ANN201, D102 return es_dsl.Q( "match", - **{ - self.walk(node.field): {"query": self.walk(node.arg), "operator": "and"} - }, + **{self.walk(node.field): {"query": self.walk(node.arg), "operator": "and"}}, ) def walk__string_value(self, node): @@ -65,9 +61,7 @@ def walk__exists(self, node): # noqa: ANN201, D102 return es_dsl.Q("exists", field=self.walk(node.field)) def walk__freergxp(self, node): # noqa: ANN201, D102 - return es_dsl.Q( - "query_string", query=f"/{self.walk(node.arg)}/", default_field="*" - ) + return es_dsl.Q("query_string", query=f"/{self.walk(node.arg)}/", default_field="*") def walk__freetext(self, node): # noqa: ANN201, D102 return es_dsl.Q("multi_match", query=self.walk(node.arg)) @@ -84,9 +78,7 @@ def walk_range(self, node): # noqa: ANN201, D102 walk__lte = walk_range def walk__missing(self, node): # noqa: ANN201, D102 - return es_dsl.Q( - "bool", must_not=es_dsl.Q("exists", field=self.walk(node.field)) - ) + return es_dsl.Q("bool", must_not=es_dsl.Q("exists", field=self.walk(node.field))) def walk__not(self, node): # noqa: ANN201, D102 must_nots = [self.walk(expr) for expr in node.exps] @@ -105,18 +97,20 @@ def walk__regexp(self, node): # noqa: ANN201, D102 def walk__startswith(self, node): # noqa: ANN201, D102 return es_dsl.Q("regexp", **{self.walk(node.field): f"{self.walk(node.arg)}.*"}) + class EsFieldNameCollector(NodeWalker): # Return a set of all field names occurring in the given query def walk_Node(self, node): result = set().union(*(self.walk(child) for child in node.children())) # TODO maybe a bit too automagic? - if hasattr(node, 'field'): + if hasattr(node, "field"): result.add(node.field) return result def walk_object(self, _obj): return set() + class Es6SearchService: def __init__( # noqa: D107, ANN204 self, @@ -197,14 +191,10 @@ def search_with_query(self, query: EsQuery): # noqa: ANN201, D102, C901 s = s.query(es_query) s = s[query.from_ : query.from_ + query.size] if query.sort: - s = s.sort( - *self.mapping_repo.translate_sort_fields([resource], query.sort) - ) + s = s.sort(*self.mapping_repo.translate_sort_fields([resource], query.sort)) elif query.sort_dict and resource in query.sort_dict: s = s.sort( - *self.translate_sort_fields( - [resource], query.sort_dict[resource] - ) + *self.translate_sort_fields([resource], query.sort_dict[resource]) ) ms = ms.add(s) @@ -237,19 +227,13 @@ def _extracted_from_search_with_query_47(self, query, es_query, field_names): # s = s[query.from_ : query.from_ + query.size] if query.lexicon_stats: - s.aggs.bucket( - "distribution", "terms", field="_index", size=len(query.resources) - ) + s.aggs.bucket("distribution", "terms", field="_index", size=len(query.resources)) if query.sort: - s = s.sort( - *self.mapping_repo.translate_sort_fields(query.resources, query.sort) - ) + s = s.sort(*self.mapping_repo.translate_sort_fields(query.resources, query.sort)) elif query.sort_dict: sort_fields = [] for resource, sort in query.sort_dict.items(): - sort_fields.extend( - self.mapping_repo.translate_sort_fields([resource], sort) - ) + sort_fields.extend(self.mapping_repo.translate_sort_fields([resource], sort)) s = s.sort(*sort_fields) logger.debug("s = %s", extra={"es_query s": s.to_dict()}) response = s.execute() @@ -274,9 +258,12 @@ def add_runtime_mappings(self, s: es_dsl.Search, field_names: set[str]) -> es_ds for field in field_names: if field.endswith(".length"): base_field = field.removesuffix(".length") - mappings[field] = \ - {"type": "long", - "script": {"source": f"emit(doc.containsKey('{base_field}') ? doc['{base_field}'].length : 0)"}} + mappings[field] = { + "type": "long", + "script": { + "source": f"emit(doc.containsKey('{base_field}') ? doc['{base_field}'].length : 0)" + }, + } # elasticsearch_dsl doesn't know about runtime_mappings so we have to add them 'by hand' if mappings: diff --git a/karp-backend/src/karp/search_infrastructure/repositories/es6_indicies.py b/karp-backend/src/karp/search_infrastructure/repositories/es6_indicies.py index 2fc3e968..588a807c 100644 --- a/karp-backend/src/karp/search_infrastructure/repositories/es6_indicies.py +++ b/karp-backend/src/karp/search_infrastructure/repositories/es6_indicies.py @@ -50,9 +50,7 @@ def create_index(self, resource_id: str, config): # noqa: ANN201, D102 } index_alias_name = self.mapping_repo.create_index_and_alias_name(resource_id) - logger.info( - "creating index", extra={"index_alias_name": index_alias_name, "body": body} - ) + logger.info("creating index", extra={"index_alias_name": index_alias_name, "body": body}) result = self.es.indices.create(index=index_alias_name["index_name"], body=body) if "error" in result: logger.error( @@ -116,9 +114,7 @@ def delete_entry( # noqa: ANN201, D102 raise ValueError("Must give either 'entry' or 'entry_id'.") if entry: entry_id = entry.entry_id - logger.info( - "deleting entry", extra={"entry_id": entry_id, "resource_id": resource_id} - ) + logger.info("deleting entry", extra={"entry_id": entry_id, "resource_id": resource_id}) index_name = self.mapping_repo.get_index_name(resource_id) try: self.es.delete( diff --git a/karp-backend/src/karp/search_infrastructure/transformers/generic_entry_transformer.py b/karp-backend/src/karp/search_infrastructure/transformers/generic_entry_transformer.py index 48d36e6a..ca3647b2 100644 --- a/karp-backend/src/karp/search_infrastructure/transformers/generic_entry_transformer.py +++ b/karp-backend/src/karp/search_infrastructure/transformers/generic_entry_transformer.py @@ -31,12 +31,8 @@ def transform(self, resource_id: str, src_entry: EntryDto) -> IndexEntry: ) index_entry = self.index_uow.repo.create_empty_object() index_entry.id = str(src_entry.id) - self.index_uow.repo.assign_field( - index_entry, "_entry_version", src_entry.version - ) - self.index_uow.repo.assign_field( - index_entry, "_last_modified", src_entry.last_modified - ) + self.index_uow.repo.assign_field(index_entry, "_entry_version", src_entry.version) + self.index_uow.repo.assign_field(index_entry, "_last_modified", src_entry.last_modified) self.index_uow.repo.assign_field( index_entry, "_last_modified_by", src_entry.last_modified_by ) @@ -51,9 +47,7 @@ def transform(self, resource_id: str, src_entry: EntryDto) -> IndexEntry: index_entry, resource.config["fields"].items(), ) - logger.debug( - "transformed entry", extra={"entry": src_entry, "index_entry": index_entry} - ) + logger.debug("transformed entry", extra={"entry": src_entry, "index_entry": index_entry}) return index_entry def _transform_to_index_entry( # noqa: ANN202, C901 @@ -83,12 +77,8 @@ def _transform_to_index_entry( # noqa: ANN202, C901 field_content, subfield_content.entry ) else: - self.index_uow.repo.add_to_list_field( - field_content, subfield - ) - self.index_uow.repo.assign_field( - _index_entry, field_name, field_content - ) + self.index_uow.repo.add_to_list_field(field_content, subfield) + self.index_uow.repo.assign_field(_index_entry, field_name, field_content) elif field_conf["type"] == "object": field_content = self.index_uow.repo.create_empty_object() @@ -99,9 +89,7 @@ def _transform_to_index_entry( # noqa: ANN202, C901 field_content, field_conf["fields"].items(), ) - self.index_uow.repo.assign_field( - _index_entry, field_name, field_content - ) + self.index_uow.repo.assign_field(_index_entry, field_name, field_content) elif field_conf["type"] in ( "integer", @@ -112,6 +100,4 @@ def _transform_to_index_entry( # noqa: ANN202, C901 ): if field_name in _src_entry: field_content = _src_entry[field_name] - self.index_uow.repo.assign_field( - _index_entry, field_name, field_content - ) + self.index_uow.repo.assign_field(_index_entry, field_name, field_content) diff --git a/karp-backend/src/karp/search_infrastructure/transformers/generic_pre_processor.py b/karp-backend/src/karp/search_infrastructure/transformers/generic_pre_processor.py index 925b3a8c..49b58907 100644 --- a/karp-backend/src/karp/search_infrastructure/transformers/generic_pre_processor.py +++ b/karp-backend/src/karp/search_infrastructure/transformers/generic_pre_processor.py @@ -3,7 +3,9 @@ from karp.lex_infrastructure import GenericEntryViews from karp.search.application.repositories import IndexEntry -from karp.search_infrastructure.transformers.generic_entry_transformer import GenericEntryTransformer +from karp.search_infrastructure.transformers.generic_entry_transformer import ( + GenericEntryTransformer, +) logger = logging.getLogger(__name__) @@ -22,12 +24,8 @@ def process( # noqa: D102 self, resource_id: str, ) -> typing.Iterable[IndexEntry]: - logger.debug( - "processing entries for resource", extra={"resource_id": resource_id} - ) + logger.debug("processing entries for resource", extra={"resource_id": resource_id}) for entry in self.entry_views.all_entries(resource_id): - logger.debug( - "processing entry", extra={"entry": entry, "resource_id": resource_id} - ) + logger.debug("processing entry", extra={"entry": entry, "resource_id": resource_id}) yield self.entry_transformer.transform(resource_id, entry) diff --git a/karp-lex-core/src/karp/lex_core/alias_generators.py b/karp-lex-core/src/karp/lex_core/alias_generators.py index d09ef590..17da91e8 100644 --- a/karp-lex-core/src/karp/lex_core/alias_generators.py +++ b/karp-lex-core/src/karp/lex_core/alias_generators.py @@ -4,6 +4,4 @@ def to_lower_camel(s: str) -> str: """Transform snake_case to lowerCamelCase.""" # noqa: D202 - return "".join( - word.capitalize() if i > 0 else word for i, word in enumerate(s.split("_")) - ) + return "".join(word.capitalize() if i > 0 else word for i, word in enumerate(s.split("_"))) diff --git a/tests/common_data.py b/tests/common_data.py index a1483e0a..f542b8b9 100644 --- a/tests/common_data.py +++ b/tests/common_data.py @@ -56,7 +56,7 @@ "area": 6312, "population": 6312, "density": 12, - "municipality": [3] + "municipality": [3], # "smaller_places": 7 "Bjurvik" }, { @@ -66,7 +66,7 @@ "population": 3812, "density": 12, "municipality": [2, 3], - "larger_place": 4 # Hambo + "larger_place": 4, # Hambo # "smaller_places": 1 "Grund test" }, { diff --git a/tests/e2e/conftest.py b/tests/e2e/conftest.py index e531e752..548f3ba3 100644 --- a/tests/e2e/conftest.py +++ b/tests/e2e/conftest.py @@ -94,7 +94,6 @@ def create_and_publish_resource( *, path_to_config: str, ) -> Tuple[bool, Optional[dict[str, Any]]]: - with open(path_to_config) as fp: resource_config = json.load(fp) @@ -122,9 +121,7 @@ def create_and_publish_resource( command_bus.dispatch(create_resource) - publish_resource = commands.PublishResource( - user="", resourceId=resource_id, version=1 - ) + publish_resource = commands.PublishResource(user="", resourceId=resource_id, version=1) command_bus.dispatch(publish_resource) diff --git a/tests/e2e/test_entries_api.py b/tests/e2e/test_entries_api.py index 72fdc26d..56f3b336 100644 --- a/tests/e2e/test_entries_api.py +++ b/tests/e2e/test_entries_api.py @@ -217,10 +217,7 @@ def test_adding_existing_fails_with_400( # noqa: ANN201 assert "error" in response_data assert "errorCode" in response_data assert ClientErrorCodes.DB_INTEGRITY_ERROR == response_data["errorCode"] - assert ( - response_data["error"] - == f"An entry with entry_id '{entry_id}' already exists." - ) + assert response_data["error"] == f"An entry with entry_id '{entry_id}' already exists." def test_add_fails_with_invalid_entry( # noqa: ANN201 self, diff --git a/tests/e2e/test_history_api.py b/tests/e2e/test_history_api.py index 56cbcf99..abcc33e0 100644 --- a/tests/e2e/test_history_api.py +++ b/tests/e2e/test_history_api.py @@ -111,9 +111,7 @@ def test_empty_user_history( # noqa: ANN201 admin_token: auth.AccessToken, history_entity_ids: list[str], ): - response_data = get_helper( - fa_data_client, "/history/places?user_id=user3", admin_token - ) + response_data = get_helper(fa_data_client, "/history/places?user_id=user3", admin_token) assert len(response_data["history"]) == 0 assert response_data["total"] == 0 diff --git a/tests/integration/test_sql_entries_uow.py b/tests/integration/test_sql_entries_uow.py index 47046439..7883a2cf 100644 --- a/tests/integration/test_sql_entries_uow.py +++ b/tests/integration/test_sql_entries_uow.py @@ -35,7 +35,4 @@ def test_repo_table_name( # noqa: ANN201 entry_uow, _ = sql_entry_uow_creator.create(**example_uow.dict(exclude={"cmdtype"})) random_part = ulid.from_uuid(entry_uow.entity_id).randomness().str with entry_uow as uw: - assert ( - uw.repo.history_model.__tablename__ - == f"{example_uow.name}_{random_part}" - ) + assert uw.repo.history_model.__tablename__ == f"{example_uow.name}_{random_part}" diff --git a/tests/integration/test_sql_resource_repository.py b/tests/integration/test_sql_resource_repository.py index fb1f797b..8a7c14ae 100644 --- a/tests/integration/test_sql_resource_repository.py +++ b/tests/integration/test_sql_resource_repository.py @@ -59,9 +59,7 @@ def test_sql_resource_repo_update_resource(resource_repo): # noqa: ANN201 assert resource_repo.by_resource_id(resource.resource_id).version == 2 assert resource_repo.get_by_id(resource.entity_id, version=1).version == 1 - assert ( - resource_repo.get_by_resource_id(resource.resource_id, version=1).version == 1 - ) + assert resource_repo.get_by_resource_id(resource.resource_id, version=1).version == 1 lex = resource_repo.by_resource_id(resource.resource_id) assert lex is not None diff --git a/tests/integration/test_sql_uow.py b/tests/integration/test_sql_uow.py index dc5595d3..e3cdea5b 100644 --- a/tests/integration/test_sql_uow.py +++ b/tests/integration/test_sql_uow.py @@ -62,7 +62,7 @@ def test_rolls_back_uncommitted_work_by_default( # noqa: ANN201 uow = SqlEntryUnitOfWork( # {"resource_id": "abc", "table_name": "abc"}, # resource_config={"resource_id": "abc", "config": {}}, - session = sqlite_session_factory(), + session=sqlite_session_factory(), event_bus=InMemoryEventBus(), name="test", config={}, @@ -82,7 +82,7 @@ def test_rolls_back_on_error(self, sqlite_session_factory): # noqa: ANN201 uow = SqlEntryUnitOfWork( # {"resource_id": "abc", "table_name": "abc"}, # resource_config={"resource_id": "abc", "config": {}}, - session = sqlite_session_factory(), + session=sqlite_session_factory(), event_bus=InMemoryEventBus(), name="test", config={}, diff --git a/tests/unit/auth/adapters.py b/tests/unit/auth/adapters.py index 1ab65cd4..8f8dcb0a 100644 --- a/tests/unit/auth/adapters.py +++ b/tests/unit/auth/adapters.py @@ -3,7 +3,6 @@ class InMemoryIsResourceProtected(LexIsResourceProtected): - def __init__(self): pass diff --git a/tests/unit/lex/adapters.py b/tests/unit/lex/adapters.py index 9f274028..e51b9eb1 100644 --- a/tests/unit/lex/adapters.py +++ b/tests/unit/lex/adapters.py @@ -32,9 +32,7 @@ def ensure_correct_id_type(v) -> unique_id.UniqueId: try: return unique_id.UniqueId.validate(v) except ValueError as exc: - raise ValueError( - f"expected valid UniqueId, got '{v}' (type: `{type(v)}')" - ) from exc + raise ValueError(f"expected valid UniqueId, got '{v}' (type: `{type(v)}')") from exc class InMemoryResourceRepository(lex_repositories.ResourceRepository): @@ -75,7 +73,9 @@ def __init__(self, resources: Dict): # noqa: ANN204 self.resources = resources def get_by_id( - self, id: UniqueIdPrimitive, version: Optional[int] = None # noqa: A002 + self, + id: UniqueIdPrimitive, + version: Optional[int] = None, # noqa: A002 ) -> Optional[ResourceDto]: resource_id = UniqueId.validate(id) if resource := self.resources.get(resource_id): @@ -96,9 +96,7 @@ def _row_to_dto(self, res: lex_entities.Resource) -> ResourceDto: return ResourceDto(**res.serialize()) def get_published_resources(self) -> Iterable[ResourceDto]: - return ( - self._row_to_dto(res) for res in self.resources.values() if res.is_published - ) + return (self._row_to_dto(res) for res in self.resources.values() if res.is_published) class InMemoryEntryRepository(Repository): @@ -190,9 +188,7 @@ def repo(self): return self._entries -class InMemoryResourceUnitOfWork( - InMemoryUnitOfWork, lex_repositories.ResourceUnitOfWork -): +class InMemoryResourceUnitOfWork(InMemoryUnitOfWork, lex_repositories.ResourceUnitOfWork): def __init__(self, event_bus: EventBus): # noqa: ANN204 InMemoryUnitOfWork.__init__(self) lex_repositories.ResourceUnitOfWork.__init__(self, event_bus=event_bus) diff --git a/tests/unit/lex/test_resource.py b/tests/unit/lex/test_resource.py index 01b06367..569b73cf 100644 --- a/tests/unit/lex/test_resource.py +++ b/tests/unit/lex/test_resource.py @@ -70,16 +70,12 @@ def test_resource_update_changes_last_modified_and_version(): # noqa: ANN201 "fields": {"baseform": {"type": "string", "required": True}}, } - resource = factories.ResourceFactory( - name=copy.deepcopy(name), config=copy.deepcopy(conf) - ) + resource = factories.ResourceFactory(name=copy.deepcopy(name), config=copy.deepcopy(conf)) previous_last_modified = resource.last_modified previous_version = resource.version conf["fields"]["new"] = {"type": "string"} - domain_events = resource.update( - name="new name", config=conf, user="Test", version=1 - ) + domain_events = resource.update(name="new name", config=conf, user="Test", version=1) assert resource.last_modified > previous_last_modified assert resource.last_modified_by == "Test" diff --git a/tests/unit/lex/test_resource_handlers.py b/tests/unit/lex/test_resource_handlers.py index 69a56f47..f1b91b80 100644 --- a/tests/unit/lex/test_resource_handlers.py +++ b/tests/unit/lex/test_resource_handlers.py @@ -77,7 +77,8 @@ def test_create_resource_with_same_resource_id_raises( # noqa: ANN201 with pytest.raises(errors.IntegrityError): lex_ctx.command_bus.dispatch( factories.CreateResourceFactory.build( - resourceId=cmd2.resource_id, entryRepoId=cmd1.id # type: ignore [attr-defined] + resourceId=cmd2.resource_id, + entryRepoId=cmd1.id, # type: ignore [attr-defined] ) ) diff --git a/tests/unit/lex_core/entry_dto_unit_test.py b/tests/unit/lex_core/entry_dto_unit_test.py index ab390492..daa17408 100644 --- a/tests/unit/lex_core/entry_dto_unit_test.py +++ b/tests/unit/lex_core/entry_dto_unit_test.py @@ -9,9 +9,7 @@ def test_can_create_entry_dto(): # noqa: ANN201 def test_can_create_entry_dto_with_last_modified_by(): # noqa: ANN201 - entry_dto = EntryDto( - entry={"field": "value"}, lastModifiedBy="username@example.com" - ) + entry_dto = EntryDto(entry={"field": "value"}, lastModifiedBy="username@example.com") assert entry_dto.last_modified is None assert entry_dto.last_modified_by == "username@example.com" diff --git a/tests/unit/search/adapters.py b/tests/unit/search/adapters.py index c974f834..333bbd24 100644 --- a/tests/unit/search/adapters.py +++ b/tests/unit/search/adapters.py @@ -33,9 +33,7 @@ def __init__(self) -> None: self.indicies: dict[str, InMemoryIndex.Index] = {} def create_index(self, resource_id: str, config: Dict): # noqa: ANN201 - self.indicies[resource_id] = InMemoryIndex.Index( - config=config, created_at=utc_now() - ) + self.indicies[resource_id] = InMemoryIndex.Index(config=config, created_at=utc_now()) def publish_index(self, alias_name: str, index_name: str = None): # noqa: ANN201 self.indicies[alias_name].published = True @@ -81,7 +79,6 @@ def _by_id(self, id) -> None: # noqa: A002 return None - class InMemoryIndexUnitOfWork(InMemoryUnitOfWork, IndexUnitOfWork): def __init__(self, event_bus: EventBus): # noqa: ANN204 IndexUnitOfWork.__init__(self, event_bus=event_bus) # type:ignore [arg-type] diff --git a/tests/unit/search/test_search_handlers.py b/tests/unit/search/test_search_handlers.py index d119687a..7c4c328a 100644 --- a/tests/unit/search/test_search_handlers.py +++ b/tests/unit/search/test_search_handlers.py @@ -43,9 +43,7 @@ def test_index_reacts_on_entry_added_event( # noqa: ANN201 ): create_entry_repo = lex_factories.CreateEntryRepositoryFactory() search_unit_ctx.command_bus.dispatch(create_entry_repo) # type: ignore [arg-type] - create_resource = lex_factories.CreateResourceFactory( - entryRepoId=create_entry_repo.id - ) + create_resource = lex_factories.CreateResourceFactory(entryRepoId=create_entry_repo.id) search_unit_ctx.command_bus.dispatch(create_resource) # type: ignore [arg-type] create_entry = lex_factories.AddEntryFactory( resourceId=create_resource.resource_id, @@ -70,9 +68,7 @@ def test_index_reacts_on_entry_updated_event( # noqa: ANN201 ): create_entry_repo = lex_factories.CreateEntryRepositoryFactory() search_unit_ctx.command_bus.dispatch(create_entry_repo) # type: ignore [arg-type] - create_resource = lex_factories.CreateResourceFactory( - entryRepoId=create_entry_repo.id - ) + create_resource = lex_factories.CreateResourceFactory(entryRepoId=create_entry_repo.id) search_unit_ctx.command_bus.dispatch(create_resource) # type: ignore [arg-type] create_entry = lex_factories.AddEntryFactory( resourceId=create_resource.resource_id, @@ -103,9 +99,7 @@ def test_index_reacts_on_entry_deleted_event( # noqa: ANN201 ): create_entry_repo = lex_factories.CreateEntryRepositoryFactory() search_unit_ctx.command_bus.dispatch(create_entry_repo) # type: ignore [arg-type] - create_resource = lex_factories.CreateResourceFactory( - entryRepoId=create_entry_repo.id - ) + create_resource = lex_factories.CreateResourceFactory(entryRepoId=create_entry_repo.id) search_unit_ctx.command_bus.dispatch(create_resource) # type: ignore [arg-type] create_entry = lex_factories.AddEntryFactory( resourceId=create_resource.resource_id, @@ -134,9 +128,7 @@ def test_reindex_resource_command( # noqa: ANN201 ): create_entry_repo = lex_factories.CreateEntryRepositoryFactory() search_unit_ctx.command_bus.dispatch(create_entry_repo) # type: ignore [arg-type] - create_resource = lex_factories.CreateResourceFactory( - entryRepoId=create_entry_repo.id - ) + create_resource = lex_factories.CreateResourceFactory(entryRepoId=create_entry_repo.id) search_unit_ctx.command_bus.dispatch(create_resource) # type: ignore [arg-type] create_entry = lex_factories.AddEntryFactory( resourceId=create_resource.resource_id, diff --git a/tests/unit/search_infrastructure/test_es6_es_query.py b/tests/unit/search_infrastructure/test_es6_es_query.py index 869d96ff..914c5950 100644 --- a/tests/unit/search_infrastructure/test_es6_es_query.py +++ b/tests/unit/search_infrastructure/test_es6_es_query.py @@ -23,12 +23,8 @@ def request_size() -> int: @pytest.fixture() -def query_request( - resource_ids: List[str], request_from: int, request_size: int -) -> QueryRequest: - return QueryRequest( - resource_ids=resource_ids, from_=request_from, size=request_size - ) +def query_request(resource_ids: List[str], request_from: int, request_size: int) -> QueryRequest: + return QueryRequest(resource_ids=resource_ids, from_=request_from, size=request_size) def test_create_EsQuery_from_QueryRequest(query_request: QueryRequest) -> None: diff --git a/tests/unit/search_infrastructure/test_es6_mappings.py b/tests/unit/search_infrastructure/test_es6_mappings.py index febc79f4..b832f1ca 100644 --- a/tests/unit/search_infrastructure/test_es6_mappings.py +++ b/tests/unit/search_infrastructure/test_es6_mappings.py @@ -84,9 +84,7 @@ def test_sort(self): # noqa: ANN201 expected = { "dynamic": False, - "properties": { - "name": {"type": "text", "fields": {"raw": {"type": "keyword"}}} - }, + "properties": {"name": {"type": "text", "fields": {"raw": {"type": "keyword"}}}}, "settings": { "analysis": { "analyzer": { @@ -143,9 +141,7 @@ def test_sort_large(self): # noqa: ANN201 mapping = create_es6_mapping(data) expected = { - "properties": { - "name": {"type": "text", "fields": {"raw": {"type": "keyword"}}} - }, + "properties": {"name": {"type": "text", "fields": {"raw": {"type": "keyword"}}}}, "settings": { "analysis": { "analyzer": { diff --git a/tests/unit/search_infrastructure/test_es6_query_parser.py b/tests/unit/search_infrastructure/test_es6_query_parser.py index b608cb12..a4499c3a 100644 --- a/tests/unit/search_infrastructure/test_es6_query_parser.py +++ b/tests/unit/search_infrastructure/test_es6_query_parser.py @@ -70,21 +70,15 @@ def parser() -> KarpQueryV6Parser: ), ( 'and(equals|ortografi|"ständigt förknippad")', - es_dsl.Q( - "match", ortografi={"query": "ständigt förknippad", "operator": "and"} - ), + es_dsl.Q("match", ortografi={"query": "ständigt förknippad", "operator": "and"}), ), ( 'and(equals|ortografi|"(ständigt) förknippad")', - es_dsl.Q( - "match", ortografi={"query": "(ständigt) förknippad", "operator": "and"} - ), + es_dsl.Q("match", ortografi={"query": "(ständigt) förknippad", "operator": "and"}), ), ( 'and(equals|ortografi|"(ständigt förknippad")', - es_dsl.Q( - "match", ortografi={"query": "(ständigt förknippad", "operator": "and"} - ), + es_dsl.Q("match", ortografi={"query": "(ständigt förknippad", "operator": "and"}), ), # escaped quotes ( @@ -148,9 +142,7 @@ def test_es_query(parser, q, expected): # noqa: ANN201 es_dsl.Q( "bool", must_not=[ - es_dsl.Q( - "match", ordklass={"query": "substantiv", "operator": "and"} - ), + es_dsl.Q("match", ordklass={"query": "substantiv", "operator": "and"}), es_dsl.Q("match", ordklass={"query": "verb", "operator": "and"}), ], ),