Modernize validators

Author: dolfinus

syncmaster/db/repositories/connection.py

@@ -121,14 +121,12 @@ async def copy(
         new_name: str | None,
     ) -> Connection:
         try:
-            kwargs_for_copy = dict(group_id=new_group_id, name=new_name)
-            new_connection = await self._copy(
+            kwargs_for_copy = dict(group_id=new_group_id, name=new_name)  # noqa: C408
+            return await self._copy(
                 Connection.id == connection_id,
                 **kwargs_for_copy,
             )
 
-            return new_connection
-
         except IntegrityError as integrity_error:
             self._raise_error(integrity_error)
 

syncmaster/dto/transfers.py

@@ -84,14 +84,15 @@ def _get_file_format(self, file_format: dict) -> CSV | JSONLine | JSON | Excel |
             self._rewrite_option_name(file_format, "line_sep", "lineSep")
             self._rewrite_option_name(file_format, "include_header", "header")
 
-        if file_type == "json" or file_type == "jsonline":
+        if file_type in {"json", "jsonline"}:
             self._rewrite_option_name(file_format, "line_sep", "lineSep")
 
         parser_class = self._format_parsers.get(file_type)
         if parser_class is not None:
             return parser_class.parse_obj(file_format)
 
-        raise ValueError(f"Unknown file type: {file_type}")
+        msg = f"Unknown file type: {file_type}"
+        raise ValueError(msg)
 
 
 @dataclass

syncmaster/dto/transfers_strategy.py

@@ -18,7 +18,8 @@ def from_dict(cls, data: dict) -> Strategy:
 
         strategy_type = data.get("type")
         if strategy_type not in strategy_classes:
-            raise ValueError(f"Unknown strategy type: {strategy_type}")
+            msg = f"Unknown strategy type: {strategy_type}"
+            raise ValueError(msg)
 
         return strategy_classes[strategy_type](**data)
 

syncmaster/scheduler/__main__.py

@@ -34,7 +34,10 @@ async def main():
             transfer_job_manager.update_jobs(transfers)
 
             transfer_fetcher.last_updated_at = max(t.updated_at for t in transfers)
-            logger.info("Scheduler state has been updated. Last updated at: %s", transfer_fetcher.last_updated_at)
+            logger.info(
+                "Scheduler state has been updated. Last updated at: %s",
+                transfer_fetcher.last_updated_at,
+            )
 
         await asyncio.sleep(settings.scheduler.TRANSFER_FETCHING_TIMEOUT_SECONDS)
 

syncmaster/scheduler/transfer_fetcher.py

@@ -13,12 +13,13 @@ def __init__(self, settings: Settings):
         self.last_updated_at = None
 
     async def fetch_updated_jobs(self) -> list[Transfer]:
-        async with get_async_engine(self.settings) as engine, get_async_session(engine) as session:
+        async with (
+            get_async_engine(self.settings) as engine,
+            get_async_session(engine) as session,
+        ):
             query = select(Transfer)
             if self.last_updated_at is not None:
                 query = query.filter(Transfer.updated_at > self.last_updated_at)
 
             result = await session.execute(query)
-            transfers = result.scalars().all()
-
-        return transfers
+            return result.scalars().all()

syncmaster/scheduler/transfer_job_manager.py

@@ -53,7 +53,10 @@ async def remove_orphan_jobs(self) -> None:
         all_jobs = self.scheduler.get_jobs()
         job_transfer_ids = [int(job.id) for job in all_jobs]
 
-        async with get_async_engine(self.settings) as engine, get_async_session(engine) as session:
+        async with (
+            get_async_engine(self.settings) as engine,
+            get_async_session(engine) as session,
+        ):
             result = await session.execute(
                 select(Transfer).where(Transfer.id == any_(job_transfer_ids)),  # type: ignore[arg-type]
             )
@@ -75,7 +78,10 @@ async def send_job_to_celery(transfer_id: int) -> None:  # noqa: WPS602, WPS217
         """
         settings = Settings()
 
-        async with get_async_engine(settings) as engine, get_async_session(engine) as session:
+        async with (
+            get_async_engine(settings) as engine,
+            get_async_session(engine) as session,
+        ):
             unit_of_work = UnitOfWork(session=session, settings=settings)
 
             try:

syncmaster/schemas/v1/connections/oracle.py

@@ -23,10 +23,12 @@ class OracleConnectionDataSchema(BaseModel):
     additional_params: dict = Field(default_factory=dict)
 
     @model_validator(mode="before")
+    @classmethod
     def validate_connection_identifiers(cls, values):
         sid, service_name = values.get("sid"), values.get("service_name")
         if sid and service_name:
-            raise ValueError("You must specify either sid or service_name but not both")
+            msg = "You must specify either sid or service_name but not both"
+            raise ValueError(msg)
         return values
 
 

syncmaster/schemas/v1/groups.py

@@ -22,6 +22,7 @@ class AddUserSchema(BaseModel):
     model_config = ConfigDict(from_attributes=True)
 
     @model_validator(mode="before")
+    @classmethod
     def validate_role(cls, values):
         if isinstance(values, dict):
             role = values.get("role")
@@ -30,8 +31,9 @@ def validate_role(cls, values):
             role = getattr(values, "role", None)
 
         if role and not GroupMemberRole.is_public_role(role):
+            msg = f"Input should be one of: {GroupMemberRole.public_roles_str()}"
             raise ValueError(
-                f"Input should be one of: {GroupMemberRole.public_roles_str()}",
+                msg,
             )
         return values
 

syncmaster/schemas/v1/transfers/__init__.py

@@ -56,21 +56,25 @@ class CreateTransferSchema(TransferSchema):
     def validate_scheduling(cls, value: str | None, info: ValidationInfo):
         if not value and info.data.get("is_scheduled"):
             # TODO make checking cron string
-            raise ValueError("If transfer must be scheduled then set schedule")
+            msg = "If transfer must be scheduled then set schedule"
+            raise ValueError(msg)
         return value or None
 
     @field_validator("strategy_params", mode="after")
     @classmethod
     def validate_strategy(cls, value: Strategy, info: ValidationInfo):
         if isinstance(value, IncrementalStrategy):
             if info.data["source_params"].type in ("s3", "hdfs"):
-                raise ValueError("S3 and HDFS sources do not support incremental strategy for now")
+                msg = "S3 and HDFS sources do not support incremental strategy for now"
+                raise ValueError(msg)
 
             source_type = info.data["source_params"].type
-            if source_type in FILE_CONNECTION_TYPES and value.increment_by not in ("file_modified_since", "file_name"):
-                raise ValueError(
-                    "Field 'increment_by' must be equal to 'file_modified_since' or 'file_name' for file source types",
-                )
+            if source_type in FILE_CONNECTION_TYPES and value.increment_by not in (
+                "file_modified_since",
+                "file_name",
+            ):
+                msg = "Field 'increment_by' must be equal to 'file_modified_since' or 'file_name' for file source types"
+                raise ValueError(msg)
         return value
 
 

syncmaster/schemas/v1/transfers/db.py

@@ -27,7 +27,8 @@ class DBTransfer(BaseModel):
     @classmethod
     def _table_name_is_qualified(cls, value):
         if not re.match(cls.TABLE_NAME_PATTERN, value):
-            raise ValueError("Table name should be in format myschema.mytable")
+            msg = "Table name should be in format myschema.mytable"
+            raise ValueError(msg)
         return value
 
 
@@ -66,7 +67,8 @@ class IcebergTransferSourceOrTarget(DBTransfer):
     @classmethod
     def _table_name_is_qualified(cls, value):
         if not re.match(cls.TABLE_NAME_PATTERN, value):
-            raise ValueError("Table name should be in format myschema.mytable")
+            msg = "Table name should be in format myschema.mytable"
+            raise ValueError(msg)
         return value