Black/isort syntax

Author: anfimovdm

alws/crud/products.py

@@ -71,7 +71,9 @@ async def create_product(
         (
             await db.execute(
                 select(models.Platform).where(
-                    models.Platform.name.in_([platform.name for platform in payload.platforms]),
+                    models.Platform.name.in_(
+                        [platform.name for platform in payload.platforms]
+                    ),
                 ),
             )
         )
@@ -105,7 +107,14 @@ async def create_product(
         )
     task_results = await asyncio.gather(*repo_tasks)
 
-    for repo_name, repo_url, arch, pulp_href, export_path, is_debug in task_results:
+    for (
+        repo_name,
+        repo_url,
+        arch,
+        pulp_href,
+        export_path,
+        is_debug,
+    ) in task_results:
         repo = models.Repository(
             name=repo_name,
             url=repo_url,
@@ -180,13 +189,21 @@ def generate_query(count=False):
                 selectinload(models.Product.owner),
                 selectinload(models.Product.platforms),
                 selectinload(models.Product.repositories),
-                selectinload(models.Product.roles).selectinload(models.UserRole.actions),
-                selectinload(models.Product.team).selectinload(models.Team.owner),
+                selectinload(models.Product.roles).selectinload(
+                    models.UserRole.actions
+                ),
+                selectinload(models.Product.team).selectinload(
+                    models.Team.owner
+                ),
                 selectinload(models.Product.team)
                 .selectinload(models.Team.roles)
                 .selectinload(models.UserRole.actions),
-                selectinload(models.Product.team).selectinload(models.Team.members),
-                selectinload(models.Product.team).selectinload(models.Team.products),
+                selectinload(models.Product.team).selectinload(
+                    models.Team.members
+                ),
+                selectinload(models.Product.team).selectinload(
+                    models.Team.products
+                ),
             )
         )
         if count:
@@ -205,7 +222,9 @@ def generate_query(count=False):
     if page_number:
         return {
             'products': (await db.execute(generate_query())).scalars().all(),
-            'total_products': (await db.execute(generate_query(count=True))).scalar(),
+            'total_products': (
+                await db.execute(generate_query(count=True))
+            ).scalar(),
             'current_page': page_number,
         }
     if product_id or product_name:
@@ -227,7 +246,9 @@ async def remove_product(
     db_product = await get_products(db, product_id=product_id)
     db_user = await get_user(db, user_id=user_id)
     if not can_perform(db_product, db_user, actions.DeleteProduct.name):
-        raise PermissionDenied(f"User has no permissions to delete the product {db_product.name}")
+        raise PermissionDenied(
+            f"User has no permissions to delete the product {db_product.name}"
+        )
     if not db_product:
         raise DataNotFoundError(f"Product={product_id} doesn't exist")
     active_builds_by_team_id = (
@@ -266,7 +287,8 @@ async def remove_product(
         # some repos from db can be absent in pulp
         # in case if you reset pulp db, but didn't reset non-pulp db
         if all(
-            product_repo.name != product_distro['name'] for product_distro in all_product_distros
+            product_repo.name != product_distro['name']
+            for product_distro in all_product_distros
         ):
             continue
         delete_tasks.append(pulp_client.delete_by_href(product_repo.pulp_href))
@@ -302,8 +324,12 @@ async def modify_product(
         )
         .options(
             selectinload(models.Build.repos),
-            selectinload(models.Build.tasks).selectinload(models.BuildTask.rpm_modules),
-            selectinload(models.Build.tasks).selectinload(models.BuildTask.platform),
+            selectinload(models.Build.tasks).selectinload(
+                models.BuildTask.rpm_modules
+            ),
+            selectinload(models.Build.tasks).selectinload(
+                models.BuildTask.platform
+            ),
         ),
     )
 
@@ -314,17 +340,19 @@ async def modify_product(
         )
         .options(
             selectinload(models.Build.repos),
-            selectinload(models.Build.tasks).selectinload(models.BuildTask.rpm_modules),
-            selectinload(models.Build.tasks).selectinload(models.BuildTask.platform),
+            selectinload(models.Build.tasks).selectinload(
+                models.BuildTask.rpm_modules
+            ),
+            selectinload(models.Build.tasks).selectinload(
+                models.BuildTask.platform
+            ),
         ),
     )
     db_build = db_build.scalars().first()
 
     if modification == 'add':
         if db_build in db_product.builds:
-            error_msg = (
-                f"Can't add build {build_id} to {product} as it's already part of the product"
-            )
+            error_msg = f"Can't add build {build_id} to {product} as it's already part of the product"
             raise ProductError(error_msg)
     if modification == 'remove':
         if db_build not in db_product.builds:
@@ -339,18 +367,24 @@ async def modify_product(
     perform_product_modification.send(db_build.id, db_product.id, modification)
 
 
-async def get_repo_product(session: AsyncSession, repository: str) -> Optional[Product]:
+async def get_repo_product(
+    session: AsyncSession, repository: str
+) -> Optional[Product]:
     product_relationships = (
         selectinload(Product.owner),
         selectinload(Product.roles).selectinload(UserRole.actions),
-        selectinload(Product.team).selectinload(Team.roles).selectinload(UserRole.actions),
+        selectinload(Product.team)
+        .selectinload(Team.roles)
+        .selectinload(UserRole.actions),
     )
     if repository.endswith("br"):
         result = (
             (
                 await session.execute(
                     select(Build)
-                    .filter(Build.repos.any(Repository.name.ilike(f'%{repository}')))
+                    .filter(
+                        Build.repos.any(Repository.name.ilike(f'%{repository}'))
+                    )
                     .options(
                         joinedload(Build.team)
                         .joinedload(Team.products)

alws/utils/copr.py

@@ -104,7 +104,9 @@ async def create_product_repo(
         create_publication=True,
         base_path_start='copr',
     )
-    export_path = f"{product_name}/{platform_name}/{'debug/' if is_debug else ''}{arch}/"
+    export_path = (
+        f"{product_name}/{platform_name}/{'debug/' if is_debug else ''}{arch}/"
+    )
     return repo_name, repo_url, arch, repo_href, export_path, is_debug
 
 

alws/utils/exporter.py

@@ -15,8 +15,14 @@ async def fs_export_repository(
     repository_ids: List[int],
     session: AsyncSession,
 ):
-    export_task = await repo_exporter.create_pulp_exporters_to_fs(session, repository_ids)
-    export_data = await repo_exporter.execute_pulp_exporters_to_fs(session, export_task)
+    export_task = await repo_exporter.create_pulp_exporters_to_fs(
+        session,
+        repository_ids,
+    )
+    export_data = await repo_exporter.execute_pulp_exporters_to_fs(
+        session,
+        export_task,
+    )
     export_paths = list(export_data.keys())
     for repo_elem, repo_data in export_data.items():
         repo_url = urllib.parse.urljoin(repo_data, 'repodata/')

alws/utils/pulp_client.py

@@ -368,9 +368,7 @@ async def _upload_local_file(
             with open(file_path, "rb") as f:
                 for i in range(chunks):
                     chunk = io.BytesIO(f.read(chunk_size))
-                    chunk.name = (
-                        f'{file_path.strip("/").replace("/", "_")}_{i}'
-                    )
+                    chunk.name = f'{file_path.strip("/").replace("/", "_")}_{i}'
                     payload = {"file": chunk}
                     if chunk_size >= file_size:
                         stop = file_size - 1
@@ -386,9 +384,7 @@ async def _upload_local_file(
                     )
                     start += chunk_size
         except Exception:
-            logging.exception(
-                "Exception during the file upload", exc_info=True
-            )
+            logging.exception("Exception during the file upload", exc_info=True)
             await self.request("DELETE", upload_href, raw=True)
         else:
             task = await self.request(
@@ -1053,7 +1049,9 @@ async def request(
             return response_json
 
 
-def get_pulp_client(semaphore: Optional[asyncio.Semaphore] = None) -> PulpClient:
+def get_pulp_client(
+    semaphore: Optional[asyncio.Semaphore] = None,
+) -> PulpClient:
     return PulpClient(
         host=settings.pulp_host,
         username=settings.pulp_user,

scripts/add_export_paths_to_product_repos.py

@@ -19,15 +19,20 @@ def main():
             session.execute(
                 select(Product)
                 .where(Product.is_community.is_(True))
-                .options(joinedload(Product.repositories), joinedload(Product.platforms))
+                .options(
+                    joinedload(Product.repositories),
+                    joinedload(Product.platforms),
+                )
             )
             .scalars()
             .unique()
             .all()
         ):
             if not product.repositories:
                 continue
-            platform_names = '|'.join((platform.name for platform in product.platforms))
+            platform_names = '|'.join(
+                (platform.name for platform in product.platforms)
+            )
             platform_pattern = re.compile(
                 rf'-({platform_names})-(\w+)(-debug|)-dr$',
                 flags=re.IGNORECASE,
@@ -39,9 +44,7 @@ def main():
                 if not regex_result:
                     continue
                 platform, *_ = regex_result.groups()
-                repo.export_path = (
-                    f"{product.name}/{platform}/{'debug/' if repo.debug else ''}{repo.arch}/"
-                )
+                repo.export_path = f"{product.name}/{platform}/{'debug/' if repo.debug else ''}{repo.arch}/"
 
 
 if __name__ == '__main__':

scripts/exporters/base_exporter.py

@@ -22,7 +22,7 @@ def __init__(
         self,
         repodata_cache_dir: str,
         logger_name: str = '',
-        log_file_path: Path = Path('/tmp/exporter.log'),
+        log_file_path: Path = Path('/srv/exporter.log'),
         verbose: bool = False,
         export_method: Literal['write', 'hardlink', 'symlink'] = 'hardlink',
         export_path: str = settings.pulp_export_path,
@@ -32,7 +32,9 @@ def __init__(
         self.export_path = export_path
         self.createrepo_c = local["createrepo_c"]
 
-        self.repodata_cache_dir = Path(repodata_cache_dir).expanduser().absolute()
+        self.repodata_cache_dir = (
+            Path(repodata_cache_dir).expanduser().absolute()
+        )
         self.checksums_cache_dir = self.repodata_cache_dir.joinpath('checksums')
         for dir_path in (self.repodata_cache_dir, self.checksums_cache_dir):
             if dir_path.exists():
@@ -52,7 +54,9 @@ def __init__(
         )
 
     def regenerate_repo_metadata(self, repo_path: str):
-        partial_path = re.sub(str(settings.pulp_export_path), "", str(repo_path)).strip("/")
+        partial_path = re.sub(
+            str(settings.pulp_export_path), "", str(repo_path)
+        ).strip("/")
         repodata_path = Path(repo_path, "repodata")
         repo_repodata_cache = self.repodata_cache_dir.joinpath(partial_path)
         cache_repodata_dir = repo_repodata_cache.joinpath("repodata")
@@ -86,20 +90,26 @@ async def create_filesystem_exporters(
         get_publications: bool = False,
     ):
         async def get_exporter_data(repository: Repository) -> Tuple[str, dict]:
-            export_path = str(Path(self.export_path, repository.export_path, "Packages"))
+            export_path = str(
+                Path(self.export_path, repository.export_path, "Packages")
+            )
             exporter_name = (
                 f"{repository.name}-{repository.arch}-debug"
                 if repository.debug
                 else f"{repository.name}-{repository.arch}"
             )
-            fs_exporter_href = await self.pulp_client.create_filesystem_exporter(
-                exporter_name,
-                export_path,
-                export_method=self.export_method,
+            fs_exporter_href = (
+                await self.pulp_client.create_filesystem_exporter(
+                    exporter_name,
+                    export_path,
+                    export_method=self.export_method,
+                )
             )
 
-            repo_latest_version = await self.pulp_client.get_repo_latest_version(
-                repository.pulp_href
+            repo_latest_version = (
+                await self.pulp_client.get_repo_latest_version(
+                    repository.pulp_href
+                )
             )
             if not repo_latest_version:
                 raise ValueError('cannot find latest repo version')
@@ -126,7 +136,9 @@ async def get_exporter_data(repository: Repository) -> Tuple[str, dict]:
             result = await session.execute(query)
             repositories = list(result.scalars().all())
 
-        results = await asyncio.gather(*(get_exporter_data(repo) for repo in repositories))
+        results = await asyncio.gather(
+            *(get_exporter_data(repo) for repo in repositories)
+        )
 
         return list(dict(results).values())
 
@@ -148,7 +160,9 @@ async def _export_repository(self, exporter: dict) -> Optional[str]:
         href = exporter["exporter_href"]
         repository_version = exporter["repo_latest_version"]
         try:
-            await self.pulp_client.export_to_filesystem(href, repository_version)
+            await self.pulp_client.export_to_filesystem(
+                href, repository_version
+            )
         except Exception:
             self.logger.exception(
                 "Cannot export repository via %s",
@@ -178,5 +192,7 @@ async def _export_repository(self, exporter: dict) -> Optional[str]:
 
     async def export_repositories(self, repo_ids: List[int]) -> List[str]:
         exporters = await self.create_filesystem_exporters(repo_ids)
-        results = await asyncio.gather(*(self._export_repository(e) for e in exporters))
+        results = await asyncio.gather(
+            *(self._export_repository(e) for e in exporters)
+        )
         return [path for path in results if path]